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 socket import error as inet_error
  18 from time import time, sleep
  19
  20 from robot.api import logger
  21
  22 from resources.libraries.python.Constants import Constants
  23 from resources.libraries.python.CpuUtils import CpuUtils
  24 from resources.libraries.python.DUTSetup import DUTSetup
  25 from resources.libraries.python.PapiExecutor import PapiExecutor
  26 from resources.libraries.python.IPUtil import convert_ipv4_netmask_prefix
  27 from resources.libraries.python.IPUtil import IPUtil
  28 from resources.libraries.python.PapiExecutor import PapiExecutor
  29 from resources.libraries.python.parsers.JsonParser import JsonParser
  30 from resources.libraries.python.ssh import SSH, exec_cmd_no_error
  31 from resources.libraries.python.topology import NodeType, Topology
  32 from resources.libraries.python.VatExecutor import VatExecutor, VatTerminal
  33 from resources.libraries.python.VatJsonUtil import VatJsonUtil
  34 from resources.libraries.python.VPPUtil import VPPUtil
  35
  36
  37 class InterfaceUtil(object):
  38     """General utilities for managing interfaces"""
  39
  40     __UDEV_IF_RULES_FILE = '/etc/udev/rules.d/10-network.rules'
  41
  42     @staticmethod
  43     def set_interface_state(node, interface, state, if_type="key"):
  44         """Set interface state on a node.
  45
  46         Function can be used for DUTs as well as for TGs.
  47
  48         :param node: Node where the interface is.
  49         :param interface: Interface key or sw_if_index or name.
  50         :param state: One of 'up' or 'down'.
  51         :param if_type: Interface type
  52         :type node: dict
  53         :type interface: str or int
  54         :type state: str
  55         :type if_type: str
  56         :returns: Nothing.
  57         :raises ValueError: If the interface type is unknown.
  58         :raises ValueError: If the state of interface is unexpected.
  59         :raises ValueError: If the node has an unknown node type.
  60         """
  61
  62         if if_type == "key":
  63             if isinstance(interface, basestring):
  64                 sw_if_index = Topology.get_interface_sw_index(node, interface)
  65                 iface_name = Topology.get_interface_name(node, interface)
  66             else:
  67                 sw_if_index = interface
  68         elif if_type == "name":
  69             iface_key = Topology.get_interface_by_name(node, interface)
  70             if iface_key is not None:
  71                 sw_if_index = Topology.get_interface_sw_index(node, iface_key)
  72             iface_name = interface
  73         else:
  74             raise ValueError("if_type unknown: {}".format(if_type))
  75
  76         if node['type'] == NodeType.DUT:
  77             if state == 'up':
  78                 state = 'admin-up link-up'
  79             elif state == 'down':
  80                 state = 'admin-down link-down'
  81             else:
  82                 raise ValueError('Unexpected interface state: {}'.format(state))
  83             VatExecutor.cmd_from_template(node, 'set_if_state.vat',
  84                                           sw_if_index=sw_if_index, state=state)
  85         elif node['type'] == NodeType.TG or node['type'] == NodeType.VM:
  86             cmd = 'ip link set {} {}'.format(iface_name, state)
  87             exec_cmd_no_error(node, cmd, sudo=True)
  88         else:
  89             raise ValueError('Node {} has unknown NodeType: "{}"'
  90                              .format(node['host'], node['type']))
  91
  92     @staticmethod
  93     def set_interface_ethernet_mtu(node, iface_key, mtu):
  94         """Set Ethernet MTU for specified interface.
  95
  96         Function can be used only for TGs.
  97
  98         :param node: Node where the interface is.
  99         :param iface_key: Interface key from topology file.
 100         :param mtu: MTU to set.
 101         :type node: dict
 102         :type iface_key: str
 103         :type mtu: int
 104         :returns: Nothing.
 105         :raises ValueError: If the node type is "DUT".
 106         :raises ValueError: If the node has an unknown node type.
 107         """
 108         if node['type'] == NodeType.DUT:
 109             raise ValueError('Node {}: Setting Ethernet MTU for interface '
 110                              'on DUT nodes not supported', node['host'])
 111         elif node['type'] == NodeType.TG:
 112             iface_name = Topology.get_interface_name(node, iface_key)
 113             cmd = 'ip link set {} mtu {}'.format(iface_name, mtu)
 114             exec_cmd_no_error(node, cmd, sudo=True)
 115         else:
 116             raise ValueError('Node {} has unknown NodeType: "{}"'
 117                              .format(node['host'], node['type']))
 118
 119     @staticmethod
 120     def set_default_ethernet_mtu_on_all_interfaces_on_node(node):
 121         """Set default Ethernet MTU on all interfaces on node.
 122
 123         Function can be used only for TGs.
 124
 125         :param node: Node where to set default MTU.
 126         :type node: dict
 127         :returns: Nothing.
 128         """
 129         for ifc in node['interfaces']:
 130             InterfaceUtil.set_interface_ethernet_mtu(node, ifc, 1500)
 131
 132     @staticmethod
 133     def vpp_set_interface_mtu(node, interface, mtu=9200):
 134         """Set Ethernet MTU on interface.
 135
 136         :param node: VPP node.
 137         :param interface: Interface to setup MTU. Default: 9200.
 138         :param mtu: Ethernet MTU size in Bytes.
 139         :type node: dict
 140         :type interface: str or int
 141         :type mtu: int
 142         """
 143         if isinstance(interface, basestring):
 144             sw_if_index = Topology.get_interface_sw_index(node, interface)
 145         else:
 146             sw_if_index = interface
 147
 148         if sw_if_index:
 149             with VatTerminal(node, json_param=False) as vat:
 150                 vat.vat_terminal_exec_cmd_from_template(
 151                     "hw_interface_set_mtu.vat", sw_if_index=sw_if_index,
 152                     mtu=mtu)
 153
 154     @staticmethod
 155     def vpp_set_interfaces_mtu_on_node(node, mtu=9200):
 156         """Set Ethernet MTU on all interfaces.
 157
 158         :param node: VPP node.
 159         :param mtu: Ethernet MTU size in Bytes. Default: 9200.
 160         :type node: dict
 161         :type mtu: int
 162         """
 163         for interface in node['interfaces']:
 164             InterfaceUtil.vpp_set_interface_mtu(node, interface, mtu)
 165
 166     @staticmethod
 167     def vpp_set_interfaces_mtu_on_all_duts(nodes, mtu=9200):
 168         """Set Ethernet MTU on all interfaces on all DUTs.
 169
 170         :param nodes: VPP nodes.
 171         :param mtu: Ethernet MTU size in Bytes. Default: 9200.
 172         :type nodes: dict
 173         :type mtu: int
 174         """
 175         for node in nodes.values():
 176             if node['type'] == NodeType.DUT:
 177                 InterfaceUtil.vpp_set_interfaces_mtu_on_node(node, mtu)
 178
 179     @staticmethod
 180     def vpp_node_interfaces_ready_wait(node, timeout=30):
 181         """Wait until all interfaces with admin-up are in link-up state.
 182
 183         :param node: Node to wait on.
 184         :param timeout: Waiting timeout in seconds (optional, default 10s).
 185         :type node: dict
 186         :type timeout: int
 187         :returns: Nothing.
 188         :raises RuntimeError: If the timeout period value has elapsed.
 189         """
 190         if_ready = False
 191         not_ready = []
 192         start = time()
 193         while not if_ready:
 194             out = InterfaceUtil.vpp_get_interface_data(node)
 195             if time() - start > timeout:
 196                 for interface in out:
 197                     if interface.get('admin_up_down') == 1:
 198                         if interface.get('link_up_down') != 1:
 199                             logger.debug('{0} link-down'.format(
 200                                 interface.get('interface_name')))
 201                 raise RuntimeError('timeout, not up {0}'.format(not_ready))
 202             not_ready = []
 203             for interface in out:
 204                 if interface.get('admin_up_down') == 1:
 205                     if interface.get('link_up_down') != 1:
 206                         not_ready.append(interface.get('interface_name'))
 207             if not not_ready:
 208                 if_ready = True
 209             else:
 210                 logger.debug('Interfaces still in link-down state: {0}, '
 211                              'waiting...'.format(not_ready))
 212                 sleep(1)
 213
 214     @staticmethod
 215     def vpp_nodes_interfaces_ready_wait(nodes, timeout=30):
 216         """Wait until all interfaces with admin-up are in link-up state for
 217         listed nodes.
 218
 219         :param nodes: List of nodes to wait on.
 220         :param timeout: Seconds to wait per node for all interfaces to come up.
 221         :type nodes: list
 222         :type timeout: int
 223         :returns: Nothing.
 224         """
 225         for node in nodes:
 226             InterfaceUtil.vpp_node_interfaces_ready_wait(node, timeout)
 227
 228     @staticmethod
 229     def all_vpp_interfaces_ready_wait(nodes, timeout=30):
 230         """Wait until all interfaces with admin-up are in link-up state for all
 231         nodes in the topology.
 232
 233         :param nodes: Nodes in the topology.
 234         :param timeout: Seconds to wait per node for all interfaces to come up.
 235         :type nodes: dict
 236         :type timeout: int
 237         :returns: Nothing.
 238         """
 239         for node in nodes.values():
 240             if node['type'] == NodeType.DUT:
 241                 InterfaceUtil.vpp_node_interfaces_ready_wait(node, timeout)
 242
 243     @staticmethod
 244     def vpp_get_interface_data(node, interface=None):
 245         """Get all interface data from a VPP node. If a name or
 246         sw_interface_index is provided, return only data for the matching
 247         interface.
 248
 249         :param node: VPP node to get interface data from.
 250         :param interface: Numeric index or name string of a specific interface.
 251         :type node: dict
 252         :type interface: int or str
 253         :returns: List of dictionaries containing data for each interface, or a
 254             single dictionary for the specified interface.
 255         :rtype: list or dict
 256         :raises TypeError: if the data type of interface is neither basestring
 257             nor int.
 258         """
 259         with VatTerminal(node) as vat:
 260             response = vat.vat_terminal_exec_cmd_from_template(
 261                 "interface_dump.vat")
 262
 263         data = response[0]
 264
 265         if interface is not None:
 266             if isinstance(interface, basestring):
 267                 param = "interface_name"
 268             elif isinstance(interface, int):
 269                 param = "sw_if_index"
 270             else:
 271                 raise TypeError
 272             for data_if in data:
 273                 if data_if[param] == interface:
 274                     return data_if
 275             return dict()
 276         return data
 277
 278     @staticmethod
 279     def vpp_get_interface_name(node, sw_if_index):
 280         """Get interface name for the given SW interface index from actual
 281         interface dump.
 282
 283         :param node: VPP node to get interface data from.
 284         :param sw_if_index: SW interface index of the specific interface.
 285         :type node: dict
 286         :type sw_if_index: int
 287         :returns: Name of the given interface.
 288         :rtype: str
 289         """
 290
 291         if_data = InterfaceUtil.vpp_get_interface_data(node, sw_if_index)
 292         if if_data['sup_sw_if_index'] != if_data['sw_if_index']:
 293             if_data = InterfaceUtil.vpp_get_interface_data(
 294                 node, if_data['sup_sw_if_index'])
 295         try:
 296             if_name = if_data["interface_name"]
 297         except KeyError:
 298             if_name = None
 299         return if_name
 300
 301     @staticmethod
 302     def vpp_get_interface_mac(node, interface=None):
 303         """Get MAC address for the given interface from actual interface dump.
 304
 305         :param node: VPP node to get interface data from.
 306         :param interface: Numeric index or name string of a specific interface.
 307         :type node: dict
 308         :type interface: int or str
 309         :returns: MAC address.
 310         :rtype: str
 311         """
 312
 313         if_data = InterfaceUtil.vpp_get_interface_data(node, interface)
 314         if if_data['sup_sw_if_index'] != if_data['sw_if_index']:
 315             if_data = InterfaceUtil.vpp_get_interface_data(
 316                 node, if_data['sup_sw_if_index'])
 317         mac_data = [str(hex(item))[2:] for item in if_data['l2_address'][:6]]
 318         mac_data_nice = []
 319         for item in mac_data:
 320             if len(item) == 1:
 321                 item = '0' + item
 322             mac_data_nice.append(item)
 323         mac = ":".join(mac_data_nice)
 324         return mac
 325
 326     @staticmethod
 327     def vpp_get_interface_ip_addresses(node, interface, ip_version):
 328         """Get list of IP addresses from an interface on a VPP node.
 329
 330          :param node: VPP node to get data from.
 331          :param interface: Name of an interface on the VPP node.
 332          :param ip_version: IP protocol version (ipv4 or ipv6).
 333          :type node: dict
 334          :type interface: str
 335          :type ip_version: str
 336          :returns: List of dictionaries, each containing IP address, subnet
 337             prefix length and also the subnet mask for ipv4 addresses.
 338             Note: A single interface may have multiple IP addresses assigned.
 339          :rtype: list
 340         """
 341
 342         try:
 343             sw_if_index = Topology.convert_interface_reference(
 344                 node, interface, "sw_if_index")
 345         except RuntimeError:
 346             if isinstance(interface, basestring):
 347                 sw_if_index = InterfaceUtil.get_sw_if_index(node, interface)
 348             else:
 349                 raise
 350
 351         with VatTerminal(node) as vat:
 352             response = vat.vat_terminal_exec_cmd_from_template(
 353                 "ip_address_dump.vat", ip_version=ip_version,
 354                 sw_if_index=sw_if_index)
 355
 356         data = response[0]
 357
 358         if ip_version == "ipv4":
 359             for item in data:
 360                 item["netmask"] = convert_ipv4_netmask_prefix(
 361                     item["prefix_length"])
 362         return data
 363
 364     @staticmethod
 365     def tg_set_interface_driver(node, pci_addr, driver):
 366         """Set interface driver on the TG node.
 367
 368         :param node: Node to set interface driver on (must be TG node).
 369         :param pci_addr: PCI address of the interface.
 370         :param driver: Driver name.
 371         :type node: dict
 372         :type pci_addr: str
 373         :type driver: str
 374         :raises RuntimeError: If unbinding from the current driver fails.
 375         :raises RuntimeError: If binding to the new driver fails.
 376         """
 377         old_driver = InterfaceUtil.tg_get_interface_driver(node, pci_addr)
 378         if old_driver == driver:
 379             return
 380
 381         ssh = SSH()
 382         ssh.connect(node)
 383
 384         # Unbind from current driver
 385         if old_driver is not None:
 386             cmd = 'sh -c "echo {0} > /sys/bus/pci/drivers/{1}/unbind"'\
 387                 .format(pci_addr, old_driver)
 388             (ret_code, _, _) = ssh.exec_command_sudo(cmd)
 389             if int(ret_code) != 0:
 390                 raise RuntimeError("'{0}' failed on '{1}'"
 391                                    .format(cmd, node['host']))
 392
 393         # Bind to the new driver
 394         cmd = 'sh -c "echo {0} > /sys/bus/pci/drivers/{1}/bind"'\
 395             .format(pci_addr, driver)
 396         (ret_code, _, _) = ssh.exec_command_sudo(cmd)
 397         if int(ret_code) != 0:
 398             raise RuntimeError("'{0}' failed on '{1}'"
 399                                .format(cmd, node['host']))
 400
 401     @staticmethod
 402     def tg_get_interface_driver(node, pci_addr):
 403         """Get interface driver from the TG node.
 404
 405         :param node: Node to get interface driver on (must be TG node).
 406         :param pci_addr: PCI address of the interface.
 407         :type node: dict
 408         :type pci_addr: str
 409         :returns: Interface driver or None if not found.
 410         :rtype: str
 411         :raises RuntimeError: If PCI rescan or lspci command execution failed.
 412         """
 413         return DUTSetup.get_pci_dev_driver(node, pci_addr)
 414
 415     @staticmethod
 416     def tg_set_interfaces_udev_rules(node):
 417         """Set udev rules for interfaces.
 418
 419         Create udev rules file in /etc/udev/rules.d where are rules for each
 420         interface used by TG node, based on MAC interface has specific name.
 421         So after unbind and bind again to kernel driver interface has same
 422         name as before. This must be called after TG has set name for each
 423         port in topology dictionary.
 424         udev rule example
 425         SUBSYSTEM=="net", ACTION=="add", ATTR{address}=="52:54:00:e1:8a:0f",
 426         NAME="eth1"
 427
 428         :param node: Node to set udev rules on (must be TG node).
 429         :type node: dict
 430         :raises RuntimeError: If setting of udev rules fails.
 431         """
 432         ssh = SSH()
 433         ssh.connect(node)
 434
 435         cmd = 'rm -f {0}'.format(InterfaceUtil.__UDEV_IF_RULES_FILE)
 436         (ret_code, _, _) = ssh.exec_command_sudo(cmd)
 437         if int(ret_code) != 0:
 438             raise RuntimeError("'{0}' failed on '{1}'"
 439                                .format(cmd, node['host']))
 440
 441         for interface in node['interfaces'].values():
 442             rule = 'SUBSYSTEM==\\"net\\", ACTION==\\"add\\", ATTR{address}' + \
 443                    '==\\"' + interface['mac_address'] + '\\", NAME=\\"' + \
 444                    interface['name'] + '\\"'
 445             cmd = 'sh -c "echo \'{0}\' >> {1}"'.format(
 446                 rule, InterfaceUtil.__UDEV_IF_RULES_FILE)
 447             (ret_code, _, _) = ssh.exec_command_sudo(cmd)
 448             if int(ret_code) != 0:
 449                 raise RuntimeError("'{0}' failed on '{1}'"
 450                                    .format(cmd, node['host']))
 451
 452         cmd = '/etc/init.d/udev restart'
 453         ssh.exec_command_sudo(cmd)
 454
 455     @staticmethod
 456     def tg_set_interfaces_default_driver(node):
 457         """Set interfaces default driver specified in topology yaml file.
 458
 459         :param node: Node to setup interfaces driver on (must be TG node).
 460         :type node: dict
 461         """
 462         for interface in node['interfaces'].values():
 463             InterfaceUtil.tg_set_interface_driver(node,
 464                                                   interface['pci_address'],
 465                                                   interface['driver'])
 466
 467     @staticmethod
 468     def update_vpp_interface_data_on_node(node):
 469         """Update vpp generated interface data for a given node in DICT__nodes.
 470
 471         Updates interface names, software if index numbers and any other details
 472         generated specifically by vpp that are unknown before testcase run.
 473         It does this by dumping interface list to JSON output from all
 474         devices using vpp_api_test, and pairing known information from topology
 475         (mac address/pci address of interface) to state from VPP.
 476
 477         :param node: Node selected from DICT__nodes.
 478         :type node: dict
 479         """
 480         vat_executor = VatExecutor()
 481         vat_executor.execute_script_json_out("dump_interfaces.vat", node)
 482         interface_dump_json = vat_executor.get_script_stdout()
 483         VatJsonUtil.update_vpp_interface_data_from_json(node,
 484                                                         interface_dump_json)
 485
 486     @staticmethod
 487     def update_nic_interface_names(node):
 488         """Update interface names based on nic type and PCI address.
 489
 490         This method updates interface names in the same format as VPP does.
 491
 492         :param node: Node dictionary.
 493         :type node: dict
 494         """
 495         for ifc in node['interfaces'].values():
 496             if_pci = ifc['pci_address'].replace('.', ':').split(':')
 497             bus = '{:x}'.format(int(if_pci[1], 16))
 498             dev = '{:x}'.format(int(if_pci[2], 16))
 499             fun = '{:x}'.format(int(if_pci[3], 16))
 500             loc = '{bus}/{dev}/{fun}'.format(bus=bus, dev=dev, fun=fun)
 501             if ifc['model'] == 'Intel-XL710':
 502                 ifc['name'] = 'FortyGigabitEthernet{loc}'.format(loc=loc)
 503             elif ifc['model'] == 'Intel-X710':
 504                 ifc['name'] = 'TenGigabitEthernet{loc}'.format(loc=loc)
 505             elif ifc['model'] == 'Intel-X520-DA2':
 506                 ifc['name'] = 'TenGigabitEthernet{loc}'.format(loc=loc)
 507             elif ifc['model'] == 'Cisco-VIC-1385':
 508                 ifc['name'] = 'FortyGigabitEthernet{loc}'.format(loc=loc)
 509             elif ifc['model'] == 'Cisco-VIC-1227':
 510                 ifc['name'] = 'TenGigabitEthernet{loc}'.format(loc=loc)
 511             else:
 512                 ifc['name'] = 'UnknownEthernet{loc}'.format(loc=loc)
 513
 514     @staticmethod
 515     def update_nic_interface_names_on_all_duts(nodes):
 516         """Update interface names based on nic type and PCI address on all DUTs.
 517
 518         This method updates interface names in the same format as VPP does.
 519
 520         :param nodes: Topology nodes.
 521         :type nodes: dict
 522         """
 523         for node in nodes.values():
 524             if node['type'] == NodeType.DUT:
 525                 InterfaceUtil.update_nic_interface_names(node)
 526
 527     @staticmethod
 528     def update_tg_interface_data_on_node(node, skip_tg_udev=False):
 529         """Update interface name for TG/linux node in DICT__nodes.
 530
 531         .. note::
 532             # for dev in `ls /sys/class/net/`;
 533             > do echo "\"`cat /sys/class/net/$dev/address`\": \"$dev\""; done
 534             "52:54:00:9f:82:63": "eth0"
 535             "52:54:00:77:ae:a9": "eth1"
 536             "52:54:00:e1:8a:0f": "eth2"
 537             "00:00:00:00:00:00": "lo"
 538
 539         :param node: Node selected from DICT__nodes.
 540         :param skip_tg_udev: Skip udev rename on TG node.
 541         :type node: dict
 542         :type skip_tg_udev: bool
 543         :raises RuntimeError: If getting of interface name and MAC fails.
 544         """
 545         # First setup interface driver specified in yaml file
 546         InterfaceUtil.tg_set_interfaces_default_driver(node)
 547
 548         # Get interface names
 549         ssh = SSH()
 550         ssh.connect(node)
 551
 552         cmd = ('for dev in `ls /sys/class/net/`; do echo "\\"`cat '
 553                '/sys/class/net/$dev/address`\\": \\"$dev\\""; done;')
 554
 555         (ret_code, stdout, _) = ssh.exec_command(cmd)
 556         if int(ret_code) != 0:
 557             raise RuntimeError('Get interface name and MAC failed')
 558         tmp = "{" + stdout.rstrip().replace('\n', ',') + "}"
 559         interfaces = JsonParser().parse_data(tmp)
 560         for interface in node['interfaces'].values():
 561             name = interfaces.get(interface['mac_address'])
 562             if name is None:
 563                 continue
 564             interface['name'] = name
 565
 566         # Set udev rules for interfaces
 567         if not skip_tg_udev:
 568             InterfaceUtil.tg_set_interfaces_udev_rules(node)
 569
 570     @staticmethod
 571     def iface_update_numa_node(node):
 572         """For all interfaces from topology file update numa node based on
 573            information from the node.
 574
 575         :param node: Node from topology.
 576         :type node: dict
 577         :returns: Nothing.
 578         :raises ValueError: If numa node ia less than 0.
 579         :raises RuntimeError: If update of numa node failes.
 580         """
 581         ssh = SSH()
 582         for if_key in Topology.get_node_interfaces(node):
 583             if_pci = Topology.get_interface_pci_addr(node, if_key)
 584             ssh.connect(node)
 585             cmd = "cat /sys/bus/pci/devices/{}/numa_node".format(if_pci)
 586             for _ in range(3):
 587                 (ret, out, _) = ssh.exec_command(cmd)
 588                 if ret == 0:
 589                     try:
 590                         numa_node = int(out)
 591                         if numa_node < 0:
 592                             if CpuUtils.cpu_node_count(node) == 1:
 593                                 numa_node = 0
 594                             else:
 595                                 raise ValueError
 596                     except ValueError:
 597                         logger.trace('Reading numa location failed for: {0}'
 598                                      .format(if_pci))
 599                     else:
 600                         Topology.set_interface_numa_node(node, if_key,
 601                                                          numa_node)
 602                         break
 603             else:
 604                 raise RuntimeError('Update numa node failed for: {0}'
 605                                    .format(if_pci))
 606
 607     @staticmethod
 608     def update_all_numa_nodes(nodes, skip_tg=False):
 609         """For all nodes and all their interfaces from topology file update numa
 610         node information based on information from the node.
 611
 612         :param nodes: Nodes in the topology.
 613         :param skip_tg: Skip TG node
 614         :type nodes: dict
 615         :type skip_tg: bool
 616         :returns: Nothing.
 617         """
 618         for node in nodes.values():
 619             if node['type'] == NodeType.DUT:
 620                 InterfaceUtil.iface_update_numa_node(node)
 621             elif node['type'] == NodeType.TG and not skip_tg:
 622                 InterfaceUtil.iface_update_numa_node(node)
 623
 624     @staticmethod
 625     def update_all_interface_data_on_all_nodes(nodes, skip_tg=False,
 626                                                skip_tg_udev=False,
 627                                                numa_node=False):
 628         """Update interface names on all nodes in DICT__nodes.
 629
 630         This method updates the topology dictionary by querying interface lists
 631         of all nodes mentioned in the topology dictionary.
 632
 633         :param nodes: Nodes in the topology.
 634         :param skip_tg: Skip TG node.
 635         :param skip_tg_udev: Skip udev rename on TG node.
 636         :param numa_node: Retrieve numa_node location.
 637         :type nodes: dict
 638         :type skip_tg: bool
 639         :type skip_tg_udev: bool
 640         :type numa_node: bool
 641         """
 642         for node_data in nodes.values():
 643             if node_data['type'] == NodeType.DUT:
 644                 InterfaceUtil.update_vpp_interface_data_on_node(node_data)
 645             elif node_data['type'] == NodeType.TG and not skip_tg:
 646                 InterfaceUtil.update_tg_interface_data_on_node(
 647                     node_data, skip_tg_udev)
 648
 649             if numa_node:
 650                 if node_data['type'] == NodeType.DUT:
 651                     InterfaceUtil.iface_update_numa_node(node_data)
 652                 elif node_data['type'] == NodeType.TG and not skip_tg:
 653                     InterfaceUtil.iface_update_numa_node(node_data)
 654
 655     @staticmethod
 656     def create_vlan_subinterface(node, interface, vlan):
 657         """Create VLAN subinterface on node.
 658
 659         :param node: Node to add VLAN subinterface on.
 660         :param interface: Interface name on which create VLAN subinterface.
 661         :param vlan: VLAN ID of the subinterface to be created.
 662         :type node: dict
 663         :type interface: str
 664         :type vlan: int
 665         :returns: Name and index of created subinterface.
 666         :rtype: tuple
 667         :raises RuntimeError: if it is unable to create VLAN subinterface on the
 668             node.
 669         """
 670         iface_key = Topology.get_interface_by_name(node, interface)
 671         sw_if_index = Topology.get_interface_sw_index(node, iface_key)
 672
 673         output = VatExecutor.cmd_from_template(node, "create_vlan_subif.vat",
 674                                                sw_if_index=sw_if_index,
 675                                                vlan=vlan)
 676         if output[0]["retval"] == 0:
 677             sw_vlan_idx = output[0]["sw_if_index"]
 678             logger.trace('VLAN subinterface with sw_if_index {} and VLAN ID {} '
 679                          'created on node {}'.format(sw_vlan_idx,
 680                                                      vlan, node['host']))
 681             if_key = Topology.add_new_port(node, "vlan_subif")
 682             Topology.update_interface_sw_if_index(node, if_key, sw_vlan_idx)
 683             ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_vlan_idx)
 684             Topology.update_interface_name(node, if_key, ifc_name)
 685         else:
 686             raise RuntimeError('Unable to create VLAN subinterface on node {}'
 687                                .format(node['host']))
 688
 689         with VatTerminal(node, False) as vat:
 690             vat.vat_terminal_exec_cmd('exec show interfaces')
 691
 692         return '{}.{}'.format(interface, vlan), sw_vlan_idx
 693
 694     @staticmethod
 695     def create_vxlan_interface(node, vni, source_ip, destination_ip):
 696         """Create VXLAN interface and return sw if index of created interface.
 697
 698         Executes "vxlan_add_del_tunnel src {src} dst {dst} vni {vni}" VAT
 699         command on the node.
 700
 701         :param node: Node where to create VXLAN interface.
 702         :param vni: VXLAN Network Identifier.
 703         :param source_ip: Source IP of a VXLAN Tunnel End Point.
 704         :param destination_ip: Destination IP of a VXLAN Tunnel End Point.
 705         :type node: dict
 706         :type vni: int
 707         :type source_ip: str
 708         :type destination_ip: str
 709         :returns: SW IF INDEX of created interface.
 710         :rtype: int
 711         :raises RuntimeError: if it is unable to create VxLAN interface on the
 712             node.
 713         """
 714         output = VatExecutor.cmd_from_template(node, "vxlan_create.vat",
 715                                                src=source_ip,
 716                                                dst=destination_ip,
 717                                                vni=vni)
 718         output = output[0]
 719
 720         if output["retval"] == 0:
 721             sw_if_idx = output["sw_if_index"]
 722             if_key = Topology.add_new_port(node, "vxlan_tunnel")
 723             Topology.update_interface_sw_if_index(node, if_key, sw_if_idx)
 724             ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_idx)
 725             Topology.update_interface_name(node, if_key, ifc_name)
 726             return sw_if_idx
 727         else:
 728             raise RuntimeError("Unable to create VXLAN interface on node {0}"
 729                                .format(node))
 730
 731     @staticmethod
 732     def vxlan_dump(node, interface=None):
 733         """Get VxLAN data for the given interface.
 734
 735         :param node: VPP node to get interface data from.
 736         :param interface: Numeric index or name string of a specific interface.
 737             If None, information about all VxLAN interfaces is returned.
 738         :type node: dict
 739         :type interface: int or str
 740         :returns: Dictionary containing data for the given VxLAN interface or if
 741             interface=None, the list of dictionaries with all VxLAN interfaces.
 742         :rtype: dict or list
 743         :raises TypeError: if the data type of interface is neither basestring
 744             nor int.
 745         """
 746         param = "sw_if_index"
 747         if interface is None:
 748             param = ''
 749             sw_if_index = ''
 750         elif isinstance(interface, basestring):
 751             sw_if_index = Topology.get_interface_sw_index(node, interface)
 752         elif isinstance(interface, int):
 753             sw_if_index = interface
 754         else:
 755             raise TypeError("Wrong interface format {0}".format(interface))
 756
 757         with VatTerminal(node) as vat:
 758             response = vat.vat_terminal_exec_cmd_from_template(
 759                 "vxlan_dump.vat", param=param, sw_if_index=sw_if_index)
 760
 761         if sw_if_index:
 762             for vxlan in response[0]:
 763                 if vxlan["sw_if_index"] == sw_if_index:
 764                     return vxlan
 765             return {}
 766         return response[0]
 767
 768     @staticmethod
 769     def vhost_user_dump(node):
 770         """Get vhost-user data for the given node.
 771
 772         :param node: VPP node to get interface data from.
 773         :type node: dict
 774         :returns: List of dictionaries with all vhost-user interfaces.
 775         :rtype: list
 776         """
 777         with VatTerminal(node) as vat:
 778             response = vat.vat_terminal_exec_cmd_from_template(
 779                 "vhost_user_dump.vat")
 780
 781         return response[0]
 782
 783     @staticmethod
 784     def tap_dump(node, name=None):
 785         """Get all TAP interface data from the given node, or data about
 786         a specific TAP interface.
 787
 788         :param node: VPP node to get data from.
 789         :param name: Optional name of a specific TAP interface.
 790         :type node: dict
 791         :type name: str
 792         :returns: Dictionary of information about a specific TAP interface, or
 793             a List of dictionaries containing all TAP data for the given node.
 794         :rtype: dict or list
 795         """
 796         with VatTerminal(node) as vat:
 797             response = vat.vat_terminal_exec_cmd_from_template(
 798                 "tap_dump.vat")
 799         if name is None:
 800             return response[0]
 801         for item in response[0]:
 802             if name == item['dev_name']:
 803                 return item
 804         return {}
 805
 806     @staticmethod
 807     def create_subinterface(node, interface, sub_id, outer_vlan_id=None,
 808                             inner_vlan_id=None, type_subif=None):
 809         """Create sub-interface on node. It is possible to set required
 810         sub-interface type and VLAN tag(s).
 811
 812         :param node: Node to add sub-interface.
 813         :param interface: Interface name on which create sub-interface.
 814         :param sub_id: ID of the sub-interface to be created.
 815         :param outer_vlan_id: Optional outer VLAN ID.
 816         :param inner_vlan_id: Optional inner VLAN ID.
 817         :param type_subif: Optional type of sub-interface. Values supported by
 818             VPP: [no_tags] [one_tag] [two_tags] [dot1ad] [exact_match]
 819             [default_sub]
 820         :type node: dict
 821         :type interface: str or int
 822         :type sub_id: int
 823         :type outer_vlan_id: int
 824         :type inner_vlan_id: int
 825         :type type_subif: str
 826         :returns: Name and index of created sub-interface.
 827         :rtype: tuple
 828         :raises RuntimeError: If it is not possible to create sub-interface.
 829         """
 830
 831         outer_vlan_id = 'outer_vlan_id {0}'.format(outer_vlan_id)\
 832             if outer_vlan_id else ''
 833
 834         inner_vlan_id = 'inner_vlan_id {0}'.format(inner_vlan_id)\
 835             if inner_vlan_id else ''
 836
 837         if type_subif is None:
 838             type_subif = ''
 839
 840         if isinstance(interface, basestring):
 841             iface_key = Topology.get_interface_by_name(node, interface)
 842             sw_if_index = Topology.get_interface_sw_index(node, iface_key)
 843         else:
 844             sw_if_index = interface
 845
 846         output = VatExecutor.cmd_from_template(node, "create_sub_interface.vat",
 847                                                sw_if_index=sw_if_index,
 848                                                sub_id=sub_id,
 849                                                outer_vlan_id=outer_vlan_id,
 850                                                inner_vlan_id=inner_vlan_id,
 851                                                type_subif=type_subif)
 852
 853         if output[0]["retval"] == 0:
 854             sw_vlan_idx = output[0]["sw_if_index"]
 855             logger.trace('Created subinterface with index {}'
 856                          .format(sw_vlan_idx))
 857             if_key = Topology.add_new_port(node, "subinterface")
 858             Topology.update_interface_sw_if_index(node, if_key, sw_vlan_idx)
 859             ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_vlan_idx)
 860             Topology.update_interface_name(node, if_key, ifc_name)
 861         else:
 862             raise RuntimeError('Unable to create sub-interface on node {}'
 863                                .format(node['host']))
 864
 865         with VatTerminal(node, json_param=False) as vat:
 866             vat.vat_terminal_exec_cmd('exec show interfaces')
 867
 868         name = '{}.{}'.format(interface, sub_id)
 869         return name, sw_vlan_idx
 870
 871     @staticmethod
 872     def create_gre_tunnel_interface(node, source_ip, destination_ip):
 873         """Create GRE tunnel interface on node.
 874
 875         :param node: VPP node to add tunnel interface.
 876         :param source_ip: Source of the GRE tunnel.
 877         :param destination_ip: Destination of the GRE tunnel.
 878         :type node: dict
 879         :type source_ip: str
 880         :type destination_ip: str
 881         :returns: Name and index of created GRE tunnel interface.
 882         :rtype: tuple
 883         :raises RuntimeError: If unable to create GRE tunnel interface.
 884         """
 885
 886         try:
 887             src_address = inet_pton(AF_INET6, source_ip)
 888             dst_address = inet_pton(AF_INET6, destination_ip)
 889             is_ipv6 = 1
 890         except inet_error:
 891             src_address = inet_pton(AF_INET, source_ip)
 892             dst_address = inet_pton(AF_INET, destination_ip)
 893             is_ipv6 = 0
 894
 895         cmd = 'gre_tunnel_add_del'
 896         tunnel = dict(type=0,
 897                       instance=Constants.BITWISE_NON_ZERO,
 898                       src=src_address,
 899                       dst=dst_address,
 900                       outer_fib_id=0,
 901                       session_id=0)
 902         args = dict(is_add=1,
 903                     tunnel=tunnel)
 904         err_msg = 'Failed to create GRE tunnel interface on host {host}'.format(
 905             host=node['host'])
 906         with PapiExecutor(node) as papi_exec:
 907             papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg).\
 908                 verify_reply(err_msg=err_msg)
 909
 910         sw_if_idx = papi_resp['sw_if_index']
 911         if_key = Topology.add_new_port(node, 'gre_tunnel')
 912         Topology.update_interface_sw_if_index(node, if_key, sw_if_idx)
 913         ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_idx)
 914         Topology.update_interface_name(node, if_key, ifc_name)
 915
 916         return ifc_name, sw_if_idx
 917
 918     @staticmethod
 919     def vpp_create_loopback(node):
 920         """Create loopback interface on VPP node.
 921
 922         :param node: Node to create loopback interface on.
 923         :type node: dict
 924         :returns: SW interface index.
 925         :rtype: int
 926         :raises RuntimeError: If it is not possible to create loopback on the
 927             node.
 928         """
 929         out = VatExecutor.cmd_from_template(node, "create_loopback.vat")
 930         if out[0].get('retval') == 0:
 931             sw_if_idx = out[0].get('sw_if_index')
 932             if_key = Topology.add_new_port(node, "loopback")
 933             Topology.update_interface_sw_if_index(node, if_key, sw_if_idx)
 934             ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_idx)
 935             Topology.update_interface_name(node, if_key, ifc_name)
 936             return sw_if_idx
 937         else:
 938             raise RuntimeError('Create loopback failed on node "{}"'
 939                                .format(node['host']))
 940
 941     @staticmethod
 942     def vpp_create_bond_interface(node, mode, load_balance=None, mac=None):
 943         """Create bond interface on VPP node.
 944
 945         :param node: DUT node from topology.
 946         :param mode: Link bonding mode.
 947         :param load_balance: Load balance (optional, valid for xor and lacp
 948             modes, otherwise ignored).
 949         :param mac: MAC address to assign to the bond interface (optional).
 950         :type node: dict
 951         :type mode: str
 952         :type load_balance: str
 953         :type mac: str
 954         :returns: Interface key (name) in topology.
 955         :rtype: str
 956         :raises RuntimeError: If it is not possible to create bond interface on
 957             the node.
 958         """
 959         hw_addr = '' if mac is None else 'hw-addr {mac}'.format(mac=mac)
 960         ldb = '' if load_balance is None \
 961             else 'lb {ldb}'.format(ldb=load_balance)
 962
 963         output = VatExecutor.cmd_from_template(
 964             node, 'create_bond_interface.vat', mode=mode, lb=ldb, mac=hw_addr)
 965
 966         if output[0].get('retval') == 0:
 967             sw_if_idx = output[0].get('sw_if_index')
 968             InterfaceUtil.add_eth_interface(node, sw_if_idx=sw_if_idx,
 969                                             ifc_pfx='eth_bond')
 970             if_key = Topology.get_interface_by_sw_index(node, sw_if_idx)
 971             return if_key
 972         else:
 973             raise RuntimeError('Create bond interface failed on "{host}"'.
 974                                format(host=node['host']))
 975
 976     @staticmethod
 977     def add_eth_interface(node, ifc_name=None, sw_if_idx=None, ifc_pfx=None):
 978         """Add ethernet interface to current topology.
 979
 980         :param node: DUT node from topology.
 981         :param ifc_name: Name of the interface.
 982         :param sw_if_idx: SW interface index.
 983         :param ifc_pfx: Interface key prefix.
 984         :type node: dict
 985         :type ifc_name: str
 986         :type sw_if_idx: int
 987         :type ifc_pfx: str
 988         """
 989         if_key = Topology.add_new_port(node, ifc_pfx)
 990
 991         vat_executor = VatExecutor()
 992         vat_executor.execute_script_json_out("dump_interfaces.vat", node)
 993         interface_dump_json = vat_executor.get_script_stdout()
 994
 995         if ifc_name and sw_if_idx is None:
 996             sw_if_idx = VatJsonUtil.get_interface_sw_index_from_json(
 997                 interface_dump_json, ifc_name)
 998         Topology.update_interface_sw_if_index(node, if_key, sw_if_idx)
 999         if sw_if_idx and ifc_name is None:
1000             ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_idx)
1001         Topology.update_interface_name(node, if_key, ifc_name)
1002         ifc_mac = VatJsonUtil.get_interface_mac_from_json(
1003             interface_dump_json, sw_if_idx)
1004         Topology.update_interface_mac_address(node, if_key, ifc_mac)
1005
1006     @staticmethod
1007     def vpp_create_avf_interface(node, vf_pci_addr, num_rx_queues=None):
1008         """Create AVF interface on VPP node.
1009
1010         :param node: DUT node from topology.
1011         :param vf_pci_addr: Virtual Function PCI address.
1012         :param num_rx_queues: Number of RX queues.
1013         :type node: dict
1014         :type vf_pci_addr: str
1015         :type num_rx_queues: int
1016         :returns: Interface key (name) in topology.
1017         :rtype: str
1018         :raises RuntimeError: If it is not possible to create AVF interface on
1019             the node.
1020         """
1021         num_rx_queues = 'num-rx-queues {num_rx_queues}'\
1022             .format(num_rx_queues=num_rx_queues) if num_rx_queues else ''
1023
1024         with VatTerminal(node, json_param=False) as vat:
1025             vat.vat_terminal_exec_cmd_from_template('create_avf_interface.vat',
1026                                                     vf_pci_addr=vf_pci_addr,
1027                                                     num_rx_queues=num_rx_queues)
1028             output = vat.vat_stdout
1029
1030         if output is not None:
1031             sw_if_idx = int(output.split()[4])
1032             InterfaceUtil.add_eth_interface(node, sw_if_idx=sw_if_idx,
1033                                             ifc_pfx='eth_avf')
1034             if_key = Topology.get_interface_by_sw_index(node, sw_if_idx)
1035             return if_key
1036         else:
1037             raise RuntimeError('Create AVF interface failed on {host}'.
1038                                format(host=node['host']))
1039
1040     @staticmethod
1041     def vpp_enslave_physical_interface(node, interface, bond_interface):
1042         """Enslave physical interface to bond interface on VPP node.
1043
1044         :param node: DUT node from topology.
1045         :param interface: Physical interface key from topology file.
1046         :param bond_interface: Load balance
1047         :type node: dict
1048         :type interface: str
1049         :type bond_interface: str
1050         :raises RuntimeError: If it is not possible to enslave physical
1051             interface to bond interface on the node.
1052         """
1053         ifc = Topology.get_interface_sw_index(node, interface)
1054         bond_ifc = Topology.get_interface_sw_index(node, bond_interface)
1055
1056         output = VatExecutor.cmd_from_template(
1057             node, 'enslave_physical_interface.vat', p_int=ifc, b_int=bond_ifc)
1058
1059         retval = output[0].get('retval', None)
1060         if retval is None or int(retval) != 0:
1061             raise RuntimeError('Enslave physical interface {ifc} to bond '
1062                                'interface {bond} failed on node "{n}"'
1063                                .format(ifc=interface, bond=bond_interface,
1064                                        n=node['host']))
1065
1066     @staticmethod
1067     def vpp_show_bond_data_on_node(node, details=False):
1068         """Show (detailed) bond information on VPP node.
1069
1070         :param node: DUT node from topology.
1071         :param details: If detailed information is required or not.
1072         :type node: dict
1073         :type details: bool
1074         """
1075         cmd = 'exec show bond details' if details else 'exec show bond'
1076         with VatTerminal(node, json_param=False) as vat:
1077             vat.vat_terminal_exec_cmd(cmd)
1078
1079     @staticmethod
1080     def vpp_show_bond_data_on_all_nodes(nodes, details=False):
1081         """Show (detailed) bond information on all VPP nodes in DICT__nodes.
1082
1083         :param nodes: Nodes in the topology.
1084         :param details: If detailed information is required or not.
1085         :type nodes: dict
1086         :type details: bool
1087         """
1088         for node_data in nodes.values():
1089             if node_data['type'] == NodeType.DUT:
1090                 InterfaceUtil.vpp_show_bond_data_on_node(node_data, details)
1091
1092     @staticmethod
1093     def vpp_enable_input_acl_interface(node, interface, ip_version,
1094                                        table_index):
1095         """Enable input acl on interface.
1096
1097         :param node: VPP node to setup interface for input acl.
1098         :param interface: Interface to setup input acl.
1099         :param ip_version: Version of IP protocol.
1100         :param table_index: Classify table index.
1101         :type node: dict
1102         :type interface: str or int
1103         :type ip_version: str
1104         :type table_index: int
1105         """
1106         if isinstance(interface, basestring):
1107             sw_if_index = Topology.get_interface_sw_index(node, interface)
1108         else:
1109             sw_if_index = interface
1110
1111         with VatTerminal(node) as vat:
1112             vat.vat_terminal_exec_cmd_from_template("input_acl_int.vat",
1113                                                     sw_if_index=sw_if_index,
1114                                                     ip_version=ip_version,
1115                                                     table_index=table_index)
1116
1117     @staticmethod
1118     def get_interface_classify_table(node, interface):
1119         """Get name of classify table for the given interface.
1120
1121         :param node: VPP node to get data from.
1122         :param interface: Name or sw_if_index of a specific interface.
1123         :type node: dict
1124         :type interface: str or int
1125         :returns: Classify table name.
1126         :rtype: str
1127         """
1128         if isinstance(interface, basestring):
1129             sw_if_index = InterfaceUtil.get_sw_if_index(node, interface)
1130         else:
1131             sw_if_index = interface
1132
1133         with VatTerminal(node) as vat:
1134             data = vat.vat_terminal_exec_cmd_from_template(
1135                 "classify_interface_table.vat",
1136                 sw_if_index=sw_if_index)
1137         return data[0]
1138
1139     @staticmethod
1140     def get_interface_vrf_table(node, interface):
1141         """Get vrf ID for the given interface.
1142
1143         :param node: VPP node.
1144         :param interface: Name or sw_if_index of a specific interface.
1145         :type node: dict
1146         :type interface: str or int
1147         :returns: vrf ID of the specified interface.
1148         :rtype: int
1149         """
1150
1151         if isinstance(interface, basestring):
1152             sw_if_index = InterfaceUtil.get_sw_if_index(node, interface)
1153         else:
1154             sw_if_index = interface
1155
1156         with VatTerminal(node) as vat:
1157             data = vat.vat_terminal_exec_cmd_from_template(
1158                 "interface_vrf_dump.vat",
1159                 sw_if_index=sw_if_index)
1160         return data[0]["vrf_id"]
1161
1162     @staticmethod
1163     def get_sw_if_index(node, interface_name):
1164         """Get sw_if_index for the given interface from actual interface dump.
1165
1166         :param node: VPP node to get interface data from.
1167         :param interface_name: Name of the specific interface.
1168         :type node: dict
1169         :type interface_name: str
1170         :returns: sw_if_index of the given interface.
1171         :rtype: str
1172         """
1173
1174         with VatTerminal(node) as vat:
1175             if_data = vat.vat_terminal_exec_cmd_from_template(
1176                 "interface_dump.vat")
1177         for interface in if_data[0]:
1178             if interface["interface_name"] == interface_name:
1179                 return interface["sw_if_index"]
1180
1181         return None
1182
1183     @staticmethod
1184     def vxlan_gpe_dump(node, interface_name=None):
1185         """Get VxLAN GPE data for the given interface.
1186
1187         :param node: VPP node to get interface data from.
1188         :param interface_name: Name of the specific interface. If None,
1189             information about all VxLAN GPE interfaces is returned.
1190         :type node: dict
1191         :type interface_name: str
1192         :returns: Dictionary containing data for the given VxLAN GPE interface
1193             or if interface=None, the list of dictionaries with all VxLAN GPE
1194             interfaces.
1195         :rtype: dict or list
1196         """
1197
1198         with VatTerminal(node) as vat:
1199             vxlan_gpe_data = vat.vat_terminal_exec_cmd_from_template(
1200                 "vxlan_gpe_dump.vat")
1201
1202         if interface_name:
1203             sw_if_index = InterfaceUtil.get_sw_if_index(node, interface_name)
1204             if sw_if_index:
1205                 for vxlan_gpe in vxlan_gpe_data[0]:
1206                     if vxlan_gpe["sw_if_index"] == sw_if_index:
1207                         return vxlan_gpe
1208             return {}
1209
1210         return vxlan_gpe_data[0]
1211
1212     @staticmethod
1213     def vpp_proxy_arp_interface_enable(node, interface):
1214         """Enable proxy ARP on interface.
1215
1216         :param node: VPP node to enable proxy ARP on interface.
1217         :param interface: Interface to enable proxy ARP.
1218         :type node: dict
1219         :type interface: str or int
1220         """
1221         if isinstance(interface, basestring):
1222             sw_if_index = InterfaceUtil.get_sw_if_index(node, interface)
1223         else:
1224             sw_if_index = interface
1225
1226         with VatTerminal(node) as vat:
1227             vat.vat_terminal_exec_cmd_from_template(
1228                 "proxy_arp_intfc_enable.vat",
1229                 sw_if_index=sw_if_index)
1230
1231     @staticmethod
1232     def vpp_ip_source_check_setup(node, interface):
1233         """Setup Reverse Path Forwarding source check on interface.
1234
1235         :param node: Node to setup RPF source check.
1236         :param interface: Interface name to setup RPF source check.
1237         :type node: dict
1238         :type interface: str
1239         """
1240         with VatTerminal(node) as vat:
1241             vat.vat_terminal_exec_cmd_from_template("ip_source_check.vat",
1242                                                     interface_name=interface)
1243
1244     @staticmethod
1245     def assign_interface_to_fib_table(node, interface, table_id, ipv6=False):
1246         """Assign VPP interface to specific VRF/FIB table.
1247
1248         :param node: VPP node where the FIB and interface are located.
1249         :param interface: Interface to be assigned to FIB.
1250         :param table_id: VRF table ID.
1251         :param ipv6: Assign to IPv6 table. Default False.
1252         :type node: dict
1253         :type interface: str or int
1254         :type table_id: int
1255         :type ipv6: bool
1256         """
1257         if isinstance(interface, basestring):
1258             sw_if_index = Topology.get_interface_sw_index(node, interface)
1259         else:
1260             sw_if_index = interface
1261
1262         ipv6 = 'ipv6' if ipv6 else ''
1263
1264         with VatTerminal(node) as vat:
1265             ret = vat.vat_terminal_exec_cmd_from_template(
1266                 "set_fib_to_interface.vat",
1267                 sw_index=sw_if_index, vrf=table_id, ipv6=ipv6)
1268
1269         if ret[0]["retval"] != 0:
1270             raise RuntimeError('Unable to assign interface to FIB node {}.'
1271                                .format(node))
1272
1273     @staticmethod
1274     def set_linux_interface_mac(node, interface, mac, namespace=None,
1275                                 vf_id=None):
1276         """Set MAC address for interface in linux.
1277
1278         :param node: Node where to execute command.
1279         :param interface: Interface in namespace.
1280         :param mac: MAC to be assigned to interface.
1281         :param namespace: Execute command in namespace. Optional
1282         :param vf_id: Virtual Function id. Optional
1283         :type node: dict
1284         :type interface: str
1285         :type mac: str
1286         :type namespace: str
1287         :type vf_id: int
1288         """
1289         mac_str = 'vf {vf_id} mac {mac}'.format(vf_id=vf_id, mac=mac) \
1290             if vf_id is not None else 'address {mac}'.format(mac=mac)
1291         ns_str = 'ip netns exec {ns}'.format(ns=namespace) if namespace else ''
1292
1293         cmd = ('{ns} ip link set {interface} {mac}'.
1294                format(ns=ns_str, interface=interface, mac=mac_str))
1295         exec_cmd_no_error(node, cmd, sudo=True)
1296
1297     @staticmethod
1298     def set_linux_interface_trust_on(node, interface, namespace=None,
1299                                      vf_id=None):
1300         """Set trust on (promisc) for interface in linux.
1301
1302         :param node: Node where to execute command.
1303         :param interface: Interface in namespace.
1304         :param namespace: Execute command in namespace. Optional
1305         :param vf_id: Virtual Function id. Optional
1306         :type node: dict
1307         :type interface: str
1308         :type namespace: str
1309         :type vf_id: int
1310         """
1311         trust_str = 'vf {vf_id} trust on'.format(vf_id=vf_id) \
1312             if vf_id is not None else 'trust on'
1313         ns_str = 'ip netns exec {ns}'.format(ns=namespace) if namespace else ''
1314
1315         cmd = ('{ns} ip link set dev {interface} {trust}'.
1316                format(ns=ns_str, interface=interface, trust=trust_str))
1317         exec_cmd_no_error(node, cmd, sudo=True)
1318
1319     @staticmethod
1320     def set_linux_interface_spoof_off(node, interface, namespace=None,
1321                                       vf_id=None):
1322         """Set spoof off for interface in linux.
1323
1324         :param node: Node where to execute command.
1325         :param interface: Interface in namespace.
1326         :param namespace: Execute command in namespace. Optional
1327         :param vf_id: Virtual Function id. Optional
1328         :type node: dict
1329         :type interface: str
1330         :type namespace: str
1331         :type vf_id: int
1332         """
1333         spoof_str = 'vf {vf_id} spoof off'.format(vf_id=vf_id) \
1334             if vf_id is not None else 'spoof off'
1335         ns_str = 'ip netns exec {ns}'.format(ns=namespace) if namespace else ''
1336
1337         cmd = ('{ns} ip link set dev {interface} {spoof}'.
1338                format(ns=ns_str, interface=interface, spoof=spoof_str))
1339         exec_cmd_no_error(node, cmd, sudo=True)
1340
1341     @staticmethod
1342     def init_avf_interface(node, ifc_key, numvfs=1, osi_layer='L2'):
1343         """Init PCI device by creating VFs and bind them to vfio-pci for AVF
1344         driver testing on DUT.
1345
1346         :param node: DUT node.
1347         :param ifc_key: Interface key from topology file.
1348         :param numvfs: Number of VFs to initialize, 0 - disable the VFs.
1349         :param osi_layer: OSI Layer type to initialize TG with.
1350             Default value "L2" sets linux interface spoof off.
1351         :type node: dict
1352         :type ifc_key: str
1353         :type numvfs: int
1354         :type osi_layer: str
1355         :returns: Virtual Function topology interface keys.
1356         :rtype: list
1357         """
1358         ssh = SSH()
1359         ssh.connect(node)
1360
1361         # Read PCI address and driver.
1362         pf_pci_addr = Topology.get_interface_pci_addr(node, ifc_key)
1363         pf_mac_addr = Topology.get_interface_mac(node, ifc_key).split(":")
1364         uio_driver = Topology.get_uio_driver(node)
1365         kernel_driver = Topology.get_interface_driver(node, ifc_key)
1366         current_driver = DUTSetup.get_pci_dev_driver(
1367             node, pf_pci_addr.replace(':', r'\:'))
1368
1369         VPPUtil.stop_vpp_service(node)
1370         if current_driver != kernel_driver:
1371             # PCI device must be re-bound to kernel driver before creating VFs.
1372             DUTSetup.verify_kernel_module(node, kernel_driver, force_load=True)
1373             # Stop VPP to prevent deadlock.
1374             # Unbind from current driver.
1375             DUTSetup.pci_driver_unbind(node, pf_pci_addr)
1376             # Bind to kernel driver.
1377             DUTSetup.pci_driver_bind(node, pf_pci_addr, kernel_driver)
1378
1379         # Initialize PCI VFs
1380         DUTSetup.set_sriov_numvfs(node, pf_pci_addr, numvfs)
1381
1382         vf_ifc_keys = []
1383         # Set MAC address and bind each virtual function to uio driver.
1384         for vf_id in range(numvfs):
1385             vf_mac_addr = ":".join([pf_mac_addr[0], pf_mac_addr[2],
1386                                     pf_mac_addr[3], pf_mac_addr[4],
1387                                     pf_mac_addr[5], "{:02x}".format(vf_id)])
1388
1389             pf_dev = '`basename /sys/bus/pci/devices/{pci}/net/*`'.\
1390                 format(pci=pf_pci_addr)
1391             InterfaceUtil.set_linux_interface_trust_on(node, pf_dev,
1392                                                        vf_id=vf_id)
1393             if osi_layer == 'L2':
1394                 InterfaceUtil.set_linux_interface_spoof_off(node, pf_dev,
1395                                                             vf_id=vf_id)
1396             InterfaceUtil.set_linux_interface_mac(node, pf_dev, vf_mac_addr,
1397                                                   vf_id=vf_id)
1398
1399             DUTSetup.pci_vf_driver_unbind(node, pf_pci_addr, vf_id)
1400             DUTSetup.pci_vf_driver_bind(node, pf_pci_addr, vf_id, uio_driver)
1401
1402             # Add newly created ports into topology file
1403             vf_ifc_name = '{pf_if_key}_vf'.format(pf_if_key=ifc_key)
1404             vf_pci_addr = DUTSetup.get_virtfn_pci_addr(node, pf_pci_addr, vf_id)
1405             vf_ifc_key = Topology.add_new_port(node, vf_ifc_name)
1406             Topology.update_interface_name(node, vf_ifc_key,
1407                                            vf_ifc_name+str(vf_id+1))
1408             Topology.update_interface_mac_address(node, vf_ifc_key, vf_mac_addr)
1409             Topology.update_interface_pci_address(node, vf_ifc_key, vf_pci_addr)
1410             vf_ifc_keys.append(vf_ifc_key)
1411
1412         return vf_ifc_keys
1413
1414     @staticmethod
1415     def vpp_create_multiple_vxlan_ipv4_tunnels(
1416             node, node_vxlan_if, node_vlan_if, op_node, op_node_if,
1417             n_tunnels, vni_start, src_ip_start, dst_ip_start, ip_step, ip_limit,
1418             bd_id_start):
1419         """Create multiple VXLAN tunnel interfaces and VLAN sub-interfaces on
1420         VPP node.
1421
1422         Put each pair of VXLAN tunnel interface and VLAN sub-interface to
1423         separate bridge-domain.
1424
1425         :param node: VPP node to create VXLAN tunnel interfaces.
1426         :param node_vxlan_if: VPP node interface key to create VXLAN tunnel
1427             interfaces.
1428         :param node_vlan_if: VPP node interface key to create VLAN
1429             sub-interface.
1430         :param op_node: Opposite VPP node for VXLAN tunnel interfaces.
1431         :param op_node_if: Opposite VPP node interface key for VXLAN tunnel
1432             interfaces.
1433         :param n_tunnels: Number of tunnel interfaces to create.
1434         :param vni_start: VNI start ID.
1435         :param src_ip_start: VXLAN tunnel source IP address start.
1436         :param dst_ip_start: VXLAN tunnel destination IP address start.
1437         :param ip_step: IP address incremental step.
1438         :param ip_limit: IP address limit.
1439         :param bd_id_start: Bridge-domain ID start.
1440         :type node: dict
1441         :type node_vxlan_if: str
1442         :type node_vlan_if: str
1443         :type op_node: dict
1444         :type op_node_if: str
1445         :type n_tunnels: int
1446         :type vni_start: int
1447         :type src_ip_start: str
1448         :type dst_ip_start: str
1449         :type ip_step: int
1450         :type ip_limit: str
1451         :type bd_id_start: int
1452         """
1453         # configure IPs, create VXLAN interfaces and VLAN sub-interfaces
1454         vxlan_count = InterfaceUtil.vpp_create_vxlan_and_vlan_interfaces(
1455             node, node_vxlan_if, node_vlan_if, n_tunnels, vni_start,
1456             src_ip_start, dst_ip_start, ip_step, ip_limit)
1457
1458         # update topology with VXLAN interfaces and VLAN sub-interfaces data
1459         # and put interfaces up
1460         InterfaceUtil.vpp_put_vxlan_and_vlan_interfaces_up(
1461             node, vxlan_count, node_vlan_if)
1462
1463         # configure bridge domains, ARPs and routes
1464         InterfaceUtil.vpp_put_vxlan_and_vlan_interfaces_to_bridge_domain(
1465             node, node_vxlan_if, vxlan_count, op_node, op_node_if, dst_ip_start,
1466             ip_step, bd_id_start)
1467
1468     @staticmethod
1469     def vpp_create_vxlan_and_vlan_interfaces(
1470             node, node_vxlan_if, node_vlan_if, vxlan_count, vni_start,
1471             src_ip_start, dst_ip_start, ip_step, ip_limit):
1472         """
1473         Configure IPs, create VXLAN interfaces and VLAN sub-interfaces on VPP
1474         node.
1475
1476         :param node: VPP node.
1477         :param node_vxlan_if: VPP node interface key to create VXLAN tunnel
1478             interfaces.
1479         :param node_vlan_if: VPP node interface key to create VLAN
1480             sub-interface.
1481         :param vxlan_count: Number of tunnel interfaces to create.
1482         :param vni_start: VNI start ID.
1483         :param src_ip_start: VXLAN tunnel source IP address start.
1484         :param dst_ip_start: VXLAN tunnel destination IP address start.
1485         :param ip_step: IP address incremental step.
1486         :param ip_limit: IP address limit.
1487         :type node: dict
1488         :type node_vxlan_if: str
1489         :type node_vlan_if: str
1490         :type vxlan_count: int
1491         :type vni_start: int
1492         :type src_ip_start: str
1493         :type dst_ip_start: str
1494         :type ip_step: int
1495         :type ip_limit: str
1496         :returns: Number of created VXLAN interfaces.
1497         :rtype: int
1498         """
1499         commands = list()
1500
1501         src_ip_start_int = IPUtil.ip_to_int(src_ip_start)
1502         dst_ip_start_int = IPUtil.ip_to_int(dst_ip_start)
1503         ip_limit_int = IPUtil.ip_to_int(ip_limit)
1504
1505         tmp_fn = '/tmp/create_vxlan_interfaces.config'
1506         for i in range(0, vxlan_count):
1507             src_ip_int = src_ip_start_int + i * ip_step
1508             dst_ip_int = dst_ip_start_int + i * ip_step
1509             if src_ip_int > ip_limit_int or dst_ip_int > ip_limit_int:
1510                 logger.warn("Can't do more iterations - IPv4 address limit "
1511                             "has been reached.")
1512                 vxlan_count = i
1513                 break
1514             src_ip = IPUtil.int_to_ip(src_ip_int)
1515             dst_ip = IPUtil.int_to_ip(dst_ip_int)
1516             commands.append(
1517                 'sw_interface_add_del_address sw_if_index {sw_idx} {ip}/32\n'
1518                 .format(sw_idx=Topology.get_interface_sw_index(
1519                     node, node_vxlan_if), ip=src_ip))
1520             commands.append(
1521                 'vxlan_add_del_tunnel src {src_ip} dst {dst_ip} vni {vni}\n'
1522                 .format(src_ip=src_ip, dst_ip=dst_ip, vni=vni_start+i))
1523             commands.append(
1524                 'create_vlan_subif sw_if_index {sw_idx} vlan {vlan}\n'
1525                 .format(sw_idx=Topology.get_interface_sw_index(
1526                     node, node_vlan_if), vlan=i+1))
1527
1528         VatExecutor().write_and_execute_script(node, tmp_fn, commands)
1529
1530         return vxlan_count
1531
1532     @staticmethod
1533     def vpp_put_vxlan_and_vlan_interfaces_up(node, vxlan_count, node_vlan_if):
1534         """
1535         Update topology with VXLAN interfaces and VLAN sub-interfaces data
1536         and put interfaces up.
1537
1538         :param node: VPP node.
1539         :param vxlan_count: Number of tunnel interfaces.
1540         :param node_vlan_if: VPP node interface key where VLAN sub-interfaces
1541             have been created.
1542         :type node: dict
1543         :type vxlan_count: int
1544         :type node_vlan_if: str
1545         """
1546         with VatTerminal(node) as vat_ter:
1547             if_data = vat_ter.vat_terminal_exec_cmd_from_template(
1548                 'interface_dump.vat')[0]
1549
1550         tmp_fn = '/tmp/put_subinterfaces_up.config'
1551         commands = list()
1552         for i in range(0, vxlan_count):
1553             vxlan_subif_key = Topology.add_new_port(node, 'vxlan_tunnel')
1554             vxlan_subif_name = 'vxlan_tunnel{nr}'.format(nr=i)
1555             vxlan_found = False
1556             vxlan_subif_idx = None
1557             vlan_subif_key = Topology.add_new_port(node, 'vlan_subif')
1558             vlan_subif_name = '{if_name}.{vlan}'.format(
1559                 if_name=Topology.get_interface_name(
1560                     node, node_vlan_if), vlan=i+1)
1561             vlan_found = False
1562             vlan_idx = None
1563             for data in if_data:
1564                 if_name = data['interface_name']
1565                 if not vxlan_found and if_name == vxlan_subif_name:
1566                     vxlan_subif_idx = data['sw_if_index']
1567                     vxlan_found = True
1568                 elif not vlan_found and if_name == vlan_subif_name:
1569                     vlan_idx = data['sw_if_index']
1570                     vlan_found = True
1571                 if vxlan_found and vlan_found:
1572                     break
1573             Topology.update_interface_sw_if_index(
1574                 node, vxlan_subif_key, vxlan_subif_idx)
1575             Topology.update_interface_name(
1576                 node, vxlan_subif_key, vxlan_subif_name)
1577             commands.append(
1578                 'sw_interface_set_flags sw_if_index {sw_idx} admin-up link-up\n'
1579                 .format(sw_idx=vxlan_subif_idx))
1580             Topology.update_interface_sw_if_index(
1581                 node, vlan_subif_key, vlan_idx)
1582             Topology.update_interface_name(
1583                 node, vlan_subif_key, vlan_subif_name)
1584             commands.append(
1585                 'sw_interface_set_flags sw_if_index {sw_idx} admin-up link-up\n'
1586                 .format(sw_idx=vlan_idx))
1587
1588         VatExecutor().write_and_execute_script(node, tmp_fn, commands)
1589
1590     @staticmethod
1591     def vpp_put_vxlan_and_vlan_interfaces_to_bridge_domain(
1592             node, node_vxlan_if, vxlan_count, op_node, op_node_if, dst_ip_start,
1593             ip_step, bd_id_start):
1594         """
1595         Configure ARPs and routes for VXLAN interfaces and put each pair of
1596         VXLAN tunnel interface and VLAN sub-interface to separate bridge-domain.
1597
1598         :param node: VPP node.
1599         :param node_vxlan_if: VPP node interface key where VXLAN tunnel
1600             interfaces have been created.
1601         :param vxlan_count: Number of tunnel interfaces.
1602         :param op_node: Opposite VPP node for VXLAN tunnel interfaces.
1603         :param op_node_if: Opposite VPP node interface key for VXLAN tunnel
1604             interfaces.
1605         :param dst_ip_start: VXLAN tunnel destination IP address start.
1606         :param ip_step: IP address incremental step.
1607         :param bd_id_start: Bridge-domain ID start.
1608         :type node: dict
1609         :type node_vxlan_if: str
1610         :type vxlan_count: int
1611         :type op_node: dict
1612         :type op_node_if:
1613         :type dst_ip_start: str
1614         :type ip_step: int
1615         :type bd_id_start: int
1616         """
1617         sw_idx_vxlan = Topology.get_interface_sw_index(node, node_vxlan_if)
1618
1619         dst_ip_start_int = IPUtil.ip_to_int(dst_ip_start)
1620
1621         tmp_fn = '/tmp/configure_routes_and_bridge_domains.config'
1622         commands = list()
1623         for i in range(0, vxlan_count):
1624             dst_ip = IPUtil.int_to_ip(dst_ip_start_int + i * ip_step)
1625             commands.append(
1626                 'ip_neighbor_add_del sw_if_index {sw_idx} dst {ip} mac {mac}\n'
1627                 .format(sw_idx=sw_idx_vxlan, ip=dst_ip,
1628                         mac=Topology.get_interface_mac(op_node, op_node_if)))
1629             commands.append(
1630                 'ip_add_del_route {ip}/32 via {ip} sw_if_index {sw_idx}'
1631                 ' resolve-attempts 10 count 1\n'.format(
1632                     ip=dst_ip, sw_idx=sw_idx_vxlan))
1633             bd_id = bd_id_start + i
1634             subif_id = i + 1
1635             commands.append(
1636                 'sw_interface_set_l2_bridge sw_if_index {sw_idx} bd_id {bd_id} '
1637                 'shg 0 enable\n'.format(sw_idx=Topology.get_interface_sw_index(
1638                     node, 'vxlan_tunnel{nr}'.format(nr=subif_id)), bd_id=bd_id))
1639             commands.append(
1640                 'sw_interface_set_l2_bridge sw_if_index {sw_idx} bd_id {bd_id} '
1641                 'shg 0 enable\n'.format(sw_idx=Topology.get_interface_sw_index(
1642                     node, 'vlan_subif{nr}'.format(nr=subif_id)), bd_id=bd_id))
1643
1644         VatExecutor().write_and_execute_script(node, tmp_fn, commands)
1645
1646     @staticmethod
1647     def vpp_sw_interface_rx_placement_dump(node):
1648         """Dump VPP interface RX placement on node.
1649
1650         :param node: Node to run command on.
1651         :type node: dict
1652         :returns: Thread mapping information as a list of dictionaries.
1653         :rtype: list
1654         """
1655
1656         cmd = 'sw_interface_rx_placement_dump'
1657         cmd_reply = 'sw_interface_rx_placement_details'
1658         err_msg = "Failed to run '{cmd}' PAPI command on host {host}!".format(
1659             cmd=cmd, host=node['host'])
1660         with PapiExecutor(node) as papi_exec:
1661             for ifc in node['interfaces'].values():
1662                 if ifc['vpp_sw_index'] is not None:
1663                     papi_exec.add(cmd, sw_if_index=ifc['vpp_sw_index'])
1664             papi_resp = papi_exec.get_dump(err_msg)
1665         thr_mapping = [s[cmd_reply] for r in papi_resp.reply
1666                        for s in r['api_reply']]
1667         return sorted(thr_mapping, key=lambda k: k['sw_if_index'])
1668
1669     @staticmethod
1670     def vpp_sw_interface_set_rx_placement(node, sw_if_index, queue_id,
1671                                           worker_id):
1672         """Set interface RX placement to worker on node.
1673
1674         :param node: Node to run command on.
1675         :param sw_if_index: VPP SW interface index.
1676         :param queue_id: VPP interface queue ID.
1677         :param worker_id: VPP worker ID (indexing from 0).
1678         :type node: dict
1679         :type sw_if_index: int
1680         :type queue_id: int
1681         :type worker_id: int
1682         :raises RuntimeError: If failed to run command on host or if no API
1683             reply received.
1684         """
1685
1686         cmd = 'sw_interface_set_rx_placement'
1687         cmd_reply = 'sw_interface_set_rx_placement_reply'
1688         err_msg = "Failed to run '{cmd}' PAPI command on host {host}!".format(
1689             host=node['host'], cmd=cmd)
1690         args = dict(sw_if_index=sw_if_index, queue_id=queue_id,
1691                     worker_id=worker_id)
1692         with PapiExecutor(node) as papi_exec:
1693             papi_resp = papi_exec.add(cmd, **args).execute_should_pass(err_msg)
1694         data = papi_resp.reply[0]['api_reply'][cmd_reply]
1695         if data['retval'] != 0:
1696             raise RuntimeError("Failed to set interface RX placement "
1697                                "to worker on host {host}".
1698                                format(host=node['host']))
1699
1700     @staticmethod
1701     def vpp_round_robin_rx_placement(node, prefix):
1702         """Set Round Robin interface RX placement on all worker threads
1703         on node.
1704
1705         :param node: Topology nodes.
1706         :param prefix: Interface name prefix.
1707         :type node: dict
1708         :type prefix: str
1709         """
1710         worker_id = 0
1711         worker_cnt = len(VPPUtil.vpp_show_threads(node)) - 1
1712         for placement in InterfaceUtil.vpp_sw_interface_rx_placement_dump(node):
1713             for interface in node['interfaces'].values():
1714                 if placement['sw_if_index'] == interface['vpp_sw_index'] \
1715                     and prefix in interface['name']:
1716                     InterfaceUtil.vpp_sw_interface_set_rx_placement(
1717                         node, placement['sw_if_index'], placement['queue_id'],
1718                         worker_id % worker_cnt)
1719                     worker_id += 1
1720
1721     @staticmethod
1722     def vpp_round_robin_rx_placement_on_all_duts(nodes, prefix):
1723         """Set Round Robin interface RX placement on all worker threads
1724         on all DUTs.
1725
1726         :param nodes: Topology nodes.
1727         :param prefix: Interface name prefix.
1728         :type nodes: dict
1729         :type prefix: str
1730         """
1731         for node in nodes.values():
1732             if node['type'] == NodeType.DUT:
1733                 InterfaceUtil.vpp_round_robin_rx_placement(node, prefix)