X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=test%2Fvpp_ip.py;h=43af5e09c07c45d3eb208845f39c5f73ea71c957;hb=61717cc38;hp=912d8430d81febb7a637917e8ef589667fd596ed;hpb=d0df49f26eabf2f534b567f3370e50c4e804aeea;p=vpp.git

diff --git a/test/vpp_ip.py b/test/vpp_ip.py
index 912d8430d81..43af5e09c07 100644
--- a/test/vpp_ip.py
+++ b/test/vpp_ip.py
@@ -2,32 +2,48 @@
   IP Types
 
 """
+import logging
 
 from ipaddress import ip_address
+from socket import AF_INET, AF_INET6
+from vpp_papi import VppEnum
+try:
+    text_type = unicode
+except NameError:
+    text_type = str
 
+_log = logging.getLogger(__name__)
 
-class IpAddressFamily:
-    ADDRESS_IP4 = 0
-    ADDRESS_IP6 = 1
+
+class DpoProto:
+    DPO_PROTO_IP4 = 0
+    DPO_PROTO_IP6 = 1
+    DPO_PROTO_MPLS = 2
+    DPO_PROTO_ETHERNET = 3
+    DPO_PROTO_BIER = 4
+    DPO_PROTO_NSH = 5
 
 
 INVALID_INDEX = 0xffffffff
 
 
-def compare_ip_address(api_address, py_address):
-    if 4 is py_address.version:
-        if py_address.packed == api_address.ip4.address:
-            return True
+def get_dpo_proto(addr):
+    if ip_address(addr).version == 6:
+        return DpoProto.DPO_PROTO_IP6
     else:
-        if py_address.packed == api_address.ip6.address:
-            return True
-    return False
+        return DpoProto.DPO_PROTO_IP4
 
 
 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 == 6:
+            return {'ip6': self.ip_addr}
+        else:
+            return {'ip4': self.ip_addr}
 
     @property
     def version(self):
@@ -37,99 +53,98 @@ class VppIpAddressUnion():
     def address(self):
         return self.addr
 
-    def encode(self):
-        if self.ip_addr.version is 6:
-            return {
-                'ip6': {
-                    'address': self.ip_addr.packed
-                },
-            }
-        else:
-            return {
-                'ip4': {
-                    'address': self.ip_addr.packed
-                },
-            }
-
-
-class VppIpAddress():
-    def __init__(self, addr):
-        self.addr = VppIpAddressUnion(addr)
-
-    def encode(self):
-        if self.addr.version is 6:
-            return {
-                'af': IpAddressFamily.ADDRESS_IP6,
-                'un': self.addr.encode()
-            }
-        else:
-            return {
-                'af': IpAddressFamily.ADDRESS_IP4,
-                'un': self.addr.encode()
-            }
-
     @property
-    def address(self):
-        return self.addr.address
-
+    def length(self):
+        return self.ip_addr.max_prefixlen
 
-class VppIpPrefix():
-    def __init__(self, addr, len):
-        self.addr = VppIpAddress(addr)
-        self.len = len
+    @property
+    def bytes(self):
+        return self.ip_addr.packed
 
     def __eq__(self, other):
-        if self.addr == other.addr and self.len == other.len:
-            return True
-        return False
+        if isinstance(other, self.__class__):
+            return self.ip_addr == other.ip_addr
+        elif hasattr(other, "ip4") and hasattr(other, "ip6"):
+            # vl_api_address_union_t
+            if 4 == self.version:
+                return self.ip_addr == other.ip4
+            else:
+                return self.ip_addr == other.ip6
+        else:
+            raise Exception("Comparing VppIpAddressUnions:%s"
+                            " with incomparable type: %s",
+                            self, other)
 
-    def encode(self):
-        return {'address': self.addr.encode(),
-                'address_length': self.len}
+    def __ne__(self, other):
+        return not (self == other)
 
-    @property
-    def address(self):
-        return self.addr.address
+    def __str__(self):
+        return str(self.ip_addr)
 
 
 class VppIpMPrefix():
-    def __init__(self, saddr, gaddr, len):
+    def __init__(self, saddr, gaddr, glen):
         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))
+        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):
-
-        if 6 is self.ip_saddr.version:
+        if 6 == self.version:
             prefix = {
-                'af': IpAddressFamily.ADDRESS_IP6,
+                'af': VppEnum.vl_api_address_family_t.ADDRESS_IP6,
                 'grp_address': {
-                    'ip6': {
-                        'address': self.ip_gaddr.packed
-                    },
+                    'ip6': self.gaddr
                 },
                 'src_address': {
-                    'ip6': {
-                        'address': self.ip_saddr.packed
-                    },
+                    'ip6': self.saddr
                 },
-                'grp_address_length': self.len,
+                'grp_address_length': self.glen,
             }
         else:
             prefix = {
-                'af': IpAddressFamily.ADDRESS_IP4,
+                'af': VppEnum.vl_api_address_family_t.ADDRESS_IP4,
                 'grp_address': {
-                    'ip4': {
-                        'address': self.ip_gaddr.packed
-                    },
+                    'ip4': self.gaddr
                 },
                 'src_address': {
-                    'ip4': {
-                        'address': self.ip_saddr.packed
-                    },
+                    'ip4':  self.saddr
                 },
-                'grp_address_length': self.len,
+                'grp_address_length': self.glen,
             }
         return prefix
+
+    @property
+    def length(self):
+        return self.glen
+
+    @property
+    def version(self):
+        return ip_address(self.gaddr).version
+
+    def __str__(self):
+        return "(%s,%s)/%d" % (self.saddr, self.gaddr, self.glen)
+
+    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))
+            raise Exception("Comparing VppIpMPrefix:%s with unknown type: %s" %
+                            (self, other))
+        return False