path: root/yardstick/network_services/libs/ixia_libs/IxNet/IxNet.py

# Copyright (c) 2016-2017 Intel Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from __future__ import absolute_import
from __future__ import print_function
import sys
import logging

import re
from itertools import product

log = logging.getLogger(__name__)

IP_VERSION_4 = 4
IP_VERSION_6 = 6


class TrafficStreamHelper(object):

    TEMPLATE = '{0.traffic_item}/{0.stream}:{0.param_id}/{1}'

    def __init__(self, traffic_item, stream, param_id):
        super(TrafficStreamHelper, self).__init__()
        self.traffic_item = traffic_item
        self.stream = stream
        self.param_id = param_id

    def __getattr__(self, item):
        return self.TEMPLATE.format(self, item)


class FramesizeHelper(object):

    def __init__(self):
        super(FramesizeHelper, self).__init__()
        self.weighted_pairs = []
        self.weighted_range_pairs = []

    @property
    def weighted_pairs_arg(self):
        return '-weightedPairs', self.weighted_pairs

    @property
    def weighted_range_pairs_arg(self):
        return '-weightedRangePairs', self.weighted_range_pairs

    def make_args(self, *args):
        return self.weighted_pairs_arg + self.weighted_range_pairs_arg + args

    def populate_data(self, framesize_data):
        for key, value in framesize_data.items():
            if value == '0':
                continue

            replaced = re.sub('[Bb]', '', key)
            self.weighted_pairs.extend([
                replaced,
                value,
            ])
            pairs = [
                replaced,
                replaced,
                value,
            ]
            self.weighted_range_pairs.append(pairs)


