X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvpp-api%2Fpython%2Fvpp_papi%2Fvpp_serializer.py;h=644aeac65c63a7747e9382b760b7f54c2a08b415;hb=3825d93af;hp=5b45cd8a5690dbe4d7f1a3660bfd2ebd721ca4e5;hpb=64e978b1bf1f30672dd305e7c35fefc31887adf2;p=vpp.git

diff --git a/src/vpp-api/python/vpp_papi/vpp_serializer.py b/src/vpp-api/python/vpp_papi/vpp_serializer.py
index 5b45cd8a569..644aeac65c6 100644
--- a/src/vpp-api/python/vpp_papi/vpp_serializer.py
+++ b/src/vpp-api/python/vpp_papi/vpp_serializer.py
@@ -13,35 +13,25 @@
 # limitations under the License.
 #
 import collections
+from enum import IntFlag
 import logging
 import socket
 import struct
 import sys
 
-if sys.version_info <= (3, 4):
-    from aenum import IntEnum  # noqa: F401
-else:
-    from enum import IntEnum  # noqa: F401
+from . import vpp_format
 
-if sys.version_info <= (3, 6):
-    from aenum import IntFlag  # noqa: F401
-else:
-
-    from enum import IntFlag  # noqa: F401
-
-from . import vpp_format  # noqa: E402
 
 #
 # Set log-level in application by doing e.g.:
 # logger = logging.getLogger('vpp_serializer')
 # logger.setLevel(logging.DEBUG)
 #
-logger = logging.getLogger(__name__)
+logger = logging.getLogger('vpp_papi.serializer')
+
 
-if sys.version[0] == '2':
-    def check(d): type(d) is dict
-else:
-    def check(d): type(d) is dict or type(d) is bytes
+def check(d):
+    return type(d) is dict or type(d) is bytes
 
 
 def conversion_required(data, field_type):
@@ -66,8 +56,36 @@ def conversion_unpacker(data, field_type):
     return vpp_format.conversion_unpacker_table[field_type](data)
 
 
-class BaseTypes(object):
+class Packer:
+    options = {}
+
+    def pack(self, data, kwargs):
+        raise NotImplementedError
+
+    def unpack(self, data, offset, result=None, ntc=False):
+        raise NotImplementedError
+
+    # override as appropriate in subclasses
+    @staticmethod
+    def _get_packer_with_options(f_type, options):
+        return types[f_type]
+
+    def get_packer_with_options(self, f_type, options):
+        if options is not None:
+            try:
+                c = types[f_type].__class__
+                return c._get_packer_with_options(f_type, options)
+            except IndexError:
+                raise VPPSerializerValueError(
+                    "Options not supported for {}{} ({})".
+                    format(f_type, types[f_type].__class__,
+                           options))
+
+
+class BaseTypes(Packer):
     def __init__(self, type, elements=0, options=None):
+        self._type = type
+        self._elements = elements
         base_types = {'u8': '>B',
                       'i8': '>b',
                       'string': '>s',
@@ -88,12 +106,8 @@ class BaseTypes(object):
         self.size = self.packer.size
         self.options = options
 
-    def __call__(self, args):
-        self.options = args
-        return self
-
     def pack(self, data, kwargs=None):
-        if not data:  # Default to zero if not specified
+        if data is None:  # Default to zero if not specified
             if self.options and 'default' in self.options:
                 data = self.options['default']
             else:
@@ -103,8 +117,17 @@ class BaseTypes(object):
     def unpack(self, data, offset, result=None, ntc=False):
         return self.packer.unpack_from(data, offset)[0], self.packer.size
 
+    @staticmethod
+    def _get_packer_with_options(f_type, options):
+        return BaseTypes(f_type, options=options)
 
-class String(object):
+    def __repr__(self):
+        return "BaseTypes(type=%s, elements=%s, options=%s)" % (self._type,
+                                                                self._elements,
+                                                                self.options)
+
+
+class String(Packer):
     def __init__(self, name, num, options):
         self.name = name
         self.num = num
@@ -114,8 +137,8 @@ class String(object):
         self.fixed = True if num else False
         if self.fixed and not self.limit:
             raise VPPSerializerValueError(
-                "Invalid argument length for: {}, {} maximum {}".
-                format(list, len(list), self.limit))
+                "Invalid combination for: {}, {} fixed:{} limit:{}".
+                format(name, options, self.fixed, self.limit))
 
     def pack(self, list, kwargs=None):
         if not list:
