FIX: Remove eth_avf and portX_vifY interfaces from topo in TC/TS tear down

[csit.git] / resources / libraries / python / InterfaceUtil.py

diff --git a/resources/libraries/python/InterfaceUtil.py b/resources/libraries/python/InterfaceUtil.py
index 7fc7f85..11ddf7f 100644 (file)
--- a/resources/libraries/python/InterfaceUtil.py
+++ b/resources/libraries/python/InterfaceUtil.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2018 Cisco and/or its affiliates.
+# Copyright (c) 2019 Cisco and/or its affiliates.

 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:


@@ -11,22 +11,40 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
 # See the License for the specific language governing permissions and
 # limitations under the License.
 

-"""Interface util library"""
+"""Interface util library."""

 
 

-from time import time, sleep
+from time import sleep

 
 

+from enum import IntEnum
+from ipaddress import ip_address

 from robot.api import logger
 
 from robot.api import logger
 

-from resources.libraries.python.ssh import SSH
-from resources.libraries.python.IPUtil import convert_ipv4_netmask_prefix
+from resources.libraries.python.Constants import Constants
+from resources.libraries.python.CpuUtils import CpuUtils

 from resources.libraries.python.DUTSetup import DUTSetup
 from resources.libraries.python.DUTSetup import DUTSetup

-from resources.libraries.python.ssh import exec_cmd_no_error
+from resources.libraries.python.L2Util import L2Util
+from resources.libraries.python.PapiExecutor import PapiSocketExecutor
+from resources.libraries.python.parsers.JsonParser import JsonParser
+from resources.libraries.python.ssh import SSH, exec_cmd_no_error

 from resources.libraries.python.topology import NodeType, Topology
 from resources.libraries.python.topology import NodeType, Topology

-from resources.libraries.python.VatExecutor import VatExecutor, VatTerminal
-from resources.libraries.python.VatJsonUtil import VatJsonUtil

 from resources.libraries.python.VPPUtil import VPPUtil
 from resources.libraries.python.VPPUtil import VPPUtil

-from resources.libraries.python.parsers.JsonParser import JsonParser
-from resources.libraries.python.CpuUtils import CpuUtils
+
+
+class LinkBondLoadBalance(IntEnum):
+    """Link bonding load balance."""
+    L2 = 0
+    L34 = 1
+    L23 = 2
+
+
+class LinkBondMode(IntEnum):
+    """Link bonding load balance."""
+    ROUND_ROBIN = 1
+    ACTIVE_BACKUP = 2
+    XOR = 3
+    BROADCAST = 4
+    LACP = 5
+

 
 class InterfaceUtil(object):
     """General utilities for managing interfaces"""
 
 class InterfaceUtil(object):
     """General utilities for managing interfaces"""


@@ -34,7 +52,47 @@ class InterfaceUtil(object):
     __UDEV_IF_RULES_FILE = '/etc/udev/rules.d/10-network.rules'
 
     @staticmethod
     __UDEV_IF_RULES_FILE = '/etc/udev/rules.d/10-network.rules'
 
     @staticmethod

-    def set_interface_state(node, interface, state, if_type="key"):
+    def pci_to_int(pci_str):
+        """Convert PCI address from string format (0000:18:0a.0) to
+        integer representation (169345024).
+
+        :param pci_str: PCI address in string representation.
+        :type pci_str: str
+        :returns: Integer representation of PCI address.
+        :rtype: int
+        """
+        pci = list(pci_str.split(':')[0:2])
+        pci.extend(pci_str.split(':')[2].split('.'))
+
+        return (int(pci[0], 16) | int(pci[1], 16) << 16 |
+                int(pci[2], 16) << 24 | int(pci[3], 16) << 29)
+
+    @staticmethod
+    def get_interface_index(node, interface):
+        """Get interface sw_if_index from topology file.
+
+        :param node: Node where the interface is.
+        :param interface: Numeric index or name string of a specific interface.
+        :type node: dict
+        :type interface: str or int
+        :returns: SW interface index.
+        :rtype: int
+        """
+        try:
+            sw_if_index = int(interface)
+        except ValueError:
+            sw_if_index = Topology.get_interface_sw_index(node, interface)
+            if sw_if_index is None:
+                sw_if_index = \
+                    Topology.get_interface_sw_index_by_name(node, interface)
+        except TypeError as err:
+            raise TypeError('Wrong interface format {ifc}: {err}'.format(
+                ifc=interface, err=err.message))
+
+        return sw_if_index
+
+    @staticmethod
+    def set_interface_state(node, interface, state, if_type='key'):

         """Set interface state on a node.
 
         Function can be used for DUTs as well as for TGs.
         """Set interface state on a node.
 
         Function can be used for DUTs as well as for TGs.


@@ -52,32 +110,38 @@ class InterfaceUtil(object):
         :raises ValueError: If the state of interface is unexpected.
         :raises ValueError: If the node has an unknown node type.
         """
         :raises ValueError: If the state of interface is unexpected.
         :raises ValueError: If the node has an unknown node type.
         """

-
-        if if_type == "key":
+        if if_type == 'key':

             if isinstance(interface, basestring):
                 sw_if_index = Topology.get_interface_sw_index(node, interface)
                 iface_name = Topology.get_interface_name(node, interface)
             else:
                 sw_if_index = interface
             if isinstance(interface, basestring):
                 sw_if_index = Topology.get_interface_sw_index(node, interface)
                 iface_name = Topology.get_interface_name(node, interface)
             else:
                 sw_if_index = interface

-        elif if_type == "name":
+        elif if_type == 'name':

             iface_key = Topology.get_interface_by_name(node, interface)
             if iface_key is not None:
                 sw_if_index = Topology.get_interface_sw_index(node, iface_key)
             iface_name = interface
         else:
             iface_key = Topology.get_interface_by_name(node, interface)
             if iface_key is not None:
                 sw_if_index = Topology.get_interface_sw_index(node, iface_key)
             iface_name = interface
         else:

-            raise ValueError("if_type unknown: {}".format(if_type))
+            raise ValueError('Unknown if_type: {type}'.format(type=if_type))

 
         if node['type'] == NodeType.DUT:
             if state == 'up':
 
         if node['type'] == NodeType.DUT:
             if state == 'up':

-                state = 'admin-up link-up'
+                admin_up_down = 1

             elif state == 'down':
             elif state == 'down':

-                state = 'admin-down link-down'
+                admin_up_down = 0

             else:
             else:

-                raise ValueError('Unexpected interface state: {}'.format(state))
-            VatExecutor.cmd_from_template(node, 'set_if_state.vat',
-                                          sw_if_index=sw_if_index, state=state)
+                raise ValueError('Unexpected interface state: {state}'.format(
+                    state=state))
+            cmd = 'sw_interface_set_flags'
+            err_msg = 'Failed to set interface state on host {host}'.format(
+                host=node['host'])
+            args = dict(sw_if_index=sw_if_index,
+                        admin_up_down=admin_up_down)
+            with PapiSocketExecutor(node) as papi_exec:
+                papi_exec.add(cmd, **args).get_reply(err_msg)

         elif node['type'] == NodeType.TG or node['type'] == NodeType.VM:
         elif node['type'] == NodeType.TG or node['type'] == NodeType.VM:

