Python3: resources and libraries

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

diff --git a/resources/libraries/python/InterfaceUtil.py b/resources/libraries/python/InterfaceUtil.py
index 46b1ffb..fa6a331 100644 (file)
--- a/resources/libraries/python/InterfaceUtil.py
+++ b/resources/libraries/python/InterfaceUtil.py
@@ -13,45 +13,100 @@
 
 """Interface util library."""
 
 
 """Interface util library."""
 

-from socket import AF_INET, AF_INET6, inet_ntop, inet_pton

 from time import sleep
 from time import sleep

-

 from enum import IntEnum
 from enum import IntEnum

-from ipaddress import IPv4Address, IPv6Address
-from ipaddress import AddressValueError, NetmaskValueError
+
+from ipaddress import ip_address

 from robot.api import logger
 
 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.L2Util import L2Util
 from robot.api import logger
 
 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.L2Util import L2Util

-from resources.libraries.python.PapiExecutor import PapiExecutor
+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.VPPUtil import VPPUtil
 
 
 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.VPPUtil import VPPUtil
 
 

-class LinkBondLoadBalance(IntEnum):
-    """Link bonding load balance."""
-    L2 = 0
-    L34 = 1
-    L23 = 2
+class InterfaceStatusFlags(IntEnum):
+    """Interface status flags."""
+    IF_STATUS_API_FLAG_ADMIN_UP = 1
+    IF_STATUS_API_FLAG_LINK_UP = 2
+
+
+class MtuProto(IntEnum):
+    """MTU protocol."""
+    MTU_PROTO_API_L3 = 0
+    MTU_PROTO_API_IP4 = 1
+    MTU_PROTO_API_IP6 = 2
+    MTU_PROTO_API_MPLS = 3
+    MTU_PROTO_API_N = 4
+
+
+class LinkDuplex(IntEnum):
+    """Link duplex"""
+    LINK_DUPLEX_API_UNKNOWN = 0
+    LINK_DUPLEX_API_HALF = 1
+    LINK_DUPLEX_API_FULL = 2
+
+
+class SubInterfaceFlags(IntEnum):
+    """Sub-interface flags."""
+    SUB_IF_API_FLAG_NO_TAGS = 1
+    SUB_IF_API_FLAG_ONE_TAG = 2
+    SUB_IF_API_FLAG_TWO_TAGS = 4
+    SUB_IF_API_FLAG_DOT1AD = 8
+    SUB_IF_API_FLAG_EXACT_MATCH = 16
+    SUB_IF_API_FLAG_DEFAULT = 32
+    SUB_IF_API_FLAG_OUTER_VLAN_ID_ANY = 64
+    SUB_IF_API_FLAG_INNER_VLAN_ID_ANY = 128
+    SUB_IF_API_FLAG_DOT1AH = 256
+
+
+class RxMode(IntEnum):
+    """RX mode"""
+    RX_MODE_API_UNKNOWN = 0
+    RX_MODE_API_POLLING = 1
+    RX_MODE_API_INTERRUPT = 2
+    RX_MODE_API_ADAPTIVE = 3
+    RX_MODE_API_DEFAULT = 4
+
+
+class IfType(IntEnum):
+    """Interface type"""
+    # A hw interface
+    IF_API_TYPE_HARDWARE = 0
+    # A sub-interface
+    IF_API_TYPE_SUB = 1
+    IF_API_TYPE_P2P = 2
+    IF_API_TYPE_PIPE = 3
+
+
+class LinkBondLoadBalanceAlgo(IntEnum):
+    """Link bonding load balance algorithm."""
+    BOND_API_LB_ALGO_L2 = 0
+    BOND_API_LB_ALGO_L34 = 1
+    BOND_API_LB_ALGO_L23 = 2
+    BOND_API_LB_ALGO_RR = 3
+    BOND_API_LB_ALGO_BC = 4
+    BOND_API_LB_ALGO_AB = 5

 
 
 class LinkBondMode(IntEnum):
 
 
 class LinkBondMode(IntEnum):

-    """Link bonding load balance."""
-    ROUND_ROBIN = 1
-    ACTIVE_BACKUP = 2
-    XOR = 3
-    BROADCAST = 4
-    LACP = 5
+    """Link bonding mode."""
+    BOND_API_MODE_ROUND_ROBIN = 1
+    BOND_API_MODE_ACTIVE_BACKUP = 2
+    BOND_API_MODE_XOR = 3
+    BOND_API_MODE_BROADCAST = 4
+    BOND_API_MODE_LACP = 5

 
 
 
 

-class InterfaceUtil(object):
+class InterfaceUtil:

     """General utilities for managing interfaces"""
 
     """General utilities for managing interfaces"""
 

-    __UDEV_IF_RULES_FILE = '/etc/udev/rules.d/10-network.rules'
+    __UDEV_IF_RULES_FILE = u"/etc/udev/rules.d/10-network.rules"

 
     @staticmethod
     def pci_to_int(pci_str):
 
     @staticmethod
     def pci_to_int(pci_str):


@@ -63,12 +118,31 @@ class InterfaceUtil(object):
         :returns: Integer representation of PCI address.
         :rtype: int
         """
         :returns: Integer representation of PCI address.
         :rtype: int
         """

-        pci = list(pci_str.split(':')[0:2])
-        pci.extend(pci_str.split(':')[2].split('.'))
+        pci = list(pci_str.split(u":")[0:2])
+        pci.extend(pci_str.split(u":")[2].split(u"."))

 
         return (int(pci[0], 16) | int(pci[1], 16) << 16 |
                 int(pci[2], 16) << 24 | int(pci[3], 16) << 29)
 
 
         return (int(pci[0], 16) | int(pci[1], 16) << 16 |
                 int(pci[2], 16) << 24 | int(pci[3], 16) << 29)
 

+    @staticmethod
+    def pci_to_eth(node, pci_str):
+        """Convert PCI address on DUT to Linux ethernet name.
+
+        :param node: DUT node
+        :param pci_str: PCI address.
+        :type node: dict
+        :type pci_str: str
+        :returns: Ethernet name.
+        :rtype: str
+        """
+        cmd = f"basename /sys/bus/pci/devices/{pci_str}/net/*"
+        try:
+            stdout, _ = exec_cmd_no_error(node, cmd)
+        except RuntimeError:
+            raise RuntimeError(f"Cannot convert {pci_str} to ethernet name!")
+
+        return stdout.strip()
+

     @staticmethod
     def get_interface_index(node, interface):
         """Get interface sw_if_index from topology file.
     @staticmethod
     def get_interface_index(node, interface):
         """Get interface sw_if_index from topology file.


@@ -88,13 +162,12 @@ class InterfaceUtil(object):
                 sw_if_index = \
                     Topology.get_interface_sw_index_by_name(node, interface)
         except TypeError as err:
                 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))
+            raise TypeError(f"Wrong interface format {interface}") from err

 
         return sw_if_index
 
     @staticmethod
 
         return sw_if_index
 
     @staticmethod

-    def set_interface_state(node, interface, state, if_type='key'):
+    def set_interface_state(node, interface, state, if_type=u"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.


@@ -112,43 +185,42 @@ 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 isinstance(interface, basestring):
+        if if_type == u"key":
+            if isinstance(interface, str):

                 sw_if_index = Topology.get_interface_sw_index(node, interface)
                 iface_name = Topology.get_interface_name(node, interface)
             else:
                 sw_if_index = interface
                 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 == u"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('Unknown if_type: {type}'.format(type=if_type))
+            raise ValueError(f"Unknown if_type: {if_type}")

 
 

-        if node['type'] == NodeType.DUT:
-            if state == 'up':
-                admin_up_down = 1
-            elif state == 'down':
-                admin_up_down = 0
+        if node[u"type"] == NodeType.DUT:
+            if state == u"up":
+                flags = InterfaceStatusFlags.IF_STATUS_API_FLAG_ADMIN_UP.value
+            elif state == u"down":
+                flags = 0

             else:
             else:

-                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 PapiExecutor(node) as papi_exec:
-                papi_exec.add(cmd, **args).get_replies(err_msg).\
-                    verify_reply(err_msg=err_msg)
-        elif node['type'] == NodeType.TG or node['type'] == NodeType.VM:
-            cmd = 'ip link set {ifc} {state}'.format(
-                ifc=iface_name, state=state)
+                raise ValueError(f"Unexpected interface state: {state}")
+            cmd = u"sw_interface_set_flags"
+            err_msg = f"Failed to set interface state on host {node[u'host']}"
+            args = dict(
+                sw_if_index=int(sw_if_index),
+                flags=flags
+            )
+            with PapiSocketExecutor(node) as papi_exec:
+                papi_exec.add(cmd, **args).get_reply(err_msg)
+        elif node[u"type"] == NodeType.TG or node[u"type"] == NodeType.VM:
+            cmd = f"ip link set {iface_name} {state}"

             exec_cmd_no_error(node, cmd, sudo=True)
         else:
             exec_cmd_no_error(node, cmd, sudo=True)
         else:

-            raise ValueError('Node {} has unknown NodeType: "{}"'
-                             .format(node['host'], node['type']))
+            raise ValueError(
+                f"Node {node[u'host']} has unknown NodeType: {node[u'type']}"
+            )

 
     @staticmethod
     def set_interface_ethernet_mtu(node, iface_key, mtu):
 
     @staticmethod
     def set_interface_ethernet_mtu(node, iface_key, mtu):


@@ -166,16 +238,17 @@ class InterfaceUtil(object):
         :raises ValueError: If the node type is "DUT".
         :raises ValueError: If the node has an unknown node type.
         """
         :raises ValueError: If the node type is "DUT".
         :raises ValueError: If the node has an unknown node type.
         """

-        if node['type'] == NodeType.DUT:
-            raise ValueError('Node {}: Setting Ethernet MTU for interface '
-                             'on DUT nodes not supported', node['host'])
-        elif node['type'] == NodeType.TG:
+        if node[u"type"] == NodeType.DUT:
+            msg = f"Node {node[u'host']}: Setting Ethernet MTU for interface " \
+                f"on DUT nodes not supported"
+        elif node[u"type"] != NodeType.TG:
+            msg = f"Node {node[u'host']} has unknown NodeType: {node[u'type']}"
+        else:

             iface_name = Topology.get_interface_name(node, iface_key)
             iface_name = Topology.get_interface_name(node, iface_key)

-            cmd = 'ip link set {} mtu {}'.format(iface_name, mtu)
+            cmd = f"ip link set {iface_name} mtu {mtu}"

             exec_cmd_no_error(node, cmd, sudo=True)
             exec_cmd_no_error(node, cmd, sudo=True)

-        else:
-            raise ValueError('Node {} has unknown NodeType: "{}"'
-                             .format(node['host'], node['type']))
+            return
+        raise ValueError(msg)

 
     @staticmethod
     def set_default_ethernet_mtu_on_all_interfaces_on_node(node):
 
     @staticmethod
     def set_default_ethernet_mtu_on_all_interfaces_on_node(node):


@@ -187,7 +260,7 @@ class InterfaceUtil(object):
         :type node: dict
         :returns: Nothing.
         """
         :type node: dict
         :returns: Nothing.
         """

-        for ifc in node['interfaces']:
+        for ifc in node[u"interfaces"]:

             InterfaceUtil.set_interface_ethernet_mtu(node, ifc, 1500)
 
     @staticmethod
             InterfaceUtil.set_interface_ethernet_mtu(node, ifc, 1500)
 
     @staticmethod


@@ -201,19 +274,23 @@ class InterfaceUtil(object):
         :type interface: str or int
         :type mtu: int
         """
         :type interface: str or int
         :type mtu: int
         """

-        if isinstance(interface, basestring):
+        if isinstance(interface, str):

             sw_if_index = Topology.get_interface_sw_index(node, interface)
         else:
             sw_if_index = interface
 
             sw_if_index = Topology.get_interface_sw_index(node, interface)
         else:
             sw_if_index = interface
 

-        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))
-        with PapiExecutor(node) as papi_exec:
-            papi_exec.add(cmd, **args).get_replies(err_msg).\
-                verify_reply(err_msg=err_msg)
+        cmd = u"hw_interface_set_mtu"
+        err_msg = f"Failed to set interface MTU on host {node[u'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(f"Setting MTU failed. Expected?\n{err}")

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


