"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)
:returns: Nothing
"""
port_types = ('subinterface', 'vlan_subif', 'memif', 'tap', 'vhost',
- 'loopback', 'gre_tunnel', 'vxlan_tunnel')
+ 'loopback', 'gre_tunnel', 'vxlan_tunnel', 'eth_bond')
for node_data in nodes.values():
if node_data['type'] == NodeType.DUT:
"""
node['interfaces'][iface_key]['mac_address'] = str(mac_address)
+ @staticmethod
+ def update_interface_pci_address(node, iface_key, pci_address):
+ """Update pci_address on the interface from the node.
+
+ :param node: Node to update PCI on.
+ :param iface_key: Topology key of the interface.
+ :param pci_address: PCI address.
+ :type node: dict
+ :type iface_key: str
+ :type pci_address: str
+ """
+ node['interfaces'][iface_key]['pci_address'] = str(pci_address)
+
@staticmethod
def update_interface_vhost_socket(node, iface_key, vhost_socket):
"""Update vhost socket name on the interface from the node.
:param node: The node topology directory.
:param link_names: List of names of the link that a interface is
- connected to.
+ connected to.
:type node: dict
:type link_names: list
:returns: Dictionary of interface names that are connected to the given
- links.
+ links.
:rtype: dict
"""
retval = {}
:type node: dict
:type iface_key: str/int
:returns: Return sw_if_index or None if not found.
+ :rtype: int or None
"""
try:
if isinstance(iface_key, basestring):
return node['interfaces'][iface_key].get('vpp_sw_index')
# TODO: use only iface_key, do not use integer
- else:
- return int(iface_key)
+ return int(iface_key)
except (KeyError, ValueError):
return None
: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:
+ if not isinstance(iface_name, basestring):
raise TypeError("Interface name must be a string.")
+ iface_key = Topology.get_interface_by_name(node, iface_name)
+ return node['interfaces'][iface_key].get('vpp_sw_index')
except (KeyError, ValueError):
return None
: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.
+ on the node.
:type node: dict
:type interface: str or int
:param node: Node in topology.
:param interface: Name, sw_if_index, link name or key of an interface
- on the node.
+ on the node.
:param wanted_format: Format of return value wanted.
- Valid options are: sw_if_index, key, name.
+ Valid options are: sw_if_index, key, name.
:type node: dict
:type interface: str or int
:type wanted_format: str
-
:returns: 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.
"""
:param iface_keys: Interface keys for lookup.
:type node: dict
:type iface_keys: strings
+ :returns: Numa node of most given interfaces or 0.
+ :rtype: int
"""
numa_list = []
for if_key in iface_keys:
numa_cnt_mc = Counter(numa_list).most_common()
- if len(numa_cnt_mc) > 0 and numa_cnt_mc[0][0] != -1:
+ if numa_cnt_mc 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:
+ if len(numa_cnt_mc) > 1 and numa_cnt_mc[0][0] == -1:
return numa_cnt_mc[1][0]
- else:
- return 0
+ return 0
@staticmethod
def get_interface_mac(node, iface_key):
on local network.
:param nodes_info: Dictionary containing information on all nodes
- in topology.
+ in topology.
:param node: Node that contains specified interface.
:param iface_key: Interface key from topology file.
:type nodes_info: dict
continue
if if_val['link'] == link_name:
return node_data, if_key
+ return None
@staticmethod
def get_interface_pci_addr(node, iface_key):
:param filter_list: Link filter criteria.
:type node: dict
:type filter_list: list of strings
- :returns: List of strings representing link names occupied by the node.
- :rtype: list
+ :returns: List of link names occupied by the node.
+ :rtype: None or list of string
"""
interfaces = node['interfaces']
link_names = []
.format(str(interface)))
else:
link_names.append(interface['link'])
- if len(link_names) == 0:
+ if not link_names:
link_names = None
return link_names
:param node2: Connected node.
:type node1: dict
:type node2: dict
- :returns: Name of link connecting the two nodes together.
+ :returns: Name of a link connecting the two nodes together.
:rtype: str
- :raises: RuntimeError
+ :raises RuntimeError: If no links are found.
"""
connecting_links = self.get_active_connecting_links(node1, node2)
- if len(connecting_links) == 0:
+ if not connecting_links:
raise RuntimeError("No links connecting the nodes were found")
- else:
- return connecting_links[0]
+ return connecting_links[0]
@keyword('Get egress interfaces name on "${node1}" for link with '
'"${node2}"')
"""
interfaces = []
links = self.get_active_connecting_links(node1, node2)
- if len(links) == 0:
+ if not links:
raise RuntimeError('No link between nodes')
for interface in node1['interfaces'].values():
link = interface.get('link')
"""
return node['host']
+ @staticmethod
+ def get_node_arch(node):
+ """Return arch of the node.
+ Default to x86_64 if no arch present
+
+ :param node: Node created from topology.
+ :type node: dict
+ :returns: Node architecture
+ :rtype: str
+ """
+ try:
+ return node['arch']
+ except KeyError:
+ node['arch'] = 'x86_64'
+ return 'x86_64'
+
@staticmethod
def get_cryptodev(node):
"""Return Crytodev configuration of the node.
Code Review / csit.git / blobdiff