CSIT-474: CSIT doc auto-generation

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

diff --git a/resources/libraries/python/topology.py b/resources/libraries/python/topology.py
index 20745eb..3c903e5 100644 (file)
--- a/resources/libraries/python/topology.py
+++ b/resources/libraries/python/topology.py
@@ -13,6 +13,8 @@
 
 """Defines nodes and topology structure."""
 
 
 """Defines nodes and topology structure."""
 

+from collections import Counter
+

 from yaml import load
 
 from robot.api import logger
 from yaml import load
 
 from robot.api import logger


@@ -27,12 +29,16 @@ def load_topo_from_yaml():
 
     :return: Nodes from loaded topology.
     """
 
     :return: Nodes from loaded topology.
     """

-    topo_path = BuiltIn().get_variable_value("${TOPOLOGY_PATH}")
+    try:
+        topo_path = BuiltIn().get_variable_value("${TOPOLOGY_PATH}")
+    except:
+        return ''

 
     with open(topo_path) as work_file:
         return load(work_file.read())['nodes']
 
 
 
     with open(topo_path) as work_file:
         return load(work_file.read())['nodes']
 
 

+# pylint: disable=invalid-name

 class NodeType(object):
     """Defines node types used in topology dictionaries."""
     # Device Under Test (this node has VPP running on it)
 class NodeType(object):
     """Defines node types used in topology dictionaries."""
     # Device Under Test (this node has VPP running on it)


@@ -44,6 +50,7 @@ class NodeType(object):
 
 
 class NodeSubTypeTG(object):
 
 
 class NodeSubTypeTG(object):

+    """Defines node sub-type TG - traffic generator."""

     # T-Rex traffic generator
     TREX = 'TREX'
     # Moongen
     # T-Rex traffic generator
     TREX = 'TREX'
     # Moongen


@@ -58,9 +65,92 @@ class Topology(object):
     """Topology data manipulation and extraction methods.
 
     Defines methods used for manipulation and extraction of data from
     """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.
     @staticmethod
     def get_node_by_hostname(nodes, hostname):
         """Get node from nodes of the topology by hostname.


@@ -99,35 +189,59 @@ class Topology(object):
 
     @staticmethod
     def _get_interface_by_key_value(node, key, value):
 
     @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.
 
         :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
         """
         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:
             if k_val is not None:
                 if k_val == value:

-                    retval = interface['name']
+                    retval = if_key

                     break
         return retval
 
                     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.
 
 
         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.
         :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
         """
         :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}.
 
     def get_interfaces_by_link_names(self, node, link_names):
         """Return dictionary of dictionaries {"interfaceN", interface name}.


@@ -135,9 +249,11 @@ class Topology(object):
         This method returns the interface names associated with given links
         for a given node.
 
         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 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
         :return: Dictionary of interface names that are connected to the given
         links.
         :rtype: dict


@@ -146,155 +262,267 @@ class Topology(object):
         interface_key_tpl = "interface{}"
         interface_number = 1
         for link_name in link_names:
         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
 
             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.
 
         """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 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: 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
 
     @staticmethod

-    def get_interface_sw_index(node, interface):
-        """Get VPP sw_if_index for the interface.
+    def get_interface_sw_index(node, iface_key):
+        """Get VPP sw_if_index for the interface using interface key.

 
         :param node: Node to get interface sw_if_index on.
 
         :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 node: dict

-        :type interface: str or int
+        :type iface_key: str/int

         :return: Return sw_if_index or None if not found.
         """
         try:
         :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
             return None
 
     @staticmethod

-    def get_interface_mtu(node, interface):
+    def get_interface_sw_index_by_name(node, iface_name):
+        """Get VPP sw_if_index for the interface using interface name.
+
+        :param node: Node to get interface sw_if_index on.
+        :param iface_name: Interface name.
+        :type node: dict
+        :type iface_name: str
+        :return: Return sw_if_index or None if not found.
+        :raises TypeError: If provided interface name is not a string.
+        """
+        try:
+            if isinstance(iface_name, basestring):
+                iface_key = Topology.get_interface_by_name(node, iface_name)
+                return node['interfaces'][iface_key].get('vpp_sw_index')
+            else:
+                raise TypeError("Interface name must be a string.")
+        except (KeyError, ValueError):
+            return None
+
+    @staticmethod
+    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.
         """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 node: dict

-        :type interface: str
+        :type iface_key: str

         :return: MTU or None if not found.
         :rtype: int
         """
         :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')