@@ -143,15 +166,18 @@ class String(object):
             return '', 0
         p = BaseTypes('u8', length)
         x, size = p.unpack(data, offset + length_field_size)
-        #x2 = x.split(b'\0', 1)[0]
         return (x.decode('ascii', errors='replace'), size + length_field_size)
 
 
-types = {'u8': BaseTypes('u8'), 'u16': BaseTypes('u16'),
+types = {'u8': BaseTypes('u8'), 'i8': BaseTypes('i8'),
+         'u16': BaseTypes('u16'), 'i16': BaseTypes('i16'),
          'u32': BaseTypes('u32'), 'i32': BaseTypes('i32'),
-         'u64': BaseTypes('u64'), 'f64': BaseTypes('f64'),
+         'u64': BaseTypes('u64'), 'i64': BaseTypes('i64'),
+         'f64': BaseTypes('f64'),
          'bool': BaseTypes('bool'), 'string': String}
 
+class_types = {}
+
 
 def vpp_get_type(name):
     try:
@@ -164,7 +190,7 @@ class VPPSerializerValueError(ValueError):
     pass
 
 
-class FixedList_u8(object):
+class FixedList_u8(Packer):
     def __init__(self, name, field_type, num):
         self.name = name
         self.num = num
@@ -172,10 +198,6 @@ class FixedList_u8(object):
         self.size = self.packer.size
         self.field_type = field_type
 
-    def __call__(self, args):
-        self.options = args
-        return self
-
     def pack(self, data, kwargs=None):
         """Packs a fixed length bytestring. Left-pads with zeros
         if input data is too short."""
@@ -194,6 +216,7 @@ class FixedList_u8(object):
             raise VPPSerializerValueError(
                 'Packing failed for "{}" {}'
                 .format(self.name, kwargs))
+
     def unpack(self, data, offset=0, result=None, ntc=False):
         if len(data[offset:]) < self.num:
             raise VPPSerializerValueError(
@@ -202,8 +225,13 @@ class FixedList_u8(object):
                 .format(self.name, len(data[offset:]), self.num))
         return self.packer.unpack(data, offset)
 
+    def __repr__(self):
+        return "FixedList_u8(name=%s, field_type=%s, num=%s)" % (
+            self.name, self.field_type, self.num
+        )
+
 
-class FixedList(object):
+class FixedList(Packer):
     def __init__(self, name, field_type, num):
         self.num = num
         self.packer = types[field_type]
@@ -211,10 +239,6 @@ class FixedList(object):
         self.name = name
         self.field_type = field_type
 
-    def __call__(self, args):
-        self.options = args
-        return self
-
     def pack(self, list, kwargs):
         if len(list) != self.num:
             raise VPPSerializerValueError(
@@ -236,8 +260,12 @@ class FixedList(object):
             total += size
         return result, total
 
+    def __repr__(self):
+        return "FixedList(name=%s, field_type=%s, num=%s)" % (
+            self.name, self.field_type, self.num)
+
 
-class VLAList(object):
+class VLAList(Packer):
     def __init__(self, name, field_type, len_field_name, index):
         self.name = name
         self.field_type = field_type
@@ -246,25 +274,22 @@ class VLAList(object):
         self.size = self.packer.size
         self.length_field = len_field_name
 
-    def __call__(self, args):
-        self.options = args
-        return self
-
-    def pack(self, list, kwargs=None):
-        if not list:
+    def pack(self, lst, kwargs=None):
+        if not lst:
             return b""
-        if len(list) != kwargs[self.length_field]:
+        if len(lst) != kwargs[self.length_field]:
             raise VPPSerializerValueError(
                 'Variable length error, got: {} expected: {}'
-                .format(len(list), kwargs[self.length_field]))
-        b = bytes()
+                .format(len(lst), kwargs[self.length_field]))
 
         # u8 array
-
         if self.packer.size == 1:
-            return bytearray(list)
+            if isinstance(lst, list):
+                return b''.join(lst)
+            return bytes(lst)
 
-        for e in list:
+        b = bytes()
+        for e in lst:
             b += self.packer.pack(e)
         return b
 
@@ -287,16 +312,20 @@ class VLAList(object):
             total += size
         return r, total
 
+    def __repr__(self):
+        return "VLAList(name=%s, field_type=%s, " \
+               "len_field_name=%s, index=%s)" % (
+                   self.name, self.field_type, self.length_field, self.index
+               )
+
 
-class VLAList_legacy():
+class VLAList_legacy(Packer):
     def __init__(self, name, field_type):
+        self.name = name
+        self.field_type = field_type
         self.packer = types[field_type]
         self.size = self.packer.size
 
-    def __call__(self, args):
-        self.options = args
-        return self
-
     def pack(self, list, kwargs=None):
         if self.packer.size == 1:
             return bytes(list)
@@ -321,11 +350,21 @@ class VLAList_legacy():
             total += size
         return r, total
 
+    def __repr__(self):
+        return "VLAList_legacy(name=%s, field_type=%s)" % (
+            self.name, self.field_type
+        )
 
-class VPPEnumType(object):
-    def __init__(self, name, msgdef):
+
+# Will change to IntEnum after 21.04 release
+class VPPEnumType(Packer):
+    output_class = IntFlag
+
+    def __init__(self, name, msgdef, options=None):
         self.size = types['u32'].size
+        self.name = name
         self.enumtype = 'u32'
+        self.msgdef = msgdef
         e_hash = {}
         for f in msgdef:
             if type(f) is dict and 'enumtype' in f:
@@ -335,12 +374,10 @@ class VPPEnumType(object):
                 continue
             ename, evalue = f
             e_hash[ename] = evalue
-        self.enum = IntFlag(name, e_hash)
+        self.enum = self.output_class(name, e_hash)
         types[name] = self
-
-    def __call__(self, args):
-        self.options = args
-        return self
+        class_types[name] = self.__class__
+        self.options = options
 
     def __getattr__(self, name):
         return self.enum[name]
@@ -348,20 +385,40 @@ class VPPEnumType(object):
     def __bool__(self):
         return True
 
-    if sys.version[0] == '2':
-        __nonzero__ = __bool__
-
     def pack(self, data, kwargs=None):
+        if data is None:  # Default to zero if not specified
+            if self.options and 'default' in self.options:
+                data = self.options['default']
+            else:
+                data = 0
+
         return types[self.enumtype].pack(data)
 
     def unpack(self, data, offset=0, result=None, ntc=False):
         x, size = types[self.enumtype].unpack(data, offset)
         return self.enum(x), size
 
+    @classmethod
+    def _get_packer_with_options(cls, f_type, options):
+        return cls(f_type, types[f_type].msgdef, options=options)
+
+    def __repr__(self):
+        return "%s(name=%s, msgdef=%s, options=%s)" % (
+            self.__class__.__name__, self.name, self.msgdef, self.options
+        )
+
+
+class VPPEnumFlagType(VPPEnumType):
+    output_class = IntFlag
+
+    def __init__(self, name, msgdef, options=None):
+        super(VPPEnumFlagType, self).__init__(name, msgdef, options)
+
 
-class VPPUnionType(object):
+class VPPUnionType(Packer):
     def __init__(self, name, msgdef):
         self.name = name
+        self.msgdef = msgdef
         self.size = 0
         self.maxindex = 0
         fields = []
@@ -385,10 +442,6 @@ class VPPUnionType(object):
         types[name] = self
         self.tuple = collections.namedtuple(name, fields, rename=True)
 
-    def __call__(self, args):
-        self.options = args
-        return self
-
     # Union of variable length?
     def pack(self, data, kwargs=None):
         if not data:
@@ -412,10 +465,14 @@ class VPPUnionType(object):
             r.append(x)
         return self.tuple._make(r), maxsize
 
+    def __repr__(self):
+        return"VPPUnionType(name=%s, msgdef=%r)" % (self.name, self.msgdef)
 
-class VPPTypeAlias(object):
-    def __init__(self, name, msgdef):
+
+class VPPTypeAlias(Packer):
+    def __init__(self, name, msgdef, options=None):
         self.name = name
+        self.msgdef = msgdef
         t = vpp_get_type(msgdef['type'])
         if not t:
             raise ValueError('No such type: {}'.format(msgdef['type']))
@@ -434,10 +491,7 @@ class VPPTypeAlias(object):
 
         types[name] = self
         self.toplevelconversion = False
-
-    def __call__(self, args):
-        self.options = args
-        return self
+        self.options = options
 
     def pack(self, data, kwargs=None):
         if data and conversion_required(data, self.name):
@@ -446,11 +500,20 @@ class VPPTypeAlias(object):
             # Python 2 and 3 raises different exceptions from inet_pton
             except(OSError, socket.error, TypeError):
                 pass
+        if data is None:  # Default to zero if not specified
+            if self.options and 'default' in self.options:
+                data = self.options['default']
+            else:
+                data = 0
 
         return self.packer.pack(data, kwargs)
 
+    @staticmethod
+    def _get_packer_with_options(f_type, options):
+        return VPPTypeAlias(f_type, types[f_type].msgdef, options=options)
+
     def unpack(self, data, offset=0, result=None, ntc=False):
-        if ntc == False and self.name in vpp_format.conversion_unpacker_table:
+        if ntc is False and self.name in vpp_format.conversion_unpacker_table:
             # Disable type conversion for dependent types
             ntc = True
             self.toplevelconversion = True
@@ -460,8 +523,12 @@ class VPPTypeAlias(object):
             return conversion_unpacker(t, self.name), size
         return t, size
 
+    def __repr__(self):
+        return "VPPTypeAlias(name=%s, msgdef=%s, options=%s)" % (
+            self.name, self.msgdef, self.options)
+
 
-class VPPType(object):
+class VPPType(Packer):
     # Set everything up to be able to pack / unpack
     def __init__(self, name, msgdef):
         self.name = name
@@ -516,7 +583,12 @@ class VPPType(object):
                 p = VLAList(f_name, f_type, f[3], length_index)
                 self.packers.append(p)
             else:
-                p = types[f_type](self.options)
+                # default support for types that decay to basetype
+                if 'default' in self.options:
+                    p = self.get_packer_with_options(f_type, self.options)
+                else:
+                    p = types[f_type]
+
                 self.packers.append(p)
                 size += p.size
 
@@ -525,10 +597,6 @@ class VPPType(object):
         types[name] = self
         self.toplevelconversion = False
 
-    def __call__(self, args):
-        self.options = args
-        return self
-
     def pack(self, data, kwargs=None):
         if not kwargs:
             kwargs = data
@@ -562,7 +630,7 @@ class VPPType(object):
         # Return a list of arguments
         result = []
         total = 0
-        if ntc == False and self.name in vpp_format.conversion_unpacker_table:
+        if ntc is False and self.name in vpp_format.conversion_unpacker_table:
             # Disable type conversion for dependent types
             ntc = True
             self.toplevelconversion = True
@@ -581,6 +649,11 @@ class VPPType(object):
             t = conversion_unpacker(t, self.name)
         return t, total
 
+    def __repr__(self):
+        return "%s(name=%s, msgdef=%s)" % (
+            self.__class__.__name__, self.name, self.msgdef
+        )
+
 
 class VPPMessage(VPPType):
     pass