Use interface key instead of interface name.

JIRA: CSIT-141

Change-Id: I75cef6d570ab45ea9c4af838b6bf68cefc7c1a91
Signed-off-by: Miroslav Miklus <mmiklus@cisco.com>

9 files changed, 280 insertions, 181 deletions

diff --git a/resources/libraries/python/IPUtil.py b/resources/libraries/python/IPUtil.py
index e364e60cee..323c75bda4 100644
--- a/resources/libraries/python/IPUtil.py
+++ b/resources/libraries/python/IPUtil.py
@@ -17,30 +17,42 @@ from ipaddress import IPv4Network
 from resources.libraries.python.ssh import SSH
 from resources.libraries.python.constants import Constants
 
+from resources.libraries.python.topology import Topology
 
 class IPUtil(object):
     """Common IP utilities"""
 
     @staticmethod
-    def vpp_ip_probe(node, interface, addr):
+    def vpp_ip_probe(node, interface, addr, if_type="key"):
         """Run ip probe on VPP node.
 
         :param node: VPP node.
-        :param interface: Interface name.
+        :param interface: Interface key or name.
         :param addr: IPv4/IPv6 address.
+        :param if_type: Interface type
         :type node: dict
         :type interface: str
         :type addr: str
+        :type if_type: str
+        :raises ValueError: If the if_type is unknown.
+        :raises Exception: If vpp probe fails.
         """
         ssh = SSH()
         ssh.connect(node)
 
+        if if_type == "key":
+            iface_name = Topology.get_interface_name(node, interface)
+        elif if_type == "name":
+            iface_name = interface
+        else:
+            raise ValueError("if_type unknown: {}".format(if_type))
+
         cmd = "{c}".format(c=Constants.VAT_BIN_NAME)
-        cmd_input = 'exec ip probe {dev} {ip}'.format(dev=interface, ip=addr)
+        cmd_input = 'exec ip probe {dev} {ip}'.format(dev=iface_name, ip=addr)
         (ret_code, _, _) = ssh.exec_command_sudo(cmd, cmd_input)
         if int(ret_code) != 0:
             raise Exception('VPP ip probe {dev} {ip} failed on {h}'.format(
-                dev=interface, ip=addr, h=node['host']))
+                dev=iface_name, ip=addr, h=node['host']))
 
 
 def convert_ipv4_netmask_prefix(network):
diff --git a/resources/libraries/python/IPv4NodeAddress.py b/resources/libraries/python/IPv4NodeAddress.py
index 25179a3119..617377d35a 100644
--- a/resources/libraries/python/IPv4NodeAddress.py
+++ b/resources/libraries/python/IPv4NodeAddress.py
@@ -79,7 +79,8 @@ def get_variables(nodes, networks=IPV4_NETWORKS[:]):
         port_idx = 0
         ports = {}
         for node in nodes.values():
