vstf/vstf/controller/sw_perf/perf_provider.py

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