@@ -224,7 +301,7 @@ class InterfaceUtil(object):
         :type node: dict
         :type mtu: int
         """
         :type node: dict
         :type mtu: int
         """

-        for interface in node['interfaces']:
+        for interface in node[u"interfaces"]:

             InterfaceUtil.vpp_set_interface_mtu(node, interface, mtu)
 
     @staticmethod
             InterfaceUtil.vpp_set_interface_mtu(node, interface, mtu)
 
     @staticmethod


@@ -237,7 +314,7 @@ class InterfaceUtil(object):
         :type mtu: int
         """
         for node in nodes.values():
         :type mtu: int
         """
         for node in nodes.values():

-            if node['type'] == NodeType.DUT:
+            if node[u"type"] == NodeType.DUT:

                 InterfaceUtil.vpp_set_interfaces_mtu_on_node(node, mtu)
 
     @staticmethod
                 InterfaceUtil.vpp_set_interfaces_mtu_on_node(node, mtu)
 
     @staticmethod


@@ -253,22 +330,22 @@ class InterfaceUtil(object):
         :raises RuntimeError: If any interface is not in link-up state after
             defined number of retries.
         """
         :raises RuntimeError: If any interface is not in link-up state after
             defined number of retries.
         """

-        for _ in xrange(0, retries):
+        for _ in range(0, retries):

             not_ready = list()
             out = InterfaceUtil.vpp_get_interface_data(node)
             for interface in out:
             not_ready = list()
             out = InterfaceUtil.vpp_get_interface_data(node)
             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:
-                break
-            else:
-                logger.debug('Interfaces still in link-down state:\n{ifs} '
-                             '\nWaiting...'.format(ifs=not_ready))
+                if interface.get(u"flags") == 1:
+                    not_ready.append(interface.get(u"interface_name"))
+            if not_ready:
+                logger.debug(
+                    f"Interfaces still not in link-up state:\n{not_ready}"
+                )

                 sleep(1)
                 sleep(1)

+            else:
+                break

         else:
         else:

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

             raise RuntimeError(err)
 
     @staticmethod
             raise RuntimeError(err)
 
     @staticmethod


@@ -284,7 +361,7 @@ class InterfaceUtil(object):
         :returns: Nothing.
         """
         for node in nodes.values():
         :returns: Nothing.
         """
         for node in nodes.values():

-            if node['type'] == NodeType.DUT:
+            if node[u"type"] == NodeType.DUT:

                 InterfaceUtil.vpp_node_interfaces_ready_wait(node, retries)
 
     @staticmethod
                 InterfaceUtil.vpp_node_interfaces_ready_wait(node, retries)
 
     @staticmethod


@@ -303,28 +380,6 @@ 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.
         """

-        if interface is not None:
-            if isinstance(interface, basestring):
-                param = 'interface_name'
-            elif isinstance(interface, int):
-                param = 'sw_if_index'
-            else:
-                raise TypeError('Wrong interface format {ifc}'.format(
-                    ifc=interface))
-        else:
-            param = ''
-
-        cmd = 'sw_interface_dump'
-        cmd_reply = 'sw_interface_details'
-        args = dict(name_filter_valid=0,
-                    name_filter='')
-        err_msg = 'Failed to get interface dump on host {host}'.format(
-            host=node['host'])
-        with PapiExecutor(node) as papi_exec:
-            papi_resp = papi_exec.add(cmd, **args).get_dump(err_msg)
-
-        papi_if_dump = papi_resp.reply[0]['api_reply']
-

         def process_if_dump(if_dump):
             """Process interface dump.
 
         def process_if_dump(if_dump):
             """Process interface dump.
 


@@ -333,23 +388,48 @@ class InterfaceUtil(object):
             :returns: Processed interface dump.
             :rtype: 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'])
+            if_dump[u"l2_address"] = str(if_dump[u"l2_address"])
+            if_dump[u"b_dmac"] = str(if_dump[u"b_dmac"])
+            if_dump[u"b_smac"] = str(if_dump[u"b_smac"])
+            if_dump[u"flags"] = if_dump[u"flags"].value
+            if_dump[u"type"] = if_dump[u"type"].value
+            if_dump[u"link_duplex"] = if_dump[u"link_duplex"].value
+            if_dump[u"sub_if_flags"] = if_dump[u"sub_if_flags"].value \
+                if hasattr(if_dump[u"sub_if_flags"], u"value") \
+                else int(if_dump[u"sub_if_flags"])
+

             return if_dump
 
             return if_dump
 

+        if interface is not None:
+            if isinstance(interface, str):
+                param = u"interface_name"
+            elif isinstance(interface, int):
+                param = u"sw_if_index"
+            else:
+                raise TypeError(f"Wrong interface format {interface}")
+        else:
+            param = u""
+
+        cmd = u"sw_interface_dump"
+        args = dict(
+            name_filter_valid=False,
+            name_filter=u""
+        )
+        err_msg = f"Failed to get interface dump on host {node[u'host']}"
+
+        with PapiSocketExecutor(node) as papi_exec:
+            details = papi_exec.add(cmd, **args).get_details(err_msg)
+        logger.debug(f"Received data:\n{details!r}")
+

         data = list() if interface is None else dict()
         data = list() if interface is None else dict()

-        for item in papi_if_dump:
+        for dump in details:

             if interface is None:
             if interface is None:

-                data.append(process_if_dump(item[cmd_reply]))
-            elif str(item[cmd_reply].get(param)).rstrip('\x00') == \
-                    str(interface):
-                data = process_if_dump(item[cmd_reply])
+                data.append(process_if_dump(dump))
+            elif str(dump.get(param)).rstrip(u"\x00") == str(interface):
+                data = process_if_dump(dump)

                 break
 
                 break
 

-        logger.debug('Interface data:\n{if_data}'.format(if_data=data))
+        logger.debug(f"Interface data:\n{data}")

         return data
 
     @staticmethod
         return data
 
     @staticmethod


@@ -365,11 +445,12 @@ class InterfaceUtil(object):
         :rtype: str
         """
         if_data = InterfaceUtil.vpp_get_interface_data(node, sw_if_index)
         :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 if_data[u"sup_sw_if_index"] != if_data[u"sw_if_index"]:

             if_data = InterfaceUtil.vpp_get_interface_data(
             if_data = InterfaceUtil.vpp_get_interface_data(

-                node, if_data['sup_sw_if_index'])
+                node, if_data[u"sup_sw_if_index"]
+            )

 
 

-        return if_data.get('interface_name')
+        return if_data.get(u"interface_name")

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


@@ -385,7 +466,7 @@ class InterfaceUtil(object):
         """
         if_data = InterfaceUtil.vpp_get_interface_data(node, interface_name)
 
         """
         if_data = InterfaceUtil.vpp_get_interface_data(node, interface_name)
 

-        return if_data.get('sw_if_index')
+        return if_data.get(u"sw_if_index")

 
     @staticmethod
     def vpp_get_interface_mac(node, interface):
 
     @staticmethod
     def vpp_get_interface_mac(node, interface):


@@ -399,11 +480,11 @@ class InterfaceUtil(object):
         :rtype: str
         """
         if_data = InterfaceUtil.vpp_get_interface_data(node, interface)
         :rtype: str
         """
         if_data = InterfaceUtil.vpp_get_interface_data(node, interface)

-        if if_data['sup_sw_if_index'] != if_data['sw_if_index']:
+        if if_data[u"sup_sw_if_index"] != if_data[u"sw_if_index"]:

             if_data = InterfaceUtil.vpp_get_interface_data(
             if_data = InterfaceUtil.vpp_get_interface_data(

-                node, if_data['sup_sw_if_index'])
+                node, if_data[u"sup_sw_if_index"])

 
 

-        return if_data.get('l2_address')
+        return if_data.get(u"l2_address")

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


@@ -427,20 +508,17 @@ class InterfaceUtil(object):
 
         # Unbind from current driver
         if old_driver is not None:
 
         # Unbind from current driver
         if old_driver is not None:

-            cmd = 'sh -c "echo {0} > /sys/bus/pci/drivers/{1}/unbind"'\
-                .format(pci_addr, old_driver)
-            (ret_code, _, _) = ssh.exec_command_sudo(cmd)
+            cmd = f"sh -c \"echo {pci_addr} > " \
+                f"/sys/bus/pci/drivers/{old_driver}/unbind\""
+            ret_code, _, _ = ssh.exec_command_sudo(cmd)

             if int(ret_code) != 0:
             if int(ret_code) != 0:

-                raise RuntimeError("'{0}' failed on '{1}'"
-                                   .format(cmd, node['host']))
+                raise RuntimeError(f"'{cmd}' failed on '{node[u'host']}'")

 
         # Bind to the new driver
 
         # Bind to the new driver

-        cmd = 'sh -c "echo {0} > /sys/bus/pci/drivers/{1}/bind"'\
-            .format(pci_addr, driver)
-        (ret_code, _, _) = ssh.exec_command_sudo(cmd)
+        cmd = f"sh -c \"echo {pci_addr} > /sys/bus/pci/drivers/{driver}/bind\""
+        ret_code, _, _ = ssh.exec_command_sudo(cmd)

         if int(ret_code) != 0:
         if int(ret_code) != 0:

-            raise RuntimeError("'{0}' failed on '{1}'"
-                               .format(cmd, node['host']))
+            raise RuntimeError(f"'{cmd}' failed on '{node[u'host']}'")

 
     @staticmethod
     def tg_get_interface_driver(node, pci_addr):
 
     @staticmethod
     def tg_get_interface_driver(node, pci_addr):


@@ -476,24 +554,23 @@ class InterfaceUtil(object):
         ssh = SSH()
         ssh.connect(node)
 
         ssh = SSH()
         ssh.connect(node)
 

-        cmd = 'rm -f {0}'.format(InterfaceUtil.__UDEV_IF_RULES_FILE)
-        (ret_code, _, _) = ssh.exec_command_sudo(cmd)
+        cmd = f"rm -f {InterfaceUtil.__UDEV_IF_RULES_FILE}"
+        ret_code, _, _ = ssh.exec_command_sudo(cmd)

         if int(ret_code) != 0:
         if int(ret_code) != 0:

