vstf/vstf/controller/sw_perf/perf_provider.py

   1 #!/usr/bin/python
   2 # -*- coding: utf8 -*-
   3 # author: wly
   4 # date: 2015-09-21
   5 # see license for license details
   6
   7 import logging
   8
   9 LOG = logging.getLogger(__name__)
  10
  11
  12 def get_agent_dict(nodes):
  13     """
  14     :param:
  15         nodes: list of flow info
  16                and ever element must be a dict and kas key "agent"
  17     :return : list for agent
  18     :rtype : dict
  19     """
  20     agent_list = map(lambda x: x["agent"], nodes)
  21     return {}.fromkeys(agent_list, False)
  22
  23
  24 class PerfProvider(object):
  25     def __init__(self, flows_info, tool_info, tester_info):
  26         self._flows_info = flows_info
  27         self._tool_info = tool_info
  28         self._tester_info = tester_info
  29
  30     def _islation(self):
  31         flows = self._flows_info["flows"]
  32         if flows == 2 and self._flows_info["senders"][0]["agent"] == self._flows_info["senders"][1]["agent"]:
  33             return True
  34         return False
  35
  36     def get_senders(self, tool, protocol):
  37         result = []
  38         flows = self._flows_info["flows"]
  39         if self._islation() and "pktgen" == tool:
  40             sender = {
  41                 "agent": self._flows_info["senders"][0]["agent"],
  42                 "params": {
  43                     "protocol": protocol,
  44                     "namespace": None,
  45                     "src": [],
  46                     "dst": [],
  47                     "time": self._tool_info[tool]["time"],
  48                     "threads": self._tool_info[tool]["threads"]
  49                 }
  50             }
  51             for i in range(flows):
  52                 sender['params']['src'].append(self._flows_info["senders"][i]['dev'])
  53                 sender['params']['dst'].append(self._flows_info["receivers"][i]['dev'])
  54             result.append(sender)
  55         else:
  56             for i in range(flows):
  57                 sender = {
  58                     "agent": self._flows_info["senders"][i]["agent"],
  59                     "params": {
  60                         "protocol": protocol,
  61                         "namespace": None if "netmap" == tool else self._flows_info["senders"][i]['dev']['namespace'],
  62                         "src": [self._flows_info["senders"][i]['dev']],
  63                         "dst": [self._flows_info["receivers"][i]['dev']],
  64                         "time": self._tool_info[tool]["time"],
  65                         "threads": self._tool_info[tool]["threads"]
  66                     }
  67                 }
  68                 result.append(sender)
  69         return result
  70
  71     def get_receivers(self, tool, protocol):
  72         result = []
  73         flows = self._flows_info["flows"]
  74         if self._islation() and "pktgen" == tool:
  75             receiver = {
  76                 "agent": self._flows_info["receivers"][0]["agent"],
  77                 "params": {
  78                     "namespace": None,
  79                     "protocol": protocol,
  80                 }
  81             }
  82             result.append(receiver)
  83         else:
  84             for i in range(flows):
  85                 receiver = {
  86                     "agent": self._flows_info["receivers"][i]["agent"],
  87                     "params": {
  88                         "namespace": None if "netmap" == tool else self._flows_info["receivers"][i]['dev']['namespace'],
  89                         "protocol": protocol,
  90                         "dst": [self._flows_info["receivers"][i]['dev']]
  91                     }
  92                 }
  93                 result.append(receiver)
  94         return result
  95
  96     def get_watchers(self, tool):
  97         result = []
  98         for watcher in self._flows_info["watchers"]:
  99             node = {
 100                 "agent": watcher["agent"],
 101                 "params": {
 102                     "iface": watcher['dev']["iface"],
 103                     "namespace": None if tool in ["pktgen", "netmap"] else watcher['dev']["namespace"],
 104                 }
 105             }
 106             result.append(node)
 107         return result
 108
 109     def get_namespaces(self, tool):
 110         result = []
 111
 112         for watcher in self._flows_info["namespaces"]:
 113             node = {
 114                 "agent": watcher["agent"],
 115                 "params": {
 116                     "iface": watcher['dev']["iface"],
 117                     "namespace": watcher['dev']["namespace"] if tool not in ["pktgen", "netmap"] else None,
 118                     "ip": watcher['dev']["ip"] + '/24',
 119                 }
 120             }
 121             result.append(node)
 122         return result
 123
 124     @property
 125     def get_cpuwatcher(self):
 126         LOG.info(self._flows_info["cpu_listens"])
 127         result = {
 128             "agent": self._flows_info["cpu_listens"][0]["agent"],
 129             "params": {
 130             }
 131         }
 132         return result
 133
 134     @property
 135     def get_cpu_affctl(self):
 136         LOG.info(self._flows_info["cpu_listens"])
 137         result = {
 138             "agent": self._flows_info["cpu_listens"][0]["agent"],
 139             "params": {
 140                 "policy": self._flows_info["cpu_listens"][0]["affctl"]["policy"]
 141             }
 142         }
 143         return result
 144
 145     def get_cleaners(self, tool, protocol):
 146         nodes = self.get_senders(tool, protocol) + \
 147             self.get_receivers(tool, protocol) + \
 148             self.get_watchers(tool) + \
 149             [self.get_cpuwatcher]
 150         return get_agent_dict(nodes).keys()
 151
 152     @property
 153     def get_testers(self):
 154         agents = get_agent_dict(self._flows_info["namespaces"]).keys()
 155         result = []
 156         for agent in agents:
 157             node = {
 158                 "agent": agent,
 159                 "params": {
 160                     "drivers": self._tester_info["drivers"]
 161                 }
 162             }
 163             result.append(node)
 164         return result
 165
 166     def duration(self, tool):
 167         return self._tool_info[tool]["time"]
 168
 169     def wait_balance(self, tool):
 170         return self._tool_info[tool]["wait"]
 171
 172
 173 def unit_test():
 174     from vstf.common.log import setup_logging
 175     setup_logging(level=logging.DEBUG, log_file="/var/log/vstf/vstf-perf-provider.log", clevel=logging.INFO)
 176
 177     from vstf.controller.settings.flows_settings import FlowsSettings
 178     from vstf.controller.settings.tool_settings import ToolSettings
 179     from vstf.controller.settings.tester_settings import TesterSettings
 180
 181     flows_settings = FlowsSettings()
 182     tool_settings = ToolSettings()
 183     tester_settings = TesterSettings()
 184
 185     provider = PerfProvider(flows_settings.settings, tool_settings.settings, tester_settings.settings)
 186
 187     tools = ['pktgen']
 188     protocols = ['udp_bw', 'udp_lat']
 189
 190     for tool in tools:
 191         LOG.info(tool)
 192         for protocol in protocols:
 193             LOG.info(protocol)
 194             senders = provider.get_senders(tool, protocols)
 195             LOG.info(len(senders))
 196             LOG.info(senders)
 197
 198             receivers = provider.get_receivers(tool, protocols)
 199             LOG.info(len(receivers))
 200             LOG.info(receivers)
 201
 202         LOG.info(provider.get_cpuwatcher)
 203         LOG.info(provider.get_watchers(tool))
 204         LOG.info(provider.get_namespaces(tool))
 205         LOG.info(provider.duration(tool))
 206
 207
 208 if __name__ == '__main__':
 209     unit_test()