-            cmd = 'ip link set {} {}'.format(iface_name, state)
+            cmd = 'ip link set {ifc} {state}'.format(
+                ifc=iface_name, state=state)

             exec_cmd_no_error(node, cmd, sudo=True)
         else:
             raise ValueError('Node {} has unknown NodeType: "{}"'
             exec_cmd_no_error(node, cmd, sudo=True)
         else:
             raise ValueError('Node {} has unknown NodeType: "{}"'


@@ -139,11 +203,18 @@ class InterfaceUtil(object):
         else:
             sw_if_index = interface
 
         else:
             sw_if_index = interface
 

-        if sw_if_index:
-            with VatTerminal(node, json_param=False) as vat:
-                vat.vat_terminal_exec_cmd_from_template(
-                    "hw_interface_set_mtu.vat", sw_if_index=sw_if_index,
-                    mtu=mtu)
+        cmd = 'hw_interface_set_mtu'
+        err_msg = 'Failed to set interface MTU on host {host}'.format(
+            host=node['host'])
+        args = dict(sw_if_index=sw_if_index,
+                    mtu=int(mtu))
+        try:
+            with PapiSocketExecutor(node) as papi_exec:
+                papi_exec.add(cmd, **args).get_reply(err_msg)
+        except AssertionError as err:
+            # TODO: Make failure tolerance optional.
+            logger.debug("Setting MTU failed. Expected?\n{err}".format(
+                err=err))

 
     @staticmethod
     def vpp_set_interfaces_mtu_on_node(node, mtu=9200):
 
     @staticmethod
     def vpp_set_interfaces_mtu_on_node(node, mtu=9200):


@@ -171,74 +242,57 @@ class InterfaceUtil(object):
                 InterfaceUtil.vpp_set_interfaces_mtu_on_node(node, mtu)
 
     @staticmethod
                 InterfaceUtil.vpp_set_interfaces_mtu_on_node(node, mtu)
 
     @staticmethod

-    def vpp_node_interfaces_ready_wait(node, timeout=30):
+    def vpp_node_interfaces_ready_wait(node, retries=15):

         """Wait until all interfaces with admin-up are in link-up state.
 
         :param node: Node to wait on.
         """Wait until all interfaces with admin-up are in link-up state.
 
         :param node: Node to wait on.

-        :param timeout: Waiting timeout in seconds (optional, default 10s).
+        :param retries: Number of retries to check interface status (optional,
+            default 15).

         :type node: dict
         :type node: dict

-        :type timeout: int
+        :type retries: int

         :returns: Nothing.
         :returns: Nothing.

-        :raises RuntimeError: If the timeout period value has elapsed.
+        :raises RuntimeError: If any interface is not in link-up state after
+            defined number of retries.

         """
         """

-        if_ready = False
-        not_ready = []
-        start = time()
-        while not if_ready:
+        for _ in xrange(0, retries):
+            not_ready = list()

             out = InterfaceUtil.vpp_get_interface_data(node)
             out = InterfaceUtil.vpp_get_interface_data(node)

-            if time() - start > timeout:
-                for interface in out:
-                    if interface.get('admin_up_down') == 1:
-                        if interface.get('link_up_down') != 1:
-                            logger.debug('{0} link-down'.format(
-                                interface.get('interface_name')))
-                raise RuntimeError('timeout, not up {0}'.format(not_ready))
-            not_ready = []

             for interface in out:
                 if interface.get('admin_up_down') == 1:
                     if interface.get('link_up_down') != 1:
                         not_ready.append(interface.get('interface_name'))
             if not not_ready:
             for interface in out:
                 if interface.get('admin_up_down') == 1:
                     if interface.get('link_up_down') != 1:
                         not_ready.append(interface.get('interface_name'))
             if not not_ready:

-                if_ready = True
+                break

             else:
             else:

-                logger.debug('Interfaces still in link-down state: {0}, '
-                             'waiting...'.format(not_ready))
+                logger.debug('Interfaces still in link-down state:\n{ifs} '
+                             '\nWaiting...'.format(ifs=not_ready))

                 sleep(1)
                 sleep(1)

+        else:
+            err = 'Timeout, interfaces not up:\n{ifs}'.format(ifs=not_ready) \
+                if 'not_ready' in locals() else 'No check executed!'
+            raise RuntimeError(err)

 
     @staticmethod
 
     @staticmethod

-    def vpp_nodes_interfaces_ready_wait(nodes, timeout=30):
-        """Wait until all interfaces with admin-up are in link-up state for
-        listed nodes.
-
-        :param nodes: List of nodes to wait on.
-        :param timeout: Seconds to wait per node for all interfaces to come up.
-        :type nodes: list
-        :type timeout: int
-        :returns: Nothing.
-        """
-        for node in nodes:
-            InterfaceUtil.vpp_node_interfaces_ready_wait(node, timeout)
-
-    @staticmethod
-    def all_vpp_interfaces_ready_wait(nodes, timeout=30):
+    def all_vpp_interfaces_ready_wait(nodes, retries=15):

         """Wait until all interfaces with admin-up are in link-up state for all
         nodes in the topology.
 
         :param nodes: Nodes in the topology.
         """Wait until all interfaces with admin-up are in link-up state for all
         nodes in the topology.
 
         :param nodes: Nodes in the topology.

-        :param timeout: Seconds to wait per node for all interfaces to come up.
+        :param retries: Number of retries to check interface status (optional,
+            default 15).

         :type nodes: dict
         :type nodes: dict

-        :type timeout: int
+        :type retries: int

         :returns: Nothing.
         """
         for node in nodes.values():
             if node['type'] == NodeType.DUT:
         :returns: Nothing.
         """
         for node in nodes.values():
             if node['type'] == NodeType.DUT:

-                InterfaceUtil.vpp_node_interfaces_ready_wait(node, timeout)
+                InterfaceUtil.vpp_node_interfaces_ready_wait(node, retries)

 
     @staticmethod
     def vpp_get_interface_data(node, interface=None):
         """Get all interface data from a VPP node. If a name or
         sw_interface_index is provided, return only data for the matching
 
     @staticmethod
     def vpp_get_interface_data(node, interface=None):
         """Get all interface data from a VPP node. If a name or
         sw_interface_index is provided, return only data for the matching

-        interface.
+        interface(s).

 
         :param node: VPP node to get interface data from.
         :param interface: Numeric index or name string of a specific interface.
 
         :param node: VPP node to get interface data from.
         :param interface: Numeric index or name string of a specific interface.


@@ -250,23 +304,49 @@ class InterfaceUtil(object):
         :raises TypeError: if the data type of interface is neither basestring
             nor int.
         """
         :raises TypeError: if the data type of interface is neither basestring
             nor int.
         """

-        with VatTerminal(node) as vat:
-            response = vat.vat_terminal_exec_cmd_from_template(
-                "interface_dump.vat")
-
-        data = response[0]
+        def process_if_dump(if_dump):
+            """Process interface dump.
+
+            :param if_dump: Interface dump.
+            :type if_dump: dict
+            :returns: Processed interface dump.
+            :rtype: dict
+            """
+            if_dump['interface_name'] = if_dump['interface_name'].rstrip('\x00')
+            if_dump['tag'] = if_dump['tag'].rstrip('\x00')
+            if_dump['l2_address'] = L2Util.bin_to_mac(if_dump['l2_address'])
+            if_dump['b_dmac'] = L2Util.bin_to_mac(if_dump['b_dmac'])
+            if_dump['b_smac'] = L2Util.bin_to_mac(if_dump['b_smac'])
+            return if_dump

 
         if interface is not None:
             if isinstance(interface, basestring):
 
         if interface is not None:
             if isinstance(interface, basestring):

-                param = "interface_name"
+                param = 'interface_name'

             elif isinstance(interface, int):
             elif isinstance(interface, int):

-                param = "sw_if_index"
+                param = 'sw_if_index'

             else:
             else:

-                raise TypeError
-            for data_if in data:
-                if data_if[param] == interface:
-                    return data_if
-            return dict()
+                raise TypeError('Wrong interface format {ifc}'.format(
+                    ifc=interface))
+        else:
+            param = ''
+
+        cmd = 'sw_interface_dump'
+        args = dict(name_filter_valid=0,
+                    name_filter='')
+        err_msg = 'Failed to get interface dump on host {host}'.format(
+            host=node['host'])
+        with PapiSocketExecutor(node) as papi_exec:
+            details = papi_exec.add(cmd, **args).get_details(err_msg)
+
+        data = list() if interface is None else dict()
+        for dump in details:
+            if interface is None:
+                data.append(process_if_dump(dump))
+            elif str(dump.get(param)).rstrip('\x00') == str(interface):
+                data = process_if_dump(dump)
+                break
+
+        logger.debug('Interface data:\n{if_data}'.format(if_data=data))

         return data
 
     @staticmethod
         return data
 
     @staticmethod


@@ -281,19 +361,31 @@ class InterfaceUtil(object):
         :returns: Name of the given interface.
         :rtype: str
         """
         :returns: Name of the given interface.
         :rtype: str
         """

-

         if_data = InterfaceUtil.vpp_get_interface_data(node, sw_if_index)
         if if_data['sup_sw_if_index'] != if_data['sw_if_index']:
             if_data = InterfaceUtil.vpp_get_interface_data(
                 node, if_data['sup_sw_if_index'])
         if_data = InterfaceUtil.vpp_get_interface_data(node, sw_if_index)
         if if_data['sup_sw_if_index'] != if_data['sw_if_index']:
             if_data = InterfaceUtil.vpp_get_interface_data(
                 node, if_data['sup_sw_if_index'])

-        try:
-            if_name = if_data["interface_name"]
-        except KeyError:
-            if_name = None
-        return if_name
+
+        return if_data.get('interface_name')
+
+    @staticmethod
+    def vpp_get_interface_sw_index(node, interface_name):
+        """Get interface name for the given SW interface index from actual
+        interface dump.
+
+        :param node: VPP node to get interface data from.
+        :param interface_name: Interface name.
+        :type node: dict
+        :type interface_name: str
+        :returns: Name of the given interface.
+        :rtype: str
+        """
+        if_data = InterfaceUtil.vpp_get_interface_data(node, interface_name)
+
+        return if_data.get('sw_if_index')

 
     @staticmethod
 
     @staticmethod

-    def vpp_get_interface_mac(node, interface=None):
+    def vpp_get_interface_mac(node, interface):

         """Get MAC address for the given interface from actual interface dump.
 
         :param node: VPP node to get interface data from.
         """Get MAC address for the given interface from actual interface dump.
 
         :param node: VPP node to get interface data from.


@@ -303,57 +395,12 @@ class InterfaceUtil(object):
         :returns: MAC address.
         :rtype: str
         """
         :returns: MAC address.
         :rtype: str
         """

-

         if_data = InterfaceUtil.vpp_get_interface_data(node, interface)
         if if_data['sup_sw_if_index'] != if_data['sw_if_index']:
             if_data = InterfaceUtil.vpp_get_interface_data(
                 node, if_data['sup_sw_if_index'])
         if_data = InterfaceUtil.vpp_get_interface_data(node, interface)
         if if_data['sup_sw_if_index'] != if_data['sw_if_index']:
             if_data = InterfaceUtil.vpp_get_interface_data(
                 node, if_data['sup_sw_if_index'])

-        mac_data = [str(hex(item))[2:] for item in if_data['l2_address'][:6]]
-        mac_data_nice = []
-        for item in mac_data:
-            if len(item) == 1:
-                item = '0' + item
-            mac_data_nice.append(item)
-        mac = ":".join(mac_data_nice)
-        return mac
-
-    @staticmethod
-    def vpp_get_interface_ip_addresses(node, interface, ip_version):
-        """Get list of IP addresses from an interface on a VPP node.
-
-         :param node: VPP node to get data from.
-         :param interface: Name of an interface on the VPP node.
-         :param ip_version: IP protocol version (ipv4 or ipv6).
-         :type node: dict
-         :type interface: str
-         :type ip_version: str
-         :returns: List of dictionaries, each containing IP address, subnet
-            prefix length and also the subnet mask for ipv4 addresses.
-            Note: A single interface may have multiple IP addresses assigned.
-         :rtype: list
-        """
-
-        try:
-            sw_if_index = Topology.convert_interface_reference(
-                node, interface, "sw_if_index")
-        except RuntimeError:
-            if isinstance(interface, basestring):
-                sw_if_index = InterfaceUtil.get_sw_if_index(node, interface)
-            else:
-                raise
-
-        with VatTerminal(node) as vat:
-            response = vat.vat_terminal_exec_cmd_from_template(
-                "ip_address_dump.vat", ip_version=ip_version,
-                sw_if_index=sw_if_index)

 
 

-        data = response[0]
-
-        if ip_version == "ipv4":
-            for item in data:
-                item["netmask"] = convert_ipv4_netmask_prefix(
-                    item["prefix_length"])
-        return data
+        return if_data.get('l2_address')

 
     @staticmethod
     def tg_set_interface_driver(node, pci_addr, driver):
 
     @staticmethod
     def tg_set_interface_driver(node, pci_addr, driver):


@@ -464,18 +511,30 @@ class InterfaceUtil(object):
 
         Updates interface names, software if index numbers and any other details
         generated specifically by vpp that are unknown before testcase run.
 
         Updates interface names, software if index numbers and any other details
         generated specifically by vpp that are unknown before testcase run.

-        It does this by dumping interface list to JSON output from all
-        devices using vpp_api_test, and pairing known information from topology
-        (mac address/pci address of interface) to state from VPP.
+        It does this by dumping interface list from all devices using python
+        api, and pairing known information from topology (mac address) to state
+        from VPP.

 
         :param node: Node selected from DICT__nodes.
         :type node: dict
         """
 
         :param node: Node selected from DICT__nodes.
         :type node: dict
         """

-        vat_executor = VatExecutor()
-        vat_executor.execute_script_json_out("dump_interfaces.vat", node)
-        interface_dump_json = vat_executor.get_script_stdout()
-        VatJsonUtil.update_vpp_interface_data_from_json(node,
-                                                        interface_dump_json)
+        interface_list = InterfaceUtil.vpp_get_interface_data(node)
+        interface_dict = dict()
+        for ifc in interface_list:
+            interface_dict[ifc['l2_address']] = ifc
+
+        for if_name, if_data in node['interfaces'].items():
+            ifc_dict = interface_dict.get(if_data['mac_address'])
+            if ifc_dict is not None:
+                if_data['name'] = ifc_dict['interface_name']
+                if_data['vpp_sw_index'] = ifc_dict['sw_if_index']
+                if_data['mtu'] = ifc_dict['mtu'][0]
+                logger.trace('Interface {ifc} found by MAC {mac}'.format(
+                    ifc=if_name, mac=if_data['mac_address']))
+            else:
+                logger.trace('Interface {ifc} not found by MAC {mac}'.format(
+                    ifc=if_name, mac=if_data['mac_address']))
+                if_data['vpp_sw_index'] = None

 
     @staticmethod
     def update_nic_interface_names(node):
 
     @staticmethod
     def update_nic_interface_names(node):


@@ -519,7 +578,7 @@ class InterfaceUtil(object):
                 InterfaceUtil.update_nic_interface_names(node)
 
     @staticmethod
                 InterfaceUtil.update_nic_interface_names(node)
 
     @staticmethod

-    def update_tg_interface_data_on_node(node):
+    def update_tg_interface_data_on_node(node, skip_tg_udev=False):

         """Update interface name for TG/linux node in DICT__nodes.
 
         .. note::
         """Update interface name for TG/linux node in DICT__nodes.
 
         .. note::


@@ -530,10 +589,10 @@ class InterfaceUtil(object):
             "52:54:00:e1:8a:0f": "eth2"
             "00:00:00:00:00:00": "lo"
 
             "52:54:00:e1:8a:0f": "eth2"
             "00:00:00:00:00:00": "lo"
 

-        .. note:: TODO: parse lshw -json instead
-

         :param node: Node selected from DICT__nodes.
         :param node: Node selected from DICT__nodes.

+        :param skip_tg_udev: Skip udev rename on TG node.

         :type node: dict
         :type node: dict

+        :type skip_tg_udev: bool

         :raises RuntimeError: If getting of interface name and MAC fails.
         """
         # First setup interface driver specified in yaml file
         :raises RuntimeError: If getting of interface name and MAC fails.
         """
         # First setup interface driver specified in yaml file


@@ -558,7 +617,8 @@ class InterfaceUtil(object):
             interface['name'] = name
 
         # Set udev rules for interfaces
             interface['name'] = name
 
         # Set udev rules for interfaces

-        InterfaceUtil.tg_set_interfaces_udev_rules(node)
+        if not skip_tg_udev:
+            InterfaceUtil.tg_set_interfaces_udev_rules(node)

 
     @staticmethod
     def iface_update_numa_node(node):
 
     @staticmethod
     def iface_update_numa_node(node):


@@ -587,15 +647,15 @@ class InterfaceUtil(object):
                             else:
                                 raise ValueError
                     except ValueError:
                             else:
                                 raise ValueError
                     except ValueError:

-                        logger.trace('Reading numa location failed for: {0}'\
-                            .format(if_pci))
+                        logger.trace('Reading numa location failed for: {0}'
+                                     .format(if_pci))

                     else:
                         Topology.set_interface_numa_node(node, if_key,
                                                          numa_node)
                         break
             else:
                     else:
                         Topology.set_interface_numa_node(node, if_key,
                                                          numa_node)
                         break
             else:

-                raise RuntimeError('Update numa node failed for: {0}'\
-                    .format(if_pci))
+                raise RuntimeError('Update numa node failed for: {0}'
+                                   .format(if_pci))

 
     @staticmethod
     def update_all_numa_nodes(nodes, skip_tg=False):
 
     @staticmethod
     def update_all_numa_nodes(nodes, skip_tg=False):


@@ -616,6 +676,7 @@ class InterfaceUtil(object):
 
     @staticmethod
     def update_all_interface_data_on_all_nodes(nodes, skip_tg=False,
 
     @staticmethod
     def update_all_interface_data_on_all_nodes(nodes, skip_tg=False,

+                                               skip_tg_udev=False,

                                                numa_node=False):
         """Update interface names on all nodes in DICT__nodes.
 
                                                numa_node=False):
         """Update interface names on all nodes in DICT__nodes.
 


@@ -623,17 +684,20 @@ class InterfaceUtil(object):
         of all nodes mentioned in the topology dictionary.
 
         :param nodes: Nodes in the topology.
         of all nodes mentioned in the topology dictionary.
 
         :param nodes: Nodes in the topology.

-        :param skip_tg: Skip TG node
+        :param skip_tg: Skip TG node.
+        :param skip_tg_udev: Skip udev rename on TG node.

         :param numa_node: Retrieve numa_node location.
         :type nodes: dict
         :type skip_tg: bool
         :param numa_node: Retrieve numa_node location.
         :type nodes: dict
         :type skip_tg: bool

+        :type skip_tg_udev: bool

         :type numa_node: bool
         """
         for node_data in nodes.values():
             if node_data['type'] == NodeType.DUT:
                 InterfaceUtil.update_vpp_interface_data_on_node(node_data)
             elif node_data['type'] == NodeType.TG and not skip_tg:
         :type numa_node: bool
         """
         for node_data in nodes.values():
             if node_data['type'] == NodeType.DUT:
                 InterfaceUtil.update_vpp_interface_data_on_node(node_data)
             elif node_data['type'] == NodeType.TG and not skip_tg:

-                InterfaceUtil.update_tg_interface_data_on_node(node_data)
+                InterfaceUtil.update_tg_interface_data_on_node(
+                    node_data, skip_tg_udev)

 
             if numa_node:
                 if node_data['type'] == NodeType.DUT:
 
             if numa_node:
                 if node_data['type'] == NodeType.DUT:


@@ -643,50 +707,41 @@ class InterfaceUtil(object):
 
     @staticmethod
     def create_vlan_subinterface(node, interface, vlan):
 
     @staticmethod
     def create_vlan_subinterface(node, interface, vlan):

-        """Create VLAN subinterface on node.
+        """Create VLAN sub-interface on node.

 
         :param node: Node to add VLAN subinterface on.
 
         :param node: Node to add VLAN subinterface on.

-        :param interface: Interface name on which create VLAN subinterface.
+        :param interface: Interface name or index on which create VLAN
+            subinterface.

         :param vlan: VLAN ID of the subinterface to be created.
         :type node: dict
         :param vlan: VLAN ID of the subinterface to be created.
         :type node: dict

-        :type interface: str
+        :type interface: str on int

         :type vlan: int
         :returns: Name and index of created subinterface.
         :rtype: tuple
         :raises RuntimeError: if it is unable to create VLAN subinterface on the
         :type vlan: int
         :returns: Name and index of created subinterface.
         :rtype: tuple
         :raises RuntimeError: if it is unable to create VLAN subinterface on the

-            node.
+            node or interface cannot be converted.

         """
         """

-        iface_key = Topology.get_interface_by_name(node, interface)
-        sw_if_index = Topology.get_interface_sw_index(node, iface_key)
-
-        output = VatExecutor.cmd_from_template(node, "create_vlan_subif.vat",
-                                               sw_if_index=sw_if_index,
-                                               vlan=vlan)
-        if output[0]["retval"] == 0:
-            sw_subif_idx = output[0]["sw_if_index"]
-            logger.trace('VLAN subinterface with sw_if_index {} and VLAN ID {} '
-                         'created on node {}'.format(sw_subif_idx,
-                                                     vlan, node['host']))
-            if_key = Topology.add_new_port(node, "vlan_subif")
-            Topology.update_interface_sw_if_index(node, if_key, sw_subif_idx)
-            ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_subif_idx)
-            Topology.update_interface_name(node, if_key, ifc_name)
-        else:
-            raise RuntimeError('Unable to create VLAN subinterface on node {}'
-                               .format(node['host']))
-
-        with VatTerminal(node, False) as vat:
-            vat.vat_terminal_exec_cmd('exec show interfaces')
+        sw_if_index = InterfaceUtil.get_interface_index(node, interface)
+
+        cmd = 'create_vlan_subif'
+        args = dict(sw_if_index=sw_if_index,
+                    vlan_id=int(vlan))
+        err_msg = 'Failed to create VLAN sub-interface on host {host}'.format(
+            host=node['host'])
+        with PapiSocketExecutor(node) as papi_exec:
+            sw_if_index = papi_exec.add(cmd, **args).get_sw_if_index(err_msg)
+
+        if_key = Topology.add_new_port(node, 'vlan_subif')
+        Topology.update_interface_sw_if_index(node, if_key, sw_if_index)
+        ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_index)
+        Topology.update_interface_name(node, if_key, ifc_name)

 
 

-        return '{}.{}'.format(interface, vlan), sw_subif_idx
+        return '{ifc}.{vlan}'.format(ifc=interface, vlan=vlan), sw_if_index

 
     @staticmethod
     def create_vxlan_interface(node, vni, source_ip, destination_ip):
         """Create VXLAN interface and return sw if index of created interface.
 
 
     @staticmethod
     def create_vxlan_interface(node, vni, source_ip, destination_ip):
         """Create VXLAN interface and return sw if index of created interface.
 

-        Executes "vxlan_add_del_tunnel src {src} dst {dst} vni {vni}" VAT
-        command on the node.
-

         :param node: Node where to create VXLAN interface.
         :param vni: VXLAN Network Identifier.
         :param source_ip: Source IP of a VXLAN Tunnel End Point.
         :param node: Node where to create VXLAN interface.
         :param vni: VXLAN Network Identifier.
         :param source_ip: Source IP of a VXLAN Tunnel End Point.


@@ -700,22 +755,57 @@ class InterfaceUtil(object):
         :raises RuntimeError: if it is unable to create VxLAN interface on the
             node.
         """
         :raises RuntimeError: if it is unable to create VxLAN interface on the
             node.
         """

-        output = VatExecutor.cmd_from_template(node, "vxlan_create.vat",
-                                               src=source_ip,
-                                               dst=destination_ip,
-                                               vni=vni)
-        output = output[0]
-
-        if output["retval"] == 0:
-            sw_if_idx = output["sw_if_index"]
-            if_key = Topology.add_new_port(node, "vxlan_tunnel")
-            Topology.update_interface_sw_if_index(node, if_key, sw_if_idx)
-            ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_idx)
-            Topology.update_interface_name(node, if_key, ifc_name)
-            return sw_if_idx
-        else:
-            raise RuntimeError("Unable to create VXLAN interface on node {0}"
-                               .format(node))
+        src_address = ip_address(unicode(source_ip))
+        dst_address = ip_address(unicode(destination_ip))
+
+        cmd = 'vxlan_add_del_tunnel'
+        args = dict(is_add=1,
+                    is_ipv6=1 if src_address.version == 6 else 0,
+                    instance=Constants.BITWISE_NON_ZERO,
+                    src_address=src_address.packed,
+                    dst_address=dst_address.packed,
+                    mcast_sw_if_index=Constants.BITWISE_NON_ZERO,
+                    encap_vrf_id=0,
+                    decap_next_index=Constants.BITWISE_NON_ZERO,
+                    vni=int(vni))
+        err_msg = 'Failed to create VXLAN tunnel interface on host {host}'.\
+            format(host=node['host'])
+        with PapiSocketExecutor(node) as papi_exec:
+            sw_if_index = papi_exec.add(cmd, **args).get_sw_if_index(err_msg)
+
+        if_key = Topology.add_new_port(node, 'vxlan_tunnel')
+        Topology.update_interface_sw_if_index(node, if_key, sw_if_index)
+        ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_index)
+        Topology.update_interface_name(node, if_key, ifc_name)
+
+        return sw_if_index
+
+    @staticmethod
+    def set_vxlan_bypass(node, interface=None):
+        """Add the 'ip4-vxlan-bypass' graph node for a given interface.
+
+        By adding the IPv4 vxlan-bypass graph node to an interface, the node
+        checks for and validate input vxlan packet and bypass ip4-lookup,
+        ip4-local, ip4-udp-lookup nodes to speedup vxlan packet forwarding.
+        This node will cause extra overhead to for non-vxlan packets which is
+        kept at a minimum.
+
+        :param node: Node where to set VXLAN bypass.
+        :param interface: Numeric index or name string of a specific interface.
+        :type node: dict
+        :type interface: int or str
+        :raises RuntimeError: if it failed to set VXLAN bypass on interface.
+        """
+        sw_if_index = InterfaceUtil.get_interface_index(node, interface)
+
+        cmd = 'sw_interface_set_vxlan_bypass'
+        args = dict(is_ipv6=0,
+                    sw_if_index=sw_if_index,
+                    enable=1)
+        err_msg = 'Failed to set VXLAN bypass on interface on host {host}'.\
+            format(host=node['host'])
+        with PapiSocketExecutor(node) as papi_exec:
+            papi_exec.add(cmd, **args).get_replies(err_msg)

 
     @staticmethod
     def vxlan_dump(node, interface=None):
 
     @staticmethod
     def vxlan_dump(node, interface=None):