-            raise RuntimeError("'{0}' failed on '{1}'"
-                               .format(cmd, node['host']))
-
-        for interface in node['interfaces'].values():
-            rule = 'SUBSYSTEM==\\"net\\", ACTION==\\"add\\", ATTR{address}' + \
-                   '==\\"' + interface['mac_address'] + '\\", NAME=\\"' + \
-                   interface['name'] + '\\"'
-            cmd = 'sh -c "echo \'{0}\' >> {1}"'.format(
-                rule, InterfaceUtil.__UDEV_IF_RULES_FILE)
-            (ret_code, _, _) = ssh.exec_command_sudo(cmd)
+            raise RuntimeError(f"'{cmd}' failed on '{node[u'host']}'")
+
+        for interface in node[u"interfaces"].values():
+            rule = u'SUBSYSTEM==\\"net\\", ACTION==\\"add\\", ATTR{address}' + \
+                   u'==\\"' + interface[u"mac_address"] + u'\\", NAME=\\"' + \
+                   interface[u"name"] + u'\\"'
+            cmd = f"sh -c \"echo '{rule}'\" >> " \
+                f"{InterfaceUtil.__UDEV_IF_RULES_FILE}'"
+
+            ret_code, _, _ = ssh.exec_command_sudo(cmd)

             if int(ret_code) != 0:
             if int(ret_code) != 0:

-                raise RuntimeError("'{0}' failed on '{1}'"
-                                   .format(cmd, node['host']))
+                raise RuntimeError(f"'{cmd}' failed on '{node[u'host']}'")

 
 

-        cmd = '/etc/init.d/udev restart'
+        cmd = u"/etc/init.d/udev restart"

         ssh.exec_command_sudo(cmd)
 
     @staticmethod
         ssh.exec_command_sudo(cmd)
 
     @staticmethod


@@ -503,10 +580,10 @@ class InterfaceUtil(object):
         :param node: Node to setup interfaces driver on (must be TG node).
         :type node: dict
         """
         :param node: Node to setup interfaces driver on (must be TG node).
         :type node: dict
         """

-        for interface in node['interfaces'].values():
-            InterfaceUtil.tg_set_interface_driver(node,
-                                                  interface['pci_address'],
-                                                  interface['driver'])
+        for interface in node[u"interfaces"].values():
+            InterfaceUtil.tg_set_interface_driver(
+                node, interface[u"pci_address"], interface[u"driver"]
+            )

 
     @staticmethod
     def update_vpp_interface_data_on_node(node):
 
     @staticmethod
     def update_vpp_interface_data_on_node(node):


@@ -524,20 +601,24 @@ class InterfaceUtil(object):
         interface_list = InterfaceUtil.vpp_get_interface_data(node)
         interface_dict = dict()
         for ifc in interface_list:
         interface_list = InterfaceUtil.vpp_get_interface_data(node)
         interface_dict = dict()
         for ifc in interface_list:

-            interface_dict[ifc['l2_address']] = ifc
+            interface_dict[ifc[u"l2_address"]] = ifc

 
 

-        for if_name, if_data in node['interfaces'].items():
-            ifc_dict = interface_dict.get(if_data['mac_address'])
+        for if_name, if_data in node[u"interfaces"].items():
+            ifc_dict = interface_dict.get(if_data[u"mac_address"])

             if ifc_dict is not None:
             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']))
+                if_data[u"name"] = ifc_dict[u"interface_name"]
+                if_data[u"vpp_sw_index"] = ifc_dict[u"sw_if_index"]
+                if_data[u"mtu"] = ifc_dict[u"mtu"][0]
+                logger.trace(
+                    f"Interface {if_name} found by MAC "
+                    f"{if_data[u'mac_address']}"
+                )

             else:
             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
+                logger.trace(
+                    f"Interface {if_name} not found by MAC "
+                    f"{if_data[u'mac_address']}"
+                )
+                if_data[u"vpp_sw_index"] = None

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


@@ -548,24 +629,22 @@ class InterfaceUtil(object):
         :param node: Node dictionary.
         :type node: dict
         """
         :param node: Node dictionary.
         :type node: dict
         """

-        for ifc in node['interfaces'].values():
-            if_pci = ifc['pci_address'].replace('.', ':').split(':')
-            bus = '{:x}'.format(int(if_pci[1], 16))
-            dev = '{:x}'.format(int(if_pci[2], 16))
-            fun = '{:x}'.format(int(if_pci[3], 16))
-            loc = '{bus}/{dev}/{fun}'.format(bus=bus, dev=dev, fun=fun)
-            if ifc['model'] == 'Intel-XL710':
-                ifc['name'] = 'FortyGigabitEthernet{loc}'.format(loc=loc)
-            elif ifc['model'] == 'Intel-X710':
-                ifc['name'] = 'TenGigabitEthernet{loc}'.format(loc=loc)
-            elif ifc['model'] == 'Intel-X520-DA2':
-                ifc['name'] = 'TenGigabitEthernet{loc}'.format(loc=loc)
-            elif ifc['model'] == 'Cisco-VIC-1385':
-                ifc['name'] = 'FortyGigabitEthernet{loc}'.format(loc=loc)
-            elif ifc['model'] == 'Cisco-VIC-1227':
-                ifc['name'] = 'TenGigabitEthernet{loc}'.format(loc=loc)
+        for ifc in node[u"interfaces"].values():
+            if_pci = ifc[u"pci_address"].replace(u".", u":").split(u":")
+            loc = f"{int(if_pci[1], 16):x}/{int(if_pci[2], 16):x}/" \
+                f"{int(if_pci[3], 16):x}"
+            if ifc[u"model"] == u"Intel-XL710":
+                ifc[u"name"] = f"FortyGigabitEthernet{loc}"
+            elif ifc[u"model"] == u"Intel-X710":
+                ifc[u"name"] = f"TenGigabitEthernet{loc}"
+            elif ifc[u"model"] == u"Intel-X520-DA2":
+                ifc[u"name"] = f"TenGigabitEthernet{loc}"
+            elif ifc[u"model"] == u"Cisco-VIC-1385":
+                ifc[u"name"] = f"FortyGigabitEthernet{loc}"
+            elif ifc[u"model"] == u"Cisco-VIC-1227":
+                ifc[u"name"] = f"TenGigabitEthernet{loc}"

             else:
             else:

-                ifc['name'] = 'UnknownEthernet{loc}'.format(loc=loc)
+                ifc[u"name"] = f"UnknownEthernet{loc}"

 
     @staticmethod
     def update_nic_interface_names_on_all_duts(nodes):
 
     @staticmethod
     def update_nic_interface_names_on_all_duts(nodes):


@@ -577,7 +656,7 @@ class InterfaceUtil(object):
         :type nodes: dict
         """
         for node in nodes.values():
         :type nodes: dict
         """
         for node in nodes.values():

-            if node['type'] == NodeType.DUT:
+            if node[u"type"] == NodeType.DUT:

                 InterfaceUtil.update_nic_interface_names(node)
 
     @staticmethod
                 InterfaceUtil.update_nic_interface_names(node)
 
     @staticmethod


@@ -605,19 +684,20 @@ class InterfaceUtil(object):
         ssh = SSH()
         ssh.connect(node)
 
         ssh = SSH()
         ssh.connect(node)
 

-        cmd = ('for dev in `ls /sys/class/net/`; do echo "\\"`cat '
-               '/sys/class/net/$dev/address`\\": \\"$dev\\""; done;')
+        cmd = u'for dev in `ls /sys/class/net/`; do echo "\\"`cat ' \
+              u'/sys/class/net/$dev/address`\\": \\"$dev\\""; done;'

 
 

-        (ret_code, stdout, _) = ssh.exec_command(cmd)
+        ret_code, stdout, _ = ssh.exec_command(cmd)

         if int(ret_code) != 0:
         if int(ret_code) != 0:

-            raise RuntimeError('Get interface name and MAC failed')
-        tmp = "{" + stdout.rstrip().replace('\n', ',') + "}"
+            raise RuntimeError(u"Get interface name and MAC failed")
+        tmp = u"{" + stdout.rstrip().replace(u"\n", u",") + u"}"
+

         interfaces = JsonParser().parse_data(tmp)
         interfaces = JsonParser().parse_data(tmp)

-        for interface in node['interfaces'].values():
-            name = interfaces.get(interface['mac_address'])
+        for interface in node[u"interfaces"].values():
+            name = interfaces.get(interface[u"mac_address"])

             if name is None:
                 continue
             if name is None:
                 continue

-            interface['name'] = name
+            interface[u"name"] = name

 
         # Set udev rules for interfaces
         if not skip_tg_udev:
 
         # Set udev rules for interfaces
         if not skip_tg_udev:


@@ -632,33 +712,37 @@ class InterfaceUtil(object):
         :type node: dict
         :returns: Nothing.
         :raises ValueError: If numa node ia less than 0.
         :type node: dict
         :returns: Nothing.
         :raises ValueError: If numa node ia less than 0.

-        :raises RuntimeError: If update of numa node failes.
+        :raises RuntimeError: If update of numa node failed.

         """
         """

+        def check_cpu_node_count(node_n, val):
+            val = int(val)
+            if val < 0:
+                if CpuUtils.cpu_node_count(node_n) == 1:
+                    val = 0
+                else:
+                    raise ValueError
+            return val

         ssh = SSH()
         for if_key in Topology.get_node_interfaces(node):
             if_pci = Topology.get_interface_pci_addr(node, if_key)
             ssh.connect(node)
         ssh = SSH()
         for if_key in Topology.get_node_interfaces(node):
             if_pci = Topology.get_interface_pci_addr(node, if_key)
             ssh.connect(node)

-            cmd = "cat /sys/bus/pci/devices/{}/numa_node".format(if_pci)
+            cmd = f"cat /sys/bus/pci/devices/{if_pci}/numa_node"

             for _ in range(3):
             for _ in range(3):

-                (ret, out, _) = ssh.exec_command(cmd)
+                ret, out, _ = ssh.exec_command(cmd)

                 if ret == 0:
                     try:
                 if ret == 0:
                     try:

-                        numa_node = int(out)
-                        if numa_node < 0:
-                            if CpuUtils.cpu_node_count(node) == 1:
-                                numa_node = 0
-                            else:
-                                raise ValueError
+                        numa_node = check_cpu_node_count(node, out)

                     except ValueError:
                     except ValueError:

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

                     else:
                     else:

-                        Topology.set_interface_numa_node(node, if_key,
-                                                         numa_node)
+                        Topology.set_interface_numa_node(
+                            node, if_key, numa_node
+                        )

                         break
             else:
                         break
             else:

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

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


@@ -672,15 +756,14 @@ class InterfaceUtil(object):
         :returns: Nothing.
         """
         for node in nodes.values():
         :returns: Nothing.
         """
         for node in nodes.values():

-            if node['type'] == NodeType.DUT:
+            if node[u"type"] == NodeType.DUT:

                 InterfaceUtil.iface_update_numa_node(node)
                 InterfaceUtil.iface_update_numa_node(node)

-            elif node['type'] == NodeType.TG and not skip_tg:
+            elif node[u"type"] == NodeType.TG and not skip_tg:

                 InterfaceUtil.iface_update_numa_node(node)
 
     @staticmethod
                 InterfaceUtil.iface_update_numa_node(node)
 
     @staticmethod