+        try:
+            return node['interfaces'][iface_key].get('mtu')
+        except KeyError:
+            return None

 
 

-        return None
+    @staticmethod
+    def get_interface_name(node, iface_key):
+        """Get interface name (retrieved from DUT/TG).
+
+        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 iface_key: str
+        :return: Interface name or None if not found.
+        :rtype: str
+        """
+        try:
+            return node['interfaces'][iface_key].get('name')
+        except KeyError:
+            return None

 
     @staticmethod
 
     @staticmethod

-    def get_interface_mac_by_port_key(node, port_key):
-        """Get MAC address for the interface based on port key.
+    def convert_interface_reference_to_key(node, interface):
+        """Takes interface reference in any format
+        (name, link name, interface key or sw_if_index)
+        and converts to interface key using Topology methods.
+
+        :param node: Node in topology.
+        :param interface: Name, sw_if_index, link name or key of an interface
+        on the node.
+        Valid formats are: sw_if_index, key, name.
+        :type node: dict
+        :type interface: str or int

 
 

-        :param node: Node to get interface mac on.
-        :param port_key: Dictionary key name of interface.
+        :return: Interface key.
+        :rtype: str
+
+        :raises TypeError: If provided with invalid interface argument.
+        :raises RuntimeError: If the interface does not exist in topology.
+        """
+
+        if isinstance(interface, int):
+            key = Topology.get_interface_by_sw_index(node, interface)
+            if key is None:
+                raise RuntimeError("Interface with sw_if_index={0} does not "
+                                   "exist in topology.".format(interface))
+        elif interface in Topology.get_node_interfaces(node):
+            key = interface
+        elif interface in Topology.get_links({"dut": node}):
+            key = Topology.get_interface_by_link_name(node, interface)
+        elif isinstance(interface, basestring):
+            key = Topology.get_interface_by_name(node, interface)
+            if key is None:
+                raise RuntimeError("Interface with key, name or link name "
+                                   "\"{0}\" does not exist in topology."
+                                   .format(interface))
+        else:
+            raise TypeError("Type of interface argument must be integer"
+                            " or string.")
+        return key
+
+    @staticmethod
+    def convert_interface_reference(node, interface, wanted_format):
+        """Takes interface reference in any format
+        (name, link name, topology key or sw_if_index) and returns
+        its equivalent in the desired format.
+
+        :param node: Node in topology.
+        :param interface: Name, sw_if_index, link name or key of an interface
+        on the node.
+        :param wanted_format: Format of return value wanted.
+        Valid options are: sw_if_index, key, name.

         :type node: dict
         :type node: dict

-        :type port_key: str
-        :return: Return MAC or None if not found.
+        :type interface: str or int
+        :type wanted_format: str
+
+        :return: Interface name, interface key or sw_if_index.
+        :rtype: str or int
+
+        :raises TypeError, ValueError: If provided with invalid arguments.
+        :raises RuntimeError: If the interface does not exist in topology.

         """
         """

-        for port_name, port_data in node['interfaces'].iteritems():
-            if port_name == port_key:
-                return port_data['mac_address']

 
 

-        return None
+        key = Topology.convert_interface_reference_to_key(node, interface)
+
+        conversions = {
+            "key": lambda x, y: y,
+            "name": Topology.get_interface_name,
+            "sw_if_index": Topology.get_interface_sw_index
+        }
+
+        try:
+            return conversions[wanted_format](node, key)
+        except KeyError:
+            raise ValueError("Unrecognized return value wanted: {0}."
+                             "Valid options are key, name, sw_if_index"
+                             .format(wanted_format))

 
     @staticmethod
 
     @staticmethod

-    def get_interface_mac(node, interface):
-        """Get MAC address for the interface.
+    def get_interface_numa_node(node, iface_key):
+        """Get interface numa node.

 
 