@@ -732,65 +822,87 @@ class InterfaceUtil(object):
         :raises TypeError: if the data type of interface is neither basestring
             nor int.
         """
         :raises TypeError: if the data type of interface is neither basestring
             nor int.
         """

-        param = "sw_if_index"
-        if interface is None:
-            param = ''
-            sw_if_index = ''
-        elif isinstance(interface, basestring):
-            sw_if_index = Topology.get_interface_sw_index(node, interface)
-        elif isinstance(interface, int):
-            sw_if_index = interface
-        else:
-            raise TypeError("Wrong interface format {0}".format(interface))
-
-        with VatTerminal(node) as vat:
-            response = vat.vat_terminal_exec_cmd_from_template(
-                "vxlan_dump.vat", param=param, sw_if_index=sw_if_index)
+        def process_vxlan_dump(vxlan_dump):
+            """Process vxlan dump.
+
+            :param vxlan_dump: Vxlan interface dump.
+            :type vxlan_dump: dict
+            :returns: Processed vxlan interface dump.
+            :rtype: dict
+            """
+            if vxlan_dump['is_ipv6']:
+                vxlan_dump['src_address'] = \
+                    ip_address(unicode(vxlan_dump['src_address']))
+                vxlan_dump['dst_address'] = \
+                    ip_address(unicode(vxlan_dump['dst_address']))
+            else:
+                vxlan_dump['src_address'] = \
+                    ip_address(unicode(vxlan_dump['src_address'][0:4]))
+                vxlan_dump['dst_address'] = \
+                    ip_address(unicode(vxlan_dump['dst_address'][0:4]))
+            return vxlan_dump

 
 