-    def update_all_interface_data_on_all_nodes(nodes, skip_tg=False,
-                                               skip_tg_udev=False,
-                                               numa_node=False):
+    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.
 
         This method updates the topology dictionary by querying interface lists
         """Update interface names on all nodes in DICT__nodes.
 
         This method updates the topology dictionary by querying interface lists


@@ -696,16 +779,16 @@ class InterfaceUtil(object):
         :type numa_node: bool
         """
         for node_data in nodes.values():
         :type numa_node: bool
         """
         for node_data in nodes.values():

-            if node_data['type'] == NodeType.DUT:
+            if node_data[u"type"] == NodeType.DUT:

                 InterfaceUtil.update_vpp_interface_data_on_node(node_data)
                 InterfaceUtil.update_vpp_interface_data_on_node(node_data)

-            elif node_data['type'] == NodeType.TG and not skip_tg:
+            elif node_data[u"type"] == NodeType.TG and not skip_tg:

                 InterfaceUtil.update_tg_interface_data_on_node(
                     node_data, skip_tg_udev)
 
             if numa_node:
                 InterfaceUtil.update_tg_interface_data_on_node(
                     node_data, skip_tg_udev)
 
             if numa_node:

-                if node_data['type'] == NodeType.DUT:
+                if node_data[u"type"] == NodeType.DUT:

                     InterfaceUtil.iface_update_numa_node(node_data)
                     InterfaceUtil.iface_update_numa_node(node_data)

-                elif node_data['type'] == NodeType.TG and not skip_tg:
+                elif node_data[u"type"] == NodeType.TG and not skip_tg:

                     InterfaceUtil.iface_update_numa_node(node_data)
 
     @staticmethod
                     InterfaceUtil.iface_update_numa_node(node_data)
 
     @staticmethod


@@ -713,35 +796,35 @@ class InterfaceUtil(object):
         """Create VLAN sub-interface on node.
 
         :param node: Node to add VLAN subinterface on.
         """Create VLAN sub-interface on node.
 
         :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)
-
-        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 PapiExecutor(node) as papi_exec:
-            papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg).\
-                verify_reply(err_msg=err_msg)
-
-        sw_if_idx = papi_resp['sw_if_index']
-        if_key = Topology.add_new_port(node, 'vlan_subif')
-        Topology.update_interface_sw_if_index(node, if_key, sw_if_idx)
-        ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_idx)
+        sw_if_index = InterfaceUtil.get_interface_index(node, interface)
+
+        cmd = u"create_vlan_subif"
+        args = dict(
+            sw_if_index=sw_if_index,
+            vlan_id=int(vlan)
+        )
+        err_msg = f"Failed to create VLAN sub-interface on host {node[u'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, u"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)
 
         Topology.update_interface_name(node, if_key, ifc_name)
 

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

 
     @staticmethod
     def create_vxlan_interface(node, vni, source_ip, destination_ip):
 
     @staticmethod
     def create_vxlan_interface(node, vni, source_ip, destination_ip):


@@ -760,40 +843,61 @@ 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.
         """

-        try:
-            src_address = IPv6Address(unicode(source_ip))
-            dst_address = IPv6Address(unicode(destination_ip))
-            af_inet = AF_INET6
-            is_ipv6 = 1
-        except (AddressValueError, NetmaskValueError):
-            src_address = IPv4Address(unicode(source_ip))
-            dst_address = IPv4Address(unicode(destination_ip))
-            af_inet = AF_INET
-            is_ipv6 = 0
-
-        cmd = 'vxlan_add_del_tunnel'
-        args = dict(is_add=1,
-                    is_ipv6=is_ipv6,
-                    instance=Constants.BITWISE_NON_ZERO,
-                    src_address=inet_pton(af_inet, str(src_address)),
-                    dst_address=inet_pton(af_inet, str(dst_address)),
-                    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 PapiExecutor(node) as papi_exec:
-            papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg).\
-                verify_reply(err_msg=err_msg)
-
-        sw_if_idx = papi_resp['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)
+        src_address = ip_address(source_ip)
+        dst_address = ip_address(destination_ip)
+
+        cmd = u"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 = f"Failed to create VXLAN tunnel interface " \
+            f"on host {node[u'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, u"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)
 
         Topology.update_interface_name(node, if_key, ifc_name)
 

-        return sw_if_idx
+        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 = u"sw_interface_set_vxlan_bypass"
+        args = dict(
+            is_ipv6=0,
+            sw_if_index=sw_if_index,
+            enable=1
+        )
+        err_msg = f"Failed to set VXLAN bypass on interface " \
+            f"on host {node[u'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):


@@ -810,21 +914,6 @@ 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.
         """

-        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'
-        cmd_reply = 'vxlan_tunnel_details'
-        args = dict(sw_if_index=sw_if_index)
-        err_msg = 'Failed to get VXLAN dump on host {host}'.format(
-            host=node['host'])
-        with PapiExecutor(node) as papi_exec:
-            papi_resp = papi_exec.add(cmd, **args).get_dump(err_msg)
-
-        papi_vxlan_dump = papi_resp.reply[0]['api_reply']
-

         def process_vxlan_dump(vxlan_dump):
             """Process vxlan dump.
 
         def process_vxlan_dump(vxlan_dump):
             """Process vxlan dump.
 


@@ -833,128 +922,47 @@ class InterfaceUtil(object):
             :returns: Processed vxlan interface dump.
             :rtype: dict
             """
             :returns: Processed vxlan interface dump.
             :rtype: dict
             """

-            if vxlan_dump['is_ipv6']:
-                vxlan_dump['src_address'] = \
-                    inet_ntop(AF_INET6, vxlan_dump['src_address'])
-                vxlan_dump['dst_address'] = \
-                    inet_ntop(AF_INET6, vxlan_dump['dst_address'])
+            if vxlan_dump[u"is_ipv6"]:
+                vxlan_dump[u"src_address"] = \
+                    ip_address(vxlan_dump[u"src_address"])
+                vxlan_dump[u"dst_address"] =  \
+                    ip_address(vxlan_dump[u"dst_address"])

             else:
             else:

-                vxlan_dump['src_address'] = \
-                    inet_ntop(AF_INET, vxlan_dump['src_address'][0:4])
-                vxlan_dump['dst_address'] = \
-                    inet_ntop(AF_INET, vxlan_dump['dst_address'][0:4])
+                vxlan_dump[u"src_address"] = \
+                    ip_address(vxlan_dump[u"src_address"][0:4])
+                vxlan_dump[u"dst_address"] = \
+                    ip_address(vxlan_dump[u"dst_address"][0:4])

             return vxlan_dump
 
             return vxlan_dump
 

-        data = list() if interface is None else dict()
-        for item in papi_vxlan_dump:
-            if interface is None:
-                data.append(process_vxlan_dump(item[cmd_reply]))
-            elif item[cmd_reply]['sw_if_index'] == sw_if_index:
-                data = process_vxlan_dump(item[cmd_reply])
-                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.
-
-        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
-        """
-        cmd = 'sw_interface_vhost_user_dump'
-        cmd_reply = 'sw_interface_vhost_user_details'
-        err_msg = 'Failed to get vhost-user dump on host {host}'.format(
-            host=node['host'])
-        with PapiExecutor(node) as papi_exec:
-            papi_resp = papi_exec.add(cmd).get_dump(err_msg)
-
-        papi_vxlan_dump = papi_resp.reply[0]['api_reply']
-
-        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
-
-        data = list()
-        for item in papi_vxlan_dump:
-            data.append(process_vhost_dump(item[cmd_reply]))
-
-        logger.debug('Vhost-user data:\n{vhost_data}'.format(vhost_data=data))
-        return data
-
-    @staticmethod
-    def tap_dump(node, name=None):
-        """Get all TAP interface data from the given node, or data about
-        a specific TAP interface.
-
-        TODO: Move to Tap.py
-
-        :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
-        """
-        cmd = 'sw_interface_tap_v2_dump'
-        cmd_reply = 'sw_interface_tap_v2_details'
-        err_msg = 'Failed to get TAP dump on host {host}'.format(
-            host=node['host'])
-        with PapiExecutor(node) as papi_exec:
-            papi_resp = papi_exec.add(cmd).get_dump(err_msg)
+        if interface is not None:
+            sw_if_index = InterfaceUtil.get_interface_index(node, interface)
+        else:
+            sw_if_index = int(Constants.BITWISE_NON_ZERO)

 
 

-        papi_tap_dump = papi_resp.reply[0]['api_reply']
+        cmd = u"vxlan_tunnel_dump"
+        args = dict(
+            sw_if_index=sw_if_index
+        )
+        err_msg = f"Failed to get VXLAN dump on host {node[u'host']}"

 
 

-        def process_tap_dump(tap_dump):
-            """Process tap dump.
+        with PapiSocketExecutor(node) as papi_exec:
+            details = papi_exec.add(cmd, **args).get_details(err_msg)

 
 

-            :param tap_dump: Tap interface dump.
-            :type tap_dump: dict
-            :returns: Processed tap interface dump.
-            :rtype: dict
-            """
-            tap_dump['dev_name'] = tap_dump['dev_name'].rstrip('\x00')
-            tap_dump['host_if_name'] = tap_dump['host_if_name'].rstrip('\x00')
-            tap_dump['host_namespace'] = \
-                tap_dump['host_namespace'].rstrip('\x00')
-            tap_dump['host_mac_addr'] = \
-                L2Util.bin_to_mac(tap_dump['host_mac_addr'])
-            tap_dump['host_ip4_addr'] = \
-                inet_ntop(AF_INET, tap_dump['host_ip4_addr'])
-            tap_dump['host_ip6_addr'] = \
-                inet_ntop(AF_INET6, tap_dump['host_ip6_addr'])
-            return tap_dump
-
-        data = list() if name is None else dict()
-        for item in papi_tap_dump:
-            if name is None:
-                data.append(process_tap_dump(item[cmd_reply]))
-            elif item[cmd_reply].get('dev_name').rstrip('\x00') == name:
-                data = process_tap_dump(item[cmd_reply])
+        data = list() if interface is None else dict()
+        for dump in details:
+            if interface is None:
+                data.append(process_vxlan_dump(dump))
+            elif dump[u"sw_if_index"] == sw_if_index:
+                data = process_vxlan_dump(dump)

                 break
 
                 break
 

-        logger.debug('TAP data:\n{tap_data}'.format(tap_data=data))
+        logger.debug(f"VXLAN data:\n{data}")

         return data
 
     @staticmethod
         return data
 
     @staticmethod

-    def create_subinterface(node, interface, sub_id, outer_vlan_id=None,
-                            inner_vlan_id=None, type_subif=None):
+    def create_subinterface(
+            node, interface, sub_id, outer_vlan_id=None, inner_vlan_id=None,
+            type_subif=None):

         """Create sub-interface on node. It is possible to set required
         sub-interface type and VLAN tag(s).
 
         """Create sub-interface on node. It is possible to set required
         sub-interface type and VLAN tag(s).
 


@@ -978,33 +986,42 @@ class InterfaceUtil(object):
         """
         subif_types = type_subif.split()
 
         """
         subif_types = type_subif.split()
 

-        cmd = 'create_subif'
+        flags = 0
+        if u"no_tags" in subif_types:
+            flags = flags | SubInterfaceFlags.SUB_IF_API_FLAG_NO_TAGS
+        if u"one_tag" in subif_types:
+            flags = flags | SubInterfaceFlags.SUB_IF_API_FLAG_ONE_TAG
+        if u"two_tags" in subif_types:
+            flags = flags | SubInterfaceFlags.SUB_IF_API_FLAG_TWO_TAGS
+        if u"dot1ad" in subif_types:
+            flags = flags | SubInterfaceFlags.SUB_IF_API_FLAG_DOT1AD
+        if u"exact_match" in subif_types:
+            flags = flags | SubInterfaceFlags.SUB_IF_API_FLAG_EXACT_MATCH
+        if u"default_sub" in subif_types:
+            flags = flags | SubInterfaceFlags.SUB_IF_API_FLAG_DEFAULT
+        if type_subif == u"default_sub":
+            flags = flags | SubInterfaceFlags.SUB_IF_API_FLAG_INNER_VLAN_ID_ANY\
+                    | SubInterfaceFlags.SUB_IF_API_FLAG_OUTER_VLAN_ID_ANY
+
+        cmd = u"create_subif"

         args = dict(
             sw_if_index=InterfaceUtil.get_interface_index(node, interface),
             sub_id=int(sub_id),
         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,
+            sub_if_flags=flags.value if hasattr(flags, u"value")
+            else int(flags),

             outer_vlan_id=int(outer_vlan_id) if outer_vlan_id 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 PapiExecutor(node) as papi_exec:
-            papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg).\
-                verify_reply(err_msg=err_msg)
-
-        sw_subif_idx = papi_resp['sw_if_index']
-        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)
+            inner_vlan_id=int(inner_vlan_id) if inner_vlan_id else 0
+        )
+        err_msg = f"Failed to create sub-interface on host {node[u'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, u"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)
 
         Topology.update_interface_name(node, if_key, ifc_name)
 

