vstf/vstf/agent/perf/netmap.py

   1 #!/usr/bin/python
   2 # -*- coding: utf8 -*-
   3 # author: wly
   4 # date: 2015-11-09
   5 # see license for license details
   6
   7
   8 import time
   9 import subprocess
  10 import vstf.common.decorator as deco
  11 from vstf.common.utils import kill_by_name, my_popen
  12
  13 import logging
  14
  15 LOG = logging.getLogger(__name__)
  16
  17
  18 class Netmap(object):
  19     def __init__(self):
  20         self._send_processes = []
  21         self._receive_processes = []
  22
  23     @deco.check("protocol", choices=['udp_bw'], defaults='udp_bw')
  24     @deco.check("namespace", defaults=None)
  25     @deco.check("dst")
  26     @deco.check("src")
  27     @deco.check("size", defaults=64)
  28     @deco.check("threads", defaults=1)
  29     @deco.check("ratep", defaults=0)
  30     def send_start(self, **kwargs):
  31         cmd = self.format_send_start(**kwargs)
  32         LOG.info("cmd:%s", cmd)
  33
  34         process = my_popen(cmd.split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
  35         self._send_processes.append(process)
  36         time.sleep(0.5)
  37
  38         ret = process.poll()
  39         if ret is None:
  40             ret = 0
  41             error_str = "start netmap send success"
  42         else:
  43             error_str = "start netmap send failed, %s" % (str(kwargs))
  44             process.wait()
  45             self._send_processes.remove(process)
  46
  47         return ret, error_str
  48
  49     def send_stop(self, **kwargs):
  50         LOG.info("send_stop")
  51         results = []
  52         ret = 0
  53         for process in self._send_processes:
  54             process.kill()
  55             process.wait()
  56             error_str = "stop netmap send success"
  57             results.append((ret, error_str))
  58         self._send_processes = []
  59         return results
  60
  61     def format_send_start(self, **kwargs):
  62         cmd = "pkt-gen -i %(src_iface)s -f tx -l %(pkt_size)s -p %(threads)s -D %(dst_mac)s -R %(ratep)s"
  63         context = {
  64             'src_iface': kwargs['src'][0]['iface'],
  65             'dst_mac': kwargs['dst'][0]['mac'],
  66             'pkt_size': kwargs['size'],
  67             'threads': kwargs['threads'],
  68             'ratep': kwargs['ratep']
  69         }
  70         cmd = cmd % context
  71         return cmd
  72
  73     @deco.namespace()
  74     def format_receive_start(self, **kwargs):
  75         cmd = "pkt-gen -i %(iface)s -f rx"
  76         context = {
  77             'iface': kwargs['dst'][0]['iface']
  78         }
  79         cmd = cmd % context
  80         return cmd
  81
  82     @deco.check("protocol", choices=['udp_bw'], defaults='udp_bw')
  83     @deco.check("namespace", defaults=None)
  84     @deco.check("dst")
  85     def receive_start(self, **kwargs):
  86
  87         cmd = self.format_receive_start(**kwargs)
  88         LOG.info("cmd:%s", cmd)
  89
  90         process = my_popen(cmd.split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
  91         self._receive_processes.append(process)
  92         time.sleep(0.5)
  93
  94         ret = process.poll()
  95         if ret is None:
  96             ret = 0
  97             error_str = "start netmap receive success"
  98         else:
  99             error_str = "start netmap receive failed, %s" % (str(kwargs))
 100             process.wait()
 101             self._receive_processes.remove(process)
 102
 103         return ret, error_str
 104
 105     def receive_stop(self, **kwargs):
 106         LOG.info("receive_stop")
 107         ret = 0
 108         for process in self._receive_processes:
 109             process.kill()
 110             process.wait()
 111         self._receive_processes = []
 112         error_str = "stop netmap receive success"
 113         self._receive_processes = []
 114         return ret, error_str
 115
 116     def clean(self):
 117         self.send_stop()
 118         self.receive_stop()
 119         return True
 120
 121     def force_clean(self):
 122         LOG.info("%s %s start", self.__class__, self.force_clean.__name__)
 123         kill_by_name('pkt-gen')
 124         self._send_processes = []
 125         self._receive_processes = []
 126         return True
 127
 128
 129 def unit_test():
 130     perf = Netmap()
 131     receive = {
 132         "protocol": "udp_bw",
 133         # "namespace": "receive",
 134         "dst": [
 135             {"iface": "p57p2"}
 136         ],
 137     }
 138     ret = perf.receive_start(**receive)
 139     LOG.info("*********receive_start***********")
 140     LOG.info("ret")
 141     send = {
 142         # "namespace": "send",
 143         "protocol": "udp_bw",
 144         "src": [
 145             {"iface": "eth4", "mac": "90:e2:ba:20:1f:d8"}
 146         ],
 147         "dst": [
 148             {"mac": "90:e2:ba:20:1f:d9"}
 149         ],
 150         "size": 64,
 151         "threads": 1,
 152         "ratep": 0
 153     }
 154     print perf.send_start(**send)
 155     print perf._send_processes
 156     time.sleep(10)
 157
 158     print perf.send_stop()
 159     print perf.receive_stop()
 160
 161
 162 if __name__ == "__main__":
 163     from vstf.common.log import setup_logging
 164
 165     setup_logging(level=logging.DEBUG, log_file="/var/log/vstf/vstf-netmap.log", clevel=logging.INFO)
 166     unit_test()