class IxNextgen(object):

    STATS_NAME_MAP = {
        "traffic_item": 'Traffic Item',
        "Tx_Frames": 'Tx Frames',
        "Rx_Frames": 'Rx Frames',
        "Tx_Frame_Rate": 'Tx Frame Rate',
        "Rx_Frame_Rate": 'Tx Frame Rate',
        "Store-Forward_Avg_latency_ns": 'Store-Forward Avg Latency (ns)',
        "Store-Forward_Min_latency_ns": 'Store-Forward Min Latency (ns)',
        "Store-Forward_Max_latency_ns": 'Store-Forward Max Latency (ns)',
    }

    PORT_STATS_NAME_MAP = {
        "stat_name": 'Stat Name',
        "Frames_Tx": 'Frames Tx.',
        "Valid_Frames_Rx": 'Valid Frames Rx.',
        "Frames_Tx_Rate": 'Frames Tx. Rate',
        "Valid_Frames_Rx_Rate": 'Valid Frames Rx. Rate',
        "Tx_Rate_Kbps": 'Tx. Rate (Kbps)',
        "Rx_Rate_Kbps": 'Rx. Rate (Kbps)',
        "Tx_Rate_Mbps": 'Tx. Rate (Mbps)',
        "Rx_Rate_Mbps": 'Rx. Rate (Mbps)',
    }

    LATENCY_NAME_MAP = {
        "Store-Forward_Avg_latency_ns": 'Store-Forward Avg Latency (ns)',
        "Store-Forward_Min_latency_ns": 'Store-Forward Min Latency (ns)',
        "Store-Forward_Max_latency_ns": 'Store-Forward Max Latency (ns)',
    }

    RANDOM_MASK_MAP = {
        IP_VERSION_4: '0.0.0.255',
        IP_VERSION_6: '0:0:0:0:0:0:0:ff',
    }

    MODE_SEEDS_MAP = {
        0: ('uplink', ['256', '2048']),
    }

    MODE_SEEDS_DEFAULT = 'downlink', ['2048', '256']

    @staticmethod
    def find_view_obj(view_name, views):
        edited_view_name = '::ixNet::OBJ-/statistics/view:"{}"'.format(view_name)
        return next((view for view in views if edited_view_name == view), '')

    @staticmethod
    def get_config(tg_cfg):
        card = []
        port = []
        external_interface = tg_cfg["vdu"][0]["external-interface"]
        for intf in external_interface:
            card_port0 = intf["virtual-interface"]["vpci"]
            card0, port0 = card_port0.split(':')[:2]
            card.append(card0)
            port.append(port0)

        cfg = {
            'py_lib_path': tg_cfg["mgmt-interface"]["tg-config"]["py_lib_path"],
            'machine': tg_cfg["mgmt-interface"]["ip"],
            'port': tg_cfg["mgmt-interface"]["tg-config"]["tcl_port"],
            'chassis': tg_cfg["mgmt-interface"]["tg-config"]["ixchassis"],
            'cards': card,
            'ports': port,
            'output_dir': tg_cfg["mgmt-interface"]["tg-config"]["dut_result_dir"],
            'version': tg_cfg["mgmt-interface"]["tg-config"]["version"],
            'bidir': True,
        }

        return cfg

    def __init__(self, ixnet=None):
        self.ixnet = ixnet
        self._objRefs = dict()
        self._cfg = None
        self._logger = logging.getLogger(__name__)
        self._params = None
        self._bidir = None

    def iter_over_get_lists(self, x1, x2, y2, offset=0):
        for x in self.ixnet.getList(x1, x2):
            y_list = self.ixnet.getList(x, y2)
            for i, y in enumerate(y_list, offset):
                yield x, y, i

    def set_random_ip_multi_attribute(self, ipv4, seed, fixed_bits, random_mask, l3_count):
        self.ixnet.setMultiAttribute(
            ipv4,
            '-seed', str(seed),
            '-fixedBits', str(fixed_bits),
            '-randomMask', str(random_mask),
            '-valueType', 'random',
            '-countValue', str(l3_count))

    def set_random_ip_multi_attributes(self, ip, version, seeds, l3):
        try:
            random_mask = self.RANDOM_MASK_MAP[version]
        except KeyError:
            raise ValueError('Unknown version %s' % version)

        l3_count = l3['count']
        if "srcIp" in ip:
            fixed_bits = l3['srcip4']
            self.set_random_ip_multi_attribute(ip, seeds[0], fixed_bits, random_mask, l3_count)
        if "dstIp" in ip:
            fixed_bits = l3['dstip4']
            self.set_random_ip_multi_attribute(ip, seeds[1], fixed_bits, random_mask, l3_count)

    def add_ip_header(self, params, version):
        for it, ep, i in self.iter_over_get_lists('/traffic', 'trafficItem', "configElement", 1):
            iter1 = (v['outer_l3'] for v in params.values() if str(v['id']) == str(i))
            try:
                l3 = next(iter1, {})
                seeds = self.MODE_SEEDS_MAP.get(i, self.MODE_SEEDS_DEFAULT)[1]
            except (KeyError, IndexError):
                continue

            for ip, ip_bits, _ in self.iter_over_get_lists(ep, 'stack', 'field'):
                self.set_random_ip_multi_attributes(ip_bits, version, seeds, l3)

        self.ixnet.commit()

    def _connect(self, tg_cfg):
        self._cfg = self.get_config(tg_cfg)

        sys.path.append(self._cfg["py_lib_path"])
        # Import IxNetwork after getting ixia lib path
        try:
            import IxNetwork
        except ImportError:
            raise

        self.ixnet = IxNetwork.IxNet()

        machine = self._cfg['machine']
        port = str(self._cfg['port'])
        version = str(self._cfg['version'])
        result = self.ixnet.connect(machine, '-port', port, '-version', version)
        return result

    def clear_ixia_config(self):
        self.ixnet.execute('newConfig')

    def load_ixia_profile(self, profile):
        self.ixnet.execute('loadConfig', self.ixnet.readFrom(profile))

    def ix_load_config(self, profile):
        self.clear_ixia_config()
        self.load_ixia_profile(profile)

    def ix_assign_ports(self):
        vports = self.ixnet.getList(self.ixnet.getRoot(), 'vport')
        ports = []

        chassis = self._cfg['chassis']
        ports = [(chassis, card, port) for card, port in
                 zip(self._cfg['cards'], self._cfg['ports'])]

        vport_list = self.ixnet.getList("/", "vport")
        self.ixnet.execute('assignPorts', ports, [], vport_list, True)
        self.ixnet.commit()

        for vport in vports:
            if self.ixnet.getAttribute(vport, '-state') != 'up':
                log.error("Both thr ports are down...")

    def ix_update_frame(self, params):
        streams = ["configElement"]

        for param in params.values():
            framesize_data = FramesizeHelper()
            traffic_items = self.ixnet.getList('/traffic', 'trafficItem')
            param_id = param['id']
            for traffic_item, stream in product(traffic_items, streams):
                helper = TrafficStreamHelper(traffic_item, stream, param_id)

                self.ixnet.setMultiAttribute(helper.transmissionControl,
                                             '-type', '{0}'.format(param.get('traffic_type',
                                                                             'continuous')),
                                             '-duration', '{0}'.format(param.get('duration',
                                                                                 "30")))

                stream_frame_rate_path = helper.frameRate
                self.ixnet.setMultiAttribute(stream_frame_rate_path, '-rate', param['iload'])
                if param['outer_l2']['framesPerSecond']:
                    self.ixnet.setMultiAttribute(stream_frame_rate_path,
                                                 '-type', 'framesPerSecond')

                framesize_data.populate_data(param['outer_l2']['framesize'])

                make_attr_args = framesize_data.make_args('-incrementFrom', '66',
                                                          '-randomMin', '66',
                                                          '-quadGaussian', [],
                                                          '-type', 'weightedPairs',
                                                          '-presetDistribution', 'cisco',
                                                          '-incrementTo', '1518')

                self.ixnet.setMultiAttribute(helper.frameSize, *make_attr_args)

                self.ixnet.commit()

    def update_ether_multi_attribute(self, ether, mac_addr):
        self.ixnet.setMultiAttribute(ether,
                                     '-singleValue', mac_addr,
                                     '-fieldValue', mac_addr,
                                     '-valueType', 'singleValue')

    def update_ether_multi_attributes(self, ether, l2):
        if "ethernet.header.destinationAddress" in ether:
            self.update_ether_multi_attribute(ether, str(l2.get('dstmac', "00:00:00:00:00:02")))

        if "ethernet.header.sourceAddress" in ether:
            self.update_ether_multi_attribute(ether, str(l2.get('srcmac', "00:00:00:00:00:01")))

    def ix_update_ether(self, params):
        for ti, ep, index in self.iter_over_get_lists('/traffic', 'trafficItem',
                                                      "configElement", 1):
            iter1 = (v['outer_l2'] for v in params.values() if str(v['id']) == str(index))
            try:
                l2 = next(iter1, {})
            except KeyError:
                continue

            for ip, ether, _ in self.iter_over_get_lists(ep, 'stack', 'field'):
                self.update_ether_multi_attributes(ether, l2)

        self.ixnet.commit()

    def ix_update_udp(self, params):
        pass

    def ix_update_tcp(self, params):
        pass

    def ix_start_traffic(self):
        tis = self.ixnet.getList('/traffic', 'trafficItem')
        for ti in tis:
            self.ixnet.execute('generate', [ti])
            self.ixnet.execute('apply', '/traffic')
            self.ixnet.execute('start', '/traffic')

    def ix_stop_traffic(self):
        tis = self.ixnet.getList('/traffic', 'trafficItem')
        for _ in tis:
            self.ixnet.execute('stop', '/traffic')

    def build_stats_map(self, view_obj, name_map):
        return {kl: self.execute_get_column_values(view_obj, kr) for kl, kr in name_map.items()}

    def execute_get_column_values(self, view_obj, name):
        return self.ixnet.execute('getColumnValues', view_obj, name)

    def ix_get_statistics(self):
        views = self.ixnet.getList('/statistics', 'view')
        stats = {}
        view_obj = self.find_view_obj("Traffic Item Statistics", views)
        stats = self.build_stats_map(view_obj, self.STATS_NAME_MAP)

        view_obj = self.find_view_obj("Port Statistics", views)
        ports_stats = self.build_stats_map(view_obj, self.PORT_STATS_NAME_MAP)

        view_obj = self.find_view_obj("Flow Statistics", views)
        stats["latency"] = self.build_stats_map(view_obj, self.LATENCY_NAME_MAP)

        return stats, ports_stats