-        :param node: Node to get interface sw_index on.
-        :param interface: Interface name.
+        Returns physical relation to numa node, numa_id.
+
+        :param node: Node to get numa id on.
+        :param iface_key: Interface key from topology file.

         :type node: dict
         :type node: dict

-        :type interface: str
-        :return: Return MAC or None if not found.
+        :type iface_key: str
+        :return: numa node id, None if not available.
+        :rtype: int

         """
         """

-        for port in node['interfaces'].values():
-            port_name = port.get('name')
-            if port_name == interface:
-                return port.get('mac_address')
+        try:
+            return node['interfaces'][iface_key].get('numa_node')
+        except KeyError:
+            return None

 
 

-        return None
+    @staticmethod
+    def get_interfaces_numa_node(node, *iface_keys):
+        """Get numa node on which are located most of the interfaces.
+
+        Return numa node with highest count of interfaces provided as arguments.
+        Return 0 if the interface does not have numa_node information available.
+        If all interfaces have unknown location (-1), then return 0.
+        If most of interfaces have unknown location (-1), but there are
+        some interfaces with known location, then return the second most
+        location of the provided interfaces.
+
+        :param node: Node from DICT__nodes.
+        :param iface_keys: Interface keys for lookup.
+        :type node: dict
+        :type iface_keys: strings
+        """
+        numa_list = []
+        for if_key in iface_keys:
+            try:
+                numa_list.append(node['interfaces'][if_key].get('numa_node'))
+            except KeyError:
+                pass
+
+        numa_cnt_mc = Counter(numa_list).most_common()
+
+        if len(numa_cnt_mc) > 0 and numa_cnt_mc[0][0] != -1:
+            return numa_cnt_mc[0][0]
+        elif len(numa_cnt_mc) > 1 and numa_cnt_mc[0][0] == -1:
+            return numa_cnt_mc[1][0]
+        else:
+            return 0

 
     @staticmethod
 
     @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.
+    def get_interface_mac(node, iface_key):
+        """Get MAC address for the interface.

 
 

-        :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
+        :param node: Node to get interface mac on.
+        :param iface_key: Interface key from topology file.

         :type node: dict
         :type node: dict

-        :type port_key: str
-        :return: Return (node, interface info) tuple or None if not found.
-        :rtype: (dict, dict)
+        :type iface_key: str
+        :return: Return MAC or None if not found.

         """
         """

-        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
 
             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
     @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.
         """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 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
         """
         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:
                 break
 
         if link_name is None:


@@ -305,42 +533,53 @@ class Topology(object):
             # skip self
             if node_data['host'] == node['host']:
                 continue
             # skip self
             if node_data['host'] == node['host']:
                 continue

-            for interface, interface_data \
+            for if_key, if_val \

                     in node_data['interfaces'].iteritems():
                     in node_data['interfaces'].iteritems():

-                if 'link' not in interface_data:
+                if 'link' not in if_val:

                     continue
                     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
 
     @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.
         """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 node: dict

-        :type interface: str
+        :type iface_key: str

         :return: Return PCI address or None if not found.
         """
         :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
 
     @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.
         """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 node: dict

