resources/libraries/python/InterfaceUtil.py

   1 # Copyright (c) 2019 Cisco and/or its affiliates.
   2 # Licensed under the Apache License, Version 2.0 (the "License");
   3 # you may not use this file except in compliance with the License.
   4 # You may obtain a copy of the License at:
   5 #
   6 #     http://www.apache.org/licenses/LICENSE-2.0
   7 #
   8 # Unless required by applicable law or agreed to in writing, software
   9 # distributed under the License is distributed on an "AS IS" BASIS,
  10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  11 # See the License for the specific language governing permissions and
  12 # limitations under the License.
  13
  14 """Interface util library."""
  15
  16 from socket import AF_INET, AF_INET6, inet_ntop, inet_pton
  17 from time import sleep
  18
  19 from enum import IntEnum
  20 from ipaddress import IPv4Address, IPv6Address
  21 from ipaddress import AddressValueError, NetmaskValueError
  22 from robot.api import logger
  23
  24 from resources.libraries.python.Constants import Constants
  25 from resources.libraries.python.CpuUtils import CpuUtils
  26 from resources.libraries.python.DUTSetup import DUTSetup
  27 from resources.libraries.python.IPUtil import convert_ipv4_netmask_prefix
  28 from resources.libraries.python.L2Util import L2Util
  29 from resources.libraries.python.PapiExecutor import PapiExecutor
  30 from resources.libraries.python.parsers.JsonParser import JsonParser
  31 from resources.libraries.python.ssh import SSH, exec_cmd_no_error
  32 from resources.libraries.python.topology import NodeType, Topology
  33 from resources.libraries.python.VPPUtil import VPPUtil
  34
  35
  36 class LinkBondLoadBalance(IntEnum):
  37     """Link bonding load balance."""
  38     L2 = 0
  39     L34 = 1
  40     L23 = 2
  41
  42
  43 class LinkBondMode(IntEnum):
  44     """Link bonding load balance."""
  45     ROUND_ROBIN = 1
  46     ACTIVE_BACKUP = 2
  47     XOR = 3
  48     BROADCAST = 4
  49     LACP = 5
  50
  51
  52 class InterfaceUtil(object):
  53     """General utilities for managing interfaces"""
  54
  55     __UDEV_IF_RULES_FILE = '/etc/udev/rules.d/10-network.rules'
  56
  57     @staticmethod
  58     def pci_to_int(pci_str):
  59         """Convert PCI address from string format (0000:18:0a.0) to
  60         integer representation (169345024).
  61
  62         :param pci_str: PCI address in string representation.
  63         :type pci_str: str
  64         :returns: Integer representation of PCI address.
  65         :rtype: int
  66         """
  67
  68         pci = list(pci_str.split(':')[0:2])
  69         pci.extend(pci_str.split(':')[2].split('.'))
  70
  71         return (int(pci[0], 16) | int(pci[1], 16) << 16 |
  72                 int(pci[2], 16) << 24 | int(pci[3], 16) << 29)
  73
  74     @staticmethod
  75     def get_interface_index(node, interface):
  76         """Get interface sw_if_index from topology file.
  77
  78         :param node: Node where the interface is.
  79         :param interface: Numeric index or name string of a specific interface.
  80         :type node: dict
  81         :type interface: str or int
  82         :returns: SW interface index.
  83         :rtype: int
  84         """
  85
  86         try:
  87             sw_if_index = int(interface)
  88         except ValueError:
  89             sw_if_index = Topology.get_interface_sw_index(node, interface)
  90             if sw_if_index is None:
  91                 sw_if_index = \
  92                     Topology.get_interface_sw_index_by_name(node, interface)
  93         except TypeError as err:
  94             raise TypeError('Wrong interface format {ifc}: {err}'.format(
  95                 ifc=interface, err=err.message))
  96
  97         return sw_if_index
  98
  99     @staticmethod
 100     def set_interface_state(node, interface, state, if_type='key'):
 101         """Set interface state on a node.
 102
 103         Function can be used for DUTs as well as for TGs.
 104
 105         :param node: Node where the interface is.
 106         :param interface: Interface key or sw_if_index or name.
 107         :param state: One of 'up' or 'down'.
 108         :param if_type: Interface type
 109         :type node: dict
 110         :type interface: str or int
 111         :type state: str
 112         :type if_type: str
 113         :returns: Nothing.
 114         :raises ValueError: If the interface type is unknown.
 115         :raises ValueError: If the state of interface is unexpected.
 116         :raises ValueError: If the node has an unknown node type.
 117         """
 118
 119         if if_type == 'key':
 120             if isinstance(interface, basestring):
 121                 sw_if_index = Topology.get_interface_sw_index(node, interface)
 122                 iface_name = Topology.get_interface_name(node, interface)
 123             else:
 124                 sw_if_index = interface
 125         elif if_type == 'name':
 126             iface_key = Topology.get_interface_by_name(node, interface)
 127             if iface_key is not None:
 128                 sw_if_index = Topology.get_interface_sw_index(node, iface_key)
 129             iface_name = interface
 130         else:
 131             raise ValueError('Unknown if_type: {type}'.format(type=if_type))
 132
 133         if node['type'] == NodeType.DUT:
 134             if state == 'up':
 135                 admin_up_down = 1
 136             elif state == 'down':
 137                 admin_up_down = 0
 138             else:
 139                 raise ValueError('Unexpected interface state: {state}'.format(
 140                     state=state))
 141             cmd = 'sw_interface_set_flags'
 142             err_msg = 'Failed to set interface state on host {host}'.format(
 143                 host=node['host'])
 144             args = dict(sw_if_index=sw_if_index,
 145                         admin_up_down=admin_up_down)
 146             with PapiExecutor(node) as papi_exec:
 147                 papi_exec.add(cmd, **args).get_replies(err_msg).\
 148                     verify_reply(err_msg=err_msg)
 149         elif node['type'] == NodeType.TG or node['type'] == NodeType.VM:
 150             cmd = 'ip link set {ifc} {state}'.format(
 151                 ifc=iface_name, state=state)
 152             exec_cmd_no_error(node, cmd, sudo=True)
 153         else:
 154             raise ValueError('Node {} has unknown NodeType: "{}"'
 155                              .format(node['host'], node['type']))
 156
 157     @staticmethod
 158     def set_interface_ethernet_mtu(node, iface_key, mtu):
 159         """Set Ethernet MTU for specified interface.
 160
 161         Function can be used only for TGs.
 162
 163         :param node: Node where the interface is.
 164         :param iface_key: Interface key from topology file.
 165         :param mtu: MTU to set.
 166         :type node: dict
 167         :type iface_key: str
 168         :type mtu: int
 169         :returns: Nothing.
 170         :raises ValueError: If the node type is "DUT".
 171         :raises ValueError: If the node has an unknown node type.
 172         """
 173
 174         if node['type'] == NodeType.DUT:
 175             raise ValueError('Node {}: Setting Ethernet MTU for interface '
 176                              'on DUT nodes not supported', node['host'])
 177         elif node['type'] == NodeType.TG:
 178             iface_name = Topology.get_interface_name(node, iface_key)
 179             cmd = 'ip link set {} mtu {}'.format(iface_name, mtu)
 180             exec_cmd_no_error(node, cmd, sudo=True)
 181         else:
 182             raise ValueError('Node {} has unknown NodeType: "{}"'
 183                              .format(node['host'], node['type']))
 184
 185     @staticmethod
 186     def set_default_ethernet_mtu_on_all_interfaces_on_node(node):
 187         """Set default Ethernet MTU on all interfaces on node.
 188
 189         Function can be used only for TGs.
 190
 191         :param node: Node where to set default MTU.
 192         :type node: dict
 193         :returns: Nothing.
 194         """
 195
 196         for ifc in node['interfaces']:
 197             InterfaceUtil.set_interface_ethernet_mtu(node, ifc, 1500)
 198
 199     @staticmethod
 200     def vpp_set_interface_mtu(node, interface, mtu=9200):
 201         """Set Ethernet MTU on interface.
 202
 203         :param node: VPP node.
 204         :param interface: Interface to setup MTU. Default: 9200.
 205         :param mtu: Ethernet MTU size in Bytes.
 206         :type node: dict
 207         :type interface: str or int
 208         :type mtu: int
 209         """
 210
 211         if isinstance(interface, basestring):
 212             sw_if_index = Topology.get_interface_sw_index(node, interface)
 213         else:
 214             sw_if_index = interface
 215
 216         cmd = 'hw_interface_set_mtu'
 217         err_msg = 'Failed to set interface MTU on host {host}'.format(
 218             host=node['host'])
 219         args = dict(sw_if_index=sw_if_index,
 220                     mtu=int(mtu))
 221         with PapiExecutor(node) as papi_exec:
 222             papi_exec.add(cmd, **args).get_replies(err_msg).\
 223                 verify_reply(err_msg=err_msg)
 224
 225     @staticmethod
 226     def vpp_set_interfaces_mtu_on_node(node, mtu=9200):
 227         """Set Ethernet MTU on all interfaces.
 228
 229         :param node: VPP node.
 230         :param mtu: Ethernet MTU size in Bytes. Default: 9200.
 231         :type node: dict
 232         :type mtu: int
 233         """
 234
 235         for interface in node['interfaces']:
 236             InterfaceUtil.vpp_set_interface_mtu(node, interface, mtu)
 237
 238     @staticmethod
 239     def vpp_set_interfaces_mtu_on_all_duts(nodes, mtu=9200):
 240         """Set Ethernet MTU on all interfaces on all DUTs.
 241
 242         :param nodes: VPP nodes.
 243         :param mtu: Ethernet MTU size in Bytes. Default: 9200.
 244         :type nodes: dict
 245         :type mtu: int
 246         """
 247
 248         for node in nodes.values():
 249             if node['type'] == NodeType.DUT:
 250                 InterfaceUtil.vpp_set_interfaces_mtu_on_node(node, mtu)
 251
 252     @staticmethod
 253     def vpp_node_interfaces_ready_wait(node, retries=15):
 254         """Wait until all interfaces with admin-up are in link-up state.
 255
 256         :param node: Node to wait on.
 257         :param retries: Number of retries to check interface status (optional,
 258             default 15).
 259         :type node: dict
 260         :type retries: int
 261         :returns: Nothing.
 262         :raises RuntimeError: If any interface is not in link-up state after
 263             defined number of retries.
 264         """
 265
 266         for _ in xrange(0, retries):
 267             not_ready = list()
 268             out = InterfaceUtil.vpp_get_interface_data(node)
 269             for interface in out:
 270                 if interface.get('admin_up_down') == 1:
 271                     if interface.get('link_up_down') != 1:
 272                         not_ready.append(interface.get('interface_name'))
 273             if not not_ready:
 274                 break
 275             else:
 276                 logger.debug('Interfaces still in link-down state:\n{ifs} '
 277                              '\nWaiting...'.format(ifs=not_ready))
 278                 sleep(1)
 279         else:
 280             err = 'Timeout, interfaces not up:\n{ifs}'.format(ifs=not_ready) \
 281                 if 'not_ready' in locals() else 'No check executed!'
 282             raise RuntimeError(err)
 283
 284     @staticmethod
 285     def all_vpp_interfaces_ready_wait(nodes, retries=15):
 286         """Wait until all interfaces with admin-up are in link-up state for all
 287         nodes in the topology.
 288
 289         :param nodes: Nodes in the topology.
 290         :param retries: Number of retries to check interface status (optional,
 291             default 15).
 292         :type nodes: dict
 293         :type retries: int
 294         :returns: Nothing.
 295         """
 296
 297         for node in nodes.values():
 298             if node['type'] == NodeType.DUT:
 299                 InterfaceUtil.vpp_node_interfaces_ready_wait(node, retries)
 300
 301     @staticmethod
 302     def vpp_get_interface_data(node, interface=None):
 303         """Get all interface data from a VPP node. If a name or
 304         sw_interface_index is provided, return only data for the matching
 305         interface(s).
 306
 307         :param node: VPP node to get interface data from.
 308         :param interface: Numeric index or name string of a specific interface.
 309         :type node: dict
 310         :type interface: int or str
 311         :returns: List of dictionaries containing data for each interface, or a
 312             single dictionary for the specified interface.
 313         :rtype: list or dict
 314         :raises TypeError: if the data type of interface is neither basestring
 315             nor int.
 316         """
 317
 318         if interface is not None:
 319             if isinstance(interface, basestring):
 320                 param = 'interface_name'
 321             elif isinstance(interface, int):
 322                 param = 'sw_if_index'
 323             else:
 324                 raise TypeError('Wrong interface format {ifc}'.format(
 325                     ifc=interface))
 326         else:
 327             param = ''
 328
 329         cmd = 'sw_interface_dump'
 330         cmd_reply = 'sw_interface_details'
 331         args = dict(name_filter_valid=0,
 332                     name_filter='')
 333         err_msg = 'Failed to get interface dump on host {host}'.format(
 334             host=node['host'])
 335         with PapiExecutor(node) as papi_exec:
 336             papi_resp = papi_exec.add(cmd, **args).get_dump(err_msg)
 337
 338         papi_if_dump = papi_resp.reply[0]['api_reply']
 339
 340         def process_if_dump(if_dump):
 341             """Process interface dump.
 342
 343             :param if_dump: Interface dump.
 344             :type if_dump: dict
 345             :returns: Processed interface dump.
 346             :rtype: dict
 347             """
 348             if_dump['interface_name'] = if_dump['interface_name'].rstrip('\x00')
 349             if_dump['tag'] = if_dump['tag'].rstrip('\x00')
 350             if_dump['l2_address'] = L2Util.bin_to_mac(if_dump['l2_address'])
 351             if_dump['b_dmac'] = L2Util.bin_to_mac(if_dump['b_dmac'])
 352             if_dump['b_smac'] = L2Util.bin_to_mac(if_dump['b_smac'])
 353             return if_dump
 354
 355         data = list() if interface is None else dict()
 356         for item in papi_if_dump:
 357             if interface is None:
 358                 data.append(process_if_dump(item[cmd_reply]))
 359             elif str(item[cmd_reply].get(param)).rstrip('\x00') == \
 360                     str(interface):
 361                 data = process_if_dump(item[cmd_reply])
 362                 break
 363
 364         logger.debug('Interface data:\n{if_data}'.format(if_data=data))
 365         return data
 366
 367     @staticmethod
 368     def vpp_get_interface_name(node, sw_if_index):
 369         """Get interface name for the given SW interface index from actual
 370         interface dump.
 371
 372         :param node: VPP node to get interface data from.
 373         :param sw_if_index: SW interface index of the specific interface.
 374         :type node: dict
 375         :type sw_if_index: int
 376         :returns: Name of the given interface.
 377         :rtype: str
 378         """
 379
 380         if_data = InterfaceUtil.vpp_get_interface_data(node, sw_if_index)
 381         if if_data['sup_sw_if_index'] != if_data['sw_if_index']:
 382             if_data = InterfaceUtil.vpp_get_interface_data(
 383                 node, if_data['sup_sw_if_index'])
 384
 385         return if_data.get('interface_name')
 386
 387     @staticmethod
 388     def vpp_get_interface_sw_index(node, interface_name):
 389         """Get interface name for the given SW interface index from actual
 390         interface dump.
 391
 392         :param node: VPP node to get interface data from.
 393         :param interface_name: Interface name.
 394         :type node: dict
 395         :type interface_name: str
 396         :returns: Name of the given interface.
 397         :rtype: str
 398         """
 399
 400         if_data = InterfaceUtil.vpp_get_interface_data(node, interface_name)
 401
 402         return if_data.get('sw_if_index')
 403
 404     @staticmethod
 405     def vpp_get_interface_mac(node, interface):
 406         """Get MAC address for the given interface from actual interface dump.
 407
 408         :param node: VPP node to get interface data from.
 409         :param interface: Numeric index or name string of a specific interface.
 410         :type node: dict
 411         :type interface: int or str
 412         :returns: MAC address.
 413         :rtype: str
 414         """
 415
 416         if_data = InterfaceUtil.vpp_get_interface_data(node, interface)
 417         if if_data['sup_sw_if_index'] != if_data['sw_if_index']:
 418             if_data = InterfaceUtil.vpp_get_interface_data(
 419                 node, if_data['sup_sw_if_index'])
 420
 421         return if_data.get('l2_address')
 422
 423     @staticmethod
 424     def vpp_get_interface_ip_addresses(node, interface, ip_version):
 425         """Get list of IP addresses from an interface on a VPP node.
 426
 427         TODO: Move to IPUtils
 428
 429         :param node: VPP node to get data from.
 430         :param interface: Name of an interface on the VPP node.
 431         :param ip_version: IP protocol version (ipv4 or ipv6).
 432         :type node: dict
 433         :type interface: str
 434         :type ip_version: str
 435         :returns: List of dictionaries, each containing IP address, subnet
 436             prefix length and also the subnet mask for ipv4 addresses.
 437             Note: A single interface may have multiple IP addresses assigned.
 438         :rtype: list
 439         """
 440
 441         try:
 442             sw_if_index = Topology.convert_interface_reference(
 443                 node, interface, 'sw_if_index')
 444         except RuntimeError:
 445             if isinstance(interface, basestring):
 446                 sw_if_index = InterfaceUtil.get_sw_if_index(node, interface)
 447             else:
 448                 raise
 449
 450         is_ipv6 = 1 if ip_version == 'ipv6' else 0
 451
 452         cmd = 'ip_address_dump'
 453         cmd_reply = 'ip_address_details'
 454         args = dict(sw_if_index=sw_if_index,
 455                     is_ipv6=is_ipv6)
 456         err_msg = 'Failed to get L2FIB dump on host {host}'.format(
 457             host=node['host'])
 458         with PapiExecutor(node) as papi_exec:
 459             papi_resp = papi_exec.add(cmd, **args).get_dump(err_msg)
 460
 461         data = list()
 462         for item in papi_resp.reply[0]['api_reply']:
 463             item[cmd_reply]['ip'] = inet_ntop(AF_INET6, item[cmd_reply]['ip']) \
 464                 if is_ipv6 else inet_ntop(AF_INET, item[cmd_reply]['ip'][0:4])
 465             data.append(item[cmd_reply])
 466
 467         if ip_version == 'ipv4':
 468             for item in data:
 469                 item['netmask'] = convert_ipv4_netmask_prefix(
 470                     item['prefix_length'])
 471         return data
 472
 473     @staticmethod
 474     def tg_set_interface_driver(node, pci_addr, driver):
 475         """Set interface driver on the TG node.
 476
 477         :param node: Node to set interface driver on (must be TG node).
 478         :param pci_addr: PCI address of the interface.
 479         :param driver: Driver name.
 480         :type node: dict
 481         :type pci_addr: str
 482         :type driver: str
 483         :raises RuntimeError: If unbinding from the current driver fails.
 484         :raises RuntimeError: If binding to the new driver fails.
 485         """
 486         old_driver = InterfaceUtil.tg_get_interface_driver(node, pci_addr)
 487         if old_driver == driver:
 488             return
 489
 490         ssh = SSH()
 491         ssh.connect(node)
 492
 493         # Unbind from current driver
 494         if old_driver is not None:
 495             cmd = 'sh -c "echo {0} > /sys/bus/pci/drivers/{1}/unbind"'\
 496                 .format(pci_addr, old_driver)
 497             (ret_code, _, _) = ssh.exec_command_sudo(cmd)
 498             if int(ret_code) != 0:
 499                 raise RuntimeError("'{0}' failed on '{1}'"
 500                                    .format(cmd, node['host']))
 501
 502         # Bind to the new driver
 503         cmd = 'sh -c "echo {0} > /sys/bus/pci/drivers/{1}/bind"'\
 504             .format(pci_addr, driver)
 505         (ret_code, _, _) = ssh.exec_command_sudo(cmd)
 506         if int(ret_code) != 0:
 507             raise RuntimeError("'{0}' failed on '{1}'"
 508                                .format(cmd, node['host']))
 509
 510     @staticmethod
 511     def tg_get_interface_driver(node, pci_addr):
 512         """Get interface driver from the TG node.
 513
 514         :param node: Node to get interface driver on (must be TG node).
 515         :param pci_addr: PCI address of the interface.
 516         :type node: dict
 517         :type pci_addr: str
 518         :returns: Interface driver or None if not found.
 519         :rtype: str
 520         :raises RuntimeError: If PCI rescan or lspci command execution failed.
 521         """
 522         return DUTSetup.get_pci_dev_driver(node, pci_addr)
 523
 524     @staticmethod
 525     def tg_set_interfaces_udev_rules(node):
 526         """Set udev rules for interfaces.
 527
 528         Create udev rules file in /etc/udev/rules.d where are rules for each
 529         interface used by TG node, based on MAC interface has specific name.
 530         So after unbind and bind again to kernel driver interface has same
 531         name as before. This must be called after TG has set name for each
 532         port in topology dictionary.
 533         udev rule example
 534         SUBSYSTEM=="net", ACTION=="add", ATTR{address}=="52:54:00:e1:8a:0f",
 535         NAME="eth1"
 536
 537         :param node: Node to set udev rules on (must be TG node).
 538         :type node: dict
 539         :raises RuntimeError: If setting of udev rules fails.
 540         """
 541         ssh = SSH()
 542         ssh.connect(node)
 543
 544         cmd = 'rm -f {0}'.format(InterfaceUtil.__UDEV_IF_RULES_FILE)
 545         (ret_code, _, _) = ssh.exec_command_sudo(cmd)
 546         if int(ret_code) != 0:
 547             raise RuntimeError("'{0}' failed on '{1}'"
 548                                .format(cmd, node['host']))
 549
 550         for interface in node['interfaces'].values():
 551             rule = 'SUBSYSTEM==\\"net\\", ACTION==\\"add\\", ATTR{address}' + \
 552                    '==\\"' + interface['mac_address'] + '\\", NAME=\\"' + \
 553                    interface['name'] + '\\"'
 554             cmd = 'sh -c "echo \'{0}\' >> {1}"'.format(
 555                 rule, InterfaceUtil.__UDEV_IF_RULES_FILE)
 556             (ret_code, _, _) = ssh.exec_command_sudo(cmd)
 557             if int(ret_code) != 0:
 558                 raise RuntimeError("'{0}' failed on '{1}'"
 559                                    .format(cmd, node['host']))
 560
 561         cmd = '/etc/init.d/udev restart'
 562         ssh.exec_command_sudo(cmd)
 563
 564     @staticmethod
 565     def tg_set_interfaces_default_driver(node):
 566         """Set interfaces default driver specified in topology yaml file.
 567
 568         :param node: Node to setup interfaces driver on (must be TG node).
 569         :type node: dict
 570         """
 571         for interface in node['interfaces'].values():
 572             InterfaceUtil.tg_set_interface_driver(node,
 573                                                   interface['pci_address'],
 574                                                   interface['driver'])
 575
 576     @staticmethod
 577     def update_vpp_interface_data_on_node(node):
 578         """Update vpp generated interface data for a given node in DICT__nodes.
 579
 580         Updates interface names, software if index numbers and any other details
 581         generated specifically by vpp that are unknown before testcase run.
 582         It does this by dumping interface list from all devices using python
 583         api, and pairing known information from topology (mac address) to state
 584         from VPP.
 585
 586         :param node: Node selected from DICT__nodes.
 587         :type node: dict
 588         """
 589
 590         interface_list = InterfaceUtil.vpp_get_interface_data(node)
 591         interface_dict = dict()
 592         for ifc in interface_list:
 593             interface_dict[ifc['l2_address']] = ifc
 594
 595         for if_name, if_data in node['interfaces'].items():
 596             ifc_dict = interface_dict.get(if_data['mac_address'])
 597             if ifc_dict is not None:
 598                 if_data['name'] = ifc_dict['interface_name']
 599                 if_data['vpp_sw_index'] = ifc_dict['sw_if_index']
 600                 if_data['mtu'] = ifc_dict['mtu'][0]
 601                 logger.trace('Interface {ifc} found by MAC {mac}'.format(
 602                     ifc=if_name, mac=if_data['mac_address']))
 603             else:
 604                 logger.trace('Interface {ifc} not found by MAC {mac}'.format(
 605                     ifc=if_name, mac=if_data['mac_address']))
 606                 if_data['vpp_sw_index'] = None
 607
 608     @staticmethod
 609     def update_nic_interface_names(node):
 610         """Update interface names based on nic type and PCI address.
 611
 612         This method updates interface names in the same format as VPP does.
 613
 614         :param node: Node dictionary.
 615         :type node: dict
 616         """
 617         for ifc in node['interfaces'].values():
 618             if_pci = ifc['pci_address'].replace('.', ':').split(':')
 619             bus = '{:x}'.format(int(if_pci[1], 16))
 620             dev = '{:x}'.format(int(if_pci[2], 16))
 621             fun = '{:x}'.format(int(if_pci[3], 16))
 622             loc = '{bus}/{dev}/{fun}'.format(bus=bus, dev=dev, fun=fun)
 623             if ifc['model'] == 'Intel-XL710':
 624                 ifc['name'] = 'FortyGigabitEthernet{loc}'.format(loc=loc)
 625             elif ifc['model'] == 'Intel-X710':
 626                 ifc['name'] = 'TenGigabitEthernet{loc}'.format(loc=loc)
 627             elif ifc['model'] == 'Intel-X520-DA2':
 628                 ifc['name'] = 'TenGigabitEthernet{loc}'.format(loc=loc)
 629             elif ifc['model'] == 'Cisco-VIC-1385':
 630                 ifc['name'] = 'FortyGigabitEthernet{loc}'.format(loc=loc)
 631             elif ifc['model'] == 'Cisco-VIC-1227':
 632                 ifc['name'] = 'TenGigabitEthernet{loc}'.format(loc=loc)
 633             else:
 634                 ifc['name'] = 'UnknownEthernet{loc}'.format(loc=loc)
 635
 636     @staticmethod
 637     def update_nic_interface_names_on_all_duts(nodes):
 638         """Update interface names based on nic type and PCI address on all DUTs.
 639
 640         This method updates interface names in the same format as VPP does.
 641
 642         :param nodes: Topology nodes.
 643         :type nodes: dict
 644         """
 645         for node in nodes.values():
 646             if node['type'] == NodeType.DUT:
 647                 InterfaceUtil.update_nic_interface_names(node)
 648
 649     @staticmethod
 650     def update_tg_interface_data_on_node(node, skip_tg_udev=False):
 651         """Update interface name for TG/linux node in DICT__nodes.
 652
 653         .. note::
 654             # for dev in `ls /sys/class/net/`;
 655             > do echo "\"`cat /sys/class/net/$dev/address`\": \"$dev\""; done
 656             "52:54:00:9f:82:63": "eth0"
 657             "52:54:00:77:ae:a9": "eth1"
 658             "52:54:00:e1:8a:0f": "eth2"
 659             "00:00:00:00:00:00": "lo"
 660
 661         :param node: Node selected from DICT__nodes.
 662         :param skip_tg_udev: Skip udev rename on TG node.
 663         :type node: dict
 664         :type skip_tg_udev: bool
 665         :raises RuntimeError: If getting of interface name and MAC fails.
 666         """
 667         # First setup interface driver specified in yaml file
 668         InterfaceUtil.tg_set_interfaces_default_driver(node)
 669
 670         # Get interface names
 671         ssh = SSH()
 672         ssh.connect(node)
 673
 674         cmd = ('for dev in `ls /sys/class/net/`; do echo "\\"`cat '
 675                '/sys/class/net/$dev/address`\\": \\"$dev\\""; done;')
 676
 677         (ret_code, stdout, _) = ssh.exec_command(cmd)
 678         if int(ret_code) != 0:
 679             raise RuntimeError('Get interface name and MAC failed')
 680         tmp = "{" + stdout.rstrip().replace('\n', ',') + "}"
 681         interfaces = JsonParser().parse_data(tmp)
 682         for interface in node['interfaces'].values():
 683             name = interfaces.get(interface['mac_address'])
 684             if name is None:
 685                 continue
 686             interface['name'] = name
 687
 688         # Set udev rules for interfaces
 689         if not skip_tg_udev:
 690             InterfaceUtil.tg_set_interfaces_udev_rules(node)
 691
 692     @staticmethod
 693     def iface_update_numa_node(node):
 694         """For all interfaces from topology file update numa node based on
 695            information from the node.
 696
 697         :param node: Node from topology.
 698         :type node: dict
 699         :returns: Nothing.
 700         :raises ValueError: If numa node ia less than 0.
 701         :raises RuntimeError: If update of numa node failes.
 702         """
 703         ssh = SSH()
 704         for if_key in Topology.get_node_interfaces(node):
 705             if_pci = Topology.get_interface_pci_addr(node, if_key)
 706             ssh.connect(node)
 707             cmd = "cat /sys/bus/pci/devices/{}/numa_node".format(if_pci)
 708             for _ in range(3):
 709                 (ret, out, _) = ssh.exec_command(cmd)
 710                 if ret == 0:
 711                     try:
 712                         numa_node = int(out)
 713                         if numa_node < 0:
 714                             if CpuUtils.cpu_node_count(node) == 1:
 715                                 numa_node = 0
 716                             else:
 717                                 raise ValueError
 718                     except ValueError:
 719                         logger.trace('Reading numa location failed for: {0}'
 720                                      .format(if_pci))
 721                     else:
 722                         Topology.set_interface_numa_node(node, if_key,
 723                                                          numa_node)
 724                         break
 725             else:
 726                 raise RuntimeError('Update numa node failed for: {0}'
 727                                    .format(if_pci))
 728
 729     @staticmethod
 730     def update_all_numa_nodes(nodes, skip_tg=False):
 731         """For all nodes and all their interfaces from topology file update numa
 732         node information based on information from the node.
 733
 734         :param nodes: Nodes in the topology.
 735         :param skip_tg: Skip TG node
 736         :type nodes: dict
 737         :type skip_tg: bool
 738         :returns: Nothing.
 739         """
 740         for node in nodes.values():
 741             if node['type'] == NodeType.DUT:
 742                 InterfaceUtil.iface_update_numa_node(node)
 743             elif node['type'] == NodeType.TG and not skip_tg:
 744                 InterfaceUtil.iface_update_numa_node(node)
 745
 746     @staticmethod
 747     def update_all_interface_data_on_all_nodes(nodes, skip_tg=False,
 748                                                skip_tg_udev=False,
 749                                                numa_node=False):
 750         """Update interface names on all nodes in DICT__nodes.
 751
 752         This method updates the topology dictionary by querying interface lists
 753         of all nodes mentioned in the topology dictionary.
 754
 755         :param nodes: Nodes in the topology.
 756         :param skip_tg: Skip TG node.
 757         :param skip_tg_udev: Skip udev rename on TG node.
 758         :param numa_node: Retrieve numa_node location.
 759         :type nodes: dict
 760         :type skip_tg: bool
 761         :type skip_tg_udev: bool
 762         :type numa_node: bool
 763         """
 764         for node_data in nodes.values():
 765             if node_data['type'] == NodeType.DUT:
 766                 InterfaceUtil.update_vpp_interface_data_on_node(node_data)
 767             elif node_data['type'] == NodeType.TG and not skip_tg:
 768                 InterfaceUtil.update_tg_interface_data_on_node(
 769                     node_data, skip_tg_udev)
 770
 771             if numa_node:
 772                 if node_data['type'] == NodeType.DUT:
 773                     InterfaceUtil.iface_update_numa_node(node_data)
 774                 elif node_data['type'] == NodeType.TG and not skip_tg:
 775                     InterfaceUtil.iface_update_numa_node(node_data)
 776
 777     @staticmethod
 778     def create_vlan_subinterface(node, interface, vlan):
 779         """Create VLAN sub-interface on node.
 780
 781         :param node: Node to add VLAN subinterface on.
 782         :param interface: Interface name on which create VLAN subinterface.
 783         :param vlan: VLAN ID of the subinterface to be created.
 784         :type node: dict
 785         :type interface: str
 786         :type vlan: int
 787         :returns: Name and index of created subinterface.
 788         :rtype: tuple
 789         :raises RuntimeError: if it is unable to create VLAN subinterface on the
 790             node.
 791         """
 792
 793         iface_key = Topology.get_interface_by_name(node, interface)
 794         sw_if_index = Topology.get_interface_sw_index(node, iface_key)
 795
 796         cmd = 'create_vlan_subif'
 797         args = dict(sw_if_index=sw_if_index,
 798                     vlan_id=int(vlan))
 799         err_msg = 'Failed to create VLAN sub-interface on host {host}'.format(
 800             host=node['host'])
 801         with PapiExecutor(node) as papi_exec:
 802             papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg).\
 803                 verify_reply(err_msg=err_msg)
 804
 805         sw_if_idx = papi_resp['sw_if_index']
 806         if_key = Topology.add_new_port(node, 'vlan_subif')
 807         Topology.update_interface_sw_if_index(node, if_key, sw_if_idx)
 808         ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_idx)
 809         Topology.update_interface_name(node, if_key, ifc_name)
 810
 811         return '{ifc}.{vlan}'.format(ifc=interface, vlan=vlan), sw_if_idx
 812
 813     @staticmethod
 814     def create_vxlan_interface(node, vni, source_ip, destination_ip):
 815         """Create VXLAN interface and return sw if index of created interface.
 816
 817         :param node: Node where to create VXLAN interface.
 818         :param vni: VXLAN Network Identifier.
 819         :param source_ip: Source IP of a VXLAN Tunnel End Point.
 820         :param destination_ip: Destination IP of a VXLAN Tunnel End Point.
 821         :type node: dict
 822         :type vni: int
 823         :type source_ip: str
 824         :type destination_ip: str
 825         :returns: SW IF INDEX of created interface.
 826         :rtype: int
 827         :raises RuntimeError: if it is unable to create VxLAN interface on the
 828             node.
 829         """
 830
 831         try:
 832             src_address = IPv6Address(unicode(source_ip))
 833             dst_address = IPv6Address(unicode(destination_ip))
 834             af_inet = AF_INET6
 835             is_ipv6 = 1
 836         except (AddressValueError, NetmaskValueError):
 837             src_address = IPv4Address(unicode(source_ip))
 838             dst_address = IPv4Address(unicode(destination_ip))
 839             af_inet = AF_INET
 840             is_ipv6 = 0
 841
 842         cmd = 'vxlan_add_del_tunnel'
 843         args = dict(is_add=1,
 844                     is_ipv6=is_ipv6,
 845                     instance=Constants.BITWISE_NON_ZERO,
 846                     src_address=inet_pton(af_inet, str(src_address)),
 847                     dst_address=inet_pton(af_inet, str(dst_address)),
 848                     mcast_sw_if_index=Constants.BITWISE_NON_ZERO,
 849                     encap_vrf_id=0,
 850                     decap_next_index=Constants.BITWISE_NON_ZERO,
 851                     vni=int(vni))
 852         err_msg = 'Failed to create VXLAN tunnel interface on host {host}'.\
 853             format(host=node['host'])
 854         with PapiExecutor(node) as papi_exec:
 855             papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg).\
 856                 verify_reply(err_msg=err_msg)
 857
 858         sw_if_idx = papi_resp['sw_if_index']
 859         if_key = Topology.add_new_port(node, 'vxlan_tunnel')
 860         Topology.update_interface_sw_if_index(node, if_key, sw_if_idx)
 861         ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_idx)
 862         Topology.update_interface_name(node, if_key, ifc_name)
 863
 864         return sw_if_idx
 865
 866     @staticmethod
 867     def vxlan_dump(node, interface=None):
 868         """Get VxLAN data for the given interface.
 869
 870         :param node: VPP node to get interface data from.
 871         :param interface: Numeric index or name string of a specific interface.
 872             If None, information about all VxLAN interfaces is returned.
 873         :type node: dict
 874         :type interface: int or str
 875         :returns: Dictionary containing data for the given VxLAN interface or if
 876             interface=None, the list of dictionaries with all VxLAN interfaces.
 877         :rtype: dict or list
 878         :raises TypeError: if the data type of interface is neither basestring
 879             nor int.
 880         """
 881
 882         if interface is not None:
 883             sw_if_index = InterfaceUtil.get_interface_index(node, interface)
 884         else:
 885             sw_if_index = int(Constants.BITWISE_NON_ZERO)
 886
 887         cmd = 'vxlan_tunnel_dump'
 888         cmd_reply = 'vxlan_tunnel_details'
 889         args = dict(sw_if_index=sw_if_index)
 890         err_msg = 'Failed to get VXLAN dump on host {host}'.format(
 891             host=node['host'])
 892         with PapiExecutor(node) as papi_exec:
 893             papi_resp = papi_exec.add(cmd, **args).get_dump(err_msg)
 894
 895         papi_vxlan_dump = papi_resp.reply[0]['api_reply']
 896
 897         def process_vxlan_dump(vxlan_dump):
 898             """Process vxlan dump.
 899
 900             :param vxlan_dump: Vxlan interface dump.
 901             :type vxlan_dump: dict
 902             :returns: Processed vxlan interface dump.
 903             :rtype: dict
 904             """
 905             if vxlan_dump['is_ipv6']:
 906                 vxlan_dump['src_address'] = \
 907                     inet_ntop(AF_INET6, vxlan_dump['src_address'])
 908                 vxlan_dump['dst_address'] = \
 909                     inet_ntop(AF_INET6, vxlan_dump['dst_address'])
 910             else:
 911                 vxlan_dump['src_address'] = \
 912                     inet_ntop(AF_INET, vxlan_dump['src_address'][0:4])
 913                 vxlan_dump['dst_address'] = \
 914                     inet_ntop(AF_INET, vxlan_dump['dst_address'][0:4])
 915             return vxlan_dump
 916
 917         data = list() if interface is None else dict()
 918         for item in papi_vxlan_dump:
 919             if interface is None:
 920                 data.append(process_vxlan_dump(item[cmd_reply]))
 921             elif item[cmd_reply]['sw_if_index'] == sw_if_index:
 922                 data = process_vxlan_dump(item[cmd_reply])
 923                 break
 924
 925         logger.debug('VXLAN data:\n{vxlan_data}'.format(vxlan_data=data))
 926         return data
 927
 928     @staticmethod
 929     def vhost_user_dump(node):
 930         """Get vhost-user data for the given node.
 931
 932         TODO: Move to VhostUser.py
 933
 934         :param node: VPP node to get interface data from.
 935         :type node: dict
 936         :returns: List of dictionaries with all vhost-user interfaces.
 937         :rtype: list
 938         """
 939
 940         cmd = 'sw_interface_vhost_user_dump'
 941         cmd_reply = 'sw_interface_vhost_user_details'
 942         err_msg = 'Failed to get vhost-user dump on host {host}'.format(
 943             host=node['host'])
 944         with PapiExecutor(node) as papi_exec:
 945             papi_resp = papi_exec.add(cmd).get_dump(err_msg)
 946
 947         papi_vxlan_dump = papi_resp.reply[0]['api_reply']
 948
 949         def process_vhost_dump(vhost_dump):
 950             """Process vhost dump.
 951
 952             :param vhost_dump: Vhost interface dump.
 953             :type vhost_dump: dict
 954             :returns: Processed vhost interface dump.
 955             :rtype: dict
 956             """
 957             vhost_dump['interface_name'] = \
 958                 vhost_dump['interface_name'].rstrip('\x00')
 959             vhost_dump['sock_filename'] = \
 960                 vhost_dump['sock_filename'].rstrip('\x00')
 961             return vhost_dump
 962
 963         data = list()
 964         for item in papi_vxlan_dump:
 965             data.append(process_vhost_dump(item[cmd_reply]))
 966
 967         logger.debug('Vhost-user data:\n{vhost_data}'.format(vhost_data=data))
 968         return data
 969
 970     @staticmethod
 971     def tap_dump(node, name=None):
 972         """Get all TAP interface data from the given node, or data about
 973         a specific TAP interface.
 974
 975         TODO: Move to Tap.py
 976
 977         :param node: VPP node to get data from.
 978         :param name: Optional name of a specific TAP interface.
 979         :type node: dict
 980         :type name: str
 981         :returns: Dictionary of information about a specific TAP interface, or
 982             a List of dictionaries containing all TAP data for the given node.
 983         :rtype: dict or list
 984         """
 985
 986         cmd = 'sw_interface_tap_v2_dump'
 987         cmd_reply = 'sw_interface_tap_v2_details'
 988         err_msg = 'Failed to get TAP dump on host {host}'.format(
 989             host=node['host'])
 990         with PapiExecutor(node) as papi_exec:
 991             papi_resp = papi_exec.add(cmd).get_dump(err_msg)
 992
 993         papi_tap_dump = papi_resp.reply[0]['api_reply']
 994
 995         def process_tap_dump(tap_dump):
 996             """Process tap dump.
 997
 998             :param tap_dump: Tap interface dump.
 999             :type tap_dump: dict
1000             :returns: Processed tap interface dump.
1001             :rtype: dict
1002             """
1003             tap_dump['dev_name'] = tap_dump['dev_name'].rstrip('\x00')
1004             tap_dump['host_if_name'] = tap_dump['host_if_name'].rstrip('\x00')
1005             tap_dump['host_namespace'] = \
1006                 tap_dump['host_namespace'].rstrip('\x00')
1007             tap_dump['host_mac_addr'] = \
1008                 L2Util.bin_to_mac(tap_dump['host_mac_addr'])
1009             tap_dump['host_ip4_addr'] = \
1010                 inet_ntop(AF_INET, tap_dump['host_ip4_addr'])
1011             tap_dump['host_ip6_addr'] = \
1012                 inet_ntop(AF_INET6, tap_dump['host_ip6_addr'])
1013             return tap_dump
1014
1015         data = list() if name is None else dict()
1016         for item in papi_tap_dump:
1017             if name is None:
1018                 data.append(process_tap_dump(item[cmd_reply]))
1019             elif item[cmd_reply].get('dev_name').rstrip('\x00') == name:
1020                 data = process_tap_dump(item[cmd_reply])
1021                 break
1022
1023         logger.debug('TAP data:\n{tap_data}'.format(tap_data=data))
1024         return data
1025
1026     @staticmethod
1027     def create_subinterface(node, interface, sub_id, outer_vlan_id=None,
1028                             inner_vlan_id=None, type_subif=None):
1029         """Create sub-interface on node. It is possible to set required
1030         sub-interface type and VLAN tag(s).
1031
1032         :param node: Node to add sub-interface.
1033         :param interface: Interface name on which create sub-interface.
1034         :param sub_id: ID of the sub-interface to be created.
1035         :param outer_vlan_id: Optional outer VLAN ID.
1036         :param inner_vlan_id: Optional inner VLAN ID.
1037         :param type_subif: Optional type of sub-interface. Values supported by
1038             VPP: [no_tags] [one_tag] [two_tags] [dot1ad] [exact_match]
1039             [default_sub]
1040         :type node: dict
1041         :type interface: str or int
1042         :type sub_id: int
1043         :type outer_vlan_id: int
1044         :type inner_vlan_id: int
1045         :type type_subif: str
1046         :returns: Name and index of created sub-interface.
1047         :rtype: tuple
1048         :raises RuntimeError: If it is not possible to create sub-interface.
1049         """
1050
1051         subif_types = type_subif.split()
1052
1053         cmd = 'create_subif'
1054         args = dict(
1055             sw_if_index=InterfaceUtil.get_interface_index(node, interface),
1056             sub_id=int(sub_id),
1057             no_tags=1 if 'no_tags' in subif_types else 0,
1058             one_tag=1 if 'one_tag' in subif_types else 0,
1059             two_tags=1 if 'two_tags' in subif_types else 0,
1060             dot1ad=1 if 'dot1ad' in subif_types else 0,
1061             exact_match=1 if 'exact_match' in subif_types else 0,
1062             default_sub=1 if 'default_sub' in subif_types else 0,
1063             outer_vlan_id_any=1 if type_subif == 'default_sub' else 0,
1064             inner_vlan_id_any=1 if type_subif == 'default_sub' else 0,
1065             outer_vlan_id=int(outer_vlan_id) if outer_vlan_id else 0,
1066             inner_vlan_id=int(inner_vlan_id) if inner_vlan_id else 0)
1067         err_msg = 'Failed to create sub-interface on host {host}'.format(
1068             host=node['host'])
1069         with PapiExecutor(node) as papi_exec:
1070             papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg).\
1071                 verify_reply(err_msg=err_msg)
1072
1073         sw_subif_idx = papi_resp['sw_if_index']
1074         if_key = Topology.add_new_port(node, 'subinterface')
1075         Topology.update_interface_sw_if_index(node, if_key, sw_subif_idx)
1076         ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_subif_idx)
1077         Topology.update_interface_name(node, if_key, ifc_name)
1078
1079         return '{ifc}.{s_id}'.format(ifc=interface, s_id=sub_id), sw_subif_idx
1080
1081     @staticmethod
1082     def create_gre_tunnel_interface(node, source_ip, destination_ip):
1083         """Create GRE tunnel interface on node.
1084
1085         :param node: VPP node to add tunnel interface.
1086         :param source_ip: Source of the GRE tunnel.
1087         :param destination_ip: Destination of the GRE tunnel.
1088         :type node: dict
1089         :type source_ip: str
1090         :type destination_ip: str
1091         :returns: Name and index of created GRE tunnel interface.
1092         :rtype: tuple
1093         :raises RuntimeError: If unable to create GRE tunnel interface.
1094         """
1095
1096         cmd = 'gre_tunnel_add_del'
1097         tunnel = dict(type=0,
1098                       instance=Constants.BITWISE_NON_ZERO,
1099                       src=str(source_ip),
1100                       dst=str(destination_ip),
1101                       outer_fib_id=0,
1102                       session_id=0)
1103         args = dict(is_add=1,
1104                     tunnel=tunnel)
1105         err_msg = 'Failed to create GRE tunnel interface on host {host}'.format(
1106             host=node['host'])
1107         with PapiExecutor(node) as papi_exec:
1108             papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg).\
1109                 verify_reply(err_msg=err_msg)
1110
1111         sw_if_idx = papi_resp['sw_if_index']
1112         if_key = Topology.add_new_port(node, 'gre_tunnel')
1113         Topology.update_interface_sw_if_index(node, if_key, sw_if_idx)
1114         ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_idx)
1115         Topology.update_interface_name(node, if_key, ifc_name)
1116
1117         return ifc_name, sw_if_idx
1118
1119     @staticmethod
1120     def vpp_create_loopback(node):
1121         """Create loopback interface on VPP node.
1122
1123         :param node: Node to create loopback interface on.
1124         :type node: dict
1125         :returns: SW interface index.
1126         :rtype: int
1127         :raises RuntimeError: If it is not possible to create loopback on the
1128             node.
1129         """
1130
1131         cmd = 'create_loopback'
1132         args = dict(mac_address=0)
1133         err_msg = 'Failed to create loopback interface on host {host}'.format(
1134             host=node['host'])
1135         with PapiExecutor(node) as papi_exec:
1136             papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg).\
1137                 verify_reply(err_msg=err_msg)
1138
1139         sw_if_idx = papi_resp['sw_if_index']
1140         if_key = Topology.add_new_port(node, 'loopback')
1141         Topology.update_interface_sw_if_index(node, if_key, sw_if_idx)
1142         ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_idx)
1143         Topology.update_interface_name(node, if_key, ifc_name)
1144
1145         return sw_if_idx
1146
1147     @staticmethod
1148     def vpp_create_bond_interface(node, mode, load_balance=None, mac=None):
1149         """Create bond interface on VPP node.
1150
1151         :param node: DUT node from topology.
1152         :param mode: Link bonding mode.
1153         :param load_balance: Load balance (optional, valid for xor and lacp
1154             modes, otherwise ignored).
1155         :param mac: MAC address to assign to the bond interface (optional).
1156         :type node: dict
1157         :type mode: str
1158         :type load_balance: str
1159         :type mac: str
1160         :returns: Interface key (name) in topology.
1161         :rtype: str
1162         :raises RuntimeError: If it is not possible to create bond interface on
1163             the node.
1164         """
1165
1166         cmd = 'bond_create'
1167         args = dict(id=int(Constants.BITWISE_NON_ZERO),
1168                     use_custom_mac=0 if mac is None else 1,
1169                     mac_address=0 if mac is None else L2Util.mac_to_bin(mac),
1170                     mode=getattr(LinkBondMode, '{md}'.format(
1171                         md=mode.replace('-', '_').upper())).value,
1172                     lb=0 if load_balance is None else getattr(
1173                         LinkBondLoadBalance, '{lb}'.format(
1174                             lb=load_balance.upper())).value)
1175         err_msg = 'Failed to create bond interface on host {host}'.format(
1176             host=node['host'])
1177         with PapiExecutor(node) as papi_exec:
1178             papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg).\
1179                 verify_reply(err_msg=err_msg)
1180
1181         sw_if_idx = papi_resp['sw_if_index']
1182         InterfaceUtil.add_eth_interface(node, sw_if_idx=sw_if_idx,
1183                                         ifc_pfx='eth_bond')
1184         if_key = Topology.get_interface_by_sw_index(node, sw_if_idx)
1185
1186         return if_key
1187
1188     @staticmethod
1189     def add_eth_interface(node, ifc_name=None, sw_if_idx=None, ifc_pfx=None):
1190         """Add ethernet interface to current topology.
1191
1192         :param node: DUT node from topology.
1193         :param ifc_name: Name of the interface.
1194         :param sw_if_idx: SW interface index.
1195         :param ifc_pfx: Interface key prefix.
1196         :type node: dict
1197         :type ifc_name: str
1198         :type sw_if_idx: int
1199         :type ifc_pfx: str
1200         """
1201
1202         if_key = Topology.add_new_port(node, ifc_pfx)
1203
1204         if ifc_name and sw_if_idx is None:
1205             sw_if_idx = InterfaceUtil.vpp_get_interface_sw_index(node, ifc_name)
1206         Topology.update_interface_sw_if_index(node, if_key, sw_if_idx)
1207         if sw_if_idx and ifc_name is None:
1208             ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_idx)
1209         Topology.update_interface_name(node, if_key, ifc_name)
1210         ifc_mac = InterfaceUtil.vpp_get_interface_mac(node, sw_if_idx)
1211         Topology.update_interface_mac_address(node, if_key, ifc_mac)
1212
1213     @staticmethod
1214     def vpp_create_avf_interface(node, vf_pci_addr, num_rx_queues=None):
1215         """Create AVF interface on VPP node.
1216
1217         :param node: DUT node from topology.
1218         :param vf_pci_addr: Virtual Function PCI address.
1219         :param num_rx_queues: Number of RX queues.
1220         :type node: dict
1221         :type vf_pci_addr: str
1222         :type num_rx_queues: int
1223         :returns: Interface key (name) in topology.
1224         :rtype: str
1225         :raises RuntimeError: If it is not possible to create AVF interface on
1226             the node.
1227         """
1228
1229         cmd = 'avf_create'
1230         args = dict(pci_addr=InterfaceUtil.pci_to_int(vf_pci_addr),
1231                     enable_elog=0,
1232                     rxq_num=int(num_rx_queues) if num_rx_queues else 0,
1233                     rxq_size=0,
1234                     txq_size=0)
1235         err_msg = 'Failed to create AVF interface on host {host}'.format(
1236             host=node['host'])
1237         with PapiExecutor(node) as papi_exec:
1238             papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg).\
1239                 verify_reply(err_msg=err_msg)
1240
1241         sw_if_idx = papi_resp['sw_if_index']
1242         InterfaceUtil.add_eth_interface(node, sw_if_idx=sw_if_idx,
1243                                         ifc_pfx='eth_avf')
1244         if_key = Topology.get_interface_by_sw_index(node, sw_if_idx)
1245
1246         return if_key
1247
1248     @staticmethod
1249     def vpp_enslave_physical_interface(node, interface, bond_if):
1250         """Enslave physical interface to bond interface on VPP node.
1251
1252         :param node: DUT node from topology.
1253         :param interface: Physical interface key from topology file.
1254         :param bond_if: Load balance
1255         :type node: dict
1256         :type interface: str
1257         :type bond_if: str
1258         :raises RuntimeError: If it is not possible to enslave physical
1259             interface to bond interface on the node.
1260         """
1261
1262         cmd = 'bond_enslave'
1263         args = dict(
1264             sw_if_index=Topology.get_interface_sw_index(node, interface),
1265             bond_sw_if_index=Topology.get_interface_sw_index(node, bond_if),
1266             is_passive=0,
1267             is_long_timeout=0)
1268         err_msg = 'Failed to enslave physical interface {ifc} to bond ' \
1269                   'interface {bond} on host {host}'.format(ifc=interface,
1270                                                            bond=bond_if,
1271                                                            host=node['host'])
1272         with PapiExecutor(node) as papi_exec:
1273             papi_exec.add(cmd, **args).get_replies(err_msg).\
1274                 verify_reply(err_msg=err_msg)
1275
1276     @staticmethod
1277     def vpp_show_bond_data_on_node(node, details=False):
1278         """Show (detailed) bond information on VPP node.
1279
1280         :param node: DUT node from topology.
1281         :param details: If detailed information is required or not.
1282         :type node: dict
1283         :type details: bool
1284         """
1285
1286         cmd = 'sw_interface_bond_dump'
1287         cmd_reply = 'sw_interface_bond_details'
1288         err_msg = 'Failed to get bond interface dump on host {host}'.format(
1289             host=node['host'])
1290
1291         data = ('Bond data on node {host}:\n'.format(host=node['host']))
1292         with PapiExecutor(node) as papi_exec:
1293             papi_resp = papi_exec.add(cmd).get_dump(err_msg)
1294
1295         papi_dump = papi_resp.reply[0]['api_reply']
1296         for item in papi_dump:
1297             data += ('{b}\n'.format(b=item[cmd_reply]['interface_name'].
1298                                     rstrip('\x00')))
1299             data += ('  mode: {m}\n'.
1300                      format(m=LinkBondMode(item[cmd_reply]['mode']).name.
1301                             lower()))
1302             data += ('  load balance: {lb}\n'.
1303                      format(lb=LinkBondLoadBalance(item[cmd_reply]['lb']).name.
1304                             lower()))
1305             data += ('  number of active slaves: {n}\n'.
1306                      format(n=item[cmd_reply]['active_slaves']))
1307             if details:
1308                 slave_data = InterfaceUtil.vpp_bond_slave_dump(
1309                     node, Topology.get_interface_by_sw_index(
1310                         node, item[cmd_reply]['sw_if_index']))
1311                 for slave in slave_data:
1312                     if not slave['is_passive']:
1313                         data += ('    {s}\n'.format(s=slave['interface_name']))
1314             data += ('  number of slaves: {n}\n'.
1315                      format(n=item[cmd_reply]['slaves']))
1316             if details:
1317                 for slave in slave_data:
1318                     data += ('    {s}\n'.format(s=slave['interface_name']))
1319             data += ('  interface id: {i}\n'.
1320                      format(i=item[cmd_reply]['id']))
1321             data += ('  sw_if_index: {i}\n'.
1322                      format(i=item[cmd_reply]['sw_if_index']))
1323         logger.info(data)
1324
1325     @staticmethod
1326     def vpp_bond_slave_dump(node, interface):
1327         """Get bond interface slave(s) data on VPP node.
1328
1329         :param node: DUT node from topology.
1330         :param interface: Physical interface key from topology file.
1331         :type node: dict
1332         :type interface: str
1333         :returns: Bond slave interface data.
1334         :rtype: dict
1335         """
1336         cmd = 'sw_interface_slave_dump'
1337         cmd_reply = 'sw_interface_slave_details'
1338         args = dict(sw_if_index=Topology.get_interface_sw_index(
1339             node, interface))
1340         err_msg = 'Failed to get slave dump on host {host}'.format(
1341             host=node['host'])
1342
1343         with PapiExecutor(node) as papi_exec:
1344             papi_resp = papi_exec.add(cmd, **args).get_dump(err_msg)
1345
1346         papi_dump = papi_resp.reply[0]['api_reply']
1347
1348         def process_slave_dump(slave_dump):
1349             """Process slave dump.
1350
1351             :param slave_dump: Slave interface dump.
1352             :type slave_dump: dict
1353             :returns: Processed slave interface dump.
1354             :rtype: dict
1355             """
1356             slave_dump['interface_name'] = slave_dump['interface_name'].\
1357                 rstrip('\x00')
1358             return slave_dump
1359
1360         data = list()
1361         for item in papi_dump:
1362             data.append(process_slave_dump(item[cmd_reply]))
1363
1364         logger.debug('Slave data:\n{slave_data}'.format(slave_data=data))
1365         return data
1366
1367     @staticmethod
1368     def vpp_show_bond_data_on_all_nodes(nodes, details=False):
1369         """Show (detailed) bond information on all VPP nodes in DICT__nodes.
1370
1371         :param nodes: Nodes in the topology.
1372         :param details: If detailed information is required or not.
1373         :type nodes: dict
1374         :type details: bool
1375         """
1376         for node_data in nodes.values():
1377             if node_data['type'] == NodeType.DUT:
1378                 InterfaceUtil.vpp_show_bond_data_on_node(node_data, details)
1379
1380     @staticmethod
1381     def vpp_enable_input_acl_interface(node, interface, ip_version,
1382                                        table_index):
1383         """Enable input acl on interface.
1384
1385         :param node: VPP node to setup interface for input acl.
1386         :param interface: Interface to setup input acl.
1387         :param ip_version: Version of IP protocol.
1388         :param table_index: Classify table index.
1389         :type node: dict
1390         :type interface: str or int
1391         :type ip_version: str
1392         :type table_index: int
1393         """
1394
1395         cmd = 'input_acl_set_interface'
1396         args = dict(
1397             sw_if_index=InterfaceUtil.get_interface_index(node, interface),
1398             ip4_table_index=table_index if ip_version == 'ip4'
1399             else Constants.BITWISE_NON_ZERO,
1400             ip6_table_index=table_index if ip_version == 'ip6'
1401             else Constants.BITWISE_NON_ZERO,
1402             l2_table_index=table_index if ip_version == 'l2'
1403             else Constants.BITWISE_NON_ZERO,
1404             is_add=1)
1405         err_msg = 'Failed to enable input acl on interface {ifc}'.format(
1406             ifc=interface)
1407         with PapiExecutor(node) as papi_exec:
1408             papi_exec.add(cmd, **args).get_replies(err_msg).\
1409                 verify_reply(err_msg=err_msg)
1410
1411     @staticmethod
1412     def get_interface_classify_table(node, interface):
1413         """Get name of classify table for the given interface.
1414
1415         TODO: Move to Classify.py.
1416
1417         :param node: VPP node to get data from.
1418         :param interface: Name or sw_if_index of a specific interface.
1419         :type node: dict
1420         :type interface: str or int
1421         :returns: Classify table name.
1422         :rtype: str
1423         """
1424         if isinstance(interface, basestring):
1425             sw_if_index = InterfaceUtil.get_sw_if_index(node, interface)
1426         else:
1427             sw_if_index = interface
1428
1429         cmd = 'classify_table_by_interface'
1430         args = dict(sw_if_index=sw_if_index)
1431         err_msg = 'Failed to get classify table name by interface {ifc}'.format(
1432             ifc=interface)
1433         with PapiExecutor(node) as papi_exec:
1434             papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg). \
1435                 verify_reply(err_msg=err_msg)
1436
1437         return papi_resp
1438
1439     @staticmethod
1440     def get_interface_vrf_table(node, interface, ip_version='ipv4'):
1441         """Get vrf ID for the given interface.
1442
1443         TODO: Move to proper IP library when implementing CSIT-1459.
1444
1445         :param node: VPP node.
1446         :param interface: Name or sw_if_index of a specific interface.
1447         :type node: dict
1448         :param ip_version: IP protocol version (ipv4 or ipv6).
1449         :type interface: str or int
1450         :type ip_version: str
1451         :returns: vrf ID of the specified interface.
1452         :rtype: int
1453         """
1454         if isinstance(interface, basestring):
1455             sw_if_index = InterfaceUtil.get_sw_if_index(node, interface)
1456         else:
1457             sw_if_index = interface
1458
1459         is_ipv6 = 1 if ip_version == 'ipv6' else 0
1460
1461         cmd = 'sw_interface_get_table'
1462         args = dict(sw_if_index=sw_if_index,
1463                     is_ipv6=is_ipv6)
1464         err_msg = 'Failed to get VRF id assigned to interface {ifc}'.format(
1465             ifc=interface)
1466         with PapiExecutor(node) as papi_exec:
1467             papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg). \
1468                 verify_reply(err_msg=err_msg)
1469
1470         return papi_resp['vrf_id']
1471
1472     @staticmethod
1473     def get_sw_if_index(node, interface_name):
1474         """Get sw_if_index for the given interface from actual interface dump.
1475
1476         :param node: VPP node to get interface data from.
1477         :param interface_name: Name of the specific interface.
1478         :type node: dict
1479         :type interface_name: str
1480         :returns: sw_if_index of the given interface.
1481         :rtype: str
1482         """
1483
1484         interface_data = InterfaceUtil.vpp_get_interface_data(
1485             node, interface=interface_name)
1486         return interface_data.get('sw_if_index')
1487
1488     @staticmethod
1489     def vxlan_gpe_dump(node, interface_name=None):
1490         """Get VxLAN GPE data for the given interface.
1491
1492         :param node: VPP node to get interface data from.
1493         :param interface_name: Name of the specific interface. If None,
1494             information about all VxLAN GPE interfaces is returned.
1495         :type node: dict
1496         :type interface_name: str
1497         :returns: Dictionary containing data for the given VxLAN GPE interface
1498             or if interface=None, the list of dictionaries with all VxLAN GPE
1499             interfaces.
1500         :rtype: dict or list
1501         """
1502
1503         if interface_name is not None:
1504             sw_if_index = InterfaceUtil.get_interface_index(
1505                 node, interface_name)
1506         else:
1507             sw_if_index = int(Constants.BITWISE_NON_ZERO)
1508
1509         cmd = 'vxlan_gpe_tunnel_dump'
1510         cmd_reply = 'vxlan_gpe_tunnel_details'
1511         args = dict(sw_if_index=sw_if_index)
1512         err_msg = 'Failed to get VXLAN-GPE dump on host {host}'.format(
1513             host=node['host'])
1514         with PapiExecutor(node) as papi_exec:
1515             papi_resp = papi_exec.add(cmd, **args).get_dump(err_msg)
1516
1517         papi_vxlan_dump = papi_resp.reply[0]['api_reply']
1518
1519         def process_vxlan_gpe_dump(vxlan_dump):
1520             """Process vxlan_gpe dump.
1521
1522             :param vxlan_dump: Vxlan_gpe nterface dump.
1523             :type vxlan_dump: dict
1524             :returns: Processed vxlan_gpe interface dump.
1525             :rtype: dict
1526             """
1527             if vxlan_dump['is_ipv6']:
1528                 vxlan_dump['local'] = \
1529                     inet_ntop(AF_INET6, vxlan_dump['local'])
1530                 vxlan_dump['remote'] = \
1531                     inet_ntop(AF_INET6, vxlan_dump['remote'])
1532             else:
1533                 vxlan_dump['local'] = \
1534                     inet_ntop(AF_INET, vxlan_dump['local'][0:4])
1535                 vxlan_dump['remote'] = \
1536                     inet_ntop(AF_INET, vxlan_dump['remote'][0:4])
1537             return vxlan_dump
1538
1539         data = list() if interface_name is None else dict()
1540         for item in papi_vxlan_dump:
1541             if interface_name is None:
1542                 data.append(process_vxlan_gpe_dump(item[cmd_reply]))
1543             elif item[cmd_reply]['sw_if_index'] == sw_if_index:
1544                 data = process_vxlan_gpe_dump(item[cmd_reply])
1545                 break
1546
1547         logger.debug('VXLAN-GPE data:\n{vxlan_gpe_data}'.format(
1548             vxlan_gpe_data=data))
1549         return data
1550
1551     @staticmethod
1552     def vpp_ip_source_check_setup(node, if_name):
1553         """Setup Reverse Path Forwarding source check on interface.
1554
1555         TODO: Move to proper IP library when implementing CSIT-1459.
1556
1557         :param node: Node to setup RPF source check.
1558         :param if_name: Interface name to setup RPF source check.
1559         :type node: dict
1560         :type if_name: str
1561         """
1562
1563         cmd = 'ip_source_check_interface_add_del'
1564         args = dict(
1565             sw_if_index=InterfaceUtil.get_interface_index(node, if_name),
1566             is_add=1,
1567             loose=0)
1568         err_msg = 'Failed to enable source check on interface {ifc}'.format(
1569             ifc=if_name)
1570         with PapiExecutor(node) as papi_exec:
1571             papi_exec.add(cmd, **args).get_replies(err_msg). \
1572                 verify_reply(err_msg=err_msg)
1573
1574     @staticmethod
1575     def assign_interface_to_fib_table(node, interface, table_id, ipv6=False):
1576         """Assign VPP interface to specific VRF/FIB table.
1577
1578         :param node: VPP node where the FIB and interface are located.
1579         :param interface: Interface to be assigned to FIB.
1580         :param table_id: VRF table ID.
1581         :param ipv6: Assign to IPv6 table. Default False.
1582         :type node: dict
1583         :type interface: str or int
1584         :type table_id: int
1585         :type ipv6: bool
1586         """
1587
1588         cmd = 'sw_interface_set_table'
1589         args = dict(
1590             sw_if_index=InterfaceUtil.get_interface_index(node, interface),
1591             is_ipv6=1 if ipv6 else 0,
1592             vrf_id=int(table_id))
1593         err_msg = 'Failed to assign interface {ifc} to FIB table'.format(
1594             ifc=interface)
1595         with PapiExecutor(node) as papi_exec:
1596             papi_exec.add(cmd, **args).get_replies(err_msg). \
1597                 verify_reply(err_msg=err_msg)
1598
1599     @staticmethod
1600     def set_linux_interface_mac(node, interface, mac, namespace=None,
1601                                 vf_id=None):
1602         """Set MAC address for interface in linux.
1603
1604         :param node: Node where to execute command.
1605         :param interface: Interface in namespace.
1606         :param mac: MAC to be assigned to interface.
1607         :param namespace: Execute command in namespace. Optional
1608         :param vf_id: Virtual Function id. Optional
1609         :type node: dict
1610         :type interface: str
1611         :type mac: str
1612         :type namespace: str
1613         :type vf_id: int
1614         """
1615         mac_str = 'vf {vf_id} mac {mac}'.format(vf_id=vf_id, mac=mac) \
1616             if vf_id is not None else 'address {mac}'.format(mac=mac)
1617         ns_str = 'ip netns exec {ns}'.format(ns=namespace) if namespace else ''
1618
1619         cmd = ('{ns} ip link set {interface} {mac}'.
1620                format(ns=ns_str, interface=interface, mac=mac_str))
1621         exec_cmd_no_error(node, cmd, sudo=True)
1622
1623     @staticmethod
1624     def set_linux_interface_trust_on(node, interface, namespace=None,
1625                                      vf_id=None):
1626         """Set trust on (promisc) for interface in linux.
1627
1628         :param node: Node where to execute command.
1629         :param interface: Interface in namespace.
1630         :param namespace: Execute command in namespace. Optional
1631         :param vf_id: Virtual Function id. Optional
1632         :type node: dict
1633         :type interface: str
1634         :type namespace: str
1635         :type vf_id: int
1636         """
1637         trust_str = 'vf {vf_id} trust on'.format(vf_id=vf_id) \
1638             if vf_id is not None else 'trust on'
1639         ns_str = 'ip netns exec {ns}'.format(ns=namespace) if namespace else ''
1640
1641         cmd = ('{ns} ip link set dev {interface} {trust}'.
1642                format(ns=ns_str, interface=interface, trust=trust_str))
1643         exec_cmd_no_error(node, cmd, sudo=True)
1644
1645     @staticmethod
1646     def set_linux_interface_spoof_off(node, interface, namespace=None,
1647                                       vf_id=None):
1648         """Set spoof off for interface in linux.
1649
1650         :param node: Node where to execute command.
1651         :param interface: Interface in namespace.
1652         :param namespace: Execute command in namespace. Optional
1653         :param vf_id: Virtual Function id. Optional
1654         :type node: dict
1655         :type interface: str
1656         :type namespace: str
1657         :type vf_id: int
1658         """
1659         spoof_str = 'vf {vf_id} spoof off'.format(vf_id=vf_id) \
1660             if vf_id is not None else 'spoof off'
1661         ns_str = 'ip netns exec {ns}'.format(ns=namespace) if namespace else ''
1662
1663         cmd = ('{ns} ip link set dev {interface} {spoof}'.
1664                format(ns=ns_str, interface=interface, spoof=spoof_str))
1665         exec_cmd_no_error(node, cmd, sudo=True)
1666
1667     @staticmethod
1668     def init_avf_interface(node, ifc_key, numvfs=1, osi_layer='L2'):
1669         """Init PCI device by creating VFs and bind them to vfio-pci for AVF
1670         driver testing on DUT.
1671
1672         :param node: DUT node.
1673         :param ifc_key: Interface key from topology file.
1674         :param numvfs: Number of VFs to initialize, 0 - disable the VFs.
1675         :param osi_layer: OSI Layer type to initialize TG with.
1676             Default value "L2" sets linux interface spoof off.
1677         :type node: dict
1678         :type ifc_key: str
1679         :type numvfs: int
1680         :type osi_layer: str
1681         :returns: Virtual Function topology interface keys.
1682         :rtype: list
1683         :raises RuntimeError: If a reason preventing initialization is found.
1684         """
1685         ssh = SSH()
1686         ssh.connect(node)
1687
1688         # Read PCI address and driver.
1689         pf_pci_addr = Topology.get_interface_pci_addr(node, ifc_key)
1690         pf_mac_addr = Topology.get_interface_mac(node, ifc_key).split(":")
1691         uio_driver = Topology.get_uio_driver(node)
1692         kernel_driver = Topology.get_interface_driver(node, ifc_key)
1693         if kernel_driver != "i40e":
1694             raise RuntimeError(
1695                 "AVF needs i40e driver, not {driver} at node {host} ifc {ifc}"\
1696                 .format(driver=kernel_driver, host=node["host"], ifc=ifc_key))
1697         current_driver = DUTSetup.get_pci_dev_driver(
1698             node, pf_pci_addr.replace(':', r'\:'))
1699
1700         VPPUtil.stop_vpp_service(node)
1701         if current_driver != kernel_driver:
1702             # PCI device must be re-bound to kernel driver before creating VFs.
1703             DUTSetup.verify_kernel_module(node, kernel_driver, force_load=True)
1704             # Stop VPP to prevent deadlock.
1705             # Unbind from current driver.
1706             DUTSetup.pci_driver_unbind(node, pf_pci_addr)
1707             # Bind to kernel driver.
1708             DUTSetup.pci_driver_bind(node, pf_pci_addr, kernel_driver)
1709
1710         # Initialize PCI VFs
1711         DUTSetup.set_sriov_numvfs(node, pf_pci_addr, numvfs)
1712
1713         vf_ifc_keys = []
1714         # Set MAC address and bind each virtual function to uio driver.
1715         for vf_id in range(numvfs):
1716             vf_mac_addr = ":".join([pf_mac_addr[0], pf_mac_addr[2],
1717                                     pf_mac_addr[3], pf_mac_addr[4],
1718                                     pf_mac_addr[5], "{:02x}".format(vf_id)])
1719
1720             pf_dev = '`basename /sys/bus/pci/devices/{pci}/net/*`'.\
1721                 format(pci=pf_pci_addr)
1722             InterfaceUtil.set_linux_interface_trust_on(node, pf_dev,
1723                                                        vf_id=vf_id)
1724             if osi_layer == 'L2':
1725                 InterfaceUtil.set_linux_interface_spoof_off(node, pf_dev,
1726                                                             vf_id=vf_id)
1727             InterfaceUtil.set_linux_interface_mac(node, pf_dev, vf_mac_addr,
1728                                                   vf_id=vf_id)
1729
1730             DUTSetup.pci_vf_driver_unbind(node, pf_pci_addr, vf_id)
1731             DUTSetup.pci_vf_driver_bind(node, pf_pci_addr, vf_id, uio_driver)
1732
1733             # Add newly created ports into topology file
1734             vf_ifc_name = '{pf_if_key}_vf'.format(pf_if_key=ifc_key)
1735             vf_pci_addr = DUTSetup.get_virtfn_pci_addr(node, pf_pci_addr, vf_id)
1736             vf_ifc_key = Topology.add_new_port(node, vf_ifc_name)
1737             Topology.update_interface_name(node, vf_ifc_key,
1738                                            vf_ifc_name+str(vf_id+1))
1739             Topology.update_interface_mac_address(node, vf_ifc_key, vf_mac_addr)
1740             Topology.update_interface_pci_address(node, vf_ifc_key, vf_pci_addr)
1741             vf_ifc_keys.append(vf_ifc_key)
1742
1743         return vf_ifc_keys
1744
1745     @staticmethod
1746     def vpp_create_multiple_vxlan_ipv4_tunnels(
1747             node, node_vxlan_if, node_vlan_if, op_node, op_node_if,
1748             n_tunnels, vni_start, src_ip_start, dst_ip_start, ip_step, ip_limit,
1749             bd_id_start):
1750         """Create multiple VXLAN tunnel interfaces and VLAN sub-interfaces on
1751         VPP node.
1752
1753         Put each pair of VXLAN tunnel interface and VLAN sub-interface to
1754         separate bridge-domain.
1755
1756         :param node: VPP node to create VXLAN tunnel interfaces.
1757         :param node_vxlan_if: VPP node interface key to create VXLAN tunnel
1758             interfaces.
1759         :param node_vlan_if: VPP node interface key to create VLAN
1760             sub-interface.
1761         :param op_node: Opposite VPP node for VXLAN tunnel interfaces.
1762         :param op_node_if: Opposite VPP node interface key for VXLAN tunnel
1763             interfaces.
1764         :param n_tunnels: Number of tunnel interfaces to create.
1765         :param vni_start: VNI start ID.
1766         :param src_ip_start: VXLAN tunnel source IP address start.
1767         :param dst_ip_start: VXLAN tunnel destination IP address start.
1768         :param ip_step: IP address incremental step.
1769         :param ip_limit: IP address limit.
1770         :param bd_id_start: Bridge-domain ID start.
1771         :type node: dict
1772         :type node_vxlan_if: str
1773         :type node_vlan_if: str
1774         :type op_node: dict
1775         :type op_node_if: str
1776         :type n_tunnels: int
1777         :type vni_start: int
1778         :type src_ip_start: str
1779         :type dst_ip_start: str
1780         :type ip_step: int
1781         :type ip_limit: str
1782         :type bd_id_start: int
1783         """
1784         # configure IPs, create VXLAN interfaces and VLAN sub-interfaces
1785         vxlan_count = InterfaceUtil.vpp_create_vxlan_and_vlan_interfaces(
1786             node, node_vxlan_if, node_vlan_if, n_tunnels, vni_start,
1787             src_ip_start, dst_ip_start, ip_step, ip_limit)
1788
1789         # update topology with VXLAN interfaces and VLAN sub-interfaces data
1790         # and put interfaces up
1791         InterfaceUtil.vpp_put_vxlan_and_vlan_interfaces_up(
1792             node, vxlan_count, node_vlan_if)
1793
1794         # configure bridge domains, ARPs and routes
1795         InterfaceUtil.vpp_put_vxlan_and_vlan_interfaces_to_bridge_domain(
1796             node, node_vxlan_if, vxlan_count, op_node, op_node_if, dst_ip_start,
1797             ip_step, bd_id_start)
1798
1799     @staticmethod
1800     def vpp_create_vxlan_and_vlan_interfaces(
1801             node, node_vxlan_if, node_vlan_if, vxlan_count, vni_start,
1802             src_ip_start, dst_ip_start, ip_step, ip_limit):
1803         """
1804         Configure IPs, create VXLAN interfaces and VLAN sub-interfaces on VPP
1805         node.
1806
1807         :param node: VPP node.
1808         :param node_vxlan_if: VPP node interface key to create VXLAN tunnel
1809             interfaces.
1810         :param node_vlan_if: VPP node interface key to create VLAN
1811             sub-interface.
1812         :param vxlan_count: Number of tunnel interfaces to create.
1813         :param vni_start: VNI start ID.
1814         :param src_ip_start: VXLAN tunnel source IP address start.
1815         :param dst_ip_start: VXLAN tunnel destination IP address start.
1816         :param ip_step: IP address incremental step.
1817         :param ip_limit: IP address limit.
1818         :type node: dict
1819         :type node_vxlan_if: str
1820         :type node_vlan_if: str
1821         :type vxlan_count: int
1822         :type vni_start: int
1823         :type src_ip_start: str
1824         :type dst_ip_start: str
1825         :type ip_step: int
1826         :type ip_limit: str
1827         :returns: Number of created VXLAN interfaces.
1828         :rtype: int
1829         """
1830
1831         try:
1832             src_address_start = IPv6Address(unicode(src_ip_start))
1833             dst_address_start = IPv6Address(unicode(dst_ip_start))
1834             ip_address_limit = IPv6Address(unicode(ip_limit))
1835             af_inet = AF_INET6
1836             is_ipv6 = 1
1837         except (AddressValueError, NetmaskValueError):
1838             src_address_start = IPv4Address(unicode(src_ip_start))
1839             dst_address_start = IPv4Address(unicode(dst_ip_start))
1840             ip_address_limit = IPv4Address(unicode(ip_limit))
1841             af_inet = AF_INET
1842             is_ipv6 = 0
1843
1844         with PapiExecutor(node) as papi_exec:
1845             for i in xrange(0, vxlan_count):
1846                 src_ip = src_address_start + i * ip_step
1847                 dst_ip = dst_address_start + i * ip_step
1848                 if src_ip > ip_address_limit or dst_ip > ip_address_limit:
1849                     logger.warn("Can't do more iterations - IP address limit "
1850                                 "has been reached.")
1851                     vxlan_count = i
1852                     break
1853                 cmd = 'sw_interface_add_del_address'
1854                 args = dict(
1855                     sw_if_index=InterfaceUtil.get_interface_index(
1856                         node, node_vxlan_if),
1857                     is_add=1,
1858                     is_ipv6=0,
1859                     del_all=0,
1860                     address_length=128 if is_ipv6 else 32,
1861                     address=inet_pton(af_inet, str(src_ip)))
1862                 papi_exec.add(cmd, **args)
1863                 cmd = 'vxlan_add_del_tunnel'
1864                 args = dict(
1865                     is_add=1,
1866                     is_ipv6=0,
1867                     instance=Constants.BITWISE_NON_ZERO,
1868                     src_address=inet_pton(af_inet, str(src_ip)),
1869                     dst_address=inet_pton(af_inet, str(dst_ip)),
1870                     mcast_sw_if_index=Constants.BITWISE_NON_ZERO,
1871                     encap_vrf_id=0,
1872                     decap_next_index=Constants.BITWISE_NON_ZERO,
1873                     vni=int(vni_start)+i)
1874                 papi_exec.add(cmd, **args)
1875                 cmd = 'create_vlan_subif'
1876                 args = dict(
1877                     sw_if_index=InterfaceUtil.get_interface_index(
1878                         node, node_vlan_if),
1879                     vlan_id=i+1)
1880                 papi_exec.add(cmd, **args)
1881             papi_exec.get_replies().verify_replies()
1882
1883         return vxlan_count
1884
1885     @staticmethod
1886     def vpp_put_vxlan_and_vlan_interfaces_up(node, vxlan_count, node_vlan_if):
1887         """
1888         Update topology with VXLAN interfaces and VLAN sub-interfaces data
1889         and put interfaces up.
1890
1891         :param node: VPP node.
1892         :param vxlan_count: Number of tunnel interfaces.
1893         :param node_vlan_if: VPP node interface key where VLAN sub-interfaces
1894             have been created.
1895         :type node: dict
1896         :type vxlan_count: int
1897         :type node_vlan_if: str
1898         """
1899
1900         if_data = InterfaceUtil.vpp_get_interface_data(node)
1901
1902         with PapiExecutor(node) as papi_exec:
1903             for i in xrange(0, vxlan_count):
1904                 vxlan_subif_key = Topology.add_new_port(node, 'vxlan_tunnel')
1905                 vxlan_subif_name = 'vxlan_tunnel{nr}'.format(nr=i)
1906                 vxlan_found = False
1907                 vxlan_subif_idx = None
1908                 vlan_subif_key = Topology.add_new_port(node, 'vlan_subif')
1909                 vlan_subif_name = '{if_name}.{vlan}'.format(
1910                     if_name=Topology.get_interface_name(
1911                         node, node_vlan_if), vlan=i+1)
1912                 vlan_found = False
1913                 vlan_idx = None
1914                 for data in if_data:
1915                     if not vxlan_found \
1916                             and data['interface_name'] == vxlan_subif_name:
1917                         vxlan_subif_idx = data['sw_if_index']
1918                         vxlan_found = True
1919                     elif not vlan_found \
1920                             and data['interface_name'] == vlan_subif_name:
1921                         vlan_idx = data['sw_if_index']
1922                         vlan_found = True
1923                     if vxlan_found and vlan_found:
1924                         break
1925                 Topology.update_interface_sw_if_index(
1926                     node, vxlan_subif_key, vxlan_subif_idx)
1927                 Topology.update_interface_name(
1928                     node, vxlan_subif_key, vxlan_subif_name)
1929                 cmd = 'sw_interface_set_flags'
1930                 args1 = dict(sw_if_index=vxlan_subif_idx,
1931                              admin_up_down=1)
1932                 Topology.update_interface_sw_if_index(
1933                     node, vlan_subif_key, vlan_idx)
1934                 Topology.update_interface_name(
1935                     node, vlan_subif_key, vlan_subif_name)
1936                 args2 = dict(sw_if_index=vlan_idx,
1937                              admin_up_down=1)
1938                 papi_exec.add(cmd, **args1).add(cmd, **args2)
1939             papi_exec.get_replies().verify_replies()
1940
1941     @staticmethod
1942     def vpp_put_vxlan_and_vlan_interfaces_to_bridge_domain(
1943             node, node_vxlan_if, vxlan_count, op_node, op_node_if, dst_ip_start,
1944             ip_step, bd_id_start):
1945         """
1946         Configure ARPs and routes for VXLAN interfaces and put each pair of
1947         VXLAN tunnel interface and VLAN sub-interface to separate bridge-domain.
1948
1949         :param node: VPP node.
1950         :param node_vxlan_if: VPP node interface key where VXLAN tunnel
1951             interfaces have been created.
1952         :param vxlan_count: Number of tunnel interfaces.
1953         :param op_node: Opposite VPP node for VXLAN tunnel interfaces.
1954         :param op_node_if: Opposite VPP node interface key for VXLAN tunnel
1955             interfaces.
1956         :param dst_ip_start: VXLAN tunnel destination IP address start.
1957         :param ip_step: IP address incremental step.
1958         :param bd_id_start: Bridge-domain ID start.
1959         :type node: dict
1960         :type node_vxlan_if: str
1961         :type vxlan_count: int
1962         :type op_node: dict
1963         :type op_node_if:
1964         :type dst_ip_start: str
1965         :type ip_step: int
1966         :type bd_id_start: int
1967         """
1968
1969         try:
1970             dst_address_start = IPv6Address(unicode(dst_ip_start))
1971             af_inet = AF_INET6
1972             is_ipv6 = 1
1973         except (AddressValueError, NetmaskValueError):
1974             dst_address_start = IPv4Address(unicode(dst_ip_start))
1975             af_inet = AF_INET
1976             is_ipv6 = 0
1977
1978         with PapiExecutor(node) as papi_exec:
1979             for i in xrange(0, vxlan_count):
1980                 dst_ip = dst_address_start + i * ip_step
1981                 neighbor = dict(
1982                     sw_if_index=Topology.get_interface_sw_index(
1983                         node, node_vxlan_if),
1984                     flags=0,
1985                     mac_address=str(
1986                         Topology.get_interface_mac(op_node, op_node_if)),
1987                     ip_address=str(dst_ip))
1988                 cmd = 'ip_neighbor_add_del'
1989                 args = dict(
1990                     is_add=1,
1991                     neighbor=neighbor)
1992                 papi_exec.add(cmd, **args)
1993                 cmd = 'ip_add_del_route'
1994                 args = dict(
1995                     next_hop_sw_if_index=Topology.get_interface_sw_index(
1996                         node, node_vxlan_if),
1997                     table_id=0,
1998                     is_add=1,
1999                     is_ipv6=is_ipv6,
2000                     next_hop_weight=1,
2001                     next_hop_proto=1 if is_ipv6 else 0,
2002                     dst_address_length=128 if is_ipv6 else 32,
2003                     dst_address=inet_pton(af_inet, str(dst_ip)),
2004                     next_hop_address=inet_pton(af_inet, str(dst_ip)))
2005                 papi_exec.add(cmd, **args)
2006                 cmd = 'sw_interface_set_l2_bridge'
2007                 args = dict(
2008                     rx_sw_if_index=Topology.get_interface_sw_index(
2009                         node, 'vxlan_tunnel{nr}'.format(nr=i+1)),
2010                     bd_id=int(bd_id_start+i),
2011                     shg=0,
2012                     port_type=0,
2013                     enable=1)
2014                 papi_exec.add(cmd, **args)
2015                 args = dict(
2016                     rx_sw_if_index=Topology.get_interface_sw_index(
2017                         node, 'vlan_subif{nr}'.format(nr=i+1)),
2018                     bd_id=int(bd_id_start+i),
2019                     shg=0,
2020                     port_type=0,
2021                     enable=1)
2022                 papi_exec.add(cmd, **args)
2023             papi_exec.get_replies().verify_replies()
2024
2025     @staticmethod
2026     def vpp_sw_interface_rx_placement_dump(node):
2027         """Dump VPP interface RX placement on node.
2028
2029         :param node: Node to run command on.
2030         :type node: dict
2031         :returns: Thread mapping information as a list of dictionaries.
2032         :rtype: list
2033         """
2034
2035         cmd = 'sw_interface_rx_placement_dump'
2036         cmd_reply = 'sw_interface_rx_placement_details'
2037         err_msg = "Failed to run '{cmd}' PAPI command on host {host}!".format(
2038             cmd=cmd, host=node['host'])
2039         with PapiExecutor(node) as papi_exec:
2040             for ifc in node['interfaces'].values():
2041                 if ifc['vpp_sw_index'] is not None:
2042                     papi_exec.add(cmd, sw_if_index=ifc['vpp_sw_index'])
2043             papi_resp = papi_exec.get_dump(err_msg)
2044         thr_mapping = [s[cmd_reply] for r in papi_resp.reply
2045                        for s in r['api_reply']]
2046         return sorted(thr_mapping, key=lambda k: k['sw_if_index'])
2047
2048     @staticmethod
2049     def vpp_sw_interface_set_rx_placement(node, sw_if_index, queue_id,
2050                                           worker_id):
2051         """Set interface RX placement to worker on node.
2052
2053         :param node: Node to run command on.
2054         :param sw_if_index: VPP SW interface index.
2055         :param queue_id: VPP interface queue ID.
2056         :param worker_id: VPP worker ID (indexing from 0).
2057         :type node: dict
2058         :type sw_if_index: int
2059         :type queue_id: int
2060         :type worker_id: int
2061         :raises RuntimeError: If failed to run command on host or if no API
2062             reply received.
2063         """
2064
2065         cmd = 'sw_interface_set_rx_placement'
2066         err_msg = "Failed to set interface RX placement to worker on host " \
2067                   "{host}!".format(host=node['host'])
2068         args = dict(sw_if_index=sw_if_index, queue_id=queue_id,
2069                     worker_id=worker_id)
2070         with PapiExecutor(node) as papi_exec:
2071             papi_exec.add(cmd, **args).get_replies(err_msg).\
2072                 verify_reply(err_msg=err_msg)
2073
2074     @staticmethod
2075     def vpp_round_robin_rx_placement(node, prefix):
2076         """Set Round Robin interface RX placement on all worker threads
2077         on node.
2078
2079         :param node: Topology nodes.
2080         :param prefix: Interface name prefix.
2081         :type node: dict
2082         :type prefix: str
2083         """
2084         worker_id = 0
2085         worker_cnt = len(VPPUtil.vpp_show_threads(node)) - 1
2086         for placement in InterfaceUtil.vpp_sw_interface_rx_placement_dump(node):
2087             for interface in node['interfaces'].values():
2088                 if placement['sw_if_index'] == interface['vpp_sw_index'] \
2089                     and prefix in interface['name']:
2090                     InterfaceUtil.vpp_sw_interface_set_rx_placement(
2091                         node, placement['sw_if_index'], placement['queue_id'],
2092                         worker_id % worker_cnt)
2093                     worker_id += 1
2094
2095     @staticmethod
2096     def vpp_round_robin_rx_placement_on_all_duts(nodes, prefix):
2097         """Set Round Robin interface RX placement on all worker threads
2098         on all DUTs.
2099
2100         :param nodes: Topology nodes.
2101         :param prefix: Interface name prefix.
2102         :type nodes: dict
2103         :type prefix: str
2104         """
2105         for node in nodes.values():
2106             if node['type'] == NodeType.DUT:
2107                 InterfaceUtil.vpp_round_robin_rx_placement(node, prefix)