resources/libraries/python/InterfaceUtil.py

   1 # Copyright (c) 2016 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 time import time, sleep
  17
  18 from robot.api import logger
  19
  20 from resources.libraries.python.ssh import SSH
  21 from resources.libraries.python.IPUtil import convert_ipv4_netmask_prefix
  22 from resources.libraries.python.ssh import exec_cmd_no_error
  23 from resources.libraries.python.topology import NodeType, Topology
  24 from resources.libraries.python.VatExecutor import VatExecutor, VatTerminal
  25 from resources.libraries.python.VatJsonUtil import VatJsonUtil
  26 from resources.libraries.python.parsers.JsonParser import JsonParser
  27
  28
  29 class InterfaceUtil(object):
  30     """General utilities for managing interfaces"""
  31
  32     __UDEV_IF_RULES_FILE = '/etc/udev/rules.d/10-network.rules'
  33
  34     @staticmethod
  35     def set_interface_state(node, interface, state, if_type="key"):
  36         """Set interface state on a node.
  37
  38         Function can be used for DUTs as well as for TGs.
  39
  40         :param node: Node where the interface is.
  41         :param interface: Interface key or sw_if_index or name.
  42         :param state: One of 'up' or 'down'.
  43         :param if_type: Interface type
  44         :type node: dict
  45         :type interface: str or int
  46         :type state: str
  47         :type if_type: str
  48         :returns: Nothing.
  49         :raises ValueError: If the interface type is unknown.
  50         :raises ValueError: If the state of interface is unexpected.
  51         :raises ValueError: If the node has an unknown node type.
  52         """
  53
  54         if if_type == "key":
  55             if isinstance(interface, basestring):
  56                 sw_if_index = Topology.get_interface_sw_index(node, interface)
  57                 iface_name = Topology.get_interface_name(node, interface)
  58             else:
  59                 sw_if_index = interface
  60         elif if_type == "name":
  61             iface_key = Topology.get_interface_by_name(node, interface)
  62             if iface_key is not None:
  63                 sw_if_index = Topology.get_interface_sw_index(node, iface_key)
  64             iface_name = interface
  65         else:
  66             raise ValueError("if_type unknown: {}".format(if_type))
  67
  68         if node['type'] == NodeType.DUT:
  69             if state == 'up':
  70                 state = 'admin-up'
  71             elif state == 'down':
  72                 state = 'admin-down'
  73             else:
  74                 raise ValueError('Unexpected interface state: {}'.format(state))
  75             VatExecutor.cmd_from_template(node, 'set_if_state.vat',
  76                                           sw_if_index=sw_if_index, state=state)
  77         elif node['type'] == NodeType.TG or node['type'] == NodeType.VM:
  78             cmd = 'ip link set {} {}'.format(iface_name, state)
  79             exec_cmd_no_error(node, cmd, sudo=True)
  80         else:
  81             raise ValueError('Node {} has unknown NodeType: "{}"'
  82                              .format(node['host'], node['type']))
  83
  84     @staticmethod
  85     def set_interface_ethernet_mtu(node, iface_key, mtu):
  86         """Set Ethernet MTU for specified interface.
  87
  88         Function can be used only for TGs.
  89
  90         :param node: Node where the interface is.
  91         :param iface_key: Interface key from topology file.
  92         :param mtu: MTU to set.
  93         :type node: dict
  94         :type iface_key: str
  95         :type mtu: int
  96         :returns: Nothing.
  97         :raises ValueError: If the node type is "DUT".
  98         :raises ValueError: If the node has an unknown node type.
  99         """
 100         if node['type'] == NodeType.DUT:
 101             raise ValueError('Node {}: Setting Ethernet MTU for interface '
 102                              'on DUT nodes not supported', node['host'])
 103         elif node['type'] == NodeType.TG:
 104             iface_name = Topology.get_interface_name(node, iface_key)
 105             cmd = 'ip link set {} mtu {}'.format(iface_name, mtu)
 106             exec_cmd_no_error(node, cmd, sudo=True)
 107         else:
 108             raise ValueError('Node {} has unknown NodeType: "{}"'
 109                              .format(node['host'], node['type']))
 110
 111     @staticmethod
 112     def set_default_ethernet_mtu_on_all_interfaces_on_node(node):
 113         """Set default Ethernet MTU on all interfaces on node.
 114
 115         Function can be used only for TGs.
 116
 117         :param node: Node where to set default MTU.
 118         :type node: dict
 119         :returns: Nothing.
 120         """
 121         for ifc in node['interfaces']:
 122             InterfaceUtil.set_interface_ethernet_mtu(node, ifc, 1500)
 123
 124     @staticmethod
 125     def vpp_node_interfaces_ready_wait(node, timeout=10):
 126         """Wait until all interfaces with admin-up are in link-up state.
 127
 128         :param node: Node to wait on.
 129         :param timeout: Waiting timeout in seconds (optional, default 10s).
 130         :type node: dict
 131         :type timeout: int
 132         :returns: Nothing.
 133         :raises: RuntimeError if the timeout period value has elapsed.
 134         """
 135         if_ready = False
 136         not_ready = []
 137         start = time()
 138         while not if_ready:
 139             out = InterfaceUtil.vpp_get_interface_data(node)
 140             if time() - start > timeout:
 141                 for interface in out:
 142                     if interface.get('admin_up_down') == 1:
 143                         if interface.get('link_up_down') != 1:
 144                             logger.debug('{0} link-down'.format(
 145                                 interface.get('interface_name')))
 146                 raise RuntimeError('timeout, not up {0}'.format(not_ready))
 147             not_ready = []
 148             for interface in out:
 149                 if interface.get('admin_up_down') == 1:
 150                     if interface.get('link_up_down') != 1:
 151                         not_ready.append(interface.get('interface_name'))
 152             if not not_ready:
 153                 if_ready = True
 154             else:
 155                 logger.debug('Interfaces still in link-down state: {0}, '
 156                              'waiting...'.format(not_ready))
 157                 sleep(1)
 158
 159     @staticmethod
 160     def vpp_nodes_interfaces_ready_wait(nodes, timeout=10):
 161         """Wait until all interfaces with admin-up are in link-up state for
 162         listed nodes.
 163
 164         :param nodes: List of nodes to wait on.
 165         :param timeout: Seconds to wait per node for all interfaces to come up.
 166         :type nodes: list
 167         :type timeout: int
 168         :returns: Nothing.
 169         """
 170         for node in nodes:
 171             InterfaceUtil.vpp_node_interfaces_ready_wait(node, timeout)
 172
 173     @staticmethod
 174     def all_vpp_interfaces_ready_wait(nodes, timeout=10):
 175         """Wait until all interfaces with admin-up are in link-up state for all
 176         nodes in the topology.
 177
 178         :param nodes: Nodes in the topology.
 179         :param timeout: Seconds to wait per node for all interfaces to come up.
 180         :type nodes: dict
 181         :type timeout: int
 182         :returns: Nothing.
 183         """
 184         for node in nodes.values():
 185             if node['type'] == NodeType.DUT:
 186                 InterfaceUtil.vpp_node_interfaces_ready_wait(node, timeout)
 187
 188     @staticmethod
 189     def vpp_get_interface_data(node, interface=None):
 190         """Get all interface data from a VPP node. If a name or
 191         sw_interface_index is provided, return only data for the matching
 192         interface.
 193
 194         :param node: VPP node to get interface data from.
 195         :param interface: Numeric index or name string of a specific interface.
 196         :type node: dict
 197         :type interface: int or str
 198         :returns: List of dictionaries containing data for each interface, or a
 199         single dictionary for the specified interface.
 200         :rtype: list or dict
 201         :raises TypeError: if the data type of interface is neither basestring
 202         nor int.
 203         """
 204         with VatTerminal(node) as vat:
 205             response = vat.vat_terminal_exec_cmd_from_template(
 206                 "interface_dump.vat")
 207
 208         data = response[0]
 209
 210         if interface is not None:
 211             if isinstance(interface, basestring):
 212                 param = "interface_name"
 213             elif isinstance(interface, int):
 214                 param = "sw_if_index"
 215             else:
 216                 raise TypeError
 217             for data_if in data:
 218                 if data_if[param] == interface:
 219                     return data_if
 220             return dict()
 221         return data
 222
 223     @staticmethod
 224     def vpp_get_interface_name(node, sw_if_index):
 225         """Get interface name for the given SW interface index from actual
 226         interface dump.
 227
 228         :param node: VPP node to get interface data from.
 229         :param sw_if_index: SW interface index of the specific interface.
 230         :type node: dict
 231         :type sw_if_index: int
 232         :returns: Name of the given interface.
 233         :rtype: str
 234         """
 235
 236         if_data = InterfaceUtil.vpp_get_interface_data(node, sw_if_index)
 237         if if_data['sup_sw_if_index'] != if_data['sw_if_index']:
 238             if_data = InterfaceUtil.vpp_get_interface_data(
 239                 node, if_data['sup_sw_if_index'])
 240         try:
 241             if_name = if_data["interface_name"]
 242         except KeyError:
 243             if_name = None
 244         return if_name
 245
 246     @staticmethod
 247     def vpp_get_interface_mac(node, interface=None):
 248         """Get MAC address for the given interface from actual interface dump.
 249
 250         :param node: VPP node to get interface data from.
 251         :param interface: Numeric index or name string of a specific interface.
 252         :type node: dict
 253         :type interface: int or str
 254         :returns: MAC address.
 255         :rtype: str
 256         """
 257
 258         if_data = InterfaceUtil.vpp_get_interface_data(node, interface)
 259         if if_data['sup_sw_if_index'] != if_data['sw_if_index']:
 260             if_data = InterfaceUtil.vpp_get_interface_data(
 261                 node, if_data['sup_sw_if_index'])
 262         mac_data = [str(hex(item))[2:] for item in if_data['l2_address'][:6]]
 263         mac_data_nice = []
 264         for item in mac_data:
 265             if len(item) == 1:
 266                 item = '0' + item
 267             mac_data_nice.append(item)
 268         mac = ":".join(mac_data_nice)
 269         return mac
 270
 271     @staticmethod
 272     def vpp_get_interface_ip_addresses(node, interface, ip_version):
 273         """Get list of IP addresses from an interface on a VPP node.
 274
 275          :param node: VPP node to get data from.
 276          :param interface: Name of an interface on the VPP node.
 277          :param ip_version: IP protocol version (ipv4 or ipv6).
 278          :type node: dict
 279          :type interface: str
 280          :type ip_version: str
 281          :returns: List of dictionaries, each containing IP address, subnet
 282          prefix length and also the subnet mask for ipv4 addresses.
 283          Note: A single interface may have multiple IP addresses assigned.
 284          :rtype: list
 285         """
 286
 287         try:
 288             sw_if_index = Topology.convert_interface_reference(
 289                 node, interface, "sw_if_index")
 290         except RuntimeError:
 291             if isinstance(interface, basestring):
 292                 sw_if_index = InterfaceUtil.get_sw_if_index(node, interface)
 293             else:
 294                 raise
 295
 296         with VatTerminal(node) as vat:
 297             response = vat.vat_terminal_exec_cmd_from_template(
 298                 "ip_address_dump.vat", ip_version=ip_version,
 299                 sw_if_index=sw_if_index)
 300
 301         data = response[0]
 302
 303         if ip_version == "ipv4":
 304             for item in data:
 305                 item["netmask"] = convert_ipv4_netmask_prefix(
 306                     item["prefix_length"])
 307         return data
 308
 309     @staticmethod
 310     def tg_set_interface_driver(node, pci_addr, driver):
 311         """Set interface driver on the TG node.
 312
 313         :param node: Node to set interface driver on (must be TG node).
 314         :param pci_addr: PCI address of the interface.
 315         :param driver: Driver name.
 316         :type node: dict
 317         :type pci_addr: str
 318         :type driver: str
 319         :returns: None.
 320         :raises RuntimeError: If unbinding from the current driver fails.
 321         :raises RuntimeError: If binding to the new driver fails.
 322         """
 323         old_driver = InterfaceUtil.tg_get_interface_driver(node, pci_addr)
 324         if old_driver == driver:
 325             return
 326
 327         ssh = SSH()
 328         ssh.connect(node)
 329
 330         # Unbind from current driver
 331         if old_driver is not None:
 332             cmd = 'sh -c "echo {0} > /sys/bus/pci/drivers/{1}/unbind"'\
 333                 .format(pci_addr, old_driver)
 334             (ret_code, _, _) = ssh.exec_command_sudo(cmd)
 335             if int(ret_code) != 0:
 336                 raise RuntimeError("'{0}' failed on '{1}'"
 337                                    .format(cmd, node['host']))
 338
 339         # Bind to the new driver
 340         cmd = 'sh -c "echo {0} > /sys/bus/pci/drivers/{1}/bind"'\
 341             .format(pci_addr, driver)
 342         (ret_code, _, _) = ssh.exec_command_sudo(cmd)
 343         if int(ret_code) != 0:
 344             raise RuntimeError("'{0}' failed on '{1}'"
 345                                .format(cmd, node['host']))
 346
 347     @staticmethod
 348     def tg_get_interface_driver(node, pci_addr):
 349         """Get interface driver from the TG node.
 350
 351         :param node: Node to get interface driver on (must be TG node).
 352         :param pci_addr: PCI address of the interface.
 353         :type node: dict
 354         :type pci_addr: str
 355         :returns: Interface driver or None if not found.
 356         :rtype: str
 357         :raises RuntimeError: If it is not possible to get the interface driver
 358         information from the node.
 359
 360         .. note::
 361             # lspci -vmmks 0000:00:05.0
 362             Slot:   00:05.0
 363             Class:  Ethernet controller
 364             Vendor: Red Hat, Inc
 365             Device: Virtio network device
 366             SVendor:        Red Hat, Inc
 367             SDevice:        Device 0001
 368             PhySlot:        5
 369             Driver: virtio-pci
 370         """
 371         ssh = SSH()
 372         ssh.connect(node)
 373
 374         for i in range(3):
 375             logger.trace('Try {}: Get interface driver'.format(i))
 376             cmd = 'sh -c "echo 1 > /sys/bus/pci/rescan"'
 377             (ret_code, _, _) = ssh.exec_command_sudo(cmd)
 378             if int(ret_code) != 0:
 379                 raise RuntimeError("'{0}' failed on '{1}'"
 380                                    .format(cmd, node['host']))
 381
 382             cmd = 'lspci -vmmks {0}'.format(pci_addr)
 383             (ret_code, stdout, _) = ssh.exec_command(cmd)
 384             if int(ret_code) != 0:
 385                 raise RuntimeError("'{0}' failed on '{1}'"
 386                                    .format(cmd, node['host']))
 387
 388             for line in stdout.splitlines():
 389                 if len(line) == 0:
 390                     continue
 391                 try:
 392                     (name, value) = line.split("\t", 1)
 393                 except ValueError:
 394                     if name != "Driver:":
 395                         pass
 396                     else:
 397                         return None
 398                 if name == 'Driver:':
 399                     return value if value else None
 400         else:
 401             raise RuntimeError('Get interface driver for: {0}'
 402                                .format(pci_addr))
 403
 404     @staticmethod
 405     def tg_set_interfaces_udev_rules(node):
 406         """Set udev rules for interfaces.
 407
 408         Create udev rules file in /etc/udev/rules.d where are rules for each
 409         interface used by TG node, based on MAC interface has specific name.
 410         So after unbind and bind again to kernel driver interface has same
 411         name as before. This must be called after TG has set name for each
 412         port in topology dictionary.
 413         udev rule example
 414         SUBSYSTEM=="net", ACTION=="add", ATTR{address}=="52:54:00:e1:8a:0f",
 415         NAME="eth1"
 416
 417         :param node: Node to set udev rules on (must be TG node).
 418         :type node: dict
 419         :raises RuntimeError: If setting of udev rules fails.
 420         """
 421         ssh = SSH()
 422         ssh.connect(node)
 423
 424         cmd = 'rm -f {0}'.format(InterfaceUtil.__UDEV_IF_RULES_FILE)
 425         (ret_code, _, _) = ssh.exec_command_sudo(cmd)
 426         if int(ret_code) != 0:
 427             raise RuntimeError("'{0}' failed on '{1}'"
 428                                .format(cmd, node['host']))
 429
 430         for interface in node['interfaces'].values():
 431             rule = 'SUBSYSTEM==\\"net\\", ACTION==\\"add\\", ATTR{address}' + \
 432                    '==\\"' + interface['mac_address'] + '\\", NAME=\\"' + \
 433                    interface['name'] + '\\"'
 434             cmd = 'sh -c "echo \'{0}\' >> {1}"'.format(
 435                 rule, 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         cmd = '/etc/init.d/udev restart'
 442         ssh.exec_command_sudo(cmd)
 443
 444     @staticmethod
 445     def tg_set_interfaces_default_driver(node):
 446         """Set interfaces default driver specified in topology yaml file.
 447
 448         :param node: Node to setup interfaces driver on (must be TG node).
 449         :type node: dict
 450         """
 451         for interface in node['interfaces'].values():
 452             InterfaceUtil.tg_set_interface_driver(node,
 453                                                   interface['pci_address'],
 454                                                   interface['driver'])
 455
 456     @staticmethod
 457     def update_vpp_interface_data_on_node(node):
 458         """Update vpp generated interface data for a given node in DICT__nodes.
 459
 460         Updates interface names, software if index numbers and any other details
 461         generated specifically by vpp that are unknown before testcase run.
 462         It does this by dumping interface list to JSON output from all
 463         devices using vpp_api_test, and pairing known information from topology
 464         (mac address/pci address of interface) to state from VPP.
 465
 466         :param node: Node selected from DICT__nodes.
 467         :type node: dict
 468         """
 469         vat_executor = VatExecutor()
 470         vat_executor.execute_script_json_out("dump_interfaces.vat", node)
 471         interface_dump_json = vat_executor.get_script_stdout()
 472         VatJsonUtil.update_vpp_interface_data_from_json(node,
 473                                                         interface_dump_json)
 474
 475     @staticmethod
 476     def update_nic_interface_names(node):
 477         """Update interface names based on nic type and PCI address.
 478
 479         This method updates interface names in the same format as VPP does.
 480
 481         :param node: Node dictionary.
 482         :type node: dict
 483         """
 484         for ifc in node['interfaces'].values():
 485             if_pci = ifc['pci_address'].replace('.', ':').split(':')
 486             bus = '{:x}'.format(int(if_pci[1], 16))
 487             dev = '{:x}'.format(int(if_pci[2], 16))
 488             fun = '{:x}'.format(int(if_pci[3], 16))
 489             loc = '{bus}/{dev}/{fun}'.format(bus=bus, dev=dev, fun=fun)
 490             if ifc['model'] == 'Intel-XL710':
 491                 ifc['name'] = 'FortyGigabitEthernet{loc}'.format(loc=loc)
 492             elif ifc['model'] == 'Intel-X710':
 493                 ifc['name'] = 'TenGigabitEthernet{loc}'.format(loc=loc)
 494             elif ifc['model'] == 'Intel-X520-DA2':
 495                 ifc['name'] = 'TenGigabitEthernet{loc}'.format(loc=loc)
 496             elif ifc['model'] == 'Cisco-VIC-1385':
 497                 ifc['name'] = 'FortyGigabitEthernet{loc}'.format(loc=loc)
 498             elif ifc['model'] == 'Cisco-VIC-1227':
 499                 ifc['name'] = 'TenGigabitEthernet{loc}'.format(loc=loc)
 500             else:
 501                 ifc['name'] = 'UnknownEthernet{loc}'.format(loc=loc)
 502
 503     @staticmethod
 504     def update_nic_interface_names_on_all_duts(nodes):
 505         """Update interface names based on nic type and PCI address on all DUTs.
 506
 507         This method updates interface names in the same format as VPP does.
 508
 509         :param nodes: Topology nodes.
 510         :type nodes: dict
 511         """
 512         for node in nodes.values():
 513             if node['type'] == NodeType.DUT:
 514                 InterfaceUtil.update_nic_interface_names(node)
 515
 516     @staticmethod
 517     def update_tg_interface_data_on_node(node):
 518         """Update interface name for TG/linux node in DICT__nodes.
 519
 520         :param node: Node selected from DICT__nodes.
 521         :type node: dict
 522         :raises RuntimeError: If getting of interface name and MAC fails.
 523
 524         .. note::
 525             # for dev in `ls /sys/class/net/`;
 526             > do echo "\"`cat /sys/class/net/$dev/address`\": \"$dev\""; done
 527             "52:54:00:9f:82:63": "eth0"
 528             "52:54:00:77:ae:a9": "eth1"
 529             "52:54:00:e1:8a:0f": "eth2"
 530             "00:00:00:00:00:00": "lo"
 531
 532         .. todo:: parse lshw -json instead
 533         """
 534         # First setup interface driver specified in yaml file
 535         InterfaceUtil.tg_set_interfaces_default_driver(node)
 536
 537         # Get interface names
 538         ssh = SSH()
 539         ssh.connect(node)
 540
 541         cmd = ('for dev in `ls /sys/class/net/`; do echo "\\"`cat '
 542                '/sys/class/net/$dev/address`\\": \\"$dev\\""; done;')
 543
 544         (ret_code, stdout, _) = ssh.exec_command(cmd)
 545         if int(ret_code) != 0:
 546             raise RuntimeError('Get interface name and MAC failed')
 547         tmp = "{" + stdout.rstrip().replace('\n', ',') + "}"
 548         interfaces = JsonParser().parse_data(tmp)
 549         for interface in node['interfaces'].values():
 550             name = interfaces.get(interface['mac_address'])
 551             if name is None:
 552                 continue
 553             interface['name'] = name
 554
 555         # Set udev rules for interfaces
 556         InterfaceUtil.tg_set_interfaces_udev_rules(node)
 557
 558     @staticmethod
 559     def iface_update_numa_node(node):
 560         """For all interfaces from topology file update numa node based on
 561            information from the node.
 562
 563         :param node: Node from topology.
 564         :type node: dict
 565         :returns: Nothing.
 566         :raises ValueError: If numa node ia less than 0.
 567         :raises RuntimeError: If update of numa node failes.
 568         """
 569         ssh = SSH()
 570         for if_key in Topology.get_node_interfaces(node):
 571             if_pci = Topology.get_interface_pci_addr(node, if_key)
 572             ssh.connect(node)
 573             cmd = "cat /sys/bus/pci/devices/{}/numa_node".format(if_pci)
 574             for _ in range(3):
 575                 (ret, out, _) = ssh.exec_command(cmd)
 576                 if ret == 0:
 577                     try:
 578                         numa_node = int(out)
 579                         if numa_node < 0:
 580                             raise ValueError
 581                     except ValueError:
 582                         logger.trace('Reading numa location failed for: {0}'\
 583                             .format(if_pci))
 584                     else:
 585                         Topology.set_interface_numa_node(node, if_key,
 586                                                          numa_node)
 587                         break
 588             else:
 589                 raise RuntimeError('Update numa node failed for: {0}'\
 590                     .format(if_pci))
 591
 592     @staticmethod
 593     def update_all_numa_nodes(nodes, skip_tg=False):
 594         """For all nodes and all their interfaces from topology file update numa
 595         node information based on information from the node.
 596
 597         :param nodes: Nodes in the topology.
 598         :param skip_tg: Skip TG node
 599         :type nodes: dict
 600         :type skip_tg: bool
 601         :returns: Nothing.
 602         """
 603         for node in nodes.values():
 604             if node['type'] == NodeType.DUT:
 605                 InterfaceUtil.iface_update_numa_node(node)
 606             elif node['type'] == NodeType.TG and not skip_tg:
 607                 InterfaceUtil.iface_update_numa_node(node)
 608
 609     @staticmethod
 610     def update_all_interface_data_on_all_nodes(nodes, skip_tg=False,
 611                                                numa_node=False):
 612         """Update interface names on all nodes in DICT__nodes.
 613
 614         This method updates the topology dictionary by querying interface lists
 615         of all nodes mentioned in the topology dictionary.
 616
 617         :param nodes: Nodes in the topology.
 618         :param skip_tg: Skip TG node
 619         :param numa_node: Retrieve numa_node location.
 620         :type nodes: dict
 621         :type skip_tg: bool
 622         :type numa_node: bool
 623         """
 624         for node_data in nodes.values():
 625             if node_data['type'] == NodeType.DUT:
 626                 InterfaceUtil.update_vpp_interface_data_on_node(node_data)
 627             elif node_data['type'] == NodeType.TG and not skip_tg:
 628                 InterfaceUtil.update_tg_interface_data_on_node(node_data)
 629
 630             if numa_node:
 631                 if node_data['type'] == NodeType.DUT:
 632                     InterfaceUtil.iface_update_numa_node(node_data)
 633                 elif node_data['type'] == NodeType.TG and not skip_tg:
 634                     InterfaceUtil.iface_update_numa_node(node_data)
 635
 636     @staticmethod
 637     def create_vlan_subinterface(node, interface, vlan):
 638         """Create VLAN subinterface on node.
 639
 640         :param node: Node to add VLAN subinterface on.
 641         :param interface: Interface name on which create VLAN subinterface.
 642         :param vlan: VLAN ID of the subinterface to be created.
 643         :type node: dict
 644         :type interface: str
 645         :type vlan: int
 646         :returns: Name and index of created subinterface.
 647         :rtype: tuple
 648         :raises RuntimeError: if it is unable to create VLAN subinterface on the
 649         node.
 650         """
 651         iface_key = Topology.get_interface_by_name(node, interface)
 652         sw_if_index = Topology.get_interface_sw_index(node, iface_key)
 653
 654         output = VatExecutor.cmd_from_template(node, "create_vlan_subif.vat",
 655                                                sw_if_index=sw_if_index,
 656                                                vlan=vlan)
 657         if output[0]["retval"] == 0:
 658             sw_subif_index = output[0]["sw_if_index"]
 659             logger.trace('VLAN subinterface with sw_if_index {} and VLAN ID {} '
 660                          'created on node {}'.format(sw_subif_index,
 661                                                      vlan, node['host']))
 662         else:
 663             raise RuntimeError('Unable to create VLAN subinterface on node {}'
 664                                .format(node['host']))
 665
 666         with VatTerminal(node, False) as vat:
 667             vat.vat_terminal_exec_cmd('exec show interfaces')
 668
 669         return '{}.{}'.format(interface, vlan), sw_subif_index
 670
 671     @staticmethod
 672     def create_vxlan_interface(node, vni, source_ip, destination_ip):
 673         """Create VXLAN interface and return sw if index of created interface.
 674
 675         Executes "vxlan_add_del_tunnel src {src} dst {dst} vni {vni}" VAT
 676         command on the node.
 677
 678         :param node: Node where to create VXLAN interface.
 679         :param vni: VXLAN Network Identifier.
 680         :param source_ip: Source IP of a VXLAN Tunnel End Point.
 681         :param destination_ip: Destination IP of a VXLAN Tunnel End Point.
 682         :type node: dict
 683         :type vni: int
 684         :type source_ip: str
 685         :type destination_ip: str
 686         :returns: SW IF INDEX of created interface.
 687         :rtype: int
 688         :raises RuntimeError: if it is unable to create VxLAN interface on the
 689         node.
 690         """
 691         output = VatExecutor.cmd_from_template(node, "vxlan_create.vat",
 692                                                src=source_ip,
 693                                                dst=destination_ip,
 694                                                vni=vni)
 695         output = output[0]
 696
 697         if output["retval"] == 0:
 698             return output["sw_if_index"]
 699         else:
 700             raise RuntimeError('Unable to create VXLAN interface on node {0}'
 701                                .format(node))
 702
 703     @staticmethod
 704     def vxlan_dump(node, interface=None):
 705         """Get VxLAN data for the given interface.
 706
 707         :param node: VPP node to get interface data from.
 708         :param interface: Numeric index or name string of a specific interface.
 709         If None, information about all VxLAN interfaces is returned.
 710         :type node: dict
 711         :type interface: int or str
 712         :returns: Dictionary containing data for the given VxLAN interface or if
 713         interface=None, the list of dictionaries with all VxLAN interfaces.
 714         :rtype: dict or list
 715         :raises TypeError: if the data type of interface is neither basestring
 716         nor int.
 717         """
 718         param = "sw_if_index"
 719         if interface is None:
 720             param = ''
 721             sw_if_index = ''
 722         elif isinstance(interface, basestring):
 723             sw_if_index = Topology.get_interface_sw_index(node, interface)
 724         elif isinstance(interface, int):
 725             sw_if_index = interface
 726         else:
 727             raise TypeError("Wrong interface format {0}".format(interface))
 728
 729         with VatTerminal(node) as vat:
 730             response = vat.vat_terminal_exec_cmd_from_template(
 731                 "vxlan_dump.vat", param=param, sw_if_index=sw_if_index)
 732
 733         if sw_if_index:
 734             for vxlan in response[0]:
 735                 if vxlan["sw_if_index"] == sw_if_index:
 736                     return vxlan
 737             return {}
 738         return response[0]
 739
 740     @staticmethod
 741     def vhost_user_dump(node):
 742         """Get vhost-user data for the given node.
 743
 744         :param node: VPP node to get interface data from.
 745         :type node: dict
 746         :returns: List of dictionaries with all vhost-user interfaces.
 747         :rtype: list
 748         """
 749         with VatTerminal(node) as vat:
 750             response = vat.vat_terminal_exec_cmd_from_template(
 751                 "vhost_user_dump.vat")
 752
 753         return response[0]
 754
 755     @staticmethod
 756     def tap_dump(node, name=None):
 757         """Get all TAP interface data from the given node, or data about
 758         a specific TAP interface.
 759
 760         :param node: VPP node to get data from.
 761         :param name: Optional name of a specific TAP interface.
 762         :type node: dict
 763         :type name: str
 764         :returns: Dictionary of information about a specific TAP interface, or
 765         a List of dictionaries containing all TAP data for the given node.
 766         :rtype: dict or list
 767         """
 768         with VatTerminal(node) as vat:
 769             response = vat.vat_terminal_exec_cmd_from_template(
 770                 "tap_dump.vat")
 771         if name is None:
 772             return response[0]
 773         else:
 774             for item in response[0]:
 775                 if name == item['dev_name']:
 776                     return item
 777             return {}
 778
 779     @staticmethod
 780     def create_subinterface(node, interface, sub_id, outer_vlan_id=None,
 781                             inner_vlan_id=None, type_subif=None):
 782         """Create sub-interface on node. It is possible to set required
 783         sub-interface type and VLAN tag(s).
 784
 785         :param node: Node to add sub-interface.
 786         :param interface: Interface name on which create sub-interface.
 787         :param sub_id: ID of the sub-interface to be created.
 788         :param outer_vlan_id: Optional outer VLAN ID.
 789         :param inner_vlan_id: Optional inner VLAN ID.
 790         :param type_subif: Optional type of sub-interface. Values supported by
 791         VPP: [no_tags] [one_tag] [two_tags] [dot1ad] [exact_match] [default_sub]
 792         :type node: dict
 793         :type interface: str or int
 794         :type sub_id: int
 795         :type outer_vlan_id: int
 796         :type inner_vlan_id: int
 797         :type type_subif: str
 798         :returns: Name and index of created sub-interface.
 799         :rtype: tuple
 800         :raises RuntimeError: If it is not possible to create sub-interface.
 801         """
 802
 803         outer_vlan_id = 'outer_vlan_id {0}'.format(outer_vlan_id)\
 804             if outer_vlan_id else ''
 805
 806         inner_vlan_id = 'inner_vlan_id {0}'.format(inner_vlan_id)\
 807             if inner_vlan_id else ''
 808
 809         if type_subif is None:
 810             type_subif = ''
 811
 812         if isinstance(interface, basestring):
 813             iface_key = Topology.get_interface_by_name(node, interface)
 814             sw_if_index = Topology.get_interface_sw_index(node, iface_key)
 815         else:
 816             sw_if_index = interface
 817
 818         output = VatExecutor.cmd_from_template(node, "create_sub_interface.vat",
 819                                                sw_if_index=sw_if_index,
 820                                                sub_id=sub_id,
 821                                                outer_vlan_id=outer_vlan_id,
 822                                                inner_vlan_id=inner_vlan_id,
 823                                                type_subif=type_subif)
 824
 825         if output[0]["retval"] == 0:
 826             sw_subif_index = output[0]["sw_if_index"]
 827             logger.trace('Created subinterface with index {}'
 828                          .format(sw_subif_index))
 829         else:
 830             raise RuntimeError('Unable to create sub-interface on node {}'
 831                                .format(node['host']))
 832
 833         with VatTerminal(node, json_param=False) as vat:
 834             vat.vat_terminal_exec_cmd('exec show interfaces')
 835
 836         name = '{}.{}'.format(interface, sub_id)
 837         return name, sw_subif_index
 838
 839     @staticmethod
 840     def create_gre_tunnel_interface(node, source_ip, destination_ip):
 841         """Create GRE tunnel interface on node.
 842
 843         :param node: VPP node to add tunnel interface.
 844         :param source_ip: Source of the GRE tunnel.
 845         :param destination_ip: Destination of the GRE tunnel.
 846         :type node: dict
 847         :type source_ip: str
 848         :type destination_ip: str
 849         :returns: Name and index of created GRE tunnel interface.
 850         :rtype: tuple
 851         :raises RuntimeError: If unable to create GRE tunnel interface.
 852         """
 853         output = VatExecutor.cmd_from_template(node, "create_gre.vat",
 854                                                src=source_ip,
 855                                                dst=destination_ip)
 856         output = output[0]
 857
 858         if output["retval"] == 0:
 859             sw_if_index = output["sw_if_index"]
 860
 861             vat_executor = VatExecutor()
 862             vat_executor.execute_script_json_out("dump_interfaces.vat", node)
 863             interface_dump_json = vat_executor.get_script_stdout()
 864             name = VatJsonUtil.get_interface_name_from_json(
 865                 interface_dump_json, sw_if_index)
 866             return name, sw_if_index
 867         else:
 868             raise RuntimeError('Unable to create GRE tunnel on node {}.'
 869                                .format(node))
 870
 871     @staticmethod
 872     def vpp_create_loopback(node):
 873         """Create loopback interface on VPP node.
 874
 875         :param node: Node to create loopback interface on.
 876         :type node: dict
 877         :returns: SW interface index.
 878         :rtype: int
 879         :raises RuntimeError: If it is not possible to create loopback on the
 880         node.
 881         """
 882         out = VatExecutor.cmd_from_template(node, "create_loopback.vat")
 883         if out[0].get('retval') == 0:
 884             return out[0].get('sw_if_index')
 885         else:
 886             raise RuntimeError('Create loopback failed on node "{}"'
 887                                .format(node['host']))
 888
 889     @staticmethod
 890     def vpp_enable_input_acl_interface(node, interface, ip_version,
 891                                        table_index):
 892         """Enable input acl on interface.
 893
 894         :param node: VPP node to setup interface for input acl.
 895         :param interface: Interface to setup input acl.
 896         :param ip_version: Version of IP protocol.
 897         :param table_index: Classify table index.
 898         :type node: dict
 899         :type interface: str or int
 900         :type ip_version: str
 901         :type table_index: int
 902         """
 903         if isinstance(interface, basestring):
 904             sw_if_index = Topology.get_interface_sw_index(node, interface)
 905         else:
 906             sw_if_index = interface
 907
 908         with VatTerminal(node) as vat:
 909             vat.vat_terminal_exec_cmd_from_template("input_acl_int.vat",
 910                                                     sw_if_index=sw_if_index,
 911                                                     ip_version=ip_version,
 912                                                     table_index=table_index)
 913
 914     @staticmethod
 915     def get_interface_classify_table(node, interface):
 916         """Get name of classify table for the given interface.
 917
 918         :param node: VPP node to get data from.
 919         :param interface: Name or sw_if_index of a specific interface.
 920         :type node: dict
 921         :type interface: str or int
 922         :returns: Classify table name.
 923         :rtype: str
 924         """
 925         if isinstance(interface, basestring):
 926             sw_if_index = InterfaceUtil.get_sw_if_index(node, interface)
 927         else:
 928             sw_if_index = interface
 929
 930         with VatTerminal(node) as vat:
 931             data = vat.vat_terminal_exec_cmd_from_template(
 932                 "classify_interface_table.vat",
 933                 sw_if_index=sw_if_index)
 934         return data[0]
 935
 936     @staticmethod
 937     def get_interface_vrf_table(node, interface):
 938         """Get vrf ID for the given interface.
 939
 940         :param node: VPP node.
 941         :param interface: Name or sw_if_index of a specific interface.
 942         :type node: dict
 943         :type interface: str or int
 944         :returns: vrf ID of the specified interface.
 945         :rtype: int
 946         """
 947
 948         if isinstance(interface, basestring):
 949             sw_if_index = InterfaceUtil.get_sw_if_index(node, interface)
 950         else:
 951             sw_if_index = interface
 952
 953         with VatTerminal(node) as vat:
 954             data = vat.vat_terminal_exec_cmd_from_template(
 955                 "interface_vrf_dump.vat",
 956                 sw_if_index=sw_if_index)
 957         return data[0]["vrf_id"]
 958
 959     @staticmethod
 960     def get_sw_if_index(node, interface_name):
 961         """Get sw_if_index for the given interface from actual interface dump.
 962
 963         :param node: VPP node to get interface data from.
 964         :param interface_name: Name of the specific interface.
 965         :type node: dict
 966         :type interface_name: str
 967         :returns: sw_if_index of the given interface.
 968         :rtype: str
 969         """
 970
 971         with VatTerminal(node) as vat:
 972             if_data = vat.vat_terminal_exec_cmd_from_template(
 973                 "interface_dump.vat")
 974         for interface in if_data[0]:
 975             if interface["interface_name"] == interface_name:
 976                 return interface["sw_if_index"]
 977
 978         return None
 979
 980     @staticmethod
 981     def vxlan_gpe_dump(node, interface_name=None):
 982         """Get VxLAN GPE data for the given interface.
 983
 984         :param node: VPP node to get interface data from.
 985         :param interface_name: Name of the specific interface. If None,
 986         information about all VxLAN GPE interfaces is returned.
 987         :type node: dict
 988         :type interface_name: str
 989         :returns: Dictionary containing data for the given VxLAN GPE interface
 990         or if interface=None, the list of dictionaries with all VxLAN GPE
 991         interfaces.
 992         :rtype: dict or list
 993         """
 994
 995         with VatTerminal(node) as vat:
 996             vxlan_gpe_data = vat.vat_terminal_exec_cmd_from_template(
 997                 "vxlan_gpe_dump.vat")
 998
 999         if interface_name:
1000             sw_if_index = InterfaceUtil.get_sw_if_index(node, interface_name)
1001             if sw_if_index:
1002                 for vxlan_gpe in vxlan_gpe_data[0]:
1003                     if vxlan_gpe["sw_if_index"] == sw_if_index:
1004                         return vxlan_gpe
1005             return {}
1006
1007         return vxlan_gpe_data[0]
1008
1009     @staticmethod
1010     def vpp_proxy_arp_interface_enable(node, interface):
1011         """Enable proxy ARP on interface.
1012
1013         :param node: VPP node to enable proxy ARP on interface.
1014         :param interface: Interface to enable proxy ARP.
1015         :type node: dict
1016         :type interface: str or int
1017         """
1018         if isinstance(interface, basestring):
1019             sw_if_index = InterfaceUtil.get_sw_if_index(node, interface)
1020         else:
1021             sw_if_index = interface
1022
1023         with VatTerminal(node) as vat:
1024             vat.vat_terminal_exec_cmd_from_template(
1025                 "proxy_arp_intfc_enable.vat",
1026                 sw_if_index=sw_if_index)
1027
1028     @staticmethod
1029     def vpp_ip_source_check_setup(node, interface):
1030         """Setup Reverse Path Forwarding source check on interface.
1031
1032         :param node: Node to setup RPF source check.
1033         :param interface: Interface name to setup RPF source check.
1034         :type node: dict
1035         :type interface: str
1036         """
1037         with VatTerminal(node) as vat:
1038             vat.vat_terminal_exec_cmd_from_template("ip_source_check.vat",
1039                                                     interface_name=interface)
1040
1041     @staticmethod
1042     def assign_interface_to_fib_table(node, interface, table_id, ipv6=False):
1043         """Assign VPP interface to specific VRF/FIB table.
1044
1045         :param node: VPP node where the FIB and interface are located.
1046         :param interface: Interface to be assigned to FIB.
1047         :param table_id: VRF table ID.
1048         :param ipv6: Assign to IPv6 table. Default False.
1049         :type node: dict
1050         :type interface: str or int
1051         :type table_id: int
1052         :type ipv6: bool
1053         """
1054         if isinstance(interface, basestring):
1055             sw_if_index = Topology.get_interface_sw_index(node, interface)
1056         else:
1057             sw_if_index = interface
1058
1059         ipv6 = 'ipv6' if ipv6 else ''
1060
1061         with VatTerminal(node) as vat:
1062             ret = vat.vat_terminal_exec_cmd_from_template(
1063                 "set_fib_to_interface.vat",
1064                 sw_index=sw_if_index, vrf=table_id, ipv6=ipv6)
1065
1066         if ret[0]["retval"] != 0:
1067             raise RuntimeError('Unable to assign interface to FIB node {}.'
1068                                .format(node))
1069
1070
1071     @staticmethod
1072     def set_linux_interface_mac(node, interface, mac, namespace=None):
1073         """Set MAC address for interface in linux.
1074
1075         :param node: Node where to execute command.
1076         :param interface: Interface in namespace.
1077         :param mac: MAC to be assigned to interface.
1078         :param namespace: Execute command in namespace. Optional
1079         :type node: dict
1080         :type interface: str
1081         :type mac: str
1082         :type namespace: str
1083         """
1084         if namespace is not None:
1085             cmd = 'ip netns exec {} ip link set {} address {}'.format(
1086                 namespace, interface, mac)
1087         else:
1088             cmd = 'ip link set {} address {}'.format(interface, mac)
1089         exec_cmd_no_error(node, cmd, sudo=True)