-# Copyright (c) 2016 Cisco and/or its affiliates.
+# Copyright (c) 2018 Cisco and/or its affiliates.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at:
@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 interface: Interface name.
: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
class Tg(IPv4Node):
"""Traffic generator node"""
- def __init__(self, node_info):
- super(Tg, self).__init__(node_info)
+
+ # Implicit constructor is inherited.
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))
class Dut(IPv4Node):
"""Device under test"""
- def __init__(self, node_info):
- super(Dut, self).__init__(node_info)
+
+ # Implicit contructor is inherited.
def get_sw_if_index(self, interface):
"""Get sw_if_index of specified interface from current node.
: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)
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 = []
:type node: dict
:type iface_key: str
:type nodes_addr: dict
- :return: IPv4 address.
+ :returns: IPv4 address.
:rtype: str
"""
interface = Topology.get_interface_name(node, iface_key)
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(
interfaces from topology and use them to setup ARP entries.
:param nodes_info: Dictionary containing information on all nodes
- in topology.
+ in topology.
:param nodes_addr: Nodes IPv4 addresses.
:type nodes_info: dict
:type nodes_addr: dict