-        if sw_if_index:
-            for vxlan in response[0]:
-                if vxlan["sw_if_index"] == sw_if_index:
-                    return vxlan
-            return {}
-        return response[0]
+        if interface is not None:
+            sw_if_index = InterfaceUtil.get_interface_index(node, interface)
+        else:
+            sw_if_index = int(Constants.BITWISE_NON_ZERO)
+
+        cmd = 'vxlan_tunnel_dump'
+        args = dict(sw_if_index=sw_if_index)
+        err_msg = 'Failed to get VXLAN dump on host {host}'.format(
+            host=node['host'])
+        with PapiSocketExecutor(node) as papi_exec:
+            details = papi_exec.add(cmd, **args).get_details(err_msg)
+
+        data = list() if interface is None else dict()
+        for dump in details:
+            if interface is None:
+                data.append(process_vxlan_dump(dump))
+            elif dump['sw_if_index'] == sw_if_index:
+                data = process_vxlan_dump(dump)
+                break
+
+        logger.debug('VXLAN data:\n{vxlan_data}'.format(vxlan_data=data))
+        return data

 
     @staticmethod
     def vhost_user_dump(node):
         """Get vhost-user data for the given node.
 
 
     @staticmethod
     def vhost_user_dump(node):
         """Get vhost-user data for the given node.
 

+        TODO: Move to VhostUser.py
+

         :param node: VPP node to get interface data from.
         :type node: dict
         :returns: List of dictionaries with all vhost-user interfaces.
         :rtype: list
         """
         :param node: VPP node to get interface data from.
         :type node: dict
         :returns: List of dictionaries with all vhost-user interfaces.
         :rtype: list
         """

