-# Copyright (c) 2019 Cisco and/or its affiliates.
+# Copyright (c) 2023 Cisco and/or its affiliates.
+# Copyright (c) 2023 PANTHEON.tech s.r.o.
# 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:
from enum import IntEnum
-from ipaddress import ip_address
+from ipaddress import ip_address, ip_network
from resources.libraries.python.Constants import Constants
+from resources.libraries.python.IncrementUtil import ObjIncrement
from resources.libraries.python.InterfaceUtil import InterfaceUtil
+from resources.libraries.python.IPAddress import IPAddress
from resources.libraries.python.PapiExecutor import PapiSocketExecutor
from resources.libraries.python.ssh import exec_cmd_no_error, exec_cmd
from resources.libraries.python.topology import Topology
-from resources.libraries.python.VatExecutor import VatTerminal
+from resources.libraries.python.Namespaces import Namespaces
# from vpp/src/vnet/vnet/mpls/mpls_types.h
MPLS_LABEL_INVALID = MPLS_IETF_MAX_LABEL + 1
-class AddressFamily(IntEnum):
- """IP address family."""
- ADDRESS_IP4 = 0
- ADDRESS_IP6 = 1
-
-
class FibPathType(IntEnum):
"""FIB path types."""
FIB_PATH_TYPE_NORMAL = 0
class FibPathFlags(IntEnum):
"""FIB path flags."""
FIB_PATH_FLAG_NONE = 0
- # TODO: Name too long for pylint, fix in VPP.
FIB_PATH_FLAG_RESOLVE_VIA_ATTACHED = 1
FIB_PATH_FLAG_RESOLVE_VIA_HOST = 2
FIB_PATH_NH_PROTO_BIER = 4
+class IpDscp(IntEnum):
+ """DSCP code points."""
+ IP_API_DSCP_CS0 = 0
+ IP_API_DSCP_CS1 = 8
+ IP_API_DSCP_AF11 = 10
+ IP_API_DSCP_AF12 = 12
+ IP_API_DSCP_AF13 = 14
+ IP_API_DSCP_CS2 = 16
+ IP_API_DSCP_AF21 = 18
+ IP_API_DSCP_AF22 = 20
+ IP_API_DSCP_AF23 = 22
+ IP_API_DSCP_CS3 = 24
+ IP_API_DSCP_AF31 = 26
+ IP_API_DSCP_AF32 = 28
+ IP_API_DSCP_AF33 = 30
+ IP_API_DSCP_CS4 = 32
+ IP_API_DSCP_AF41 = 34
+ IP_API_DSCP_AF42 = 36
+ IP_API_DSCP_AF43 = 38
+ IP_API_DSCP_CS5 = 40
+ IP_API_DSCP_EF = 46
+ IP_API_DSCP_CS6 = 48
+ IP_API_DSCP_CS7 = 50
+
+
+class NetworkIncrement(ObjIncrement):
+ """
+ An iterator object which accepts an IPv4Network or IPv6Network and
+ returns a new network, its address part incremented by the increment
+ number of network sizes, each time it is iterated or when inc_fmt is called.
+ The increment may be positive, negative or 0
+ (in which case the network is always the same).
+
+ Both initial and subsequent IP address can have host bits set,
+ check the initial value before creating instance if needed.
+ String formatting is configurable via constructor argument.
+ """
+ def __init__(self, initial_value, increment=1, format=u"dash"):
+ """
+ :param initial_value: The initial network. Can have host bits set.
+ :param increment: The current network will be incremented by this
+ amount of network sizes in each iteration/var_str call.
+ :param format: Type of formatting to use, "dash" or "slash" or "addr".
+ :type initial_value: Union[ipaddress.IPv4Network, ipaddress.IPv6Network]
+ :type increment: int
+ :type format: str
+ """
+ super().__init__(initial_value, increment)
+ self._prefix_len = self._value.prefixlen
+ host_len = self._value.max_prefixlen - self._prefix_len
+ self._net_increment = self._increment * (1 << host_len)
+ self._format = str(format).lower()
+
+ def _incr(self):
+ """
+ Increment the network, e.g.:
+ '30.0.0.0/24' incremented by 1 (the next network) is '30.0.1.0/24'.
+ '30.0.0.0/24' incremented by 2 is '30.0.2.0/24'.
+ """
+ self._value = ip_network(
+ f"{self._value.network_address + self._net_increment}"
+ f"/{self._prefix_len}", strict=False
+ )
+
+ def _str_fmt(self):
+ """
+ The string representation of the network depends on format.
+
+ Dash format is '<ip_address_start> - <ip_address_stop>',
+ useful for 'ipsec policy add spd' CLI.
+
+ Slash format is '<ip_address_start>/<prefix_length>',
+ useful for other CLI.
+
+ Addr format is '<ip_address_start>', useful for PAPI.
+
+ :returns: Current value converted to string according to format.
+ :rtype: str
+ :raises RuntimeError: If the format is not supported.
+ """
+ if self._format == u"dash":
+ return f"{self._value.network_address} - " \
+ f"{self._value.broadcast_address}"
+ elif self._format == u"slash":
+ return f"{self._value.network_address}/{self._prefix_len}"
+ elif self._format == u"addr":
+ return f"{self._value.network_address}"
+
+ raise RuntimeError(f"Unsupported format {self._format}")
+
+
class IPUtil:
"""Common IP utilities"""
with PapiSocketExecutor(node) as papi_exec:
details = papi_exec.add(cmd, **args).get_details(err_msg)
- # TODO: CSIT currently looks only whether the list is empty.
- # Add proper value processing if values become important.
-
return details
@staticmethod
PapiSocketExecutor.run_cli_cmd(node, u"show ip6 fib")
PapiSocketExecutor.run_cli_cmd(node, u"show ip6 fib summary")
+ @staticmethod
+ def vpp_get_ip_table_summary(node):
+ """Get IPv4 FIB table summary on a VPP node.
+
+ :param node: VPP node.
+ :type node: dict
+ """
+ PapiSocketExecutor.run_cli_cmd(node, u"show ip fib summary")
+
+ @staticmethod
+ def vpp_get_ip_table(node):
+ """Get IPv4 FIB table on a VPP node.
+
+ :param node: VPP node.
+ :type node: dict
+ """
+ PapiSocketExecutor.run_cli_cmd(node, u"show ip fib")
+
@staticmethod
def vpp_get_ip_tables_prefix(node, address):
"""Get dump of all IP FIB tables on a VPP node.
raise AssertionError(f"IP addresses are not equal: {ip1} != {ip2}")
@staticmethod
- def setup_network_namespace(
- node, namespace_name, interface_name, ip_addr, prefix):
+ def setup_network_namespace(node, namespace_name, interface_name,
+ ip_addr_list, prefix_length):
"""Setup namespace on given node and attach interface and IP to
this namespace. Applicable also on TG node.
:param node: VPP node.
:param namespace_name: Namespace name.
:param interface_name: Interface name.
- :param ip_addr: IP address of namespace's interface.
- :param prefix: IP address prefix length.
+ :param ip_addr_list: List of IP addresses of namespace's interface.
+ :param prefix_length: IP address prefix length.
:type node: dict
:type namespace_name: str
:type interface_name: str
- :type ip_addr: str
- :type prefix: int
+ :type ip_addr_list: list
+ :type prefix_length: int
"""
- cmd = f"ip netns add {namespace_name}"
- exec_cmd_no_error(node, cmd, sudo=True)
+ Namespaces.create_namespace(node, namespace_name)
- cmd = f"ip link set dev {interface_name} up netns {namespace_name}"
+ cmd = f"ip netns exec {namespace_name} ip link set {interface_name} up"
exec_cmd_no_error(node, cmd, sudo=True)
- cmd = f"ip netns exec {namespace_name} ip addr add {ip_addr}/{prefix}" \
- f" dev {interface_name}"
- exec_cmd_no_error(node, cmd, sudo=True)
+ for ip_addr in ip_addr_list:
+ cmd = f"ip netns exec {namespace_name} ip addr add " \
+ f"{ip_addr}/{prefix_length} dev {interface_name}"
+ exec_cmd_no_error(node, cmd, sudo=True)
@staticmethod
def linux_enable_forwarding(node, ip_ver=u"ipv4"):
return None
@staticmethod
- def set_linux_interface_up(node, interface):
+ def set_linux_interface_up(
+ node, interface, namespace=None):
"""Set the specified interface up.
-
:param node: VPP/TG node.
:param interface: Interface in namespace.
+ :param namespace: Execute command in namespace. Optional
:type node: dict
:type interface: str
+ :type namespace: str
:raises RuntimeError: If the interface could not be set up.
"""
- cmd = f"ip link set {interface} up"
+ if namespace is not None:
+ cmd = f"ip netns exec {namespace} ip link set dev {interface} up"
+ else:
+ cmd = f"ip link set dev {interface} up"
exec_cmd_no_error(node, cmd, timeout=30, sudo=True)
+
@staticmethod
def set_linux_interface_ip(
node, interface, ip_addr, prefix, namespace=None):
exec_cmd_no_error(node, cmd, timeout=5, sudo=True)
+ @staticmethod
+ def delete_linux_interface_ip(
+ node, interface, ip_addr, prefix_length, namespace=None):
+ """Delete IP address from interface in linux.
+
+ :param node: VPP/TG node.
+ :param interface: Interface in namespace.
+ :param ip_addr: IP to be deleted from interface.
+ :param prefix_length: IP prefix length.
+ :param namespace: Execute command in namespace. Optional
+ :type node: dict
+ :type interface: str
+ :type ip_addr: str
+ :type prefix_length: int
+ :type namespace: str
+ :raises RuntimeError: IP could not be deleted.
+ """
+ if namespace is not None:
+ cmd = f"ip netns exec {namespace} ip addr del " \
+ f"{ip_addr}/{prefix_length} dev {interface}"
+ else:
+ cmd = f"ip addr del {ip_addr}/{prefix_length} dev {interface}"
+
+ exec_cmd_no_error(node, cmd, timeout=5, sudo=True)
+
+ @staticmethod
+ def linux_interface_has_ip(
+ node, interface, ip_addr, prefix_length, namespace=None):
+ """Return True if interface in linux has IP address.
+
+ :param node: VPP/TG node.
+ :param interface: Interface in namespace.
+ :param ip_addr: IP to be queried on interface.
+ :param prefix_length: IP prefix length.
+ :param namespace: Execute command in namespace. Optional
+ :type node: dict
+ :type interface: str
+ :type ip_addr: str
+ :type prefix_length: int
+ :type namespace: str
+ :rtype: boolean
+ :raises RuntimeError: Request fails.
+ """
+ ip_addr_with_prefix = f"{ip_addr}/{prefix_length}"
+ if namespace is not None:
+ cmd = f"ip netns exec {namespace} ip addr show dev {interface}"
+ else:
+ cmd = f"ip addr show dev {interface}"
+
+ cmd += u" | grep 'inet ' | awk -e '{print $2}'"
+ cmd += f" | grep '{ip_addr_with_prefix}'"
+ _, stdout, _ = exec_cmd(node, cmd, timeout=5, sudo=True)
+
+ has_ip = stdout.rstrip()
+ return bool(has_ip == ip_addr_with_prefix)
+
@staticmethod
def add_linux_route(node, ip_addr, prefix, gateway, namespace=None):
"""Add linux route in namespace.
with PapiSocketExecutor(node) as papi_exec:
papi_exec.add(cmd, **args).get_reply(err_msg)
+ @staticmethod
+ def vpp_interface_set_ip_addresses(node, interface, ip_addr_list,
+ prefix_length=None):
+ """Set IP addresses to VPP interface.
+
+ :param node: VPP node.
+ :param interface: Interface name.
+ :param ip_addr_list: IP addresses.
+ :param prefix_length: Prefix length.
+ :type node: dict
+ :type interface: str
+ :type ip_addr_list: list
+ :type prefix_length: int
+ """
+ for ip_addr in ip_addr_list:
+ IPUtil.vpp_interface_set_ip_address(node, interface, ip_addr,
+ prefix_length)
+
@staticmethod
def vpp_add_ip_neighbor(node, iface_key, ip_addr, mac_address):
"""Add IP neighbor on DUT node.
with PapiSocketExecutor(node) as papi_exec:
papi_exec.add(cmd, **args).get_reply(err_msg)
- @staticmethod
- def union_addr(ip_addr):
- """Creates union IP address.
-
- :param ip_addr: IPv4 or IPv6 address.
- :type ip_addr: IPv4Address or IPv6Address
- :returns: Union IP address.
- :rtype: dict
- """
- return dict(ip6=ip_addr.packed) if ip_addr.version == 6 \
- else dict(ip4=ip_addr.packed)
-
- @staticmethod
- def create_ip_address_object(ip_addr):
- """Create IP address object.
-
- :param ip_addr: IPv4 or IPv6 address
- :type ip_addr: IPv4Address or IPv6Address
- :returns: IP address object.
- :rtype: dict
- """
- return dict(
- af=getattr(
- AddressFamily, u"ADDRESS_IP6" if ip_addr.version == 6
- else u"ADDRESS_IP4"
- ).value,
- un=IPUtil.union_addr(ip_addr)
- )
-
@staticmethod
def create_prefix_object(ip_addr, addr_len):
"""Create prefix object.
:param ip_addr: IPv4 or IPv6 address.
- :para, addr_len: Length of IP address.
+ :param addr_len: Length of IP address.
:type ip_addr: IPv4Address or IPv6Address
:type addr_len: int
:returns: Prefix object.
:rtype: dict
"""
- addr = IPUtil.create_ip_address_object(ip_addr)
+ addr = IPAddress.create_ip_address_object(ip_addr)
return dict(
len=int(addr_len),
vrf: VRF table ID. (int)
count: number of IP addresses to add starting from network IP (int)
local: The route is local with same prefix (increment is 1).
- If None, then is not used. (bool)
+ If None, then is not used. (bool)
lookup_vrf: VRF table ID for lookup. (int)
- multipath: Enable multipath routing. (bool)
weight: Weight value for unequal cost multipath routing. (int)
+ (Multipath value enters at higher level.)
:type node: dict
:type network: str
paths = list()
n_hop = dict(
- address=IPUtil.union_addr(ip_address(gateway)) if gateway else 0,
+ address=IPAddress.union_addr(ip_address(gateway)) if gateway else 0,
via_label=MPLS_LABEL_INVALID,
obj_id=Constants.BITWISE_NON_ZERO
)
return route
@staticmethod
- def vpp_route_add(node, network, prefix_len, **kwargs):
- """Add route to the VPP node.
+ def vpp_route_add(node, network, prefix_len, strict=True, **kwargs):
+ """Add route to the VPP node. Prefer multipath behavior.
:param node: VPP node.
:param network: Route destination network address.
:param prefix_len: Route destination network prefix length.
+ :param strict: If true, fail if address has host bits set.
:param kwargs: Optional key-value arguments:
gateway: Route gateway address. (str)
interface: Route interface. (str)
vrf: VRF table ID. (int)
count: number of IP addresses to add starting from network IP (int)
- local: The route is local with same prefix (increment is 1).
- If None, then is not used. (bool)
+ local: The route is local with same prefix (increment is 1 network)
+ If None, then is not used. (bool)
lookup_vrf: VRF table ID for lookup. (int)
- multipath: Enable multipath routing. (bool)
+ multipath: Enable multipath routing. (bool) Default: True.
weight: Weight value for unequal cost multipath routing. (int)
:type node: dict
:type network: str
:type prefix_len: int
+ :type strict: bool
:type kwargs: dict
+ :raises RuntimeError: If the argument combination is not supported.
"""
count = kwargs.get(u"count", 1)
- if count > 100:
- gateway = kwargs.get(u"gateway", '')
- interface = kwargs.get(u"interface", '')
- vrf = kwargs.get(u"vrf", None)
- multipath = kwargs.get(u"multipath", False)
-
- with VatTerminal(node, json_param=False) as vat:
-
- vat.vat_terminal_exec_cmd_from_template(
- u"vpp_route_add.vat",
- network=network,
- prefix_length=prefix_len,
- via=f"via {gateway}" if gateway else u"",
- sw_if_index=f"sw_if_index "
- f"{InterfaceUtil.get_interface_index(node, interface)}"
- if interface else u"",
- vrf=f"vrf {vrf}" if vrf else u"",
- count=f"count {count}" if count else u"",
- multipath=u"multipath" if multipath else u""
- )
- return
-
- net_addr = ip_address(network)
cmd = u"ip_route_add_del"
args = dict(
is_add=True,
- is_multipath=kwargs.get(u"multipath", False),
+ is_multipath=kwargs.get(u"multipath", True),
route=None
)
err_msg = f"Failed to add route(s) on host {node[u'host']}"
- with PapiSocketExecutor(node) as papi_exec:
- for i in range(kwargs.get(u"count", 1)):
+ netiter = NetworkIncrement(
+ ip_network(f"{network}/{prefix_len}", strict=strict),
+ format=u"addr"
+ )
+ with PapiSocketExecutor(node, is_async=True) as papi_exec:
+ for i in range(count):
args[u"route"] = IPUtil.compose_vpp_route_structure(
- node, net_addr + i, prefix_len, **kwargs
+ node, netiter.inc_fmt(), prefix_len, **kwargs
)
- history = bool(not 1 < i < kwargs.get(u"count", 1))
+ history = bool(not 0 < i < count - 1)
papi_exec.add(cmd, history=history, **args)
papi_exec.get_replies(err_msg)
Code Review / csit.git / blobdiff