-        :type interface: str
+        :type iface_key: str

         :return: Return interface driver or None if not found.
         """
         :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_interfaces(node):
+        """Get all node interfaces.
+
+        :param node: Node to get list of interfaces from.
+        :type node: dict
+        :return: Return list of keys of all interfaces.
+        :rtype: list
+        """
+        return node['interfaces'].keys()

 
     @staticmethod
     def get_node_link_mac(node, link_name):
 
     @staticmethod
     def get_node_link_mac(node, link_name):


@@ -359,10 +598,13 @@ class Topology(object):
         return None
 
     @staticmethod
         return None
 
     @staticmethod

-    def _get_node_active_link_names(node):
+    def _get_node_active_link_names(node, filter_list=None):

         """Return list of link names that are other than mgmt links.
 
         :param node: Node topology dictionary.
         """Return list of link names that are other than mgmt links.
 
         :param node: Node topology dictionary.

+        :param filter_list: Link filter criteria.
+        :type node: dict
+        :type filter_list: list of strings

         :return: List of strings that represent link names occupied by the node.
         :rtype: list
         """
         :return: List of strings that represent link names occupied by the node.
         :rtype: list
         """


@@ -370,28 +612,53 @@ class Topology(object):
         link_names = []
         for interface in interfaces.values():
             if 'link' in interface:
         link_names = []
         for interface in interfaces.values():
             if 'link' in interface:

-                link_names.append(interface['link'])
+                if (filter_list is not None) and ('model' in interface):
+                    for filt in filter_list:
+                        if filt == interface['model']:
+                            link_names.append(interface['link'])
+                elif (filter_list is not None) and ('model' not in interface):
+                    logger.trace("Cannot apply filter on interface: {}"
+                                 .format(str(interface)))
+                else:
+                    link_names.append(interface['link'])

         if len(link_names) == 0:
             link_names = None
         return link_names
 
     @keyword('Get active links connecting "${node1}" and "${node2}"')
         if len(link_names) == 0:
             link_names = None
         return link_names
 
     @keyword('Get active links connecting "${node1}" and "${node2}"')

-    def get_active_connecting_links(self, node1, node2):
+    def get_active_connecting_links(self, node1, node2,
+                                    filter_list_node1=None,
+                                    filter_list_node2=None):

         """Return list of link names that connect together node1 and node2.
 
         :param node1: Node topology dictionary.
         :param node2: Node topology dictionary.
         """Return list of link names that connect together node1 and node2.
 
         :param node1: Node topology dictionary.
         :param node2: Node topology dictionary.

+        :param filter_list_node1: Link filter criteria for node1.
+        :param filter_list_node2: Link filter criteria for node2.

         :type node1: dict
         :type node2: dict
         :type node1: dict
         :type node2: dict

+        :type filter_list_node1: list of strings
+        :type filter_list_node2: list of strings

         :return: List of strings that represent connecting link names.
         :rtype: list
         """
 
         logger.trace("node1: {}".format(str(node1)))
         logger.trace("node2: {}".format(str(node2)))
         :return: List of strings that represent connecting link names.
         :rtype: list
         """
 
         logger.trace("node1: {}".format(str(node1)))
         logger.trace("node2: {}".format(str(node2)))

-        node1_links = self._get_node_active_link_names(node1)
-        node2_links = self._get_node_active_link_names(node2)
-        connecting_links = list(set(node1_links).intersection(node2_links))
+        node1_links = self._get_node_active_link_names(
+            node1,
+            filter_list=filter_list_node1)
+        node2_links = self._get_node_active_link_names(
+            node2,
+            filter_list=filter_list_node2)
+
+        connecting_links = None
+        if node1_links is None:
+            logger.error("Unable to find active links for node1")
+        elif node2_links is None:
+            logger.error("Unable to find active links for node2")
+        else:
+            connecting_links = list(set(node1_links).intersection(node2_links))

 
         return connecting_links
 
 
         return connecting_links
 


@@ -414,8 +681,9 @@ class Topology(object):
         else:
             return connecting_links[0]
 
         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.
         """Get egress interfaces on node1 for link with node2.
 
         :param node1: First node, node to get egress interface on.


@@ -441,19 +709,19 @@ class Topology(object):
             interfaces.append(name)
         return interfaces
 
             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.
 
              '"${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
         :param node2: Second node.
         :type node1: dict
         :type node2: dict

-        :return: Egress interface.
+        :return: Egress interface name.

         :rtype: str
         """
         :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]
         if not interfaces:
             raise RuntimeError('No egress interface for nodes')
         return interfaces[0]


@@ -522,3 +790,19 @@ class Topology(object):
         :rtype: str
         """
         return node['host']
         :rtype: str
         """
         return node['host']

+
+    @staticmethod
+    def set_interface_numa_node(node, iface_key, numa_node_id):
+        """Set interface numa_node location.
+
+        :param node: Node to set numa_node on.
+        :param iface_key: Interface key from topology file.
+        :type node: dict
+        :type iface_key: str
+        :return: Return iface_key or None if not found.
+        """
+        try:
+            node['interfaces'][iface_key]['numa_node'] = numa_node_id
+            return iface_key
+        except KeyError:
+            return None