-        with VatTerminal(node) as vat:
-            response = vat.vat_terminal_exec_cmd_from_template(
-                "vhost_user_dump.vat")
-
-        return response[0]
-
-    @staticmethod
-    def tap_dump(node, name=None):
-        """Get all TAP interface data from the given node, or data about
-        a specific TAP interface.
-
-        :param node: VPP node to get data from.
-        :param name: Optional name of a specific TAP interface.
-        :type node: dict
-        :type name: str
-        :returns: Dictionary of information about a specific TAP interface, or
-            a List of dictionaries containing all TAP data for the given node.
-        :rtype: dict or list
-        """
-        with VatTerminal(node) as vat:
-            response = vat.vat_terminal_exec_cmd_from_template(
-                "tap_dump.vat")
-        if name is None:
-            return response[0]
-        for item in response[0]:
-            if name == item['dev_name']:
-                return item
-        return {}
+        def process_vhost_dump(vhost_dump):
+            """Process vhost dump.
+
+            :param vhost_dump: Vhost interface dump.
+            :type vhost_dump: dict
+            :returns: Processed vhost interface dump.
+            :rtype: dict
+            """
+            vhost_dump['interface_name'] = \
+                vhost_dump['interface_name'].rstrip('\x00')
+            vhost_dump['sock_filename'] = \
+                vhost_dump['sock_filename'].rstrip('\x00')
+            return vhost_dump
+
+        cmd = 'sw_interface_vhost_user_dump'
+        err_msg = 'Failed to get vhost-user dump on host {host}'.format(
+            host=node['host'])
+        with PapiSocketExecutor(node) as papi_exec:
+            details = papi_exec.add(cmd).get_details(err_msg)
+
+        for dump in details:
+            # In-place edits.
+            process_vhost_dump(dump)
+
+        logger.debug('Vhost-user details:\n{vhost_details}'.format(
+            vhost_details=details))
+        return details

 
     @staticmethod
     def create_subinterface(node, interface, sub_id, outer_vlan_id=None,
 
     @staticmethod
     def create_subinterface(node, interface, sub_id, outer_vlan_id=None,


@@ -816,46 +928,33 @@ class InterfaceUtil(object):
         :rtype: tuple
         :raises RuntimeError: If it is not possible to create sub-interface.
         """
         :rtype: tuple
         :raises RuntimeError: If it is not possible to create sub-interface.
         """

+        subif_types = type_subif.split()
+
+        cmd = 'create_subif'
+        args = dict(
+            sw_if_index=InterfaceUtil.get_interface_index(node, interface),
+            sub_id=int(sub_id),
+            no_tags=1 if 'no_tags' in subif_types else 0,
+            one_tag=1 if 'one_tag' in subif_types else 0,
+            two_tags=1 if 'two_tags' in subif_types else 0,
+            dot1ad=1 if 'dot1ad' in subif_types else 0,
+            exact_match=1 if 'exact_match' in subif_types else 0,
+            default_sub=1 if 'default_sub' in subif_types else 0,
+            outer_vlan_id_any=1 if type_subif == 'default_sub' else 0,
+            inner_vlan_id_any=1 if type_subif == 'default_sub' else 0,
+            outer_vlan_id=int(outer_vlan_id) if outer_vlan_id else 0,
+            inner_vlan_id=int(inner_vlan_id) if inner_vlan_id else 0)
+        err_msg = 'Failed to create sub-interface on host {host}'.format(
+            host=node['host'])
+        with PapiSocketExecutor(node) as papi_exec:
+            sw_if_index = papi_exec.add(cmd, **args).get_sw_if_index(err_msg)
+
+        if_key = Topology.add_new_port(node, 'subinterface')
+        Topology.update_interface_sw_if_index(node, if_key, sw_if_index)
+        ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_index)
+        Topology.update_interface_name(node, if_key, ifc_name)

 
 

-        outer_vlan_id = 'outer_vlan_id {0}'.format(outer_vlan_id)\
-            if outer_vlan_id else ''
-
-        inner_vlan_id = 'inner_vlan_id {0}'.format(inner_vlan_id)\
-            if inner_vlan_id else ''
-
-        if type_subif is None:
-            type_subif = ''
-
-        if isinstance(interface, basestring):
-            iface_key = Topology.get_interface_by_name(node, interface)
-            sw_if_index = Topology.get_interface_sw_index(node, iface_key)
-        else:
-            sw_if_index = interface
-
-        output = VatExecutor.cmd_from_template(node, "create_sub_interface.vat",
-                                               sw_if_index=sw_if_index,
-                                               sub_id=sub_id,
-                                               outer_vlan_id=outer_vlan_id,
-                                               inner_vlan_id=inner_vlan_id,
-                                               type_subif=type_subif)
-
-        if output[0]["retval"] == 0:
-            sw_subif_idx = output[0]["sw_if_index"]
-            logger.trace('Created subinterface with index {}'
-                         .format(sw_subif_idx))
-            if_key = Topology.add_new_port(node, "subinterface")
-            Topology.update_interface_sw_if_index(node, if_key, sw_subif_idx)
-            ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_subif_idx)
-            Topology.update_interface_name(node, if_key, ifc_name)
-        else:
-            raise RuntimeError('Unable to create sub-interface on node {}'
-                               .format(node['host']))
-
-        with VatTerminal(node, json_param=False) as vat:
-            vat.vat_terminal_exec_cmd('exec show interfaces')
-
-        name = '{}.{}'.format(interface, sub_id)
-        return name, sw_subif_idx
+        return '{ifc}.{s_id}'.format(ifc=interface, s_id=sub_id), sw_if_index

 
     @staticmethod
     def create_gre_tunnel_interface(node, source_ip, destination_ip):
 
     @staticmethod
     def create_gre_tunnel_interface(node, source_ip, destination_ip):


@@ -871,51 +970,56 @@ class InterfaceUtil(object):
         :rtype: tuple
         :raises RuntimeError: If unable to create GRE tunnel interface.
         """
         :rtype: tuple
         :raises RuntimeError: If unable to create GRE tunnel interface.
         """

-        output = VatExecutor.cmd_from_template(node, "create_gre.vat",
-                                               src=source_ip,
-                                               dst=destination_ip)
-        output = output[0]
-
-        if output["retval"] == 0:
-            sw_if_idx = output["sw_if_index"]
-
-            vat_executor = VatExecutor()
-            vat_executor.execute_script_json_out("dump_interfaces.vat", node)
-            interface_dump_json = vat_executor.get_script_stdout()
-            name = VatJsonUtil.get_interface_name_from_json(
-                interface_dump_json, sw_if_idx)
-
-            if_key = Topology.add_new_port(node, "gre_tunnel")
-            Topology.update_interface_sw_if_index(node, if_key, sw_if_idx)
-            Topology.update_interface_name(node, if_key, name)
+        cmd = 'gre_tunnel_add_del'
+        tunnel = dict(type=0,
+                      instance=Constants.BITWISE_NON_ZERO,
+                      src=str(source_ip),
+                      dst=str(destination_ip),
+                      outer_fib_id=0,
+                      session_id=0)
+        args = dict(is_add=1,
+                    tunnel=tunnel)
+        err_msg = 'Failed to create GRE tunnel interface on host {host}'.format(
+            host=node['host'])
+        with PapiSocketExecutor(node) as papi_exec:
+            sw_if_index = papi_exec.add(cmd, **args).get_sw_if_index(err_msg)
+
+        if_key = Topology.add_new_port(node, 'gre_tunnel')
+        Topology.update_interface_sw_if_index(node, if_key, sw_if_index)
+        ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_index)
+        Topology.update_interface_name(node, if_key, ifc_name)

 
 

-            return name, sw_if_idx
-        else:
-            raise RuntimeError('Unable to create GRE tunnel on node {}.'
-                               .format(node))
+        return ifc_name, sw_if_index

 
     @staticmethod
 
     @staticmethod

-    def vpp_create_loopback(node):
+    def vpp_create_loopback(node, mac=None):

         """Create loopback interface on VPP node.
 
         :param node: Node to create loopback interface on.
         """Create loopback interface on VPP node.
 
         :param node: Node to create loopback interface on.

+        :param mac: Optional MAC address for Loopback interface.

         :type node: dict
         :type node: dict

+        :type mac: str

         :returns: SW interface index.
         :rtype: int
         :raises RuntimeError: If it is not possible to create loopback on the
             node.
         """
         :returns: SW interface index.
         :rtype: int
         :raises RuntimeError: If it is not possible to create loopback on the
             node.
         """

-        out = VatExecutor.cmd_from_template(node, "create_loopback.vat")
-        if out[0].get('retval') == 0:
-            sw_if_idx = out[0].get('sw_if_index')
-            if_key = Topology.add_new_port(node, "loopback")
-            Topology.update_interface_sw_if_index(node, if_key, sw_if_idx)
-            ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_idx)
-            Topology.update_interface_name(node, if_key, ifc_name)
-            return sw_if_idx
-        else:
-            raise RuntimeError('Create loopback failed on node "{}"'
-                               .format(node['host']))
+        cmd = 'create_loopback'
+        args = dict(mac_address=L2Util.mac_to_bin(mac) if mac else 0)
+        err_msg = 'Failed to create loopback interface on host {host}'.format(
+            host=node['host'])
+        with PapiSocketExecutor(node) as papi_exec:
+            sw_if_index = papi_exec.add(cmd, **args).get_sw_if_index(err_msg)
+
+        if_key = Topology.add_new_port(node, 'loopback')
+        Topology.update_interface_sw_if_index(node, if_key, sw_if_index)
+        ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_index)
+        Topology.update_interface_name(node, if_key, ifc_name)
+        if mac:
+            mac = InterfaceUtil.vpp_get_interface_mac(node, ifc_name)
+            Topology.update_interface_mac_address(node, if_key, mac)
+
+        return sw_if_index

 
     @staticmethod
     def vpp_create_bond_interface(node, mode, load_balance=None, mac=None):
 
     @staticmethod
     def vpp_create_bond_interface(node, mode, load_balance=None, mac=None):


@@ -935,132 +1039,198 @@ class InterfaceUtil(object):
         :raises RuntimeError: If it is not possible to create bond interface on
             the node.
         """
         :raises RuntimeError: If it is not possible to create bond interface on
             the node.
         """

-        hw_addr = '' if mac is None else 'hw-addr {mac}'.format(mac=mac)
-        ldb = '' if load_balance is None \
-            else 'lb {ldb}'.format(ldb=load_balance)
-
-        output = VatExecutor.cmd_from_template(
-            node, 'create_bond_interface.vat', mode=mode, lb=ldb, mac=hw_addr)
-
-        if output[0].get('retval') == 0:
-            sw_if_idx = output[0].get('sw_if_index')
-            InterfaceUtil.add_eth_interface(node, sw_if_idx=sw_if_idx,
-                                            ifc_pfx='eth_bond')
-            if_key = Topology.get_interface_by_sw_index(node, sw_if_idx)
-            return if_key
-        else:
-            raise RuntimeError('Create bond interface failed on "{host}"'.
-                               format(host=node['host']))
+        cmd = 'bond_create'
+        args = dict(id=int(Constants.BITWISE_NON_ZERO),
+                    use_custom_mac=0 if mac is None else 1,
+                    mac_address=0 if mac is None else L2Util.mac_to_bin(mac),
+                    mode=getattr(LinkBondMode, '{md}'.format(
+                        md=mode.replace('-', '_').upper())).value,
+                    lb=0 if load_balance is None else getattr(
+                        LinkBondLoadBalance, '{lb}'.format(
+                            lb=load_balance.upper())).value)
+        err_msg = 'Failed to create bond interface on host {host}'.format(
+            host=node['host'])
+        with PapiSocketExecutor(node) as papi_exec:
+            sw_if_index = papi_exec.add(cmd, **args).get_sw_if_index(err_msg)
+
+        InterfaceUtil.add_eth_interface(node, sw_if_index=sw_if_index,
+                                        ifc_pfx='eth_bond')
+        if_key = Topology.get_interface_by_sw_index(node, sw_if_index)
+
+        return if_key

 
     @staticmethod
 
     @staticmethod

