yardstick/network_services/libs/ixia_libs/IxNet/IxNet.py

   1 # Copyright (c) 2016-2017 Intel Corporation
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #      http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 from __future__ import absolute_import
  16 from __future__ import print_function
  17 import sys
  18 import logging
  19
  20 import re
  21 from itertools import product
  22
  23 log = logging.getLogger(__name__)
  24
  25 IP_VERSION_4 = 4
  26 IP_VERSION_6 = 6
  27
  28
  29 class TrafficStreamHelper(object):
  30
  31     TEMPLATE = '{0.traffic_item}/{0.stream}:{0.param_id}/{1}'
  32
  33     def __init__(self, traffic_item, stream, param_id):
  34         super(TrafficStreamHelper, self).__init__()
  35         self.traffic_item = traffic_item
  36         self.stream = stream
  37         self.param_id = param_id
  38
  39     def __getattr__(self, item):
  40         return self.TEMPLATE.format(self, item)
  41
  42
  43 class FramesizeHelper(object):
  44
  45     def __init__(self):
  46         super(FramesizeHelper, self).__init__()
  47         self.weighted_pairs = []
  48         self.weighted_range_pairs = []
  49
  50     @property
  51     def weighted_pairs_arg(self):
  52         return '-weightedPairs', self.weighted_pairs
  53
  54     @property
  55     def weighted_range_pairs_arg(self):
  56         return '-weightedRangePairs', self.weighted_range_pairs
  57
  58     def make_args(self, *args):
  59         return self.weighted_pairs_arg + self.weighted_range_pairs_arg + args
  60
  61     def populate_data(self, framesize_data):
  62         for key, value in framesize_data.items():
  63             if value == '0':
  64                 continue
  65
  66             replaced = re.sub('[Bb]', '', key)
  67             self.weighted_pairs.extend([
  68                 replaced,
  69                 value,
  70             ])
  71             pairs = [
  72                 replaced,
  73                 replaced,
  74                 value,
  75             ]
  76             self.weighted_range_pairs.append(pairs)
  77
  78
  79 class IxNextgen(object):
  80
  81     STATS_NAME_MAP = {
  82         "traffic_item": 'Traffic Item',
  83         "Tx_Frames": 'Tx Frames',
  84         "Rx_Frames": 'Rx Frames',
  85         "Tx_Frame_Rate": 'Tx Frame Rate',
  86         "Rx_Frame_Rate": 'Tx Frame Rate',
  87         "Store-Forward_Avg_latency_ns": 'Store-Forward Avg Latency (ns)',
  88         "Store-Forward_Min_latency_ns": 'Store-Forward Min Latency (ns)',
  89         "Store-Forward_Max_latency_ns": 'Store-Forward Max Latency (ns)',
  90     }
  91
  92     PORT_STATS_NAME_MAP = {
  93         "stat_name": 'Stat Name',
  94         "Frames_Tx": 'Frames Tx.',
  95         "Valid_Frames_Rx": 'Valid Frames Rx.',
  96         "Frames_Tx_Rate": 'Frames Tx. Rate',
  97         "Valid_Frames_Rx_Rate": 'Valid Frames Rx. Rate',
  98         "Tx_Rate_Kbps": 'Tx. Rate (Kbps)',
  99         "Rx_Rate_Kbps": 'Rx. Rate (Kbps)',
 100         "Tx_Rate_Mbps": 'Tx. Rate (Mbps)',
 101         "Rx_Rate_Mbps": 'Rx. Rate (Mbps)',
 102     }
 103
 104     LATENCY_NAME_MAP = {
 105         "Store-Forward_Avg_latency_ns": 'Store-Forward Avg Latency (ns)',
 106         "Store-Forward_Min_latency_ns": 'Store-Forward Min Latency (ns)',
 107         "Store-Forward_Max_latency_ns": 'Store-Forward Max Latency (ns)',
 108     }
 109
 110     RANDOM_MASK_MAP = {
 111         IP_VERSION_4: '0.0.0.255',
 112         IP_VERSION_6: '0:0:0:0:0:0:0:ff',
 113     }
 114
 115     MODE_SEEDS_MAP = {
 116         0: ('private_1', ['256', '2048']),
 117     }
 118
 119     MODE_SEEDS_DEFAULT = 'public_1', ['2048', '256']
 120
 121     @staticmethod
 122     def find_view_obj(view_name, views):
 123         edited_view_name = '::ixNet::OBJ-/statistics/view:"{}"'.format(view_name)
 124         return next((view for view in views if edited_view_name == view), '')
 125
 126     @staticmethod
 127     def get_config(tg_cfg):
 128         external_interface = tg_cfg["vdu"][0]["external-interface"]
 129         card_port0 = external_interface[0]["virtual-interface"]["vpci"]
 130         card_port1 = external_interface[1]["virtual-interface"]["vpci"]
 131         card0, port0 = card_port0.split(':')[:2]
 132         card1, port1 = card_port1.split(':')[:2]
 133         cfg = {
 134             'py_lib_path': tg_cfg["mgmt-interface"]["tg-config"]["py_lib_path"],
 135             'machine': tg_cfg["mgmt-interface"]["ip"],
 136             'port': tg_cfg["mgmt-interface"]["tg-config"]["tcl_port"],
 137             'chassis': tg_cfg["mgmt-interface"]["tg-config"]["ixchassis"],
 138             'card1': card0,
 139             'port1': port0,
 140             'card2': card1,
 141             'port2': port1,
 142             'output_dir': tg_cfg["mgmt-interface"]["tg-config"]["dut_result_dir"],
 143             'version': tg_cfg["mgmt-interface"]["tg-config"]["version"],
 144             'bidir': True,
 145         }
 146         return cfg
 147
 148     def __init__(self, ixnet=None):
 149         self.ixnet = ixnet
 150         self._objRefs = dict()
 151         self._cfg = None
 152         self._logger = logging.getLogger(__name__)
 153         self._params = None
 154         self._bidir = None
 155
 156     def iter_over_get_lists(self, x1, x2, y2, offset=0):
 157         for x in self.ixnet.getList(x1, x2):
 158             y_list = self.ixnet.getList(x, y2)
 159             for i, y in enumerate(y_list, offset):
 160                 yield x, y, i
 161
 162     def set_random_ip_multi_attribute(self, ipv4, seed, fixed_bits, random_mask, l3_count):
 163         self.ixnet.setMultiAttribute(
 164             ipv4,
 165             '-seed', str(seed),
 166             '-fixedBits', str(fixed_bits),
 167             '-randomMask', str(random_mask),
 168             '-valueType', 'random',
 169             '-countValue', str(l3_count))
 170
 171     def set_random_ip_multi_attributes(self, ip, version, seeds, l3):
 172         try:
 173             random_mask = self.RANDOM_MASK_MAP[version]
 174         except KeyError:
 175             raise ValueError('Unknown version %s' % version)
 176
 177         l3_count = l3['count']
 178         if "srcIp" in ip:
 179             fixed_bits = l3['srcip4']
 180             self.set_random_ip_multi_attribute(ip, seeds[0], fixed_bits, random_mask, l3_count)
 181         if "dstIp" in ip:
 182             fixed_bits = l3['dstip4']
 183             self.set_random_ip_multi_attribute(ip, seeds[1], fixed_bits, random_mask, l3_count)
 184
 185     def add_ip_header(self, params, version):
 186         for it, ep, i in self.iter_over_get_lists('/traffic', 'trafficItem', "configElement"):
 187             mode, seeds = self.MODE_SEEDS_MAP.get(i, self.MODE_SEEDS_DEFAULT)
 188             l3 = params[mode]['outer_l3']
 189
 190             for ip, ip_bits, _ in self.iter_over_get_lists(ep, 'stack', 'field'):
 191                 self.set_random_ip_multi_attributes(ip_bits, version, seeds, l3)
 192
 193         self.ixnet.commit()
 194
 195     def _connect(self, tg_cfg):
 196         self._cfg = self.get_config(tg_cfg)
 197
 198         sys.path.append(self._cfg["py_lib_path"])
 199         # Import IxNetwork after getting ixia lib path
 200         try:
 201             import IxNetwork
 202         except ImportError:
 203             raise
 204
 205         self.ixnet = IxNetwork.IxNet()
 206
 207         machine = self._cfg['machine']
 208         port = str(self._cfg['port'])
 209         version = str(self._cfg['version'])
 210         result = self.ixnet.connect(machine, '-port', port, '-version', version)
 211         return result
 212
 213     def clear_ixia_config(self):
 214         self.ixnet.execute('newConfig')
 215
 216     def load_ixia_profile(self, profile):
 217         self.ixnet.execute('loadConfig', self.ixnet.readFrom(profile))
 218
 219     def ix_load_config(self, profile):
 220         self.clear_ixia_config()
 221         self.load_ixia_profile(profile)
 222
 223     def ix_assign_ports(self):
 224         vports = self.ixnet.getList(self.ixnet.getRoot(), 'vport')
 225         ports = [
 226             (self._cfg['chassis'], self._cfg['card1'], self._cfg['port1']),
 227             (self._cfg['chassis'], self._cfg['card2'], self._cfg['port2']),
 228         ]
 229
 230         vport_list = self.ixnet.getList("/", "vport")
 231         self.ixnet.execute('assignPorts', ports, [], vport_list, True)
 232         self.ixnet.commit()
 233
 234         for vport in vports:
 235             if self.ixnet.getAttribute(vport, '-state') != 'up':
 236                 log.error("Both thr ports are down...")
 237
 238     def ix_update_frame(self, params):
 239         streams = ["configElement"]
 240
 241         for param in params.values():
 242             framesize_data = FramesizeHelper()
 243             traffic_items = self.ixnet.getList('/traffic', 'trafficItem')
 244             param_id = param['id']
 245             for traffic_item, stream in product(traffic_items, streams):
 246                 helper = TrafficStreamHelper(traffic_item, stream, param_id)
 247
 248                 self.ixnet.setMultiAttribute(helper.transmissionControl,
 249                                              '-type', '{0}'.format(param['traffic_type']),
 250                                              '-duration', '{0}'.format(param['duration']))
 251
 252                 stream_frame_rate_path = helper.frameRate
 253                 self.ixnet.setMultiAttribute(stream_frame_rate_path, '-rate', param['iload'])
 254                 if param['outer_l2']['framesPerSecond']:
 255                     self.ixnet.setMultiAttribute(stream_frame_rate_path,
 256                                                  '-type', 'framesPerSecond')
 257
 258                 framesize_data.populate_data(param['outer_l2']['framesize'])
 259
 260                 make_attr_args = framesize_data.make_args('-incrementFrom', '66',
 261                                                           '-randomMin', '66',
 262                                                           '-quadGaussian', [],
 263                                                           '-type', 'weightedPairs',
 264                                                           '-presetDistribution', 'cisco',
 265                                                           '-incrementTo', '1518')
 266
 267                 self.ixnet.setMultiAttribute(helper.frameSize, *make_attr_args)
 268
 269                 self.ixnet.commit()
 270
 271     def update_ether_multi_attribute(self, ether, mac_addr):
 272         self.ixnet.setMultiAttribute(ether,
 273                                      '-singleValue', mac_addr,
 274                                      '-fieldValue', mac_addr,
 275                                      '-valueType', 'singleValue')
 276
 277     def update_ether_multi_attributes(self, ether, l2):
 278         if "ethernet.header.destinationAddress" in ether:
 279             self.update_ether_multi_attribute(ether, str(l2['dstmac']))
 280
 281         if "ethernet.header.sourceAddress" in ether:
 282             self.update_ether_multi_attribute(ether, str(l2['srcmac']))
 283
 284     def ix_update_ether(self, params):
 285         for ti, ep, index in self.iter_over_get_lists('/traffic', 'trafficItem',
 286                                                       "configElement", 1):
 287             iter1 = (v['outer_l2'] for v in params.values() if str(v['id']) == str(index))
 288             try:
 289                 l2 = next(iter1, {})
 290             except KeyError:
 291                 continue
 292
 293             for ip, ether, _ in self.iter_over_get_lists(ep, 'stack', 'field'):
 294                 self.update_ether_multi_attributes(ether, l2)
 295
 296         self.ixnet.commit()
 297
 298     def ix_update_udp(self, params):
 299         pass
 300
 301     def ix_update_tcp(self, params):
 302         pass
 303
 304     def ix_start_traffic(self):
 305         tis = self.ixnet.getList('/traffic', 'trafficItem')
 306         for ti in tis:
 307             self.ixnet.execute('generate', [ti])
 308             self.ixnet.execute('apply', '/traffic')
 309             self.ixnet.execute('start', '/traffic')
 310
 311     def ix_stop_traffic(self):
 312         tis = self.ixnet.getList('/traffic', 'trafficItem')
 313         for _ in tis:
 314             self.ixnet.execute('stop', '/traffic')
 315
 316     def build_stats_map(self, view_obj, name_map):
 317         return {kl: self.execute_get_column_values(view_obj, kr) for kl, kr in name_map.items()}
 318
 319     def execute_get_column_values(self, view_obj, name):
 320         return self.ixnet.execute('getColumnValues', view_obj, name)
 321
 322     def ix_get_statistics(self):
 323         views = self.ixnet.getList('/statistics', 'view')
 324         stats = {}
 325         view_obj = self.find_view_obj("Traffic Item Statistics", views)
 326         stats = self.build_stats_map(view_obj, self.STATS_NAME_MAP)
 327
 328         view_obj = self.find_view_obj("Port Statistics", views)
 329         ports_stats = self.build_stats_map(view_obj, self.PORT_STATS_NAME_MAP)
 330
 331         view_obj = self.find_view_obj("Flow Statistics", views)
 332         stats["latency"] = self.build_stats_map(view_obj, self.LATENCY_NAME_MAP)
 333
 334         return stats, ports_stats