-        return '{ifc}.{s_id}'.format(ifc=interface, s_id=sub_id), sw_subif_idx
+        return f"{interface}.{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):


@@ -1020,55 +1037,61 @@ 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.
         """

-        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 PapiExecutor(node) as papi_exec:
-            papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg).\
-                verify_reply(err_msg=err_msg)
-
-        sw_if_idx = papi_resp['sw_if_index']
-        if_key = Topology.add_new_port(node, 'gre_tunnel')
-        Topology.update_interface_sw_if_index(node, if_key, sw_if_idx)
-        ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_idx)
+        cmd = u"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 = f"Failed to create GRE tunnel interface " \
+            f"on host {node[u'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, u"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)
 
         Topology.update_interface_name(node, if_key, ifc_name)
 

-        return ifc_name, sw_if_idx
+        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.
         """

-        cmd = 'create_loopback'
-        args = dict(mac_address=0)
-        err_msg = 'Failed to create loopback interface on host {host}'.format(
-            host=node['host'])
-        with PapiExecutor(node) as papi_exec:
-            papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg).\
-                verify_reply(err_msg=err_msg)
-
-        sw_if_idx = papi_resp['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)
+        cmd = u"create_loopback"
+        args = dict(
+            mac_address=L2Util.mac_to_bin(mac) if mac else 0
+        )
+        err_msg = f"Failed to create loopback interface on host {node[u'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, u"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)
         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_idx
+        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):


@@ -1088,50 +1111,55 @@ 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.
         """

-        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 PapiExecutor(node) as papi_exec:
-            papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg).\
-                verify_reply(err_msg=err_msg)
-
-        sw_if_idx = papi_resp['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)
+        cmd = u"bond_create"
+        args = dict(
+            id=int(Constants.BITWISE_NON_ZERO),
+            use_custom_mac=bool(mac is not None),
+            mac_address=L2Util.mac_to_bin(mac) if mac else None,
+            mode=getattr(
+                LinkBondMode,
+                f"BOND_API_MODE_{mode.replace(u'-', u'_').upper()}"
+            ).value,
+            lb=0 if load_balance is None else getattr(
+                LinkBondLoadBalanceAlgo,
+                f"BOND_API_LB_ALGO_{load_balance.upper()}"
+            ).value,
+            numa_only=False
+        )
+        err_msg = f"Failed to create bond interface on host {node[u'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=u"eth_bond"
+        )
+        if_key = Topology.get_interface_by_sw_index(node, sw_if_index)

 
         return if_key
 
     @staticmethod
 
         return if_key
 
     @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)
 

-        if ifc_name and sw_if_idx is None:
-            sw_if_idx = InterfaceUtil.vpp_get_interface_sw_index(node, 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 = InterfaceUtil.vpp_get_interface_mac(node, 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


@@ -1139,7 +1167,7 @@ class InterfaceUtil(object):
         """Create AVF interface on VPP node.
 
         :param node: DUT node from topology.
         """Create AVF interface on VPP node.
 
         :param node: DUT node from topology.

-        :param vf_pci_addr: Virtual Function PCI address.
+        :param vf_pci_addr: PCI address binded to i40evf driver.

         :param num_rx_queues: Number of RX queues.
         :type node: dict
         :type vf_pci_addr: str
         :param num_rx_queues: Number of RX queues.
         :type node: dict
         :type vf_pci_addr: str


@@ -1149,22 +1177,60 @@ class InterfaceUtil(object):
         :raises RuntimeError: If it is not possible to create AVF interface on
             the node.
         """
         :raises RuntimeError: If it is not possible to create AVF interface on
             the node.
         """

-        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 PapiExecutor(node) as papi_exec:
-            papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg).\
-                verify_reply(err_msg=err_msg)
-
-        sw_if_idx = papi_resp['sw_if_index']
-        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)
+        PapiSocketExecutor.run_cli_cmd(
+            node, u"set logging class avf level debug"
+        )
+
+        cmd = u"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 = f"Failed to create AVF interface on host {node[u'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=u"eth_avf"
+        )
+        if_key = Topology.get_interface_by_sw_index(node, sw_if_index)
+
+        return if_key
+
+    @staticmethod
+    def vpp_create_rdma_interface(node, pci_addr, num_rx_queues=None):
+        """Create RDMA interface on VPP node.
+
+        :param node: DUT node from topology.
+        :param pci_addr: PCI address binded to rdma-core driver.
+        :param num_rx_queues: Number of RX queues.
+        :type node: dict
+        :type 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 RDMA interface on
+            the node.
+        """
+        cmd = u"rdma_create"
+        args = dict(
+            name=InterfaceUtil.pci_to_eth(node, pci_addr),
+            host_if=InterfaceUtil.pci_to_eth(node, pci_addr),
+            rxq_num=int(num_rx_queues) if num_rx_queues else 0,
+            rxq_size=0,
+            txq_size=0
+        )
+        err_msg = f"Failed to create RDMA interface on host {node[u'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=u"eth_rdma"
+        )
+        if_key = Topology.get_interface_by_sw_index(node, sw_if_index)

 
         return if_key
 
 
         return if_key
 


@@ -1181,66 +1247,58 @@ class InterfaceUtil(object):
         :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.
         """

-        cmd = 'bond_enslave'
+        cmd = u"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),
         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 PapiExecutor(node) as papi_exec:
-            papi_exec.add(cmd, **args).get_replies(err_msg).\
-                verify_reply(err_msg=err_msg)
+            is_passive=False,
+            is_long_timeout=False
+        )
+        err_msg = f"Failed to enslave physical interface {interface} to bond " \
+            f"interface {bond_if} on host {node[u'host']}"
+        with PapiSocketExecutor(node) as papi_exec:
+            papi_exec.add(cmd, **args).get_reply(err_msg)

 
     @staticmethod
 
     @staticmethod

-    def vpp_show_bond_data_on_node(node, details=False):
+    def vpp_show_bond_data_on_node(node, verbose=False):

         """Show (detailed) bond information on VPP node.
 
         :param node: DUT node from topology.
         """Show (detailed) bond information on VPP node.
 
         :param node: DUT node from topology.

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

         :type node: dict
         :type node: dict

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

         """
         """

-        cmd = 'sw_interface_bond_dump'
-        cmd_reply = 'sw_interface_bond_details'
-        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 PapiExecutor(node) as papi_exec:
-            papi_resp = papi_exec.add(cmd).get_dump(err_msg)
-
-        papi_dump = papi_resp.reply[0]['api_reply']
-        for item in papi_dump:
-            data += ('{b}\n'.format(b=item[cmd_reply]['interface_name'].
-                                    rstrip('\x00')))
-            data += ('  mode: {m}\n'.
-                     format(m=LinkBondMode(item[cmd_reply]['mode']).name.
-                            lower()))
-            data += ('  load balance: {lb}\n'.
-                     format(lb=LinkBondLoadBalance(item[cmd_reply]['lb']).name.
-                            lower()))
-            data += ('  number of active slaves: {n}\n'.
-                     format(n=item[cmd_reply]['active_slaves']))
-            if details:
+        cmd = u"sw_interface_bond_dump"
+        err_msg = f"Failed to get bond interface dump on host {node[u'host']}"
+
+        data = f"Bond data on node {node[u'host']}:\n"
+        with PapiSocketExecutor(node) as papi_exec:
+            details = papi_exec.add(cmd).get_details(err_msg)
+
+        for bond in details:
+            data += f"{bond[u'interface_name']}\n"
+            data += u"  mode: {m}\n".format(
+                m=bond[u"mode"].name.replace(u"BOND_API_MODE_", u"").lower()
+            )
+            data += u"  load balance: {lb}\n".format(
+                lb=bond[u"lb"].name.replace(u"BOND_API_LB_ALGO_", u"").lower()
+            )
+            data += f"  number of active slaves: {bond[u'active_slaves']}\n"
+            if verbose:

                 slave_data = InterfaceUtil.vpp_bond_slave_dump(
                     node, Topology.get_interface_by_sw_index(
                 slave_data = InterfaceUtil.vpp_bond_slave_dump(
                     node, Topology.get_interface_by_sw_index(

-                        node, item[cmd_reply]['sw_if_index']))
+                        node, bond[u"sw_if_index"]
+                    )
+                )

                 for slave in slave_data:
                 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=item[cmd_reply]['slaves']))
-            if details:
+                    if not slave[u"is_passive"]:
+                        data += f"    {slave[u'interface_name']}\n"
+            data += f"  number of slaves: {bond[u'slaves']}\n"
+            if verbose:

                 for slave in slave_data:
                 for slave in slave_data:

-                    data += ('    {s}\n'.format(s=slave['interface_name']))
-            data += ('  interface id: {i}\n'.
-                     format(i=item[cmd_reply]['id']))
-            data += ('  sw_if_index: {i}\n'.
-                     format(i=item[cmd_reply]['sw_if_index']))
+                    data += f"    {slave[u'interface_name']}\n"
+            data += f"  interface id: {bond[u'id']}\n"
+            data += f"  sw_if_index: {bond[u'sw_if_index']}\n"

         logger.info(data)
 
     @staticmethod
         logger.info(data)
 
     @staticmethod


@@ -1254,53 +1312,34 @@ class InterfaceUtil(object):
         :returns: Bond slave interface data.
         :rtype: dict
         """
         :returns: Bond slave interface data.
         :rtype: dict
         """

