X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=test%2Fvpp_ip.py;h=fa32c35200f36588db990f63354c74a29ee8153f;hb=56e17cf7a23831b353bc1836def47dad7f869dad;hp=e92c91943db8d97c24b960ee4465fdc7d6392f9b;hpb=0685da4a6db8195d1a86f3466fcd3395b0ccb83e;p=vpp.git diff --git a/test/vpp_ip.py b/test/vpp_ip.py index e92c91943db..fa32c35200f 100644 --- a/test/vpp_ip.py +++ b/test/vpp_ip.py @@ -2,10 +2,17 @@ IP Types """ +import logging from ipaddress import ip_address -from socket import AF_INET, AF_INET6 -from vpp_papi import VppEnum +from vpp_object import VppObject + +try: + text_type = unicode +except NameError: + text_type = str + +_log = logging.getLogger(__name__) class DpoProto: @@ -17,27 +24,26 @@ class DpoProto: DPO_PROTO_NSH = 5 -INVALID_INDEX = 0xffffffff +INVALID_INDEX = 0xFFFFFFFF + + +def get_dpo_proto(addr): + if ip_address(addr).version == 6: + return DpoProto.DPO_PROTO_IP6 + else: + return DpoProto.DPO_PROTO_IP4 -class VppIpAddressUnion(): +class VppIpAddressUnion: def __init__(self, addr): self.addr = addr - self.ip_addr = ip_address(unicode(self.addr)) + self.ip_addr = ip_address(text_type(self.addr)) def encode(self): - if self.version is 6: - return { - 'ip6': { - 'address': self.ip_addr.packed - }, - } + if self.version == 6: + return {"ip6": self.ip_addr} else: - return { - 'ip4': { - 'address': self.ip_addr.packed - }, - } + return {"ip4": self.ip_addr} @property def version(self): @@ -49,10 +55,7 @@ class VppIpAddressUnion(): @property def length(self): - if self.version is 6: - return 128 - else: - return 32 + return self.ip_addr.max_prefixlen @property def bytes(self): @@ -63,169 +66,175 @@ class VppIpAddressUnion(): return self.ip_addr == other.ip_addr elif hasattr(other, "ip4") and hasattr(other, "ip6"): # vl_api_address_union_t - if 4 is self.version: - return self.ip_addr.packed == other.ip4.address - else: - return self.ip_addr.packed == other.ip6.address - else: - raise Exception("Comparing VppIpAddresUnions:%s" - " with unknown type: %s" % - (self, other)) - - return False - - -class VppIpAddress(): - def __init__(self, addr): - self.addr = VppIpAddressUnion(addr) - - def encode(self): - if self.addr.version is 6: - return { - 'af': VppEnum.vl_api_address_family_t.ADDRESS_IP6, - 'un': self.addr.encode() - } - else: - return { - 'af': VppEnum.vl_api_address_family_t.ADDRESS_IP4, - 'un': self.addr.encode() - } - - def __eq__(self, other): - if isinstance(other, self.__class__): - return self.addr == other.addr - elif hasattr(other, "af") and hasattr(other, "un"): - # a vp_api_address_t - if 4 is self.version: - return other.af == \ - VppEnum.vl_api_address_family_t.ADDRESS_IP4 and \ - other.un == self.addr + if 4 == self.version: + return self.ip_addr == other.ip4 else: - return other.af == \ - VppEnum.vl_api_address_family_t.ADDRESS_IP6 and \ - other.un == self.addr + return self.ip_addr == other.ip6 else: - raise Exception("Comparing VppIpAddress:%s with unknown type: %s" % - (self, other)) - return False + raise Exception( + "Comparing VppIpAddressUnions:%s with incomparable type: %s", + self, + other, + ) def __ne__(self, other): return not (self == other) def __str__(self): - return self.address + return str(self.ip_addr) - @property - def bytes(self): - return self.addr.bytes - @property - def address(self): - return self.addr.address +class VppIpMPrefix: + def __init__(self, saddr, gaddr, glen): + self.saddr = saddr + self.gaddr = gaddr + self.glen = glen + if ip_address(self.saddr).version != ip_address(self.gaddr).version: + raise ValueError( + "Source and group addresses must be of the same address family." + ) + + def encode(self): + return { + "af": ip_address(self.gaddr).vapi_af, + "grp_address": {ip_address(self.gaddr).vapi_af_name: self.gaddr}, + "src_address": {ip_address(self.saddr).vapi_af_name: self.saddr}, + "grp_address_length": self.glen, + } @property def length(self): - return self.addr.length + return self.glen @property def version(self): - return self.addr.version - - @property - def is_ip6(self): - return (self.version == 6) + return ip_address(self.gaddr).version - @property - def af(self): - if self.version == 6: - return AF_INET6 - else: - return AF_INET + def __str__(self): + return "(%s,%s)/%d" % (self.saddr, self.gaddr, self.glen) - @property - def dpo_proto(self): - if self.version is 6: - return DpoProto.DPO_PROTO_IP6 - else: - return DpoProto.DPO_PROTO_IP4 + def __eq__(self, other): + if isinstance(other, self.__class__): + return ( + self.glen == other.glen + and self.saddr == other.gaddr + and self.saddr == other.saddr + ) + elif ( + hasattr(other, "grp_address_length") + and hasattr(other, "grp_address") + and hasattr(other, "src_address") + ): + # vl_api_mprefix_t + if 4 == self.version: + return ( + self.glen == other.grp_address_length + and self.gaddr == str(other.grp_address.ip4) + and self.saddr == str(other.src_address.ip4) + ) + else: + return ( + self.glen == other.grp_address_length + and self.gaddr == str(other.grp_address.ip6) + and self.saddr == str(other.src_address.ip6) + ) + return NotImplemented -class VppIpPrefix(): - def __init__(self, addr, len): - self.addr = VppIpAddress(addr) - self.len = len +class VppIpPuntPolicer(VppObject): + def __init__(self, test, policer_index, is_ip6=False): + self._test = test + self._policer_index = policer_index + self._is_ip6 = is_ip6 - def __eq__(self, other): - if self.addr == other.addr and self.len == other.len: - return True - return False + def add_vpp_config(self): + self._test.vapi.ip_punt_police( + policer_index=self._policer_index, is_ip6=self._is_ip6, is_add=True + ) - def encode(self): - return {'address': self.addr.encode(), - 'address_length': self.len} + def remove_vpp_config(self): + self._test.vapi.ip_punt_police( + policer_index=self._policer_index, is_ip6=self._is_ip6, is_add=False + ) - @property - def address(self): - return self.addr.address + def query_vpp_config(self): + NotImplemented - @property - def length(self): - return self.len - def __str__(self): - return "%s/%d" % (self.address, self.length) +class VppIpPuntRedirect(VppObject): + def __init__(self, test, rx_index, tx_index, nh_addr): + self._test = test + self._rx_index = rx_index + self._tx_index = tx_index + self._nh_addr = ip_address(nh_addr) - def __eq__(self, other): - if isinstance(other, self.__class__): - return (self.len == other.len and self.addr == other.addr) - elif hasattr(other, "address") and hasattr(other, "address_length"): - # vl_api_prefix_t - return self.len == other.address_length and \ - self.addr == other.address - else: - raise Exception("Comparing VppIpPrefix:%s with unknown type: %s" % - (self, other)) + def encode(self): + return { + "rx_sw_if_index": self._rx_index, + "tx_sw_if_index": self._tx_index, + "nh": self._nh_addr, + } + + def add_vpp_config(self): + self._test.vapi.ip_punt_redirect(punt=self.encode(), is_add=True) + self._test.registry.register(self, self._test.logger) + return self + + def remove_vpp_config(self): + self._test.vapi.ip_punt_redirect(punt=self.encode(), is_add=False) + + def get_vpp_config(self): + is_ipv6 = True if self._nh_addr.version == 6 else False + return self._test.vapi.ip_punt_redirect_dump( + sw_if_index=self._rx_index, is_ipv6=is_ipv6 + ) + + def query_vpp_config(self): + if self.get_vpp_config(): + return True return False -class VppIpMPrefix(): - def __init__(self, saddr, gaddr, len): - self.saddr = saddr - self.gaddr = gaddr - self.len = len - self.ip_saddr = ip_address(unicode(self.saddr)) - self.ip_gaddr = ip_address(unicode(self.gaddr)) +class VppIpPathMtu(VppObject): + def __init__(self, test, nh, pmtu, table_id=0): + self._test = test + self.nh = nh + self.pmtu = pmtu + self.table_id = table_id + + def add_vpp_config(self): + self._test.vapi.ip_path_mtu_update( + pmtu={"nh": self.nh, "table_id": self.table_id, "path_mtu": self.pmtu} + ) + self._test.registry.register(self, self._test.logger) + return self + + def modify(self, pmtu): + self.pmtu = pmtu + self._test.vapi.ip_path_mtu_update( + pmtu={"nh": self.nh, "table_id": self.table_id, "path_mtu": self.pmtu} + ) + return self + + def remove_vpp_config(self): + self._test.vapi.ip_path_mtu_update( + pmtu={"nh": self.nh, "table_id": self.table_id, "path_mtu": 0} + ) + + def query_vpp_config(self): + ds = list(self._test.vapi.vpp.details_iter(self._test.vapi.ip_path_mtu_get)) + + for d in ds: + if ( + self.nh == str(d.pmtu.nh) + and self.table_id == d.pmtu.table_id + and self.pmtu == d.pmtu.path_mtu + ): + return True + return False - def encode(self): + def object_id(self): + return "ip-path-mtu-%d-%s-%d" % (self.table_id, self.nh, self.pmtu) - if 6 is self.ip_saddr.version: - prefix = { - 'af': VppEnum.vl_api_address_family_t.ADDRESS_IP6, - 'grp_address': { - 'ip6': { - 'address': self.ip_gaddr.packed - }, - }, - 'src_address': { - 'ip6': { - 'address': self.ip_saddr.packed - }, - }, - 'grp_address_length': self.len, - } - else: - prefix = { - 'af': VppEnum.vl_api_address_family_t.ADDRESS_IP4, - 'grp_address': { - 'ip4': { - 'address': self.ip_gaddr.packed - }, - }, - 'src_address': { - 'ip4': { - 'address': self.ip_saddr.packed - }, - }, - 'grp_address_length': self.len, - } - return prefix + def __str__(self): + return self.object_id()