@staticmethod
def _get_netmask(prefix_length):
+ """Convert IPv4 network prefix length into IPV4 network mask.
+
+ :param prefix_length: Length of network prefix.
+ :type prefix_length: int
+ :returns: Network mask.
+ :rtype: str
+ """
+
bits = 0xffffffff ^ (1 << 32 - prefix_length) - 1
return inet_ntoa(pack('>I', bits))
:type interface: str
:type address: str
:type prefix_length: int
- :return: nothing
+ :returns: nothing
"""
pass
@abstractmethod
- def set_route(self, network, prefix_length, gateway, interface):
+ def set_route(self, network, prefix_length, gateway, interface, count=1):
"""Configure IPv4 route.
:param network: Network IPv4 address.
:param prefix_length: IPv4 prefix length.
:param gateway: IPv4 address of the gateway.
:param interface: Interface name.
+ :param count: Number of consecutive routes to add.
:type network: str
:type prefix_length: int
:type gateway: str
:type interface: str
- :return: nothing
+ :type route: int
+ :returns: nothing
"""
pass
:type prefix_length: int
:type gateway: str
:type interface: str
- :return: nothing
+ :returns: nothing
"""
pass
:param source_interface: Source interface name.
:type destination_address: str
:type source_interface: str
- :return: nothing
+ :returns: nothing
"""
pass
super(Tg, self).__init__(node_info)
def _execute(self, cmd):
+ """Executes the specified command on TG using SSH.
+
+ :param cmd: Command to be executed.
+ :type cmd: str
+ :returns: Content of stdout and stderr returned by command.
+ :rtype: tuple
+ """
return exec_cmd_no_error(self.node_info, cmd)
def _sudo_execute(self, cmd):
+ """Executes the specified command with sudo on TG using SSH.
+
+ :param cmd: Command to be executed.
+ :type cmd: str
+ :returns: Content of stdout and stderr returned by command.
+ :rtype: tuple
+ """
return exec_cmd_no_error(self.node_info, cmd, sudo=True)
def set_ip(self, interface, address, prefix_length):
interface)
self._sudo_execute(cmd)
- def set_route(self, network, prefix_length, gateway, interface):
+ def set_route(self, network, prefix_length, gateway, interface, count=1):
netmask = self._get_netmask(prefix_length)
cmd = 'route add -net {} netmask {} gw {}'.\
format(network, netmask, gateway)
format(network, prefix_length))
def arp_ping(self, destination_address, source_interface):
+ """Execute 'arping' command to send one ARP packet from the TG node.
+
+ :param destination_address: Destination IP address for the ARP packet.
+ :param source_interface: Name of an interface to send ARP packet from.
+ :type destination_address: str
+ :type source_interface: str
+ """
self._sudo_execute('arping -c 1 -I {} {}'.format(source_interface,
destination_address))
:param interface: Interface name.
:type interface: str
- :return: sw_if_index of the interface or None.
+ :returns: sw_if_index of the interface or None.
:rtype: int
"""
return Topology().get_interface_sw_index(self.node_info, interface)
:param args: Parameters to the script.
:type script: str
:type args: dict
- :return: nothing
+ :returns: nothing
"""
# 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):
sw_if_index=self.get_sw_if_index(interface),
address=address, prefix_length=prefix_length)
- def set_route(self, network, prefix_length, gateway, interface):
+ def set_route(self, network, prefix_length, gateway, interface, count=1):
Routing.vpp_route_add(self.node_info,
network=network, prefix_len=prefix_length,
- gateway=gateway, interface=interface)
+ gateway=gateway, interface=interface, count=count)
def unset_route(self, network, prefix_length, gateway, interface):
self.exec_vat('del_route.vat', network=network,
sw_if_index=self.get_sw_if_index(interface))
def arp_ping(self, destination_address, source_interface):
+ """Does nothing."""
pass
def flush_ip_addresses(self, interface):
:param node_info: Dictionary containing information on nodes in topology.
:type node_info: dict
- :return: Class instance that is derived from Node.
+ :returns: Class instance that is derived from Node.
"""
if node_info['type'] == NodeType.TG:
return Tg(node_info)
:param nodes_addr: Available nodes IPv4 addresses.
:type nodes: dict
:type nodes_addr: dict
- :return: Affected interfaces as list of (node, interface) tuples.
+ :returns: Affected interfaces as list of (node, interface) tuples.
:rtype: list
"""
interfaces = []
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
@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.
+ :returns: 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')
dev = port.get('if')
if host == node['host'] and dev == interface:
- ip = port.get('addr')
- if ip is not None:
- return ip
+ ip_addr = port.get('addr')
+ if ip_addr is not None:
+ return ip_addr
else:
raise Exception(
'Node {n} port {p} IPv4 address is not set'.format(
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: Node in the topology.
- :param interface: Interface name of the node.
+ :param node: VPP Node in the topology.
+ :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)
Code Review / csit.git / blobdiff