-        cmd = 'sw_interface_slave_dump'
-        cmd_reply = 'sw_interface_slave_details'
-        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 PapiExecutor(node) as papi_exec:
-            papi_resp = papi_exec.add(cmd, **args).get_dump(err_msg)
-
-        papi_dump = papi_resp.reply[0]['api_reply']
-
-        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 = u"sw_interface_slave_dump"
+        args = dict(
+            sw_if_index=Topology.get_interface_sw_index(node, interface)
+        )
+        err_msg = f"Failed to get slave dump on host {node[u'host']}"

 
 

-        data = list()
-        for item in papi_dump:
-            data.append(process_slave_dump(item[cmd_reply]))
+        with PapiSocketExecutor(node) as papi_exec:
+            details = papi_exec.add(cmd, **args).get_details(err_msg)

 
 

-        logger.debug('Slave data:\n{slave_data}'.format(slave_data=data))
-        return data
+        logger.debug(f"Slave data:\n{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():
         """
         for node_data in nodes.values():

-            if node_data['type'] == NodeType.DUT:
-                InterfaceUtil.vpp_show_bond_data_on_node(node_data, details)
+            if node_data[u"type"] == NodeType.DUT:
+                InterfaceUtil.vpp_show_bond_data_on_node(node_data, verbose)

 
     @staticmethod
 
     @staticmethod

-    def vpp_enable_input_acl_interface(node, interface, ip_version,
-                                       table_index):
+    def vpp_enable_input_acl_interface(
+            node, interface, ip_version, table_index):

         """Enable input acl on interface.
 
         :param node: VPP node to setup interface for input acl.
         """Enable input acl on interface.
 
         :param node: VPP node to setup interface for input acl.


@@ -1312,21 +1351,19 @@ class InterfaceUtil(object):
         :type ip_version: str
         :type table_index: int
         """
         :type ip_version: str
         :type table_index: int
         """

-        cmd = 'input_acl_set_interface'
+        cmd = u"input_acl_set_interface"

         args = dict(
             sw_if_index=InterfaceUtil.get_interface_index(node, interface),
         args = dict(
             sw_if_index=InterfaceUtil.get_interface_index(node, interface),

-            ip4_table_index=table_index if ip_version == 'ip4'
+            ip4_table_index=table_index if ip_version == u"ip4"

             else Constants.BITWISE_NON_ZERO,
             else Constants.BITWISE_NON_ZERO,

-            ip6_table_index=table_index if ip_version == 'ip6'
+            ip6_table_index=table_index if ip_version == u"ip6"

             else Constants.BITWISE_NON_ZERO,
             else Constants.BITWISE_NON_ZERO,

-            l2_table_index=table_index if ip_version == 'l2'
+            l2_table_index=table_index if ip_version == u"l2"

             else Constants.BITWISE_NON_ZERO,
             is_add=1)
             else Constants.BITWISE_NON_ZERO,
             is_add=1)

-        err_msg = 'Failed to enable input acl on interface {ifc}'.format(
-            ifc=interface)
-        with PapiExecutor(node) as papi_exec:
-            papi_exec.add(cmd, **args).get_replies(err_msg).\
-                verify_reply(err_msg=err_msg)
+        err_msg = f"Failed to enable input acl on interface {interface}"
+        with PapiSocketExecutor(node) as papi_exec:
+            papi_exec.add(cmd, **args).get_reply(err_msg)

 
     @staticmethod
     def get_interface_classify_table(node, interface):
 
     @staticmethod
     def get_interface_classify_table(node, interface):


@@ -1341,20 +1378,20 @@ class InterfaceUtil(object):
         :returns: Classify table name.
         :rtype: str
         """
         :returns: Classify table name.
         :rtype: str
         """

-        if isinstance(interface, basestring):
+        if isinstance(interface, str):

             sw_if_index = InterfaceUtil.get_sw_if_index(node, interface)
         else:
             sw_if_index = interface
 
             sw_if_index = InterfaceUtil.get_sw_if_index(node, interface)
         else:
             sw_if_index = interface
 

-        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 PapiExecutor(node) as papi_exec:
-            papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg). \
-                verify_reply(err_msg=err_msg)
+        cmd = u"classify_table_by_interface"
+        args = dict(
+            sw_if_index=sw_if_index
+        )
+        err_msg = f"Failed to get classify table name by interface {interface}"
+        with PapiSocketExecutor(node) as papi_exec:
+            reply = papi_exec.add(cmd, **args).get_reply(err_msg)

 
 

-        return papi_resp
+        return reply

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


@@ -1368,8 +1405,9 @@ class InterfaceUtil(object):
         :rtype: str
         """
         interface_data = InterfaceUtil.vpp_get_interface_data(
         :rtype: str
         """
         interface_data = InterfaceUtil.vpp_get_interface_data(

-            node, interface=interface_name)
-        return interface_data.get('sw_if_index')
+            node, interface=interface_name
+        )
+        return interface_data.get(u"sw_if_index")

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


@@ -1385,22 +1423,6 @@ class InterfaceUtil(object):
             interfaces.
         :rtype: dict or list
         """
             interfaces.
         :rtype: dict or list
         """

-        if interface_name is not None:
-            sw_if_index = InterfaceUtil.get_interface_index(
-                node, interface_name)
-        else:
-            sw_if_index = int(Constants.BITWISE_NON_ZERO)
-
-        cmd = 'vxlan_gpe_tunnel_dump'
-        cmd_reply = 'vxlan_gpe_tunnel_details'
-        args = dict(sw_if_index=sw_if_index)
-        err_msg = 'Failed to get VXLAN-GPE dump on host {host}'.format(
-            host=node['host'])
-        with PapiExecutor(node) as papi_exec:
-            papi_resp = papi_exec.add(cmd, **args).get_dump(err_msg)
-
-        papi_vxlan_dump = papi_resp.reply[0]['api_reply']
-

         def process_vxlan_gpe_dump(vxlan_dump):
             """Process vxlan_gpe dump.
 
         def process_vxlan_gpe_dump(vxlan_dump):
             """Process vxlan_gpe dump.
 


@@ -1409,28 +1431,38 @@ class InterfaceUtil(object):
             :returns: Processed vxlan_gpe interface dump.
             :rtype: dict
             """
             :returns: Processed vxlan_gpe interface dump.
             :rtype: dict
             """

-            if vxlan_dump['is_ipv6']:
-                vxlan_dump['local'] = \
-                    inet_ntop(AF_INET6, vxlan_dump['local'])
-                vxlan_dump['remote'] = \
-                    inet_ntop(AF_INET6, vxlan_dump['remote'])
+            if vxlan_dump[u"is_ipv6"]:
+                vxlan_dump[u"local"] = ip_address(vxlan_dump[u"local"])
+                vxlan_dump[u"remote"] = ip_address(vxlan_dump[u"remote"])

             else:
             else:

-                vxlan_dump['local'] = \
-                    inet_ntop(AF_INET, vxlan_dump['local'][0:4])
-                vxlan_dump['remote'] = \
-                    inet_ntop(AF_INET, vxlan_dump['remote'][0:4])
+                vxlan_dump[u"local"] = ip_address(vxlan_dump[u"local"][0:4])
+                vxlan_dump[u"remote"] = ip_address(vxlan_dump[u"remote"][0:4])

             return vxlan_dump
 
             return vxlan_dump
 

+        if interface_name is not None:
+            sw_if_index = InterfaceUtil.get_interface_index(
+                node, interface_name
+            )
+        else:
+            sw_if_index = int(Constants.BITWISE_NON_ZERO)
+
+        cmd = u"vxlan_gpe_tunnel_dump"
+        args = dict(
+            sw_if_index=sw_if_index
+        )
+        err_msg = f"Failed to get VXLAN-GPE dump on host {node[u'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()
         data = list() if interface_name is None else dict()

-        for item in papi_vxlan_dump:
+        for dump in details:

             if interface_name is None:
             if interface_name is None:

-                data.append(process_vxlan_gpe_dump(item[cmd_reply]))
-            elif item[cmd_reply]['sw_if_index'] == sw_if_index:
-                data = process_vxlan_gpe_dump(item[cmd_reply])
+                data.append(process_vxlan_gpe_dump(dump))
+            elif dump[u"sw_if_index"] == sw_if_index:
+                data = process_vxlan_gpe_dump(dump)

                 break
 
                 break
 

-        logger.debug('VXLAN-GPE data:\n{vxlan_gpe_data}'.format(
-            vxlan_gpe_data=data))
+        logger.debug(f"VXLAN-GPE data:\n{data}")

         return data
 
     @staticmethod
         return data
 
     @staticmethod


@@ -1446,20 +1478,19 @@ class InterfaceUtil(object):
         :type table_id: int
         :type ipv6: bool
         """
         :type table_id: int
         :type ipv6: bool
         """

-        cmd = 'sw_interface_set_table'
+        cmd = u"sw_interface_set_table"

         args = dict(
             sw_if_index=InterfaceUtil.get_interface_index(node, interface),
         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 PapiExecutor(node) as papi_exec:
-            papi_exec.add(cmd, **args).get_replies(err_msg). \
-                verify_reply(err_msg=err_msg)
+            is_ipv6=ipv6,
+            vrf_id=int(table_id)
+        )
+        err_msg = f"Failed to assign interface {interface} to FIB table"
+        with PapiSocketExecutor(node) as papi_exec:
+            papi_exec.add(cmd, **args).get_reply(err_msg)

 
     @staticmethod
 
     @staticmethod

-    def set_linux_interface_mac(node, interface, mac, namespace=None,
-                                vf_id=None):
+    def set_linux_interface_mac(
+            node, interface, mac, namespace=None, vf_id=None):

         """Set MAC address for interface in linux.
 
         :param node: Node where to execute command.
         """Set MAC address for interface in linux.
 
         :param node: Node where to execute command.


@@ -1473,17 +1504,16 @@ class InterfaceUtil(object):
         :type namespace: str
         :type vf_id: int
         """
         :type namespace: str
         :type vf_id: int
         """

-        mac_str = 'vf {vf_id} mac {mac}'.format(vf_id=vf_id, mac=mac) \
-            if vf_id is not None else 'address {mac}'.format(mac=mac)
-        ns_str = 'ip netns exec {ns}'.format(ns=namespace) if namespace else ''
+        mac_str = f"vf {vf_id} mac {mac}" if vf_id is not None \
+            else f"address {mac}"
+        ns_str = f"ip netns exec {namespace}" if namespace else u""

 
 

-        cmd = ('{ns} ip link set {interface} {mac}'.
-               format(ns=ns_str, interface=interface, mac=mac_str))
+        cmd = f"{ns_str} ip link set {interface} {mac_str}"

         exec_cmd_no_error(node, cmd, sudo=True)
 
     @staticmethod
         exec_cmd_no_error(node, cmd, sudo=True)
 
     @staticmethod

-    def set_linux_interface_trust_on(node, interface, namespace=None,
-                                     vf_id=None):
+    def set_linux_interface_trust_on(
+            node, interface, namespace=None, vf_id=None):

         """Set trust on (promisc) for interface in linux.
 
         :param node: Node where to execute command.
         """Set trust on (promisc) for interface in linux.
 
         :param node: Node where to execute command.


@@ -1495,17 +1525,15 @@ class InterfaceUtil(object):
         :type namespace: str
         :type vf_id: int
         """
         :type namespace: str
         :type vf_id: int
         """

-        trust_str = 'vf {vf_id} trust on'.format(vf_id=vf_id) \
-            if vf_id is not None else 'trust on'
-        ns_str = 'ip netns exec {ns}'.format(ns=namespace) if namespace else ''
+        trust_str = f"vf {vf_id} trust on" if vf_id is not None else u"trust on"
+        ns_str = f"ip netns exec {namespace}" if namespace else u""

 
 

-        cmd = ('{ns} ip link set dev {interface} {trust}'.
-               format(ns=ns_str, interface=interface, trust=trust_str))
+        cmd = f"{ns_str} ip link set dev {interface} {trust_str}"

         exec_cmd_no_error(node, cmd, sudo=True)
 
     @staticmethod
         exec_cmd_no_error(node, cmd, sudo=True)
 
     @staticmethod

-    def set_linux_interface_spoof_off(node, interface, namespace=None,
-                                      vf_id=None):
+    def set_linux_interface_spoof_off(
+            node, interface, namespace=None, vf_id=None):

         """Set spoof off for interface in linux.
 
         :param node: Node where to execute command.
         """Set spoof off for interface in linux.
 
         :param node: Node where to execute command.


@@ -1517,22 +1545,21 @@ class InterfaceUtil(object):
         :type namespace: str
         :type vf_id: int
         """
         :type namespace: str
         :type vf_id: int
         """

-        spoof_str = 'vf {vf_id} spoof off'.format(vf_id=vf_id) \
-            if vf_id is not None else 'spoof off'
-        ns_str = 'ip netns exec {ns}'.format(ns=namespace) if namespace else ''
+        spoof_str = f"vf {vf_id} spoof off" if vf_id is not None \
+            else u"spoof off"
+        ns_str = f"ip netns exec {namespace}" if namespace else u""

 
 

-        cmd = ('{ns} ip link set dev {interface} {spoof}'.
-               format(ns=ns_str, interface=interface, spoof=spoof_str))
+        cmd = f"{ns_str} ip link set dev {interface} {spoof_str}"

         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, osi_layer='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=u"L2"):
+        """Init PCI device by creating VIFs and bind them to vfio-pci for AVF

         driver testing on DUT.
 
         :param node: DUT node.
         :param ifc_key: Interface key from topology file.
         driver testing on DUT.
 
         :param node: DUT node.
         :param ifc_key: Interface key from topology file.

-        :param numvfs: Number of VFs to initialize, 0 - disable the VFs.
+        :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
         :param osi_layer: OSI Layer type to initialize TG with.
             Default value "L2" sets linux interface spoof off.
         :type node: dict


@@ -1543,20 +1570,18 @@ class InterfaceUtil(object):
         :rtype: list
         :raises RuntimeError: If a reason preventing initialization is found.
         """
         :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)

-        if kernel_driver != "i40e":
+        if kernel_driver not in (u"i40e", u"i40evf"):

             raise RuntimeError(
             raise RuntimeError(

-                "AVF needs i40e driver, not {driver} at node {host} ifc {ifc}"\
-                .format(driver=kernel_driver, host=node["host"], ifc=ifc_key))
+                f"AVF needs i40e-compatible driver, not {kernel_driver} "
+                f"at node {node[u'host']} ifc {ifc_key}"
+            )

         current_driver = DUTSetup.get_pci_dev_driver(
         current_driver = DUTSetup.get_pci_dev_driver(

-            node, pf_pci_addr.replace(':', r'\:'))
+            node, pf_pci_addr.replace(u":", r"\:"))

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


@@ -1568,318 +1593,45 @@ 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 = []
         # Set MAC address and bind each virtual function to uio driver.
         for vf_id in range(numvfs):
         DUTSetup.set_sriov_numvfs(node, pf_pci_addr, numvfs)
 
         vf_ifc_keys = []
         # Set MAC address and bind each virtual function to uio driver.
         for vf_id in range(numvfs):

-            vf_mac_addr = ":".join([pf_mac_addr[0], pf_mac_addr[2],
-                                    pf_mac_addr[3], pf_mac_addr[4],
-                                    pf_mac_addr[5], "{:02x}".format(vf_id)])
+            vf_mac_addr = u":".join(
+                [pf_mac_addr[0], pf_mac_addr[2], pf_mac_addr[3], pf_mac_addr[4],
+                 pf_mac_addr[5], f"{vf_id:02x}"
+                 ]
+            )

 
 

-            pf_dev = '`basename /sys/bus/pci/devices/{pci}/net/*`'.\
-                format(pci=pf_pci_addr)
+            pf_dev = f"`basename /sys/bus/pci/devices/{pf_pci_addr}/net/*`"

             InterfaceUtil.set_linux_interface_trust_on(node, pf_dev,
                                                        vf_id=vf_id)
             InterfaceUtil.set_linux_interface_trust_on(node, pf_dev,
                                                        vf_id=vf_id)

-            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,
-                                                  vf_id=vf_id)
+            if osi_layer == u"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, vf_id=vf_id
+            )

 
             DUTSetup.pci_vf_driver_unbind(node, pf_pci_addr, vf_id)
             DUTSetup.pci_vf_driver_bind(node, pf_pci_addr, vf_id, uio_driver)
 
             # Add newly created ports into topology file
 
             DUTSetup.pci_vf_driver_unbind(node, pf_pci_addr, vf_id)
             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 = f"{ifc_key}_vif"

             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)
             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_ifc_name+str(vf_id+1))
+            Topology.update_interface_name(
+                node, vf_ifc_key, vf_ifc_name+str(vf_id+1)
+            )

             Topology.update_interface_mac_address(node, vf_ifc_key, vf_mac_addr)
             Topology.update_interface_pci_address(node, vf_ifc_key, vf_pci_addr)
             vf_ifc_keys.append(vf_ifc_key)
 
         return vf_ifc_keys
 
             Topology.update_interface_mac_address(node, vf_ifc_key, vf_mac_addr)
             Topology.update_interface_pci_address(node, vf_ifc_key, vf_pci_addr)
             vf_ifc_keys.append(vf_ifc_key)
 
         return vf_ifc_keys
 

-    @staticmethod
-    def vpp_create_multiple_vxlan_ipv4_tunnels(
-            node, node_vxlan_if, node_vlan_if, op_node, op_node_if,
-            n_tunnels, vni_start, src_ip_start, dst_ip_start, ip_step, ip_limit,
-            bd_id_start):
-        """Create multiple VXLAN tunnel interfaces and VLAN sub-interfaces on
-        VPP node.
-
-        Put each pair of VXLAN tunnel interface and VLAN sub-interface to
-        separate bridge-domain.
-
-        :param node: VPP node to create VXLAN tunnel interfaces.
-        :param node_vxlan_if: VPP node interface key to create VXLAN tunnel
-            interfaces.
-        :param node_vlan_if: VPP node interface key to create VLAN
-            sub-interface.
-        :param op_node: Opposite VPP node for VXLAN tunnel interfaces.
-        :param op_node_if: Opposite VPP node interface key for VXLAN tunnel
-            interfaces.
-        :param n_tunnels: Number of tunnel interfaces to create.
-        :param vni_start: VNI start ID.
-        :param src_ip_start: VXLAN tunnel source IP address start.
-        :param dst_ip_start: VXLAN tunnel destination IP address start.
-        :param ip_step: IP address incremental step.
-        :param ip_limit: IP address limit.
-        :param bd_id_start: Bridge-domain ID start.
-        :type node: dict
-        :type node_vxlan_if: str
-        :type node_vlan_if: str
-        :type op_node: dict
-        :type op_node_if: str
-        :type n_tunnels: int
-        :type vni_start: int
-        :type src_ip_start: str
-        :type dst_ip_start: str
-        :type ip_step: int
-        :type ip_limit: str
-        :type bd_id_start: int
-        """
-        # configure IPs, create VXLAN interfaces and VLAN sub-interfaces
-        vxlan_count = InterfaceUtil.vpp_create_vxlan_and_vlan_interfaces(
-            node, node_vxlan_if, node_vlan_if, n_tunnels, vni_start,
-            src_ip_start, dst_ip_start, ip_step, ip_limit)
-
-        # update topology with VXLAN interfaces and VLAN sub-interfaces data
-        # and put interfaces up
-        InterfaceUtil.vpp_put_vxlan_and_vlan_interfaces_up(
-            node, vxlan_count, node_vlan_if)
-
-        # configure bridge domains, ARPs and routes
-        InterfaceUtil.vpp_put_vxlan_and_vlan_interfaces_to_bridge_domain(
-            node, node_vxlan_if, vxlan_count, op_node, op_node_if, dst_ip_start,
-            ip_step, bd_id_start)
-
-    @staticmethod
-    def vpp_create_vxlan_and_vlan_interfaces(
-            node, node_vxlan_if, node_vlan_if, vxlan_count, vni_start,
-            src_ip_start, dst_ip_start, ip_step, ip_limit):
-        """
-        Configure IPs, create VXLAN interfaces and VLAN sub-interfaces on VPP
-        node.
-
-        :param node: VPP node.
-        :param node_vxlan_if: VPP node interface key to create VXLAN tunnel
-            interfaces.
-        :param node_vlan_if: VPP node interface key to create VLAN
-            sub-interface.
-        :param vxlan_count: Number of tunnel interfaces to create.
-        :param vni_start: VNI start ID.
-        :param src_ip_start: VXLAN tunnel source IP address start.
-        :param dst_ip_start: VXLAN tunnel destination IP address start.
-        :param ip_step: IP address incremental step.
-        :param ip_limit: IP address limit.
-        :type node: dict
-        :type node_vxlan_if: str
-        :type node_vlan_if: str
-        :type vxlan_count: int
-        :type vni_start: int
-        :type src_ip_start: str
-        :type dst_ip_start: str
-        :type ip_step: int
-        :type ip_limit: str
-        :returns: Number of created VXLAN interfaces.
-        :rtype: int
-        """
-        try:
-            src_address_start = IPv6Address(unicode(src_ip_start))
-            dst_address_start = IPv6Address(unicode(dst_ip_start))
-            ip_address_limit = IPv6Address(unicode(ip_limit))
-            af_inet = AF_INET6
-            is_ipv6 = 1
-        except (AddressValueError, NetmaskValueError):
-            src_address_start = IPv4Address(unicode(src_ip_start))
-            dst_address_start = IPv4Address(unicode(dst_ip_start))
-            ip_address_limit = IPv4Address(unicode(ip_limit))
-            af_inet = AF_INET
-            is_ipv6 = 0
-
-        with PapiExecutor(node) as papi_exec:
-            for i in xrange(0, vxlan_count):
-                src_ip = src_address_start + i * ip_step
-                dst_ip = dst_address_start + i * ip_step
-                if src_ip > ip_address_limit or dst_ip > ip_address_limit:
-                    logger.warn("Can't do more iterations - IP address limit "
-                                "has been reached.")
-                    vxlan_count = i
-                    break
-                cmd = 'sw_interface_add_del_address'
-                args = dict(
-                    sw_if_index=InterfaceUtil.get_interface_index(
-                        node, node_vxlan_if),
-                    is_add=1,
-                    is_ipv6=0,
-                    del_all=0,
-                    address_length=128 if is_ipv6 else 32,
-                    address=inet_pton(af_inet, str(src_ip)))
-                papi_exec.add(cmd, **args)
-                cmd = 'vxlan_add_del_tunnel'
-                args = dict(
-                    is_add=1,
-                    is_ipv6=0,
-                    instance=Constants.BITWISE_NON_ZERO,
-                    src_address=inet_pton(af_inet, str(src_ip)),
-                    dst_address=inet_pton(af_inet, str(dst_ip)),
-                    mcast_sw_if_index=Constants.BITWISE_NON_ZERO,
-                    encap_vrf_id=0,
-                    decap_next_index=Constants.BITWISE_NON_ZERO,
-                    vni=int(vni_start)+i)
-                papi_exec.add(cmd, **args)
-                cmd = 'create_vlan_subif'
-                args = dict(
-                    sw_if_index=InterfaceUtil.get_interface_index(
-                        node, node_vlan_if),
-                    vlan_id=i+1)
-                papi_exec.add(cmd, **args)
-            papi_exec.get_replies().verify_replies()
-
-        return vxlan_count
-
-    @staticmethod
-    def vpp_put_vxlan_and_vlan_interfaces_up(node, vxlan_count, node_vlan_if):
-        """
-        Update topology with VXLAN interfaces and VLAN sub-interfaces data
-        and put interfaces up.
-
-        :param node: VPP node.
-        :param vxlan_count: Number of tunnel interfaces.
-        :param node_vlan_if: VPP node interface key where VLAN sub-interfaces
-            have been created.
-        :type node: dict
-        :type vxlan_count: int
-        :type node_vlan_if: str
-        """
-        if_data = InterfaceUtil.vpp_get_interface_data(node)
-
-        with PapiExecutor(node) as papi_exec:
-            for i in xrange(0, vxlan_count):
-                vxlan_subif_key = Topology.add_new_port(node, 'vxlan_tunnel')
-                vxlan_subif_name = 'vxlan_tunnel{nr}'.format(nr=i)
-                vxlan_found = False
-                vxlan_subif_idx = None
-                vlan_subif_key = Topology.add_new_port(node, 'vlan_subif')
-                vlan_subif_name = '{if_name}.{vlan}'.format(
-                    if_name=Topology.get_interface_name(
-                        node, node_vlan_if), vlan=i+1)
-                vlan_found = False
-                vlan_idx = None
-                for data in if_data:
-                    if not vxlan_found \
-                            and data['interface_name'] == vxlan_subif_name:
-                        vxlan_subif_idx = data['sw_if_index']
-                        vxlan_found = True
-                    elif not vlan_found \
-                            and data['interface_name'] == vlan_subif_name:
-                        vlan_idx = data['sw_if_index']
-                        vlan_found = True
-                    if vxlan_found and vlan_found:
-                        break
-                Topology.update_interface_sw_if_index(
-                    node, vxlan_subif_key, vxlan_subif_idx)
-                Topology.update_interface_name(
-                    node, vxlan_subif_key, vxlan_subif_name)
-                cmd = 'sw_interface_set_flags'
-                args1 = dict(sw_if_index=vxlan_subif_idx,
-                             admin_up_down=1)
-                Topology.update_interface_sw_if_index(
-                    node, vlan_subif_key, vlan_idx)
-                Topology.update_interface_name(
-                    node, vlan_subif_key, vlan_subif_name)
-                args2 = dict(sw_if_index=vlan_idx,
-                             admin_up_down=1)
-                papi_exec.add(cmd, **args1).add(cmd, **args2)
-            papi_exec.get_replies().verify_replies()
-
-    @staticmethod
-    def vpp_put_vxlan_and_vlan_interfaces_to_bridge_domain(
-            node, node_vxlan_if, vxlan_count, op_node, op_node_if, dst_ip_start,
-            ip_step, bd_id_start):
-        """
-        Configure ARPs and routes for VXLAN interfaces and put each pair of
-        VXLAN tunnel interface and VLAN sub-interface to separate bridge-domain.
-
-        :param node: VPP node.
-        :param node_vxlan_if: VPP node interface key where VXLAN tunnel
-            interfaces have been created.
-        :param vxlan_count: Number of tunnel interfaces.
-        :param op_node: Opposite VPP node for VXLAN tunnel interfaces.
-        :param op_node_if: Opposite VPP node interface key for VXLAN tunnel
-            interfaces.
-        :param dst_ip_start: VXLAN tunnel destination IP address start.
-        :param ip_step: IP address incremental step.
-        :param bd_id_start: Bridge-domain ID start.
-        :type node: dict
-        :type node_vxlan_if: str
-        :type vxlan_count: int
-        :type op_node: dict
-        :type op_node_if:
-        :type dst_ip_start: str
-        :type ip_step: int
-        :type bd_id_start: int
-        """
-        try:
-            dst_address_start = IPv6Address(unicode(dst_ip_start))
-            af_inet = AF_INET6
-            is_ipv6 = 1
-        except (AddressValueError, NetmaskValueError):
-            dst_address_start = IPv4Address(unicode(dst_ip_start))
-            af_inet = AF_INET
-            is_ipv6 = 0
-
-        with PapiExecutor(node) as papi_exec:
-            for i in xrange(0, vxlan_count):
-                dst_ip = dst_address_start + i * ip_step
-                neighbor = dict(
-                    sw_if_index=Topology.get_interface_sw_index(
-                        node, node_vxlan_if),
-                    flags=0,
-                    mac_address=str(
-                        Topology.get_interface_mac(op_node, op_node_if)),
-                    ip_address=str(dst_ip))
-                cmd = 'ip_neighbor_add_del'
-                args = dict(
-                    is_add=1,
-                    neighbor=neighbor)
-                papi_exec.add(cmd, **args)
-                cmd = 'ip_add_del_route'
-                args = dict(
-                    next_hop_sw_if_index=Topology.get_interface_sw_index(
-                        node, node_vxlan_if),
-                    table_id=0,
-                    is_add=1,
-                    is_ipv6=is_ipv6,
-                    next_hop_weight=1,
-                    next_hop_proto=1 if is_ipv6 else 0,
-                    dst_address_length=128 if is_ipv6 else 32,
-                    dst_address=inet_pton(af_inet, str(dst_ip)),
-                    next_hop_address=inet_pton(af_inet, str(dst_ip)))
-                papi_exec.add(cmd, **args)
-                cmd = 'sw_interface_set_l2_bridge'
-                args = dict(
-                    rx_sw_if_index=Topology.get_interface_sw_index(
-                        node, 'vxlan_tunnel{nr}'.format(nr=i+1)),
-                    bd_id=int(bd_id_start+i),
-                    shg=0,
-                    port_type=0,
-                    enable=1)
-                papi_exec.add(cmd, **args)
-                args = dict(
-                    rx_sw_if_index=Topology.get_interface_sw_index(
-                        node, 'vlan_subif{nr}'.format(nr=i+1)),
-                    bd_id=int(bd_id_start+i),
-                    shg=0,
-                    port_type=0,
-                    enable=1)
-                papi_exec.add(cmd, **args)
-            papi_exec.get_replies().verify_replies()
-

     @staticmethod
     def vpp_sw_interface_rx_placement_dump(node):
         """Dump VPP interface RX placement on node.
     @staticmethod
     def vpp_sw_interface_rx_placement_dump(node):
         """Dump VPP interface RX placement on node.


@@ -1889,22 +1641,18 @@ class InterfaceUtil(object):
         :returns: Thread mapping information as a list of dictionaries.
         :rtype: list
         """
         :returns: Thread mapping information as a list of dictionaries.
         :rtype: list
         """

-        cmd = 'sw_interface_rx_placement_dump'
-        cmd_reply = 'sw_interface_rx_placement_details'
-        err_msg = "Failed to run '{cmd}' PAPI command on host {host}!".format(
-            cmd=cmd, host=node['host'])
-        with PapiExecutor(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'])
-            papi_resp = papi_exec.get_dump(err_msg)
-        thr_mapping = [s[cmd_reply] for r in papi_resp.reply
-                       for s in r['api_reply']]
-        return sorted(thr_mapping, key=lambda k: k['sw_if_index'])
+        cmd = u"sw_interface_rx_placement_dump"
+        err_msg = f"Failed to run '{cmd}' PAPI command on host {node[u'host']}!"
+        with PapiSocketExecutor(node) as papi_exec:
+            for ifc in node[u"interfaces"].values():
+                if ifc[u"vpp_sw_index"] is not None:
+                    papi_exec.add(cmd, sw_if_index=ifc[u"vpp_sw_index"])
+            details = papi_exec.get_details(err_msg)
+        return sorted(details, key=lambda k: k[u"sw_if_index"])

 
     @staticmethod
 
     @staticmethod

-    def vpp_sw_interface_set_rx_placement(node, sw_if_index, queue_id,
-                                          worker_id):
+    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.
         """Set interface RX placement to worker on node.
 
         :param node: Node to run command on.


@@ -1918,14 +1666,17 @@ class InterfaceUtil(object):
         :raises RuntimeError: If failed to run command on host or if no API
             reply received.
         """
         :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 PapiExecutor(node) as papi_exec:
-            papi_exec.add(cmd, **args).get_replies(err_msg).\
-                verify_reply(err_msg=err_msg)
+        cmd = u"sw_interface_set_rx_placement"
+        err_msg = f"Failed to set interface RX placement to worker " \
+            f"on host {node[u'host']}!"
+        args = dict(
+            sw_if_index=sw_if_index,
+            queue_id=queue_id,
+            worker_id=worker_id,
+            is_main=False
+        )
+        with PapiSocketExecutor(node) as papi_exec:
+            papi_exec.add(cmd, **args).get_reply(err_msg)

 
     @staticmethod
     def vpp_round_robin_rx_placement(node, prefix):
 
     @staticmethod
     def vpp_round_robin_rx_placement(node, prefix):


@@ -1939,13 +1690,16 @@ class InterfaceUtil(object):
         """
         worker_id = 0
         worker_cnt = len(VPPUtil.vpp_show_threads(node)) - 1
         """
         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 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']:
+            for interface in node[u"interfaces"].values():
+                if placement[u"sw_if_index"] == interface[u"vpp_sw_index"] \
+                    and prefix in interface[u"name"]:

                     InterfaceUtil.vpp_sw_interface_set_rx_placement(
                     InterfaceUtil.vpp_sw_interface_set_rx_placement(

-                        node, placement['sw_if_index'], placement['queue_id'],
-                        worker_id % worker_cnt)
+                        node, placement[u"sw_if_index"], placement[u"queue_id"],
+                        worker_id % worker_cnt
+                    )

                     worker_id += 1
 
     @staticmethod
                     worker_id += 1
 
     @staticmethod


@@ -1959,5 +1713,5 @@ class InterfaceUtil(object):
         :type prefix: str
         """
         for node in nodes.values():
         :type prefix: str
         """
         for node in nodes.values():

-            if node['type'] == NodeType.DUT:
+            if node[u"type"] == NodeType.DUT:

                 InterfaceUtil.vpp_round_robin_rx_placement(node, prefix)
                 InterfaceUtil.vpp_round_robin_rx_placement(node, prefix)