-    def add_eth_interface(node, ifc_name=None, sw_if_idx=None, ifc_pfx=None):
+    def add_eth_interface(node, ifc_name=None, sw_if_index=None, ifc_pfx=None):

         """Add ethernet interface to current topology.
 
         :param node: DUT node from topology.
         :param ifc_name: Name of the interface.
         """Add ethernet interface to current topology.
 
         :param node: DUT node from topology.
         :param ifc_name: Name of the interface.

-        :param sw_if_idx: SW interface index.
+        :param sw_if_index: SW interface index.

         :param ifc_pfx: Interface key prefix.
         :type node: dict
         :type ifc_name: str
         :param ifc_pfx: Interface key prefix.
         :type node: dict
         :type ifc_name: str

-        :type sw_if_idx: int
+        :type sw_if_index: int

         :type ifc_pfx: str
         """
         if_key = Topology.add_new_port(node, ifc_pfx)
 
         :type ifc_pfx: str
         """
         if_key = Topology.add_new_port(node, ifc_pfx)
 

-        vat_executor = VatExecutor()
-        vat_executor.execute_script_json_out("dump_interfaces.vat", node)
-        interface_dump_json = vat_executor.get_script_stdout()
-
-        if ifc_name and sw_if_idx is None:
-            sw_if_idx = VatJsonUtil.get_interface_sw_index_from_json(
-                interface_dump_json, ifc_name)
-        Topology.update_interface_sw_if_index(node, if_key, sw_if_idx)
-        if sw_if_idx and ifc_name is None:
-            ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_idx)
+        if ifc_name and sw_if_index is None:
+            sw_if_index = InterfaceUtil.vpp_get_interface_sw_index(
+                node, ifc_name)
+        Topology.update_interface_sw_if_index(node, if_key, sw_if_index)
+        if sw_if_index and ifc_name is None:
+            ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_index)

         Topology.update_interface_name(node, if_key, ifc_name)
         Topology.update_interface_name(node, if_key, ifc_name)

-        ifc_mac = VatJsonUtil.get_interface_mac_from_json(
-            interface_dump_json, sw_if_idx)
+        ifc_mac = InterfaceUtil.vpp_get_interface_mac(node, sw_if_index)

         Topology.update_interface_mac_address(node, if_key, ifc_mac)
 
     @staticmethod
         Topology.update_interface_mac_address(node, if_key, ifc_mac)
 
     @staticmethod

-    def vpp_create_avf_interface(node, vf_pci_addr):
+    def vpp_create_avf_interface(node, vf_pci_addr, num_rx_queues=None):

         """Create AVF interface on VPP node.
 
         :param node: DUT node from topology.
         :param vf_pci_addr: Virtual Function PCI address.
         """Create AVF interface on VPP node.
 
         :param node: DUT node from topology.
         :param vf_pci_addr: Virtual Function PCI address.

+        :param num_rx_queues: Number of RX queues.

         :type node: dict
         :type vf_pci_addr: str
         :type node: dict
         :type vf_pci_addr: str

+        :type num_rx_queues: int

         :returns: Interface key (name) in topology.
         :rtype: str
         :raises RuntimeError: If it is not possible to create AVF interface on
             the node.
         """
         :returns: Interface key (name) in topology.
         :rtype: str
         :raises RuntimeError: If it is not possible to create AVF interface on
             the node.
         """

-        with VatTerminal(node, json_param=False) as vat:
-            vat.vat_terminal_exec_cmd_from_template('create_avf_interface.vat',
-                                                    vf_pci_addr=vf_pci_addr)
-            output = vat.vat_stdout
-
-        if output is not None:
-            sw_if_idx = int(output.split()[4])
-            InterfaceUtil.add_eth_interface(node, sw_if_idx=sw_if_idx,
-                                            ifc_pfx='eth_avf')
-            if_key = Topology.get_interface_by_sw_index(node, sw_if_idx)
-            return if_key
-        else:
-            raise RuntimeError('Create AVF interface failed on {host}'.
-                               format(host=node['host']))
+        cmd = 'avf_create'
+        args = dict(pci_addr=InterfaceUtil.pci_to_int(vf_pci_addr),
+                    enable_elog=0,
+                    rxq_num=int(num_rx_queues) if num_rx_queues else 0,
+                    rxq_size=0,
+                    txq_size=0)
+        err_msg = 'Failed to create AVF interface on host {host}'.format(
+            host=node['host'])
+        with PapiSocketExecutor(node) as papi_exec:
+            sw_if_index = papi_exec.add(cmd, **args).get_sw_if_index(err_msg)
+
+        InterfaceUtil.add_eth_interface(node, sw_if_index=sw_if_index,
+                                        ifc_pfx='eth_avf')
+        if_key = Topology.get_interface_by_sw_index(node, sw_if_index)
+
+        return if_key

 
     @staticmethod
 
     @staticmethod

-    def vpp_enslave_physical_interface(node, interface, bond_interface):
+    def vpp_enslave_physical_interface(node, interface, bond_if):

         """Enslave physical interface to bond interface on VPP node.
 
         :param node: DUT node from topology.
         :param interface: Physical interface key from topology file.
         """Enslave physical interface to bond interface on VPP node.
 
         :param node: DUT node from topology.
         :param interface: Physical interface key from topology file.

-        :param bond_interface: Load balance
+        :param bond_if: Load balance

         :type node: dict
         :type interface: str
         :type node: dict
         :type interface: str

-        :type bond_interface: str
+        :type bond_if: str

         :raises RuntimeError: If it is not possible to enslave physical
             interface to bond interface on the node.
         """
         :raises RuntimeError: If it is not possible to enslave physical
             interface to bond interface on the node.
         """

-        ifc = Topology.get_interface_sw_index(node, interface)
-        bond_ifc = Topology.get_interface_sw_index(node, bond_interface)
+        cmd = 'bond_enslave'
+        args = dict(
+            sw_if_index=Topology.get_interface_sw_index(node, interface),
+            bond_sw_if_index=Topology.get_interface_sw_index(node, bond_if),
+            is_passive=0,
+            is_long_timeout=0)
+        err_msg = 'Failed to enslave physical interface {ifc} to bond ' \
+                  'interface {bond} on host {host}'.format(ifc=interface,
+                                                           bond=bond_if,
+                                                           host=node['host'])
+        with PapiSocketExecutor(node) as papi_exec:
+            papi_exec.add(cmd, **args).get_reply(err_msg)

 
 

-        output = VatExecutor.cmd_from_template(
-            node, 'enslave_physical_interface.vat', p_int=ifc, b_int=bond_ifc)
+    @staticmethod
+    def vpp_show_bond_data_on_node(node, verbose=False):
+        """Show (detailed) bond information on VPP node.

 
 

-        retval = output[0].get('retval', None)
-        if retval is None or int(retval) != 0:
-            raise RuntimeError('Enslave physical interface {ifc} to bond '
-                               'interface {bond} failed on node "{n}"'
-                               .format(ifc=interface, bond=bond_interface,
-                                       n=node['host']))
+        :param node: DUT node from topology.
+        :param verbose: If detailed information is required or not.
+        :type node: dict
+        :type verbose: bool
+        """
+        cmd = 'sw_interface_bond_dump'
+        err_msg = 'Failed to get bond interface dump on host {host}'.format(
+            host=node['host'])
+
+        data = ('Bond data on node {host}:\n'.format(host=node['host']))
+        with PapiSocketExecutor(node) as papi_exec:
+            details = papi_exec.add(cmd).get_details(err_msg)
+
+        for bond in details:
+            data += ('{b}\n'.format(b=bond['interface_name'].rstrip('\x00')))
+            data += ('  mode: {m}\n'.format(m=bond['mode']).lower())
+            data += ('  load balance: {lb}\n'.format(lb=bond['lb']).lower())
+            data += ('  number of active slaves: {n}\n'.format(
+                n=bond['active_slaves']))
+            if verbose:
+                slave_data = InterfaceUtil.vpp_bond_slave_dump(
+                    node, Topology.get_interface_by_sw_index(
+                        node, bond['sw_if_index']))
+                for slave in slave_data:
+                    if not slave['is_passive']:
+                        data += ('    {s}\n'.format(s=slave['interface_name']))
+            data += ('  number of slaves: {n}\n'.format(n=bond['slaves']))
+            if verbose:
+                for slave in slave_data:
+                    data += ('    {s}\n'.format(s=slave['interface_name']))
+            data += ('  interface id: {i}\n'.format(i=bond['id']))
+            data += ('  sw_if_index: {i}\n'.format(i=bond['sw_if_index']))
+        logger.info(data)

 
     @staticmethod
 
     @staticmethod

-    def vpp_show_bond_data_on_node(node, details=False):
-        """Show (detailed) bond information on VPP node.
+    def vpp_bond_slave_dump(node, interface):
+        """Get bond interface slave(s) data on VPP node.

 
         :param node: DUT node from topology.
 
         :param node: DUT node from topology.

-        :param details: If detailed information is required or not.
+        :param interface: Physical interface key from topology file.

         :type node: dict
         :type node: dict

-        :type details: bool
+        :type interface: str
+        :returns: Bond slave interface data.
+        :rtype: dict

         """
         """

-        cmd = 'exec show bond details' if details else 'exec show bond'
-        with VatTerminal(node, json_param=False) as vat:
-            vat.vat_terminal_exec_cmd(cmd)
+        def process_slave_dump(slave_dump):
+            """Process slave dump.
+
+            :param slave_dump: Slave interface dump.
+            :type slave_dump: dict
+            :returns: Processed slave interface dump.
+            :rtype: dict
+            """
+            slave_dump['interface_name'] = slave_dump['interface_name'].\
+                rstrip('\x00')
+            return slave_dump
+
+        cmd = 'sw_interface_slave_dump'
+        args = dict(sw_if_index=Topology.get_interface_sw_index(
+            node, interface))
+        err_msg = 'Failed to get slave dump on host {host}'.format(
+            host=node['host'])
+
+        with PapiSocketExecutor(node) as papi_exec:
+            details = papi_exec.add(cmd, **args).get_details(err_msg)
+
+        for dump in details:
+            # In-place edits.
+            process_slave_dump(dump)
+
+        logger.debug('Slave data:\n{slave_data}'.format(slave_data=details))
+        return details

 
     @staticmethod
 
     @staticmethod