-            if_name = topo.get_interface_by_link_name(node, link)
+            if_key = topo.get_interface_by_link_name(node, link)
+            if_name = topo.get_interface_name(node, if_key)
             if if_name is not None:
                 port = {'addr': str(next(net_hosts)),
                         'node': node['host'],
diff --git a/resources/libraries/python/IPv4Setup.py b/resources/libraries/python/IPv4Setup.py
index 577b225ad1..d89eeed3d0 100644
--- a/resources/libraries/python/IPv4Setup.py
+++ b/resources/libraries/python/IPv4Setup.py
@@ -173,18 +173,18 @@ class Dut(IPv4Node):
         # TODO: check return value
         VatExecutor.cmd_from_template(self.node_info, script, **args)
 
-    def set_arp(self, interface, ip_address, mac_address):
+    def set_arp(self, iface_key, ip_address, mac_address):
         """Set entry in ARP cache.
 
-        :param interface: Interface name.
+        :param iface_key: Interface key.
         :param ip_address: IP address.
         :param mac_address: MAC address.
-        :type interface: str
+        :type iface_key: str
         :type ip_address: str
         :type mac_address: str
         """
         self.exec_vat('add_ip_neighbor.vat',
-                      sw_if_index=self.get_sw_if_index(interface),
+                      sw_if_index=self.get_sw_if_index(iface_key),
                       ip_address=ip_address, mac_address=mac_address)
 
     def set_ip(self, interface, address, prefix_length):
@@ -255,7 +255,8 @@ class IPv4Setup(object):
                     continue
                 if node['type'] != NodeType.DUT:
                     continue
-                get_node(node).set_ip(port['if'], port['addr'], net['prefix'])
+                iface_key = topo.get_interface_by_name(node, port['if'])
+                get_node(node).set_ip(iface_key, port['addr'], net['prefix'])
                 interfaces.append((node, port['if']))
 
         return interfaces
@@ -263,18 +264,19 @@ class IPv4Setup(object):
     @staticmethod
     @keyword('Get IPv4 address of node "${node}" interface "${port}" '
              'from "${nodes_addr}"')
-    def get_ip_addr(node, interface, nodes_addr):
+    def get_ip_addr(node, iface_key, nodes_addr):
         """Return IPv4 address of the node port.
 
         :param node: Node in the topology.
-        :param interface: Interface name of the node.
+        :param iface_key: Interface key of the node.
         :param nodes_addr: Nodes IPv4 addresses.
         :type node: dict
-        :type interface: str
+        :type iface_key: str
         :type nodes_addr: dict
         :return: IPv4 address.
         :rtype: str
         """
+        interface = Topology.get_interface_name(node, iface_key)
         for net in nodes_addr.values():
             for port in net['ports'].values():
                 host = port.get('node')
@@ -305,27 +307,25 @@ class IPv4Setup(object):
         for node in nodes_info.values():
             if node['type'] == NodeType.TG:
                 continue
-            for interface, interface_data in node['interfaces'].iteritems():
-                interface_name = interface_data['name']
+            for iface_key in node['interfaces'].keys():
                 adj_node, adj_int = Topology.\
-                    get_adjacent_node_and_interface(nodes_info, node,
-                                                    interface_name)
-                ip_address = IPv4Setup.get_ip_addr(adj_node, adj_int['name'],
+                    get_adjacent_node_and_interface(nodes_info, node, iface_key)
+                ip_address = IPv4Setup.get_ip_addr(adj_node, adj_int,
                                                    nodes_addr)
-                mac_address = adj_int['mac_address']
-                get_node(node).set_arp(interface_name, ip_address, mac_address)
+                mac_address = Topology.get_interface_mac(adj_node, adj_int)
+                get_node(node).set_arp(iface_key, ip_address, mac_address)
 
     @staticmethod
-    def add_arp_on_dut(node, interface, ip_address, mac_address):
+    def add_arp_on_dut(node, iface_key, ip_address, mac_address):
         """Set ARP cache entree on DUT node.
 
         :param node: VPP Node in the topology.
-        :param interface: Interface name of the node.
+        :param iface_key: Interface key.
         :param ip_address: IP address of the interface.
         :param mac_address: MAC address of the interface.
         :type node: dict
-        :type interface: str
+        :type iface_key: str
         :type ip_address: str
         :type mac_address: str
         """
-        get_node(node).set_arp(interface, ip_address, mac_address)
+        get_node(node).set_arp(iface_key, ip_address, mac_address)
diff --git a/resources/libraries/python/IPv6NodesAddr.py b/resources/libraries/python/IPv6NodesAddr.py
index 133c861b27..0482cf3cf4 100644
--- a/resources/libraries/python/IPv6NodesAddr.py
+++ b/resources/libraries/python/IPv6NodesAddr.py
@@ -52,7 +52,8 @@ def get_variables(nodes, networks=IPV6_NETWORKS):
         port_idx = 0
         ports = {}
         for node in nodes.values():
-            if_name = topo.get_interface_by_link_name(node, link)
+            if_key = topo.get_interface_by_link_name(node, link)
+            if_name = topo.get_interface_name(node, if_key)
             if if_name is not None:
                 port = {'addr': str(next(net_hosts)),
                         'node': node['host'],
diff --git a/resources/libraries/python/IPv6Setup.py b/resources/libraries/python/IPv6Setup.py
index 12f6de7af9..2c68c338e2 100644
--- a/resources/libraries/python/IPv6Setup.py
+++ b/resources/libraries/python/IPv6Setup.py
@@ -78,7 +78,8 @@ class IPv6Setup(object):
                 if node is None:
                     continue
                 if node['type'] == NodeType.DUT:
-                    self.vpp_set_if_ipv6_addr(node, port['if'], port['addr'],
+                    port_key = topo.get_interface_by_name(node, port['if'])
+                    self.vpp_set_if_ipv6_addr(node, port_key, port['addr'],
                                               net['prefix'])
 
                     interfaces.append((node, port['if']))
@@ -156,19 +157,20 @@ class IPv6Setup(object):
             raise Exception('TG ifconfig failed')
 
     @staticmethod
-    def vpp_set_if_ipv6_addr(node, interface, addr, prefix):
+    def vpp_set_if_ipv6_addr(node, iface_key, addr, prefix):
         """Set IPv6 address on VPP.
 
         :param node: VPP node.
-        :param interface: Node interface.
+        :param iface_key: Node interface key.
         :param addr: IPv6 address.
         :param prefix: IPv6 address prefix.
         :type node: dict
-        :type interface: str
+        :type iface_key: str
         :type addr: str
         :type prefix: str
         """
-        sw_if_index = Topology.get_interface_sw_index(node, interface)
+        topo = Topology()
+        sw_if_index = Topology.get_interface_sw_index(node, iface_key)
         with VatTerminal(node) as vat:
             vat.vat_terminal_exec_cmd_from_template('add_ip_address.vat',
                                                     sw_if_index=sw_if_index,
@@ -274,11 +276,8 @@ class IPv6Setup(object):
         for node in nodes.values():
             if node['type'] == NodeType.TG:
                 continue
-            for port_k, port_v in node['interfaces'].items():
-                if_name = port_v.get('name')
-                if if_name is None:
-                    continue
-                self.vpp_ra_suppress_link_layer(node, if_name)
+            for port_k in node['interfaces'].keys():
+                self.vpp_ra_suppress_link_layer(node, port_k)
 
     @staticmethod
     def get_link_address(link, nodes_addr):
diff --git a/resources/libraries/python/IPv6Util.py b/resources/libraries/python/IPv6Util.py
index 35ec8d5258..437a7c0cbb 100644
--- a/resources/libraries/python/IPv6Util.py
+++ b/resources/libraries/python/IPv6Util.py
@@ -81,18 +81,19 @@ class IPv6Util(object):
         return IPv6Util.ipv6_ping(src_node, dst_ip, cnt, size, timeout)
 
     @staticmethod
-    def get_node_port_ipv6_address(node, interface, nodes_addr):
+    def get_node_port_ipv6_address(node, iface_key, nodes_addr):
         """Return IPv6 address of the node port.
 
         :param node: Node in the topology.
-        :param interface: Interface name of the node.
+        :param iface_key: Interface key of the node.
         :param nodes_addr: Nodes IPv6 addresses.
         :type node: dict
-        :type interface: str
+        :type iface_key: str
         :type nodes_addr: dict
         :return: IPv6 address string.
         :rtype: str
         """
+        interface = Topology.get_interface_name(node, iface_key)
         for net in nodes_addr.values():
             for port in net['ports'].values():
                 host = port.get('node')
diff --git a/resources/libraries/python/InterfaceUtil.py b/resources/libraries/python/InterfaceUtil.py
index a84d595767..7bf0584697 100644
--- a/resources/libraries/python/InterfaceUtil.py
+++ b/resources/libraries/python/InterfaceUtil.py
@@ -32,19 +32,36 @@ class InterfaceUtil(object):
     __UDEV_IF_RULES_FILE = '/etc/udev/rules.d/10-network.rules'
 
     @staticmethod
-    def set_interface_state(node, interface, state):
+    def set_interface_state(node, interface, state, if_type="key"):
         """Set interface state on a node.
 
         Function can be used for DUTs as well as for TGs.
 
         :param node: Node where the interface is.
-        :param interface: Interface name or sw_if_index.
+        :param interface: Interface key or sw_if_index or name.
         :param state: One of 'up' or 'down'.
+        :param if_type: Interface type
         :type node: dict
         :type interface: str or int
         :type state: str
+        :type if_type: str
         :return: nothing
         """
+
+        if if_type == "key":
+            if isinstance(interface, basestring):
+                sw_if_index = Topology.get_interface_sw_index(node, interface)
+                iface_name = Topology.get_interface_name(node, interface)
+            else:
+                sw_if_index = interface
+        elif if_type == "name":
+            iface_key = Topology.get_interface_by_name(node, interface)
+            if iface_key is not None:
+                sw_if_index = Topology.get_interface_sw_index(node, iface_key)
+            iface_name = interface
+        else:
+            raise ValueError("if_type unknown: {}".format(if_type))
+
         if node['type'] == NodeType.DUT:
             if state == 'up':
                 state = 'admin-up'
@@ -52,33 +69,26 @@ class InterfaceUtil(object):
                 state = 'admin-down'
             else:
                 raise ValueError('Unexpected interface state: {}'.format(state))
-
-            if isinstance(interface, basestring):
-                sw_if_index = Topology.get_interface_sw_index(node, interface)
-            else:
-                sw_if_index = interface
-
             VatExecutor.cmd_from_template(node, 'set_if_state.vat',
                                           sw_if_index=sw_if_index, state=state)
-
         elif node['type'] == NodeType.TG or node['type'] == NodeType.VM:
-            cmd = 'ip link set {} {}'.format(interface, state)
+            cmd = 'ip link set {} {}'.format(iface_name, state)
             exec_cmd_no_error(node, cmd, sudo=True)
         else:
             raise Exception('Node {} has unknown NodeType: "{}"'.
                             format(node['host'], node['type']))
 
     @staticmethod
-    def set_interface_ethernet_mtu(node, interface, mtu):
+    def set_interface_ethernet_mtu(node, iface_key, mtu):
         """Set Ethernet MTU for specified interface.
 
         Function can be used only for TGs.
 
         :param node: Node where the interface is.
-        :param interface: Interface name.
+        :param interface: Interface key from topology file.
         :param mtu: MTU to set.
         :type node: dict
-        :type interface: str
+        :type iface_key: str
         :type mtu: int
         :return: nothing
         """
@@ -86,7 +96,8 @@ class InterfaceUtil(object):
             ValueError('Node {}: Setting Ethernet MTU for interface '
                        'on DUT nodes not supported', node['host'])
         elif node['type'] == NodeType.TG:
-            cmd = 'ip link set {} mtu {}'.format(interface, mtu)
+            iface_name = Topology.get_interface_name(node, iface_key)
+            cmd = 'ip link set {} mtu {}'.format(iface_name, mtu)
             exec_cmd_no_error(node, cmd, sudo=True)
         else:
             raise ValueError('Node {} has unknown NodeType: "{}"'.
@@ -102,8 +113,8 @@ class InterfaceUtil(object):
         :type node: dict
         :return: nothing
         """
-        for ifc in node['interfaces'].values():
-            InterfaceUtil.set_interface_ethernet_mtu(node, ifc['name'], 1500)
+        for ifc in node['interfaces']:
+            InterfaceUtil.set_interface_ethernet_mtu(node, ifc, 1500)
 
     @staticmethod
     def vpp_node_interfaces_ready_wait(node, timeout=10):
@@ -444,7 +455,8 @@ class InterfaceUtil(object):
         :return: Name and index of created subinterface.
         :rtype: tuple
         """
-        sw_if_index = Topology.get_interface_sw_index(node, interface)
+        iface_key = Topology.get_interface_by_name(node, interface)
+        sw_if_index = Topology.get_interface_sw_index(node, iface_key)
 
         output = VatExecutor.cmd_from_template(node, "create_vlan_subif.vat",
                                                sw_if_index=sw_if_index,
diff --git a/resources/libraries/python/ssh.py b/resources/libraries/python/ssh.py
index 67193c11e2..a96a55f257 100644
--- a/resources/libraries/python/ssh.py
+++ b/resources/libraries/python/ssh.py
@@ -250,7 +250,7 @@ def exec_cmd(node, cmd, timeout=None, sudo=False):
     try:
         ssh.connect(node)
     except Exception, e:
-        logger.error("Failed to connect to node" + e)
+        logger.error("Failed to connect to node" + str(e))
         return None
 
     try:
diff --git a/resources/libraries/python/topology.py b/resources/libraries/python/topology.py
index 7e9400757e..80cbb1f4e1 100644
--- a/resources/libraries/python/topology.py
+++ b/resources/libraries/python/topology.py
@@ -58,10 +58,93 @@ class Topology(object):
     """Topology data manipulation and extraction methods.
 
     Defines methods used for manipulation and extraction of data from
-    the used topology.
+    the active topology.
+
+    "Active topology" contains initially data from the topology file and can be
+    extended with additional data from the DUTs like internal interface indexes
+    or names. Additional data which can be filled to the active topology are
+        - additional internal representation (index, name, ...)
+        - operational data (dynamic ports)
+
+    To access the port data it is recommended to use a port key because the key
+    does not rely on the data retrieved from nodes, this allows to call most of
+    the methods without having filled active topology with internal nodes data.
     """
 
     @staticmethod
+    def add_new_port(node, ptype):
+        """Add new port to the node to active topology.
+
+        :param node: Node to add new port on.
+        :param ptype: Port type, used as key prefix.
+        :type node: dict
+        :type ptype: str
+        :return: Port key or None
+        :rtype: string or None
+        """
+        max_ports = 1000000
+        iface = None
+        for i in range(1, max_ports):
+            if node['interfaces'].get(str(ptype) + str(i)) is None:
+                iface = str(ptype) + str(i)
+                node['interfaces'][iface] = dict()
+                break
+        return iface
+
+    @staticmethod
+    def remove_all_ports(node, ptype):
+        """Remove all ports with ptype as prefix.
+
+        :param node: Node to remove ports on.
+        :param: ptype: Port type, used as key prefix.
+        :type node: dict
+        :type ptype: str
+        :return: Nothing
+        """
+        for if_key in list(node['interfaces']):
+            if if_key.startswith(str(ptype)):
+                node['interfaces'].pop(if_key)
+
+    @staticmethod
+    def update_interface_sw_if_index(node, iface_key, sw_if_index):
+        """Update sw_if_index on the interface from the node.
+
+        :param node: Node to update sw_if_index on.
+        :param iface_key: Topology key of the interface.
+        :param sw_if_index: Internal index to store.
+        :type node: dict
+        :type iface_key: str
+        :type sw_if_index: int
+        """
+        node['interfaces'][iface_key]['vpp_sw_index'] = int(sw_if_index)
+
+    @staticmethod
+    def update_interface_mac_address(node, iface_key, mac_address):
+        """Update mac_address on the interface from the node.
+
+        :param node: Node to update MAC on.
+        :param iface_key: Topology key of the interface.
+        :param mac_address: MAC address.
+        :type node: dict
+        :type iface_key: str
+        :type mac_address: str
+        """
+        node['interfaces'][iface_key]['mac_address'] = str(mac_address)
+
+    @staticmethod
+    def update_interface_vhost_socket(node, iface_key, vhost_socket):
+        """Update vhost socket name on the interface from the node.
+
+        :param node: Node to update socket name on.
+        :param iface_key: Topology key of the interface.
+        :param vhost_socket: Path to named socket on node.
+        :type node: dict
+        :type iface_key: str
+        :type vhost_socket: str
+        """
+        node['interfaces'][iface_key]['vhost_socket'] = str(vhost_socket)
+
+    @staticmethod
     def get_node_by_hostname(nodes, hostname):
         """Get node from nodes of the topology by hostname.
 
@@ -99,35 +182,59 @@ class Topology(object):
 
     @staticmethod
     def _get_interface_by_key_value(node, key, value):
-        """Return node interface name according to key and value.
+        """Return node interface key from topology file
+        according to key and value.
 
         :param node: The node dictionary.
         :param key: Key by which to select the interface.
         :param value: Value that should be found using the key.
-        :return:
+        :type node: dict
+        :type key: string
+        :type value: string
+        :return: Interface key from topology file
+        :rtype: string
         """
         interfaces = node['interfaces']
         retval = None
-        for interface in interfaces.values():
-            k_val = interface.get(key)
+        for if_key, if_val in interfaces.iteritems():
+            k_val = if_val.get(key)
             if k_val is not None:
                 if k_val == value:
-                    retval = interface['name']
+                    retval = if_key
                     break
         return retval
 
-    def get_interface_by_link_name(self, node, link_name):
-        """Return interface name of link on node.
+    @staticmethod
+    def get_interface_by_name(node, iface_name):
+        """Return interface key based on name from DUT/TG.
+
+        This method returns interface key based on interface name
+        retrieved from the DUT, or TG.
+
+        :param node: The node topology dictionary.
+        :param iface_name: Interface name (string form).
+        :type node: dict
+        :type iface_name: string
+        :return: Interface key.
+        :rtype: str
+        """
+        return Topology._get_interface_by_key_value(node, "name", iface_name)
+
+    @staticmethod
+    def get_interface_by_link_name(node, link_name):
+        """Return interface key of link on node.
 
         This method returns the interface name associated with a given link
         for a given node.
 
-        :param link_name: Name of the link that a interface is connected to.
         :param node: The node topology dictionary.
-        :return: Interface name of the interface connected to the given link.
+        :param link_name: Name of the link that a interface is connected to.
+        :type node: dict
+        :type link_name: string
+        :return: Interface key of the interface connected to the given link.
         :rtype: str
         """
-        return self._get_interface_by_key_value(node, "link", link_name)
+        return Topology._get_interface_by_key_value(node, "link", link_name)
 
     def get_interfaces_by_link_names(self, node, link_names):
         """Return dictionary of dictionaries {"interfaceN", interface name}.
@@ -135,9 +242,11 @@ class Topology(object):
         This method returns the interface names associated with given links
         for a given node.
 
+        :param node: The node topology directory.
         :param link_names: List of names of the link that a interface is
         connected to.
-        :param node: The node topology directory.
+        :type node: dict
+        :type link_names: list
         :return: Dictionary of interface names that are connected to the given
         links.
         :rtype: dict
@@ -146,155 +255,119 @@ class Topology(object):
         interface_key_tpl = "interface{}"
         interface_number = 1
         for link_name in link_names:
-            interface_name = self.get_interface_by_link_name(node, link_name)
+            interface = self.get_interface_by_link_name(node, link_name)
+            interface_name = self.get_interface_name(node, interface)
             interface_key = interface_key_tpl.format(str(interface_number))
             retval[interface_key] = interface_name
             interface_number += 1
         return retval
 
-    def get_interface_by_sw_index(self, node, sw_index):
+    @staticmethod
+    def get_interface_by_sw_index(node, sw_index):
         """Return interface name of link on node.
 
         This method returns the interface name associated with a software
         interface index assigned to the interface by vpp for a given node.
 
-        :param sw_index: Sw_index of the link that a interface is connected to.
         :param node: The node topology dictionary.
+        :param sw_index: Sw_index of the link that a interface is connected to.
+        :type node: dict
+        :type sw_index: int
         :return: Interface name of the interface connected to the given link.
         :rtype: str
         """
-        return self._get_interface_by_key_value(node, "vpp_sw_index", sw_index)
+        return Topology._get_interface_by_key_value(node, "vpp_sw_index", sw_index)
 
     @staticmethod
-    def get_interface_sw_index(node, interface):
+    def get_interface_sw_index(node, iface_key):
         """Get VPP sw_if_index for the interface.
 
         :param node: Node to get interface sw_if_index on.
-        :param interface: Interface identifier.
+        :param iface_key: Interface key from topology file, or sw_index.
         :type node: dict
-        :type interface: str or int
+        :type iface_key: str/int
         :return: Return sw_if_index or None if not found.
         """
         try:
-            return int(interface)
-        except ValueError:
-            for port in node['interfaces'].values():
-                port_name = port.get('name')
-                if port_name == interface:
-                    return port.get('vpp_sw_index')
+            if isinstance(iface_key, basestring):
+                return node['interfaces'][iface_key].get('vpp_sw_index')
+            #FIXME: use only iface_key, do not use integer
+            else:
+                return int(iface_key)
+        except (KeyError, ValueError):
             return None
 
     @staticmethod
-    def get_interface_mtu(node, interface):
+    def get_interface_mtu(node, iface_key):
         """Get interface MTU.
 
         Returns physical layer MTU (max. size of Ethernet frame).
         :param node: Node to get interface MTU on.
-        :param interface: Interface name.
+        :param iface_key: Interface key from topology file.
         :type node: dict
-        :type interface: str
+        :type iface_key: str
         :return: MTU or None if not found.
         :rtype: int
         """
-        for port in node['interfaces'].values():
-            port_name = port.get('name')
-            if port_name == interface:
-                return port.get('mtu')
-
-        return None
+        try:
+            return node['interfaces'][iface_key].get('mtu')
+        except KeyError:
+            return None
 
     @staticmethod
-    def get_interface_mac_by_port_key(node, port_key):
-        """Get MAC address for the interface based on port key.
+    def get_interface_name(node, iface_key):
+        """Get interface name (retrieved from DUT/TG).
 
-        :param node: Node to get interface mac on.
-        :param port_key: Dictionary key name of interface.
+        Returns name in string format, retrieved from the node.
+        :param node: Node to get interface name on.
+        :param iface_key: Interface key from topology file.
         :type node: dict
-        :type port_key: str
-        :return: Return MAC or None if not found.
+        :type iface_key: str
+        :return: Interface name or None if not found.
+        :rtype: int
         """
-        for port_name, port_data in node['interfaces'].iteritems():
-            if port_name == port_key:
-                return port_data['mac_address']
-
-        return None
+        try:
+            return node['interfaces'][iface_key].get('name')
+        except KeyError:
+            return None
 
     @staticmethod
-    def get_interface_mac(node, interface):
+    def get_interface_mac(node, iface_key):
         """Get MAC address for the interface.
 
-        :param node: Node to get interface sw_index on.
-        :param interface: Interface name.
+        :param node: Node to get interface mac on.
+        :param iface_key: Interface key from topology file.
         :type node: dict
-        :type interface: str
+        :type iface_key: str
         :return: Return MAC or None if not found.
         """
-        for port in node['interfaces'].values():
-            port_name = port.get('name')
-            if port_name == interface:
-                return port.get('mac_address')
-
-        return None
-
-    @staticmethod
-    def get_adjacent_node_and_interface_by_key(nodes_info, node, port_key):
-        """Get node and interface adjacent to specified interface
-        on local network.
-
-        :param nodes_info: Dictionary containing information on all nodes
-        in topology.
-        :param node: Node that contains specified interface.
-        :param port_key: Interface port key.
-        :type nodes_info: dict
-        :type node: dict
-        :type port_key: str
-        :return: Return (node, interface info) tuple or None if not found.
-        :rtype: (dict, dict)
-        """
-        link_name = None
-        # get link name where the interface belongs to
-        for port_name, port_data in node['interfaces'].iteritems():
-            if port_name == 'mgmt':
-                continue
-            if port_name == port_key:
-                link_name = port_data['link']
-                break
-
-        if link_name is None:
+        try:
+            return node['interfaces'][iface_key].get('mac_address')
+        except KeyError:
             return None
 
-        # find link
-        for node_data in nodes_info.values():
-            # skip self
-            if node_data['host'] == node['host']:
-                continue
-            for interface, interface_data \
-                    in node_data['interfaces'].iteritems():
-                if 'link' not in interface_data:
-                    continue
-                if interface_data['link'] == link_name:
-                    return node_data, node_data['interfaces'][interface]
-
     @staticmethod
-    def get_adjacent_node_and_interface(nodes_info, node, interface_name):
+    def get_adjacent_node_and_interface(nodes_info, node, iface_key):
         """Get node and interface adjacent to specified interface
         on local network.
 
         :param nodes_info: Dictionary containing information on all nodes
         in topology.
         :param node: Node that contains specified interface.
-        :param interface_name: Interface name.
+        :param iface_key: Interface key from topology file.
         :type nodes_info: dict
         :type node: dict
-        :type interface_name: str
-        :return: Return (node, interface info) tuple or None if not found.
-        :rtype: (dict, dict)
+        :type iface_key: str
+        :return: Return (node, interface_key) tuple or None if not found.
+        :rtype: (dict, str)
         """
         link_name = None
         # get link name where the interface belongs to
-        for port_name, port_data in node['interfaces'].iteritems():
-            if port_data['name'] == interface_name:
-                link_name = port_data['link']
+        for if_key, if_val in node['interfaces'].iteritems():
+            if if_key == 'mgmt':
+                continue
+            if if_key == iface_key:
+                link_name = if_val['link']
                 break
 
         if link_name is None:
@@ -305,42 +378,42 @@ class Topology(object):
             # skip self
             if node_data['host'] == node['host']:
                 continue
-            for interface, interface_data \
+            for if_key, if_val \
                     in node_data['interfaces'].iteritems():
-                if 'link' not in interface_data:
+                if 'link' not in if_val:
                     continue
-                if interface_data['link'] == link_name:
-                    return node_data, node_data['interfaces'][interface]
+                if if_val['link'] == link_name:
+                    return node_data, if_key
 
     @staticmethod
-    def get_interface_pci_addr(node, interface):
+    def get_interface_pci_addr(node, iface_key):
         """Get interface PCI address.
 
         :param node: Node to get interface PCI address on.
-        :param interface: Interface name.
+        :param iface_key: Interface key from topology file.
         :type node: dict
-        :type interface: str
+        :type iface_key: str
         :return: Return PCI address or None if not found.
         """
-        for port in node['interfaces'].values():
-            if interface == port.get('name'):
-                return port.get('pci_address')
-        return None
+        try:
+            return node['interfaces'][iface_key].get('pci_address')
+        except KeyError:
+            return None
 
     @staticmethod
-    def get_interface_driver(node, interface):
+    def get_interface_driver(node, iface_key):
         """Get interface driver.
 
         :param node: Node to get interface driver on.
-        :param interface: Interface name.
+        :param iface_key: Interface key from topology file.
         :type node: dict
-        :type interface: str
+        :type iface_key: str
         :return: Return interface driver or None if not found.
         """
-        for port in node['interfaces'].values():
-            if interface == port.get('name'):
-                return port.get('driver')
-        return None
+        try:
+            return node['interfaces'][iface_key].get('driver')
+        except KeyError:
+            return None
 
     @staticmethod
     def get_node_link_mac(node, link_name):
@@ -442,8 +515,8 @@ class Topology(object):
         else:
             return connecting_links[0]
 
-    @keyword('Get egress interfaces on "${node1}" for link with "${node2}"')
-    def get_egress_interfaces_for_nodes(self, node1, node2):
+    @keyword('Get egress interfaces name on "${node1}" for link with "${node2}"')
+    def get_egress_interfaces_name_for_nodes(self, node1, node2):
         """Get egress interfaces on node1 for link with node2.
 
         :param node1: First node, node to get egress interface on.
@@ -469,19 +542,19 @@ class Topology(object):
             interfaces.append(name)
         return interfaces
 
-    @keyword('Get first egress interface on "${node1}" for link with '
+    @keyword('Get first egress interface name on "${node1}" for link with '
              '"${node2}"')
     def get_first_egress_interface_for_nodes(self, node1, node2):
         """Get first egress interface on node1 for link with node2.
 
-        :param node1: First node, node to get egress interface on.
+        :param node1: First node, node to get egress interface name on.
         :param node2: Second node.
         :type node1: dict
         :type node2: dict
-        :return: Egress interface.
+        :return: Egress interface name.
         :rtype: str
         """
-        interfaces = self.get_egress_interfaces_for_nodes(node1, node2)
+        interfaces = self.get_egress_interfaces_name_for_nodes(node1, node2)
         if not interfaces:
             raise RuntimeError('No egress interface for nodes')
         return interfaces[0]