vstf/vstf/controller/sw_perf/model.py

   1 #!/usr/bin/python
   2 # -*- coding: utf8 -*-
   3 # author:
   4 # date:
   5 # see license for license details
   6
   7 import logging
   8
   9 from vstf.controller.fabricant import Fabricant
  10 from vstf.controller.sw_perf.raw_data import RawDataProcess
  11 from vstf.common import perfmark as mark
  12
  13 LOG = logging.getLogger(__name__)
  14
  15
  16 class NetDeviceMgr(Fabricant):
  17     @classmethod
  18     def add(cls, dst, conn, dev):
  19         self = cls(dst, conn)
  20         LOG.info(dev)
  21         ret = self.config_dev(netdev=dev)
  22         LOG.info(ret)
  23
  24     @classmethod
  25     def remove(cls, dst, conn, dev):
  26         self = cls(dst, conn)
  27         LOG.info(dev)
  28         ret = self.recover_dev(netdev=dev)
  29         LOG.info(ret)
  30
  31     @classmethod
  32     def clear(cls, dst, conn):
  33         self = cls(dst, conn)
  34         self.clean_all_namespace()
  35
  36
  37 class Actor(Fabricant):
  38     def __init__(self, dst, conn, tool, params):
  39         super(Actor, self).__init__(dst, conn)
  40         self._tool = tool
  41         self._params = params
  42         self._data = {}
  43
  44     def __repr__(self):
  45         repr_dict = self.__dict__
  46         repr_keys = list(repr_dict.keys())
  47         repr_keys.sort()
  48         return '%s(%s)' % (self.__class__.__name__, ', '.join(['%s=%r' % (k, repr_dict[k]) for k in repr_keys]))
  49
  50
  51 class Sender(Actor):
  52     def start(self, pktsize, **kwargs):
  53         LOG.info("Sender.start")
  54         if 'ratep' in kwargs and kwargs['ratep']:
  55             self._params['ratep'] = kwargs['ratep']
  56         self._params['size'] = pktsize
  57
  58         ret, info = self.perf_run(
  59             operation="start",
  60             action="send",
  61             tool=self._tool,
  62             params=self._params
  63         )
  64         LOG.info(ret)
  65         if ret:
  66             raise Exception(info)
  67         LOG.info(info)
  68         print ret
  69
  70     def stop(self):
  71         LOG.info(self._params)
  72         rets = self.perf_run(
  73             operation="stop",
  74             action="send",
  75             tool=self._tool,
  76             params={}
  77         )
  78         LOG.info(rets)
  79         minlatency, avglatency, maxlatency = 0, 0, 0
  80         count = 0
  81         for (ret, info) in rets:
  82             if ret:
  83                 raise Exception(info)
  84             if self.is_data() and ret == 0:
  85                 count += 1
  86                 minlatency += info[mark.minLatency]
  87                 avglatency += info[mark.avgLatency]
  88                 maxlatency += info[mark.maxLatency]
  89         count = 1 if not count else count
  90         self._data[mark.minLatency] = minlatency / count
  91         self._data[mark.avgLatency] = avglatency / count
  92         self._data[mark.maxLatency] = maxlatency / count
  93
  94         print rets
  95
  96     def is_data(self):
  97         if '_lat' in self._params['protocol']:
  98             return True
  99         return False
 100
 101     def result(self):
 102         return self._data
 103
 104
 105 class Receiver(Actor):
 106     def start(self, **kwargs):
 107         LOG.info("Receiver.start")
 108         ret, info = self.perf_run(
 109             operation="start",
 110             action="receive",
 111             tool=self._tool,
 112             params=self._params
 113         )
 114         LOG.info(ret)
 115         if ret:
 116             raise Exception(info)
 117         LOG.info(info)
 118         return ret
 119
 120     def stop(self):
 121         LOG.info("Receiver.stop")
 122         ret, info = self.perf_run(
 123             operation="stop",
 124             action="receive",
 125             tool=self._tool,
 126             params=self._params
 127         )
 128         LOG.info(ret)
 129         if ret:
 130             raise Exception(info)
 131         LOG.info(info)
 132         return ret
 133
 134
 135 class NicWatcher(Fabricant):
 136     def __init__(self, dst, conn, params):
 137         super(NicWatcher, self).__init__(dst, conn)
 138         self._params = params
 139         self._pid = None
 140         self._data = {}
 141
 142     def start(self):
 143         print "NicWatcher.start"
 144         self._pid = self.run_vnstat(device=self._params["iface"], namespace=self._params["namespace"])
 145         print self._pid
 146
 147     def stop(self):
 148         print "NicWatcher.stop"
 149         if self._pid:
 150             data = self.kill_vnstat(pid=self._pid)
 151             self._data = RawDataProcess.process(data)
 152             print "---------------------------------"
 153             print self._data
 154             print "---------------------------------"
 155
 156     def result(self, **kwargs):
 157         return self._data
 158
 159
 160 class CpuWatcher(Fabricant):
 161     def __init__(self, dst, conn):
 162         super(CpuWatcher, self).__init__(dst, conn)
 163         self._pid = None
 164         self._data = {}
 165
 166     def start(self):
 167         print "CpuWatcher.start"
 168         self._pid = self.run_cpuwatch()
 169         print self._pid
 170
 171     def stop(self):
 172         print "CpuWatcher.stop"
 173         if self._pid:
 174             print self._pid
 175             data = self.kill_cpuwatch(pid=self._pid)
 176             self._data = RawDataProcess.process(data)
 177             print "---------------------------------"
 178             print self._data
 179             print "---------------------------------"
 180
 181     def result(self, **kwargs):
 182         return self._data
 183
 184
 185 def unit_test():
 186     pass
 187
 188
 189 if __name__ == '__main__':
 190     unit_test()