-    def vpp_show_bond_data_on_all_nodes(nodes, details=False):
+    def vpp_show_bond_data_on_all_nodes(nodes, verbose=False):

         """Show (detailed) bond information on all VPP nodes in DICT__nodes.
 
         :param nodes: Nodes in the topology.
         """Show (detailed) bond information on all VPP nodes in DICT__nodes.
 
         :param nodes: Nodes in the topology.

-        :param details: If detailed information is required or not.
+        :param verbose: If detailed information is required or not.

         :type nodes: dict
         :type nodes: dict

-        :type details: bool
+        :type verbose: bool

         """
         for node_data in nodes.values():
             if node_data['type'] == NodeType.DUT:
         """
         for node_data in nodes.values():
             if node_data['type'] == NodeType.DUT:

-                InterfaceUtil.vpp_show_bond_data_on_node(node_data, details)
+                InterfaceUtil.vpp_show_bond_data_on_node(node_data, verbose)

 
     @staticmethod
     def vpp_enable_input_acl_interface(node, interface, ip_version,
 
     @staticmethod
     def vpp_enable_input_acl_interface(node, interface, ip_version,


@@ -1076,21 +1246,27 @@ class InterfaceUtil(object):
         :type ip_version: str
         :type table_index: int
         """
         :type ip_version: str
         :type table_index: int
         """

-        if isinstance(interface, basestring):
-            sw_if_index = Topology.get_interface_sw_index(node, interface)
-        else:
-            sw_if_index = interface
-
-        with VatTerminal(node) as vat:
-            vat.vat_terminal_exec_cmd_from_template("input_acl_int.vat",
-                                                    sw_if_index=sw_if_index,
-                                                    ip_version=ip_version,
-                                                    table_index=table_index)
+        cmd = 'input_acl_set_interface'
+        args = dict(
+            sw_if_index=InterfaceUtil.get_interface_index(node, interface),
+            ip4_table_index=table_index if ip_version == 'ip4'
+            else Constants.BITWISE_NON_ZERO,
+            ip6_table_index=table_index if ip_version == 'ip6'
+            else Constants.BITWISE_NON_ZERO,
+            l2_table_index=table_index if ip_version == 'l2'
+            else Constants.BITWISE_NON_ZERO,
+            is_add=1)
+        err_msg = 'Failed to enable input acl on interface {ifc}'.format(
+            ifc=interface)
+        with PapiSocketExecutor(node) as papi_exec:
+            papi_exec.add(cmd, **args).get_reply(err_msg)

 
     @staticmethod
     def get_interface_classify_table(node, interface):
         """Get name of classify table for the given interface.
 
 
     @staticmethod
     def get_interface_classify_table(node, interface):
         """Get name of classify table for the given interface.
 

+        TODO: Move to Classify.py.
+

         :param node: VPP node to get data from.
         :param interface: Name or sw_if_index of a specific interface.
         :type node: dict
         :param node: VPP node to get data from.
         :param interface: Name or sw_if_index of a specific interface.
         :type node: dict


@@ -1103,34 +1279,14 @@ class InterfaceUtil(object):
         else:
             sw_if_index = interface
 
         else:
             sw_if_index = interface
 

-        with VatTerminal(node) as vat:
-            data = vat.vat_terminal_exec_cmd_from_template(
-                "classify_interface_table.vat",
-                sw_if_index=sw_if_index)
-        return data[0]
+        cmd = 'classify_table_by_interface'
+        args = dict(sw_if_index=sw_if_index)
+        err_msg = 'Failed to get classify table name by interface {ifc}'.format(
+            ifc=interface)
+        with PapiSocketExecutor(node) as papi_exec:
+            reply = papi_exec.add(cmd, **args).get_reply(err_msg)

 
 

-    @staticmethod
-    def get_interface_vrf_table(node, interface):
-        """Get vrf ID for the given interface.
-
-        :param node: VPP node.
-        :param interface: Name or sw_if_index of a specific interface.
-        :type node: dict
-        :type interface: str or int
-        :returns: vrf ID of the specified interface.
-        :rtype: int
-        """
-
-        if isinstance(interface, basestring):
-            sw_if_index = InterfaceUtil.get_sw_if_index(node, interface)
-        else:
-            sw_if_index = interface
-
-        with VatTerminal(node) as vat:
-            data = vat.vat_terminal_exec_cmd_from_template(
-                "interface_vrf_dump.vat",
-                sw_if_index=sw_if_index)
-        return data[0]["vrf_id"]
+        return reply

 
     @staticmethod
     def get_sw_if_index(node, interface_name):
 
     @staticmethod
     def get_sw_if_index(node, interface_name):


@@ -1143,15 +1299,9 @@ class InterfaceUtil(object):
         :returns: sw_if_index of the given interface.
         :rtype: str
         """
         :returns: sw_if_index of the given interface.
         :rtype: str
         """

-
-        with VatTerminal(node) as vat:
-            if_data = vat.vat_terminal_exec_cmd_from_template(
-                "interface_dump.vat")
-        for interface in if_data[0]:
-            if interface["interface_name"] == interface_name:
-                return interface["sw_if_index"]
-
-        return None
+        interface_data = InterfaceUtil.vpp_get_interface_data(
+            node, interface=interface_name)
+        return interface_data.get('sw_if_index')

 
     @staticmethod
     def vxlan_gpe_dump(node, interface_name=None):
 
     @staticmethod
     def vxlan_gpe_dump(node, interface_name=None):


@@ -1167,52 +1317,50 @@ class InterfaceUtil(object):
             interfaces.
         :rtype: dict or list
         """
             interfaces.
         :rtype: dict or list
         """

-
-        with VatTerminal(node) as vat:
-            vxlan_gpe_data = vat.vat_terminal_exec_cmd_from_template(
-                "vxlan_gpe_dump.vat")
-
-        if interface_name:
-            sw_if_index = InterfaceUtil.get_sw_if_index(node, interface_name)
-            if sw_if_index:
-                for vxlan_gpe in vxlan_gpe_data[0]:
-                    if vxlan_gpe["sw_if_index"] == sw_if_index:
-                        return vxlan_gpe
-            return {}
-
-        return vxlan_gpe_data[0]
-
-    @staticmethod
-    def vpp_proxy_arp_interface_enable(node, interface):
-        """Enable proxy ARP on interface.
-
-        :param node: VPP node to enable proxy ARP on interface.
-        :param interface: Interface to enable proxy ARP.
-        :type node: dict
-        :type interface: str or int
-        """
-        if isinstance(interface, basestring):
-            sw_if_index = InterfaceUtil.get_sw_if_index(node, interface)
+        def process_vxlan_gpe_dump(vxlan_dump):
+            """Process vxlan_gpe dump.
+
+            :param vxlan_dump: Vxlan_gpe nterface dump.
+            :type vxlan_dump: dict
+            :returns: Processed vxlan_gpe interface dump.
+            :rtype: dict
+            """
+            if vxlan_dump['is_ipv6']:
+                vxlan_dump['local'] = \
+                    ip_address(unicode(vxlan_dump['local']))
+                vxlan_dump['remote'] = \
+                    ip_address(unicode(vxlan_dump['remote']))
+            else:
+                vxlan_dump['local'] = \
+                    ip_address(unicode(vxlan_dump['local'][0:4]))
+                vxlan_dump['remote'] = \
+                    ip_address(unicode(vxlan_dump['remote'][0:4]))
+            return vxlan_dump
+
+        if interface_name is not None:
+            sw_if_index = InterfaceUtil.get_interface_index(
+                node, interface_name)

         else:
         else:

-            sw_if_index = interface
-
-        with VatTerminal(node) as vat:
-            vat.vat_terminal_exec_cmd_from_template(
-                "proxy_arp_intfc_enable.vat",
-                sw_if_index=sw_if_index)
-
-    @staticmethod
-    def vpp_ip_source_check_setup(node, interface):
-        """Setup Reverse Path Forwarding source check on interface.
-
-        :param node: Node to setup RPF source check.
-        :param interface: Interface name to setup RPF source check.
-        :type node: dict
-        :type interface: str
-        """
-        with VatTerminal(node) as vat:
-            vat.vat_terminal_exec_cmd_from_template("ip_source_check.vat",
-                                                    interface_name=interface)
+            sw_if_index = int(Constants.BITWISE_NON_ZERO)
+
+        cmd = 'vxlan_gpe_tunnel_dump'
+        args = dict(sw_if_index=sw_if_index)
+        err_msg = 'Failed to get VXLAN-GPE dump on host {host}'.format(
+            host=node['host'])
+        with PapiSocketExecutor(node) as papi_exec:
+            details = papi_exec.add(cmd, **args).get_details(err_msg)
+
+        data = list() if interface_name is None else dict()
+        for dump in details:
+            if interface_name is None:
+                data.append(process_vxlan_gpe_dump(dump))
+            elif dump['sw_if_index'] == sw_if_index:
+                data = process_vxlan_gpe_dump(dump)
+                break
+
+        logger.debug('VXLAN-GPE data:\n{vxlan_gpe_data}'.format(
+            vxlan_gpe_data=data))
+        return data

 
     @staticmethod
     def assign_interface_to_fib_table(node, interface, table_id, ipv6=False):
 
     @staticmethod
     def assign_interface_to_fib_table(node, interface, table_id, ipv6=False):


@@ -1227,21 +1375,15 @@ class InterfaceUtil(object):
         :type table_id: int
         :type ipv6: bool
         """
         :type table_id: int
         :type ipv6: bool
         """

-        if isinstance(interface, basestring):
-            sw_if_index = Topology.get_interface_sw_index(node, interface)
-        else:
-            sw_if_index = interface
-
-        ipv6 = 'ipv6' if ipv6 else ''
-
-        with VatTerminal(node) as vat:
-            ret = vat.vat_terminal_exec_cmd_from_template(
-                "set_fib_to_interface.vat",
-                sw_index=sw_if_index, vrf=table_id, ipv6=ipv6)
-
-        if ret[0]["retval"] != 0:
-            raise RuntimeError('Unable to assign interface to FIB node {}.'
-                               .format(node))
+        cmd = 'sw_interface_set_table'
+        args = dict(
+            sw_if_index=InterfaceUtil.get_interface_index(node, interface),
+            is_ipv6=1 if ipv6 else 0,
+            vrf_id=int(table_id))
+        err_msg = 'Failed to assign interface {ifc} to FIB table'.format(
+            ifc=interface)
+        with PapiSocketExecutor(node) as papi_exec:
+            papi_exec.add(cmd, **args).get_reply(err_msg)

 
     @staticmethod
     def set_linux_interface_mac(node, interface, mac, namespace=None,
 
     @staticmethod
     def set_linux_interface_mac(node, interface, mac, namespace=None,


@@ -1312,31 +1454,35 @@ class InterfaceUtil(object):
         exec_cmd_no_error(node, cmd, sudo=True)
 
     @staticmethod
         exec_cmd_no_error(node, cmd, sudo=True)
 
     @staticmethod

-    def init_avf_interface(node, ifc_key, numvfs=1, topology_type='L2'):
-        """Init PCI device by creating VFs and bind them to vfio-pci for AVF
+    def init_avf_interface(node, ifc_key, numvfs=1, osi_layer='L2'):
+        """Init PCI device by creating VIFs and bind them to vfio-pci for AVF

         driver testing on DUT.
 
         :param node: DUT node.
         driver testing on DUT.
 
         :param node: DUT node.

-        :param iface_key: Interface key from topology file.
-        :param numvfs: Number of VFs to initialize, 0 - disable the VFs.
-        :param topology_type: Topology type.
+        :param ifc_key: Interface key from topology file.
+        :param numvfs: Number of VIFs to initialize, 0 - disable the VIFs.
+        :param osi_layer: OSI Layer type to initialize TG with.
+            Default value "L2" sets linux interface spoof off.

         :type node: dict
         :type node: dict

-        :iface_key: str
+        :type ifc_key: str

         :type numvfs: int
         :type numvfs: int

-        :typ topology_type: str
+        :type osi_layer: str

         :returns: Virtual Function topology interface keys.
         :rtype: list
         :returns: Virtual Function topology interface keys.
         :rtype: list

+        :raises RuntimeError: If a reason preventing initialization is found.

         """
         """

-        ssh = SSH()
-        ssh.connect(node)
-

         # Read PCI address and driver.
         pf_pci_addr = Topology.get_interface_pci_addr(node, ifc_key)
         pf_mac_addr = Topology.get_interface_mac(node, ifc_key).split(":")
         uio_driver = Topology.get_uio_driver(node)
         kernel_driver = Topology.get_interface_driver(node, ifc_key)
         # Read PCI address and driver.
         pf_pci_addr = Topology.get_interface_pci_addr(node, ifc_key)
         pf_mac_addr = Topology.get_interface_mac(node, ifc_key).split(":")
         uio_driver = Topology.get_uio_driver(node)
         kernel_driver = Topology.get_interface_driver(node, ifc_key)

-        current_driver = DUTSetup.get_pci_dev_driver(node,\
-            pf_pci_addr.replace(':', r'\:'))
+        if kernel_driver not in ("i40e", "i40evf"):
+            raise RuntimeError(
+                "AVF needs i40e-compatible driver, not {driver} at node {host}"
+                " ifc {ifc}".format(
+                    driver=kernel_driver, host=node["host"], ifc=ifc_key))
+        current_driver = DUTSetup.get_pci_dev_driver(
+            node, pf_pci_addr.replace(':', r'\:'))

 
         VPPUtil.stop_vpp_service(node)
         if current_driver != kernel_driver:
 
         VPPUtil.stop_vpp_service(node)
         if current_driver != kernel_driver:


@@ -1348,7 +1494,7 @@ class InterfaceUtil(object):
             # Bind to kernel driver.
             DUTSetup.pci_driver_bind(node, pf_pci_addr, kernel_driver)
 
             # Bind to kernel driver.
             DUTSetup.pci_driver_bind(node, pf_pci_addr, kernel_driver)
 

-        # Initialize PCI VFs
+        # Initialize PCI VFs.

         DUTSetup.set_sriov_numvfs(node, pf_pci_addr, numvfs)
 
         vf_ifc_keys = []
         DUTSetup.set_sriov_numvfs(node, pf_pci_addr, numvfs)
 
         vf_ifc_keys = []


@@ -1362,7 +1508,7 @@ class InterfaceUtil(object):
                 format(pci=pf_pci_addr)
             InterfaceUtil.set_linux_interface_trust_on(node, pf_dev,
                                                        vf_id=vf_id)
                 format(pci=pf_pci_addr)
             InterfaceUtil.set_linux_interface_trust_on(node, pf_dev,
                                                        vf_id=vf_id)

-            if topology_type == 'L2':
+            if osi_layer == 'L2':

                 InterfaceUtil.set_linux_interface_spoof_off(node, pf_dev,
                                                             vf_id=vf_id)
             InterfaceUtil.set_linux_interface_mac(node, pf_dev, vf_mac_addr,
                 InterfaceUtil.set_linux_interface_spoof_off(node, pf_dev,
                                                             vf_id=vf_id)
             InterfaceUtil.set_linux_interface_mac(node, pf_dev, vf_mac_addr,


@@ -1372,7 +1518,7 @@ class InterfaceUtil(object):
             DUTSetup.pci_vf_driver_bind(node, pf_pci_addr, vf_id, uio_driver)
 
             # Add newly created ports into topology file
             DUTSetup.pci_vf_driver_bind(node, pf_pci_addr, vf_id, uio_driver)
 
             # Add newly created ports into topology file

-            vf_ifc_name = '{pf_if_key}_vf'.format(pf_if_key=ifc_key)
+            vf_ifc_name = '{pf_if_key}_vif'.format(pf_if_key=ifc_key)

             vf_pci_addr = DUTSetup.get_virtfn_pci_addr(node, pf_pci_addr, vf_id)
             vf_ifc_key = Topology.add_new_port(node, vf_ifc_name)
             Topology.update_interface_name(node, vf_ifc_key,
             vf_pci_addr = DUTSetup.get_virtfn_pci_addr(node, pf_pci_addr, vf_id)
             vf_ifc_key = Topology.add_new_port(node, vf_ifc_name)
             Topology.update_interface_name(node, vf_ifc_key,


@@ -1382,3 +1528,83 @@ class InterfaceUtil(object):
             vf_ifc_keys.append(vf_ifc_key)
 
         return vf_ifc_keys
             vf_ifc_keys.append(vf_ifc_key)
 
         return vf_ifc_keys

+
+    @staticmethod
+    def vpp_sw_interface_rx_placement_dump(node):
+        """Dump VPP interface RX placement on node.
+
+        :param node: Node to run command on.
+        :type node: dict
+        :returns: Thread mapping information as a list of dictionaries.
+        :rtype: list
+        """
+        cmd = 'sw_interface_rx_placement_dump'
+        err_msg = "Failed to run '{cmd}' PAPI command on host {host}!".format(
+            cmd=cmd, host=node['host'])
+        with PapiSocketExecutor(node) as papi_exec:
+            for ifc in node['interfaces'].values():
+                if ifc['vpp_sw_index'] is not None:
+                    papi_exec.add(cmd, sw_if_index=ifc['vpp_sw_index'])
+            details = papi_exec.get_details(err_msg)
+        return sorted(details, key=lambda k: k['sw_if_index'])
+
+    @staticmethod
+    def vpp_sw_interface_set_rx_placement(node, sw_if_index, queue_id,
+                                          worker_id):
+        """Set interface RX placement to worker on node.
+
+        :param node: Node to run command on.
+        :param sw_if_index: VPP SW interface index.
+        :param queue_id: VPP interface queue ID.
+        :param worker_id: VPP worker ID (indexing from 0).
+        :type node: dict
+        :type sw_if_index: int
+        :type queue_id: int
+        :type worker_id: int
+        :raises RuntimeError: If failed to run command on host or if no API
+            reply received.
+        """
+        cmd = 'sw_interface_set_rx_placement'
+        err_msg = "Failed to set interface RX placement to worker on host " \
+                  "{host}!".format(host=node['host'])
+        args = dict(sw_if_index=sw_if_index, queue_id=queue_id,
+                    worker_id=worker_id)
+        with PapiSocketExecutor(node) as papi_exec:
+            papi_exec.add(cmd, **args).get_reply(err_msg)
+
+    @staticmethod
+    def vpp_round_robin_rx_placement(node, prefix):
+        """Set Round Robin interface RX placement on all worker threads
+        on node.
+
+        :param node: Topology nodes.
+        :param prefix: Interface name prefix.
+        :type node: dict
+        :type prefix: str
+        """
+        worker_id = 0
+        worker_cnt = len(VPPUtil.vpp_show_threads(node)) - 1
+        if not worker_cnt:
+            return
+        for placement in InterfaceUtil.vpp_sw_interface_rx_placement_dump(node):
+            for interface in node['interfaces'].values():
+                if placement['sw_if_index'] == interface['vpp_sw_index'] \
+                    and prefix in interface['name']:
+                    InterfaceUtil.vpp_sw_interface_set_rx_placement(
+                        node, placement['sw_if_index'], placement['queue_id'],
+                        worker_id % worker_cnt)
+                    worker_id += 1
+
+    @staticmethod
+    def vpp_round_robin_rx_placement_on_all_duts(nodes, prefix):
+        """Set Round Robin interface RX placement on all worker threads
+        on all DUTs.
+
+        :param nodes: Topology nodes.
+        :param prefix: Interface name prefix.
+        :type nodes: dict
+        :type prefix: str
+        """
+        for node in nodes.values():
+            if node['type'] == NodeType.DUT:
+                InterfaceUtil.vpp_round_robin_rx_placement(node, prefix)