diff options
Diffstat (limited to 'resources/libraries/python')
| -rw-r--r-- | resources/libraries/python/IPv4NodeAddress.py | 98 | ||||
| -rw-r--r-- | resources/libraries/python/IPv4Setup.py | 309 | ||||
| -rw-r--r-- | resources/libraries/python/IPv4Util.py | 499 | ||||
| -rw-r--r-- | resources/libraries/python/InterfaceUtil.py | 54 | ||||
| -rw-r--r-- | resources/libraries/python/topology.py | 17 |
5 files changed, 462 insertions, 515 deletions
diff --git a/resources/libraries/python/IPv4NodeAddress.py b/resources/libraries/python/IPv4NodeAddress.py index 8db9ffafe3..49ce41b25c 100644 --- a/resources/libraries/python/IPv4NodeAddress.py +++ b/resources/libraries/python/IPv4NodeAddress.py @@ -18,6 +18,8 @@ """ from ipaddress import IPv4Network +from resources.libraries.python.topology import Topology + # Default list of IPv4 subnets IPV4_NETWORKS = ['20.20.20.0/24', '10.10.10.0/24', @@ -34,14 +36,14 @@ class IPv4NetworkGenerator(object): self._networks = list() for network in networks: net = IPv4Network(unicode(network)) - subnet, _ = network.split('/') - self._networks.append((net, subnet)) + self._networks.append(net) if len(self._networks) == 0: raise Exception('No IPv4 networks') def next_network(self): """ :return: next network in form (IPv4Network, subnet) + :raises: StopIteration if there are no more elements. """ if len(self._networks): return self._networks.pop() @@ -49,56 +51,44 @@ class IPv4NetworkGenerator(object): raise StopIteration() -def get_variables(networks=IPV4_NETWORKS[:]): - """ - Create dictionary of IPv4 addresses generated from provided subnet list. - - Example of returned dictionary: - network = { - 'NET1': { - 'subnet': '192.168.1.0', - 'prefix': 24, - 'port1': { - 'addr': '192.168.1.1', - }, - 'port2': { - 'addr': '192.168.1.0', - }, - }, - 'NET2': { - 'subnet': '192.168.2.0', - 'prefix': 24, - 'port1': { - 'addr': '192.168.2.1', - }, - 'port2': { - 'addr': '192.168.2.2', - }, - }, - } - - This function is called by RobotFramework automatically. - - :param networks: list of subnets in form a.b.c.d/length - :return: Dictionary of IPv4 addresses +def get_variables(nodes, networks=IPV4_NETWORKS[:]): + """Special robot framework method that returns dictionary nodes_ipv4_addr, + mapping of node and interface name to IPv4 adddress. + + :param nodes: Nodes of the test topology. + :param networks: list of available IPv4 networks + :type nodes: dict + :type networks: list + + .. note:: + Robot framework calls it automatically. """ - net_object = IPv4NetworkGenerator(networks) - - network = {} - interface_count_per_node = 2 - - for subnet_num in range(len(networks)): - net, net_str = net_object.next_network() - key = 'NET{}'.format(subnet_num + 1) - network[key] = { - 'subnet': net_str, - 'prefix': net.prefixlen, - } - hosts = net.hosts() - for port_num in range(interface_count_per_node): - port = 'port{}'.format(port_num + 1) - network[key][port] = { - 'addr': str(next(hosts)), - } - - return {'DICT__nodes_ipv4_addr': network} + topo = Topology() + links = topo.get_links(nodes) + + if len(links) > len(networks): + raise Exception('Not enough available IPv4 networks for topology.') + + ip4_n = IPv4NetworkGenerator(networks) + + nets = {} + + for link in links: + ip4_net = ip4_n.next_network() + net_hosts = ip4_net.hosts() + port_idx = 0 + ports = {} + for node in nodes.values(): + if_name = topo.get_interface_by_link_name(node, link) + if if_name is not None: + port = {'addr': str(next(net_hosts)), + 'node': node['host'], + 'if': if_name} + port_idx += 1 + port_id = 'port{0}'.format(port_idx) + ports.update({port_id: port}) + nets.update({link: {'net_addr': str(ip4_net.network_address), + 'prefix': ip4_net.prefixlen, + 'ports': ports}}) + + return {'DICT__nodes_ipv4_addr': nets} diff --git a/resources/libraries/python/IPv4Setup.py b/resources/libraries/python/IPv4Setup.py new file mode 100644 index 0000000000..ed65518254 --- /dev/null +++ b/resources/libraries/python/IPv4Setup.py @@ -0,0 +1,309 @@ +# Copyright (c) 2016 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: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""IPv4 setup library""" + +from socket import inet_ntoa +from struct import pack +from abc import ABCMeta, abstractmethod +from robot.api.deco import keyword + +import resources.libraries.python.ssh as ssh +from resources.libraries.python.Routing import Routing +from resources.libraries.python.InterfaceUtil import InterfaceUtil +from resources.libraries.python.topology import NodeType, Topology +from resources.libraries.python.VatExecutor import VatExecutor + + +class IPv4Node(object): + """Abstract class of a node in a topology.""" + __metaclass__ = ABCMeta + + def __init__(self, node_info): + self.node_info = node_info + + @staticmethod + def _get_netmask(prefix_length): + bits = 0xffffffff ^ (1 << 32 - prefix_length) - 1 + return inet_ntoa(pack('>I', bits)) + + @abstractmethod + def set_ip(self, interface, address, prefix_length): + """Configure IPv4 address on interface + + :param interface: interface name + :param address: + :param prefix_length: + :type interface: str + :type address: str + :type prefix_length: int + :return: nothing + """ + pass + + @abstractmethod + def set_route(self, network, prefix_length, gateway, interface): + """Configure IPv4 route + + :param network: network IPv4 address + :param prefix_length: mask length + :param gateway: IPv4 address of the gateway + :param interface: interface name + :type network: str + :type prefix_length: int + :type gateway: str + :type interface: str + :return: nothing + """ + pass + + @abstractmethod + def unset_route(self, network, prefix_length, gateway, interface): + """Remove specified IPv4 route + + :param network: network IPv4 address + :param prefix_length: mask length + :param gateway: IPv4 address of the gateway + :param interface: interface name + :type network: str + :type prefix_length: int + :type gateway: str + :type interface: str + :return: nothing + """ + pass + + @abstractmethod + def flush_ip_addresses(self, interface): + """Flush all IPv4 addresses from specified interface + + :param interface: interface name + :type interface: str + :return: nothing + """ + pass + + @abstractmethod + def ping(self, destination_address, source_interface): + """Send an ICMP request to destination node + + :param destination_address: address to send the ICMP request + :param source_interface: + :type destination_address: str + :type source_interface: str + :return: nothing + """ + pass + + +class Tg(IPv4Node): + """Traffic generator node""" + def __init__(self, node_info): + super(Tg, self).__init__(node_info) + + def _execute(self, cmd): + return ssh.exec_cmd_no_error(self.node_info, cmd) + + def _sudo_execute(self, cmd): + return ssh.exec_cmd_no_error(self.node_info, cmd, sudo=True) + + def set_ip(self, interface, address, prefix_length): + cmd = 'ip -4 addr flush dev {}'.format(interface) + self._sudo_execute(cmd) + cmd = 'ip addr add {}/{} dev {}'.format(address, prefix_length, + interface) + self._sudo_execute(cmd) + + def set_route(self, network, prefix_length, gateway, interface): + netmask = self._get_netmask(prefix_length) + cmd = 'route add -net {} netmask {} gw {}'.\ + format(network, netmask, gateway) + self._sudo_execute(cmd) + + def unset_route(self, network, prefix_length, gateway, interface): + self._sudo_execute('ip route delete {}/{}'. + format(network, prefix_length)) + + def arp_ping(self, destination_address, source_interface): + self._sudo_execute('arping -c 1 -I {} {}'.format(source_interface, + destination_address)) + + def ping(self, destination_address, source_interface): + self._execute('ping -c 1 -w 5 -I {} {}'.format(source_interface, + destination_address)) + + def flush_ip_addresses(self, interface): + self._sudo_execute('ip addr flush dev {}'.format(interface)) + + +class Dut(IPv4Node): + """Device under test""" + def __init__(self, node_info): + super(Dut, self).__init__(node_info) + + 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 'int' type + """ + return Topology().get_interface_sw_index(self.node_info, interface) + + def exec_vat(self, script, **args): + """Wrapper for VAT executor. + + :param script: script to execute + :param args: parameters to the script + :type script: str + :type args: dict + :return: nothing + """ + # TODO: check return value + VatExecutor.cmd_from_template(self.node_info, script, **args) + + def set_arp(self, interface, ip_address, mac_address): + """Set entry in ARP cache. + + :param interface: Interface name. + :param ip_address: IP address. + :param mac_address: MAC address. + :type interface: 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), + ip_address=ip_address, mac_address=mac_address) + + def set_ip(self, interface, address, prefix_length): + self.exec_vat('add_ip_address.vat', + sw_if_index=self.get_sw_if_index(interface), + address=address, prefix_length=prefix_length) + + def set_route(self, network, prefix_length, gateway, interface): + Routing.vpp_route_add(self.node_info, + network=network, prefix_len=prefix_length, + gateway=gateway, interface=interface) + + def unset_route(self, network, prefix_length, gateway, interface): + self.exec_vat('del_route.vat', network=network, + prefix_length=prefix_length, gateway=gateway, + sw_if_index=self.get_sw_if_index(interface)) + + def arp_ping(self, destination_address, source_interface): + pass + + def flush_ip_addresses(self, interface): + self.exec_vat('flush_ip_addresses.vat', + sw_if_index=self.get_sw_if_index(interface)) + + def ping(self, destination_address, source_interface): + pass + + +def get_node(node_info): + """Creates a class instance derived from Node based on type. + + :param node_info: dictionary containing information on nodes in topology + :return: Class instance that is derived from Node + """ + if node_info['type'] == NodeType.TG: + return Tg(node_info) + elif node_info['type'] == NodeType.DUT: + return Dut(node_info) + else: + raise NotImplementedError('Node type "{}" unsupported!'. + format(node_info['type'])) + + +class IPv4Setup(object): + """IPv4 setup in topology.""" + + @staticmethod + def vpp_nodes_setup_ipv4_addresses(nodes, nodes_addr): + """Setup IPv4 addresses on all VPP nodes in topology. + + :param nodes: Nodes of the test topology. + :param nodes_addr: Available nodes IPv4 adresses. + :type nodes: dict + :type nodes_addr: dict + """ + for net in nodes_addr.values(): + for port in net['ports'].values(): + host = port.get('node') + if host is None: + continue + topo = Topology() + node = topo.get_node_by_hostname(nodes, host) + if node is None: + continue + if node['type'] != NodeType.DUT: + continue + get_node(node).set_ip(port['if'], port['addr'], net['prefix']) + InterfaceUtil.set_interface_state(node, port['if'], 'up') + + @staticmethod + @keyword('Get IPv4 address of node "${node}" interface "${port}" ' + 'from "${nodes_addr}"') + def get_ip_addr(node, interface, nodes_addr): + """Return IPv4 address of the node port. + :param node: Node in the topology. + :param interface: Interface name of the node. + :param nodes_addr: Nodes IPv4 adresses. + :type node: dict + :type interface: str + :type nodes_addr: dict + :return: IPv4 address string + """ + 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 + else: + raise Exception( + 'Node {n} port {p} IPv4 address is not set'.format( + n=node['host'], p=interface)) + + raise Exception('Node {n} port {p} IPv4 address not found.'.format( + n=node['host'], p=interface)) + + @staticmethod + def setup_arp_on_all_duts(nodes_info, nodes_addr): + """For all DUT nodes extract MAC and IP addresses of adjacent + interfaces from topology and use them to setup ARP entries. + + :param nodes_info: Dictionary containing information on all nodes + in topology. + :param nodes_addr: Nodes IPv4 adresses. + :type nodes_info: dict + :type nodes_addr: dict + """ + for node in nodes_info.values(): + if node['type'] == NodeType.TG: + continue + for interface, interface_data in node['interfaces'].iteritems(): + if interface == 'mgmt': + continue + interface_name = interface_data['name'] + 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'], + nodes_addr) + mac_address = adj_int['mac_address'] + get_node(node).set_arp(interface_name, ip_address, mac_address)
\ No newline at end of file diff --git a/resources/libraries/python/IPv4Util.py b/resources/libraries/python/IPv4Util.py index d3a016d767..30e185c9ff 100644 --- a/resources/libraries/python/IPv4Util.py +++ b/resources/libraries/python/IPv4Util.py @@ -13,430 +13,26 @@ """Implements IPv4 RobotFramework keywords""" -from socket import inet_ntoa -from struct import pack -from abc import ABCMeta, abstractmethod -import copy - from robot.api import logger as log from robot.api.deco import keyword -from robot.utils.asserts import assert_not_equal -import resources.libraries.python.ssh as ssh from resources.libraries.python.topology import Topology from resources.libraries.python.topology import NodeType -from resources.libraries.python.VatExecutor import VatExecutor from resources.libraries.python.TrafficScriptExecutor\ import TrafficScriptExecutor - - -class IPv4Node(object): - """Abstract class of a node in a topology.""" - __metaclass__ = ABCMeta - - def __init__(self, node_info): - self.node_info = node_info - - @staticmethod - def _get_netmask(prefix_length): - bits = 0xffffffff ^ (1 << 32 - prefix_length) - 1 - return inet_ntoa(pack('>I', bits)) - - @abstractmethod - def set_ip(self, interface, address, prefix_length): - """Configure IPv4 address on interface - - :param interface: interface name - :param address: - :param prefix_length: - :type interface: str - :type address: str - :type prefix_length: int - :return: nothing - """ - pass - - @abstractmethod - def set_interface_state(self, interface, state): - """Set interface state - - :param interface: interface name string - :param state: one of following values: "up" or "down" - :return: nothing - """ - pass - - @abstractmethod - def set_route(self, network, prefix_length, gateway, interface): - """Configure IPv4 route - - :param network: network IPv4 address - :param prefix_length: mask length - :param gateway: IPv4 address of the gateway - :param interface: interface name - :type network: str - :type prefix_length: int - :type gateway: str - :type interface: str - :return: nothing - """ - pass - - @abstractmethod - def unset_route(self, network, prefix_length, gateway, interface): - """Remove specified IPv4 route - - :param network: network IPv4 address - :param prefix_length: mask length - :param gateway: IPv4 address of the gateway - :param interface: interface name - :type network: str - :type prefix_length: int - :type gateway: str - :type interface: str - :return: nothing - """ - pass - - @abstractmethod - def flush_ip_addresses(self, interface): - """Flush all IPv4 addresses from specified interface - - :param interface: interface name - :type interface: str - :return: nothing - """ - pass - - @abstractmethod - def ping(self, destination_address, source_interface): - """Send an ICMP request to destination node - - :param destination_address: address to send the ICMP request - :param source_interface: - :type destination_address: str - :type source_interface: str - :return: nothing - """ - pass - - -class Tg(IPv4Node): - """Traffic generator node""" - def __init__(self, node_info): - super(Tg, self).__init__(node_info) - - def _execute(self, cmd): - return ssh.exec_cmd_no_error(self.node_info, cmd) - - def _sudo_execute(self, cmd): - return ssh.exec_cmd_no_error(self.node_info, cmd, sudo=True) - - def set_ip(self, interface, address, prefix_length): - cmd = 'ip -4 addr flush dev {}'.format(interface) - self._sudo_execute(cmd) - cmd = 'ip addr add {}/{} dev {}'.format(address, prefix_length, - interface) - self._sudo_execute(cmd) - - # TODO: not ipv4-specific, move to another class - def set_interface_state(self, interface, state): - cmd = 'ip link set {} {}'.format(interface, state) - self._sudo_execute(cmd) - - def set_route(self, network, prefix_length, gateway, interface): - netmask = self._get_netmask(prefix_length) - cmd = 'route add -net {} netmask {} gw {}'.\ - format(network, netmask, gateway) - self._sudo_execute(cmd) - - def unset_route(self, network, prefix_length, gateway, interface): - self._sudo_execute('ip route delete {}/{}'. - format(network, prefix_length)) - - def arp_ping(self, destination_address, source_interface): - self._sudo_execute('arping -c 1 -I {} {}'.format(source_interface, - destination_address)) - - def ping(self, destination_address, source_interface): - self._execute('ping -c 1 -w 5 -I {} {}'.format(source_interface, - destination_address)) - - def flush_ip_addresses(self, interface): - self._sudo_execute('ip addr flush dev {}'.format(interface)) - - -class Dut(IPv4Node): - """Device under test""" - def __init__(self, node_info): - super(Dut, self).__init__(node_info) - - 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 'int' type - """ - return Topology().get_interface_sw_index(self.node_info, interface) - - def exec_vat(self, script, **args): - """Wrapper for VAT executor. - - :param script: script to execute - :param args: parameters to the script - :type script: str - :type args: dict - :return: nothing - """ - # TODO: check return value - VatExecutor.cmd_from_template(self.node_info, script, **args) - - def set_arp(self, interface, ip_address, mac_address): - """Set entry in ARP cache. - - :param interface: Interface name. - :param ip_address: IP address. - :param mac_address: MAC address. - :type interface: 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), - ip_address=ip_address, mac_address=mac_address) - - def set_ip(self, interface, address, prefix_length): - self.exec_vat('add_ip_address.vat', - sw_if_index=self.get_sw_if_index(interface), - address=address, prefix_length=prefix_length) - - def set_interface_state(self, interface, state): - if state == 'up': - state = 'admin-up link-up' - elif state == 'down': - state = 'admin-down link-down' - else: - raise Exception('Unexpected interface state: {}'.format(state)) - - self.exec_vat('set_if_state.vat', - sw_if_index=self.get_sw_if_index(interface), state=state) - - def set_route(self, network, prefix_length, gateway, interface): - sw_if_index = self.get_sw_if_index(interface) - self.exec_vat('add_route.vat', - network=network, prefix_length=prefix_length, - gateway=gateway, sw_if_index=sw_if_index) - - def unset_route(self, network, prefix_length, gateway, interface): - self.exec_vat('del_route.vat', network=network, - prefix_length=prefix_length, gateway=gateway, - sw_if_index=self.get_sw_if_index(interface)) - - def arp_ping(self, destination_address, source_interface): - pass - - def flush_ip_addresses(self, interface): - self.exec_vat('flush_ip_addresses.vat', - sw_if_index=self.get_sw_if_index(interface)) - - def ping(self, destination_address, source_interface): - pass - - -def get_node(node_info): - """Creates a class instance derived from Node based on type. - - :param node_info: dictionary containing information on nodes in topology - :return: Class instance that is derived from Node - """ - if node_info['type'] == NodeType.TG: - return Tg(node_info) - elif node_info['type'] == NodeType.DUT: - return Dut(node_info) - else: - raise NotImplementedError('Node type "{}" unsupported!'. - format(node_info['type'])) - - -def get_node_hostname(node_info): - """Get string identifying specifed node. - - :param node_info: Node in the topology. - :type node_info: Dict - :return: String identifying node. - """ - return node_info['host'] +from resources.libraries.python.IPv4Setup import get_node class IPv4Util(object): """Implements keywords for IPv4 tests.""" - ADDRESSES = {} # holds configured IPv4 addresses - PREFIXES = {} # holds configured IPv4 addresses' prefixes - SUBNETS = {} # holds configured IPv4 addresses' subnets - - """ - Helper dictionary used when setting up ipv4 addresses in topology - - Example value: - 'link1': { b'port1': {b'addr': b'192.168.3.1'}, - b'port2': {b'addr': b'192.168.3.2'}, - b'prefix': 24, - b'subnet': b'192.168.3.0'} - """ - topology_helper = None - - @staticmethod - def setup_arp_on_all_duts(nodes_info): - """For all DUT nodes extract MAC and IP addresses of adjacent interfaces - from topology and use them to setup ARP entries. - - :param nodes_info: Dictionary containing information on all nodes - in topology. - :type nodes_info: dict - """ - for node in nodes_info.values(): - if node['type'] == NodeType.TG: - continue - for interface, interface_data in node['interfaces'].iteritems(): - if interface == 'mgmt': - continue - interface_name = interface_data['name'] - adj_node, adj_int = Topology.\ - get_adjacent_node_and_interface(nodes_info, node, - interface_name) - ip_address = IPv4Util.get_ip_addr(adj_node, adj_int['name']) - mac_address = adj_int['mac_address'] - get_node(node).set_arp(interface_name, ip_address, mac_address) - - @staticmethod - def next_address(subnet): - """Get next unused IPv4 address from a subnet - - :param subnet: holds available IPv4 addresses - :return: tuple (ipv4_address, prefix_length) - """ - for i in range(1, 4): - # build a key and try to get it from address dictionary - interface = 'port{}'.format(i) - if interface in subnet: - addr = subnet[interface]['addr'] - del subnet[interface] - return addr, subnet['prefix'] - raise Exception('Not enough ipv4 addresses in subnet') - - @staticmethod - def next_network(nodes_addr): - """Get next unused network from dictionary - - :param nodes_addr: dictionary of available networks - :return: dictionary describing an IPv4 subnet with addresses - """ - assert_not_equal(len(nodes_addr), 0, 'Not enough networks') - _, subnet = nodes_addr.popitem() - return subnet - - @staticmethod - def configure_ipv4_addr_on_node(node, nodes_addr): - """Configure IPv4 address for all non-management interfaces - on a node in topology. - - :param node: dictionary containing information about node - :param nodes_addr: dictionary containing IPv4 addresses - :return: - """ - for interface, interface_data in node['interfaces'].iteritems(): - if interface == 'mgmt': - continue - if interface_data['link'] not in IPv4Util.topology_helper: - IPv4Util.topology_helper[interface_data['link']] = \ - IPv4Util.next_network(nodes_addr) - - network = IPv4Util.topology_helper[interface_data['link']] - address, prefix = IPv4Util.next_address(network) - - if node['type'] != NodeType.TG: - get_node(node).set_ip(interface_data['name'], address, prefix) - get_node(node).set_interface_state(interface_data['name'], 'up') - - key = (get_node_hostname(node), interface_data['name']) - IPv4Util.ADDRESSES[key] = address - IPv4Util.PREFIXES[key] = prefix - IPv4Util.SUBNETS[key] = network['subnet'] - - @staticmethod - def dut_nodes_setup_ipv4_addresses(nodes_info, nodes_addr): - """Configure IPv4 addresses on all non-management interfaces for each - node in nodes_info if node type is not traffic generator - - :param nodes_info: dictionary containing information on all nodes - in topology - :param nodes_addr: dictionary containing IPv4 addresses - :return: nothing - """ - IPv4Util.topology_helper = {} - # make a deep copy of nodes_addr because of modifications - nodes_addr_copy = copy.deepcopy(nodes_addr) - for node in nodes_info.values(): - IPv4Util.configure_ipv4_addr_on_node(node, nodes_addr_copy) - - @staticmethod - def nodes_clear_ipv4_addresses(nodes): - """Clear all addresses from all nodes in topology - - :param nodes: dictionary containing information on all nodes - :return: nothing - """ - for node in nodes.values(): - for interface, interface_data in node['interfaces'].iteritems(): - if interface == 'mgmt': - continue - IPv4Util.flush_ip_addresses(interface_data['name'], node) - - # TODO: not ipv4-specific, move to another class - @staticmethod - @keyword('Node "${node}" interface "${interface}" is in "${state}" state') - def set_interface_state(node, interface, state): - """See IPv4Node.set_interface_state for more information. - - :param node: - :param interface: - :param state: - :return: - """ - log.debug('Node {} interface {} is in {} state'.format( - get_node_hostname(node), interface, state)) - get_node(node).set_interface_state(interface, state) - - @staticmethod - @keyword('Node "${node}" interface "${port}" has IPv4 address ' - '"${address}" with prefix length "${prefix_length}"') - def set_interface_address(node, interface, address, length): - """See IPv4Node.set_ip for more information. - - :param node: - :param interface: - :param address: - :param length: - :return: - """ - log.debug('Node {} interface {} has IPv4 address {} with prefix ' - 'length {}'.format(get_node_hostname(node), interface, - address, length)) - get_node(node).set_ip(interface, address, int(length)) - hostname = get_node_hostname(node) - IPv4Util.ADDRESSES[hostname, interface] = address - IPv4Util.PREFIXES[hostname, interface] = int(length) - # TODO: Calculate subnet from ip address and prefix length. - # IPv4Util.SUBNETS[hostname, interface] = - @staticmethod @keyword('From node "${node}" interface "${port}" ARP-ping ' 'IPv4 address "${ip_address}"') def arp_ping(node, interface, ip_address): log.debug('From node {} interface {} ARP-ping IPv4 address {}'. - format(get_node_hostname(node), interface, ip_address)) + format(Topology.get_node_hostname(node), + interface, ip_address)) get_node(node).arp_ping(ip_address, interface) @staticmethod @@ -454,40 +50,28 @@ class IPv4Util(object): :return: """ log.debug('Node {} routes to network {} with prefix length {} ' - 'via {} interface {}'.format(get_node_hostname(node), + 'via {} interface {}'.format(Topology.get_node_hostname(node), network, prefix_length, gateway, interface)) get_node(node).set_route(network, int(prefix_length), gateway, interface) @staticmethod - @keyword('Remove IPv4 route from "${node}" to network "${network}" with ' - 'prefix length "${prefix_length}" interface "${interface}" via ' - '"${gateway}"') - def unset_route(node, network, prefix_length, interface, gateway): - """See IPv4Node.unset_route for more information. - - :param node: - :param network: - :param prefix_length: - :param interface: - :param gateway: - :return: - """ - get_node(node).unset_route(network, prefix_length, gateway, interface) - - @staticmethod @keyword('After ping is sent in topology "${nodes_info}" from node ' - '"${src_node}" interface "${src_port}" with destination IPv4 ' - 'address of node "${dst_node}" interface "${dst_port}" a ping ' - 'response arrives and TTL is decreased by "${hops}"') - def send_ping(nodes_info, src_node, src_port, dst_node, dst_port, hops): + '"${src_node}" interface "${src_port}" "${src_ip}" with ' + 'destination IPv4 address "${dst_ip}" of node "${dst_node}" ' + 'interface "${dst_port}" a ping response arrives and TTL is ' + 'decreased by "${hops}"') + def send_ping(nodes_info, src_node, src_port, src_ip, dst_ip, dst_node, + dst_port, hops): """Send IPv4 ping and wait for response. :param nodes_info: Dictionary containing information on all nodes in topology. :param src_node: Source node. :param src_port: Source interface. + :param src_ip: Source ipv4 address. + :param dst_ip: Destination ipv4 address. :param dst_node: Destination node. :param dst_port: Destination interface. :param hops: Number of hops between src_node and dst_node. @@ -495,61 +79,58 @@ class IPv4Util(object): log.debug('After ping is sent from node "{}" interface "{}" ' 'with destination IPv4 address of node "{}" interface "{}" ' 'a ping response arrives and TTL is decreased by "${}"'. - format(get_node_hostname(src_node), src_port, - get_node_hostname(dst_node), dst_port, hops)) - node = src_node + format(Topology.get_node_hostname(src_node), src_port, + Topology.get_node_hostname(dst_node), dst_port, hops)) + dst_mac = None src_mac = Topology.get_interface_mac(src_node, src_port) if dst_node['type'] == NodeType.TG: dst_mac = Topology.get_interface_mac(src_node, src_port) _, adj_int = Topology.\ get_adjacent_node_and_interface(nodes_info, src_node, src_port) first_hop_mac = adj_int['mac_address'] - src_ip = IPv4Util.get_ip_addr(src_node, src_port) - dst_ip = IPv4Util.get_ip_addr(dst_node, dst_port) args = '--src_if "{}" --src_mac "{}" --first_hop_mac "{}" ' \ '--src_ip "{}" --dst_ip "{}" --hops "{}"'\ .format(src_port, src_mac, first_hop_mac, src_ip, dst_ip, hops) if dst_node['type'] == NodeType.TG: args += ' --dst_if "{}" --dst_mac "{}"'.format(dst_port, dst_mac) TrafficScriptExecutor.run_traffic_script_on_node( - "ipv4_ping_ttl_check.py", node, args) + "ipv4_ping_ttl_check.py", src_node, args) @staticmethod - @keyword('Get IPv4 address of node "${node}" interface "${port}"') - def get_ip_addr(node, port): - """Get IPv4 address configured on specified interface - - :param node: node dictionary - :param port: interface name - :return: IPv4 address of specified interface as a 'str' type - """ - log.debug('Get IPv4 address of node {} interface {}'. - format(get_node_hostname(node), port)) - return IPv4Util.ADDRESSES[(get_node_hostname(node), port)] - - @staticmethod - @keyword('Get IPv4 address prefix of node "${node}" interface "${port}"') - def get_ip_addr_prefix(node, port): + @keyword('Get IPv4 address prefix of node "${node}" interface "${port}" ' + 'from "${nodes_addr}"') + def get_ip_addr_prefix_length(node, port, nodes_addr): """ Get IPv4 address prefix for specified interface. :param node: Node dictionary. :param port: Interface name. + :return: IPv4 prefix length """ - log.debug('Get IPv4 address prefix of node {} interface {}'. - format(get_node_hostname(node), port)) - return IPv4Util.PREFIXES[(get_node_hostname(node), port)] + for net in nodes_addr.values(): + for p in net['ports'].values(): + if p['node'] == node['host'] and p['if'] == port: + return net['prefix'] + + raise Exception('Subnet not found for node {n} port {p}'. + format(n=node['host'], p=port)) @staticmethod - @keyword('Get IPv4 subnet of node "${node}" interface "${port}"') - def get_ip_addr_subnet(node, port): + @keyword('Get IPv4 subnet of node "${node}" interface "${port}" from ' + '"${nodes_addr}"') + def get_ip_addr_subnet(node, port, nodes_addr): """ Get IPv4 subnet of specified interface. :param node: Node dictionary. :param port: Interface name. + :return: IPv4 subnet of 'str' type """ - log.debug('Get IPv4 subnet of node {} interface {}'. - format(get_node_hostname(node), port)) - return IPv4Util.SUBNETS[(get_node_hostname(node), port)] + for net in nodes_addr.values(): + for p in net['ports'].values(): + if p['node'] == node['host'] and p['if'] == port: + return net['net_addr'] + + raise Exception('Subnet not found for node {n} port {p}'. + format(n=node['host'], p=port)) @staticmethod @keyword('Flush IPv4 addresses "${port}" "${node}"') @@ -560,8 +141,4 @@ class IPv4Util(object): :param node: :return: """ - key = (get_node_hostname(node), port) - del IPv4Util.ADDRESSES[key] - del IPv4Util.PREFIXES[key] - del IPv4Util.SUBNETS[key] get_node(node).flush_ip_addresses(port) diff --git a/resources/libraries/python/InterfaceUtil.py b/resources/libraries/python/InterfaceUtil.py new file mode 100644 index 0000000000..bc8bf94a9b --- /dev/null +++ b/resources/libraries/python/InterfaceUtil.py @@ -0,0 +1,54 @@ +# Copyright (c) 2016 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: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Interface util library""" + +from resources.libraries.python.ssh import exec_cmd_no_error +from resources.libraries.python.topology import NodeType, Topology +from resources.libraries.python.VatExecutor import VatExecutor + + +class InterfaceUtil(object): + """General utilities for managing interfaces""" + + @staticmethod + def set_interface_state(node, interface, state): + """Set interface state on a node. + + Function can be used for DUTs as well as for TGs. + + :param node: node where the interface is + :param interface: interface name + :param state: one of 'up' or 'down' + :type node: dict + :type interface: str + :type state: str + :return: nothing + """ + if node['type'] == NodeType.DUT: + if state == 'up': + state = 'admin-up link-up' + elif state == 'down': + state = 'admin-down link-down' + else: + raise Exception('Unexpected interface state: {}'.format(state)) + + sw_if_index = Topology.get_interface_sw_index(node, interface) + VatExecutor.cmd_from_template(node, 'set_if_state.vat', + sw_if_index=sw_if_index, state=state) + + elif node['type'] == NodeType.TG: + cmd = 'ip link set {} {}'.format(interface, state) + exec_cmd_no_error(node, cmd, sudo=True) + else: + raise Exception('Unknown NodeType: "{}"'.format(node['type'])) diff --git a/resources/libraries/python/topology.py b/resources/libraries/python/topology.py index 6a7ea798cc..8b6905d7e1 100644 --- a/resources/libraries/python/topology.py +++ b/resources/libraries/python/topology.py @@ -647,3 +647,20 @@ class Topology(object): 'DUT1_BD_LINKS': dut1_bd_links, 'DUT2_BD_LINKS': dut2_bd_links} return topology_links + + @staticmethod + def is_tg_node(node): + """Find out whether the node is TG + + :param node: node to examine + :return: True if node is type of TG; False otherwise + """ + return node['type'] == NodeType.TG + + @staticmethod + def get_node_hostname(node): + """ + :param node: node dictionary + :return: host name as 'str' type + """ + return node['host']
\ No newline at end of file |