return dict()
return data
+ @staticmethod
+ def vpp_get_interface_mac(node, interface=None):
+ """Get MAC address for the given interface from actual interface dump.
+
+ :param node: VPP node to get interface data from.
+ :param interface: Numeric index or name string of a specific interface.
+ :type node: dict
+ :type interface: int or str
+ :return: MAC address.
+ :rtype: str
+ """
+
+ if_data = InterfaceUtil.vpp_get_interface_data(node, interface)
+ mac_data = [str(hex(item))[2:] for item in if_data['l2_address'][:6]]
+ mac_data_nice = []
+ for item in mac_data:
+ if len(item) == 1:
+ item = '0' + item
+ mac_data_nice.append(item)
+ mac = ":".join(mac_data_nice)
+ return mac
+
@staticmethod
def vpp_get_interface_ip_addresses(node, interface, ip_version):
"""Get list of IP addresses from an interface on a VPP node.
Note: A single interface may have multiple IP addresses assigned.
:rtype: list
"""
- sw_if_index = Topology.get_interface_sw_index(node, interface)
+ sw_if_index = InterfaceUtil.get_sw_if_index(node, interface)
with VatTerminal(node) as vat:
response = vat.vat_terminal_exec_cmd_from_template(
InterfaceUtil.tg_set_interfaces_udev_rules(node)
@staticmethod
- def update_all_interface_data_on_all_nodes(nodes):
+ def iface_update_numa_node(node):
+ """For all interfaces from topology file update numa node based on
+ information from the node.
+
+ :param node: Node from topology.
+ :type node: dict
+ :return: nothing
+ """
+ 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)
+ (ret, out, _) = ssh.exec_command(cmd)
+ if ret == 0:
+ Topology.set_interface_numa_node(node, if_key, int(out))
+
+ @staticmethod
+ def update_all_interface_data_on_all_nodes(nodes, skip_tg=False,
+ numa_node=False):
"""Update interface names on all nodes in DICT__nodes.
This method updates the topology dictionary by querying interface lists
of all nodes mentioned in the topology dictionary.
:param nodes: Nodes in the topology.
+ :param skip_tg: Skip TG node
+ :param numa_node: Retrieve numa_node location.
:type nodes: dict
+ :type skip_tg: bool
+ :type numa_node: bool
"""
for node_data in nodes.values():
if node_data['type'] == NodeType.DUT:
InterfaceUtil.update_vpp_interface_data_on_node(node_data)
- elif node_data['type'] == NodeType.TG:
+ elif node_data['type'] == NodeType.TG and not skip_tg:
InterfaceUtil.update_tg_interface_data_on_node(node_data)
+ if numa_node:
+ if node_data['type'] == NodeType.DUT:
+ InterfaceUtil.iface_update_numa_node(node_data)
+ elif node_data['type'] == NodeType.TG and not skip_tg:
+ InterfaceUtil.iface_update_numa_node(node_data)
+
@staticmethod
def create_vlan_subinterface(node, interface, vlan):
"""Create VLAN subinterface on node.
return {}
@staticmethod
- def create_subinterface(node, interface, sub_id, outer_vlan_id,
- inner_vlan_id, type_subif):
- """Create sub-interface on node.
+ 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).
:param node: Node to add sub-interface.
:param interface: Interface name on which create sub-interface.
:param sub_id: ID of the sub-interface to be created.
- :param outer_vlan_id: Outer VLAN ID.
- :param inner_vlan_id: Inner VLAN ID.
- :param type_subif: Type of sub-interface.
+ :param outer_vlan_id: Optional outer VLAN ID.
+ :param inner_vlan_id: Optional inner VLAN ID.
+ :param type_subif: Optional type of sub-interface. Values supported by
+ VPP: [no_tags] [one_tag] [two_tags] [dot1ad] [exact_match] [default_sub]
:type node: dict
:type interface: str or int
:type sub_id: int
:type outer_vlan_id: int
:type inner_vlan_id: int
:type type_subif: str
- :return: name and index of created sub-interface
+ :return: Name and index of created sub-interface.
:rtype: tuple
+ :raises RuntimeError: If it is not possible to create sub-interface.
"""
+ outer_vlan_id = 'outer_vlan_id {0}'.format(outer_vlan_id)\
+ if outer_vlan_id else ''
+
+ inner_vlan_id = 'inner_vlan_id {0}'.format(inner_vlan_id)\
+ if inner_vlan_id else ''
+
+ if type_subif is None:
+ type_subif = ''
+
if isinstance(interface, basestring):
- 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)
else:
sw_if_index = interface
logger.trace('Created subinterface with index {}'
.format(sw_subif_index))
else:
- raise RuntimeError('Unable to create subinterface on node {}'
+ raise RuntimeError('Unable to create sub-interface on node {}'
.format(node['host']))
- with VatTerminal(node) as vat:
+ with VatTerminal(node, json_param=False) as vat:
vat.vat_terminal_exec_cmd('exec show interfaces')
name = '{}.{}'.format(interface, sub_id)
ip_version=ip_version,
table_index=table_index)
+ @staticmethod
+ def get_interface_classify_table(node, interface):
+ """Get name of classify table for the given interface.
+
+ :param node: VPP node to get data from.
+ :param interface: Name or sw_if_index of a specific interface.
+ :type node: dict
+ :type interface: str or int
+ :return: Classify table name.
+ :rtype: str
+ """
+ if isinstance(interface, basestring):
+ sw_if_index = InterfaceUtil.get_sw_if_index(node, interface)
+ else:
+ sw_if_index = interface
+
+ with VatTerminal(node) as vat:
+ data = vat.vat_terminal_exec_cmd_from_template(
+ "classify_interface_table.vat",
+ sw_if_index=sw_if_index
+ )
+ return data[0]
+
@staticmethod
def get_sw_if_index(node, interface_name):
"""Get sw_if_index for the given interface from actual interface dump.
vat.vat_terminal_exec_cmd_from_template(
"proxy_arp_intfc_enable.vat",
sw_if_index=sw_if_index)
+
+ @staticmethod
+ def vpp_ip_source_check_setup(node, interface):
+ """Setup Reverse Path Forwarding source check on interface.
+
+ :param node: Node to setup RPF source check.
+ :param interface: Interface name to setup RPF source check.
+ :type node: dict
+ :type interface: str
+ """
+ with VatTerminal(node) as vat:
+ vat.vat_terminal_exec_cmd_from_template("ip_source_check.vat",
+ interface_name=interface)
+
+ @staticmethod
+ def assign_interface_to_fib_table(node, interface, table_id, ipv6=False):
+ """Assign VPP interface to specific VRF/FIB table.
+
+ :param node: VPP node where the FIB and interface are located.
+ :param interface: Interface to be assigned to FIB.
+ :param table_id: VRF table ID.
+ :param ipv6: Assign to IPv6 table. Default False.
+ :type node: dict
+ :type interface: str or int
+ :type table_id: int
+ :type ipv6: bool
+ """
+ if isinstance(interface, basestring):
+ sw_if_index = Topology.get_interface_sw_index(node, interface)
+ else:
+ sw_if_index = interface
+
+ ipv6 = 'ipv6' if ipv6 else ''
+
+ with VatTerminal(node) as vat:
+ vat.vat_terminal_exec_cmd_from_template("set_fib_to_interface.vat",
+ sw_index=sw_if_index,
+ vrf=table_id,
+ ipv6=ipv6)
+
+ @staticmethod
+ def set_linux_interface_mac(node, interface, mac, namespace=None):
+ """Set MAC address for interface in linux.
+
+ :param node: Node where to execute command.
+ :param interface: Interface in namespace.
+ :param mac: MAC to be assigned to interface.
+ :param namespace: Execute command in namespace. Optional
+ :type node: dict
+ :type interface: str
+ :type mac: str
+ :type namespace: str
+ """
+ if namespace is not None:
+ cmd = 'ip netns exec {} ip link set {} address {}'.format(
+ namespace, interface, mac)
+ else:
+ cmd = 'ip link set {} address {}'.format(interface, mac)
+ exec_cmd_no_error(node, cmd, sudo=True)