testsuites/vstf/vstf_scripts/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
  30     def __init__(self, flows_info, tool_info, tester_info):
  31         self._flows_info = flows_info
  32         self._tool_info = tool_info
  33         self._tester_info = tester_info
  34
  35     def _islation(self):
  36         flows = self._flows_info["flows"]
  37         if flows == 2 and self._flows_info["senders"][0][
  38                 "agent"] == self._flows_info["senders"][1]["agent"]:
  39             return True
  40         return False
  41
  42     def get_senders(self, tool, protocol):
  43         result = []
  44         flows = self._flows_info["flows"]
  45         if self._islation() and "pktgen" == tool:
  46             sender = {
  47                 "agent": self._flows_info["senders"][0]["agent"],
  48                 "params": {
  49                     "protocol": protocol,
  50                     "namespace": None,
  51                     "src": [],
  52                     "dst": [],
  53                     "time": self._tool_info[tool]["time"],
  54                     "threads": self._tool_info[tool]["threads"]
  55                 }
  56             }
  57             for i in range(flows):
  58                 sender['params']['src'].append(
  59                     self._flows_info["senders"][i]['dev'])
  60                 sender['params']['dst'].append(
  61                     self._flows_info["receivers"][i]['dev'])
  62             result.append(sender)
  63         else:
  64             for i in range(flows):
  65                 sender = {
  66                     "agent": self._flows_info["senders"][i]["agent"],
  67                     "params": {
  68                         "protocol": protocol,
  69                         "namespace": None if "netmap" == tool else self._flows_info["senders"][i]['dev']['namespace'],
  70                         "src": [
  71                             self._flows_info["senders"][i]['dev']],
  72                         "dst": [
  73                             self._flows_info["receivers"][i]['dev']],
  74                         "time": self._tool_info[tool]["time"],
  75                         "threads": self._tool_info[tool]["threads"]}}
  76                 result.append(sender)
  77         return result
  78
  79     def get_receivers(self, tool, protocol):
  80         result = []
  81         flows = self._flows_info["flows"]
  82         if self._islation() and "pktgen" == tool:
  83             receiver = {
  84                 "agent": self._flows_info["receivers"][0]["agent"],
  85                 "params": {
  86                     "namespace": None,
  87                     "protocol": protocol,
  88                 }
  89             }
  90             result.append(receiver)
  91         else:
  92             for i in range(flows):
  93                 receiver = {
  94                     "agent": self._flows_info["receivers"][i]["agent"],
  95                     "params": {
  96                         "namespace": None if "netmap" == tool else self._flows_info["receivers"][i]['dev']['namespace'],
  97                         "protocol": protocol,
  98                         "dst": [
  99                             self._flows_info["receivers"][i]['dev']]}}
 100                 result.append(receiver)
 101         return result
 102
 103     def get_watchers(self, tool):
 104         result = []
 105         for watcher in self._flows_info["watchers"]:
 106             node = {
 107                 "agent": watcher["agent"],
 108                 "params": {
 109                     "iface": watcher['dev']["iface"],
 110                     "namespace": None if tool in [
 111                         "pktgen",
 112                         "netmap"] else watcher['dev']["namespace"],
 113                 }}
 114             result.append(node)
 115         return result
 116
 117     def get_namespaces(self, tool):
 118         result = []
 119
 120         for watcher in self._flows_info["namespaces"]:
 121             node = {
 122                 "agent": watcher["agent"],
 123                 "params": {
 124                     "iface": watcher['dev']["iface"],
 125                     "namespace": watcher['dev']["namespace"] if tool not in [
 126                         "pktgen",
 127                         "netmap"] else None,
 128                     "ip": watcher['dev']["ip"] +
 129                     '/24',
 130                 }}
 131             result.append(node)
 132         return result
 133
 134     @property
 135     def get_cpuwatcher(self):
 136         LOG.info(self._flows_info["cpu_listens"])
 137         result = {
 138             "agent": self._flows_info["cpu_listens"][0]["agent"],
 139             "params": {
 140             }
 141         }
 142         return result
 143
 144     @property
 145     def get_cpu_affctl(self):
 146         LOG.info(self._flows_info["cpu_listens"])
 147         result = {
 148             "agent": self._flows_info["cpu_listens"][0]["agent"],
 149             "params": {
 150                 "policy": self._flows_info["cpu_listens"][0]["affctl"]["policy"]
 151             }
 152         }
 153         return result
 154
 155     def get_cleaners(self, tool, protocol):
 156         nodes = self.get_senders(tool, protocol) + \
 157             self.get_receivers(tool, protocol) + \
 158             self.get_watchers(tool) + \
 159             [self.get_cpuwatcher]
 160         return get_agent_dict(nodes).keys()
 161
 162     @property
 163     def get_testers(self):
 164         agents = get_agent_dict(self._flows_info["namespaces"]).keys()
 165         result = []
 166         for agent in agents:
 167             node = {
 168                 "agent": agent,
 169                 "params": {
 170                     "drivers": self._tester_info["drivers"]
 171                 }
 172             }
 173             result.append(node)
 174         return result
 175
 176     def duration(self, tool):
 177         return self._tool_info[tool]["time"]
 178
 179     def wait_balance(self, tool):
 180         return self._tool_info[tool]["wait"]
 181
 182
 183 def unit_test():
 184     from vstf.common.log import setup_logging
 185     setup_logging(
 186         level=logging.DEBUG,
 187         log_file="/var/log/vstf/vstf-perf-provider.log",
 188         clevel=logging.INFO)
 189
 190     from vstf.controller.settings.flows_settings import FlowsSettings
 191     from vstf.controller.settings.tool_settings import ToolSettings
 192     from vstf.controller.settings.tester_settings import TesterSettings
 193
 194     flows_settings = FlowsSettings()
 195     tool_settings = ToolSettings()
 196     tester_settings = TesterSettings()
 197
 198     provider = PerfProvider(
 199         flows_settings.settings,
 200         tool_settings.settings,
 201         tester_settings.settings)
 202
 203     tools = ['pktgen']
 204     protocols = ['udp_bw', 'udp_lat']
 205
 206     for tool in tools:
 207         LOG.info(tool)
 208         for protocol in protocols:
 209             LOG.info(protocol)
 210             senders = provider.get_senders(tool, protocols)
 211             LOG.info(len(senders))
 212             LOG.info(senders)
 213
 214             receivers = provider.get_receivers(tool, protocols)
 215             LOG.info(len(receivers))
 216             LOG.info(receivers)
 217
 218         LOG.info(provider.get_cpuwatcher)
 219         LOG.info(provider.get_watchers(tool))
 220         LOG.info(provider.get_namespaces(tool))
 221         LOG.info(provider.duration(tool))
 222
 223
 224 if __name__ == '__main__':
 225     unit_test()