packet.utils - Pktt utilities module

       Jorge Mora (mora@netapp.com)

NFStest 3.2                                       21 March 2023                                         UTILS(3)

       No known bugs.

classBitmapInval(builtins.Exception)
       Exception for an invalid bit number

   classByteHex(builtins.int)
       Byte integer object which is displayed in hex

       Methodsdefinedhere:
       ---------------------

       __repr__=__str__(self)__str__(self)
       Return str(self).

   classDateStr(builtins.float)
       Floating point object which is displayed as a date

       Methodsdefinedhere:
       ---------------------

       __str__(self)
       Return str(self).

   classEnum(builtins.int)
       Enum base object
       This should only be used as a base class where the class attributes
       should be initialized

       Methodsdefinedhere:
       ---------------------

       __repr__(self)
       Official string representation, display value using the mapping
       dictionary provided as a class attribute when ENUM_REPR is False

       __str__(self)
       Informal string representation, display value using the mapping
       dictionary provided as a class attribute

       Staticmethodsdefinedhere:
       ----------------------------

       __new__(cls,unpack)
       Constructor which checks if integer is a valid enum value

   classEnumInval(builtins.Exception)
       Exception for an invalid enum value

   classIntHex(builtins.int)
       Integer object which is displayed in hex

       Methodsdefinedhere:
       ---------------------

       __repr__=__str__(self)__str__(self)
       Return str(self).

   classLongHex(builtins.int)
       Long integer object which is displayed in hex

       Methodsdefinedhere:
       ---------------------

       __repr__=__str__(self)__str__(self)
       Return str(self).

   classOptionFlags(baseobj.BaseObj)
       OptionFlags base object

       This base class is used to have a set of raw flags represented by an
       integer and splits every bit into an object attribute according to the
       class attribute _bitnames where the key is the bit number and the value
       is the attribute name.

       This should only be used as a base class where the class attribute
       _bitnames should be initialized. The class attribute _reversed can
       also be initialized to reverse the _bitnames so the first bit becomes
       the last, e.g., _reversed = 31, bits are reversed on a 32 bit integer
       so 0 becomes 31, 1 becomes 30, etc.

       Usage:
           from packet.utils import OptionFlags

           class MyFlags(OptionFlags):
               _bitnames = {0:"bit0", 1:"bit1", 2:"bit2", 3:"bit3"}

           x = MyFlags(10) # 10 = 0b1010

           The attributes of object are:
               x.rawflags = 10, # Original raw flags
               x.bit0     = 0,
               x.bit1     = 1,
               x.bit2     = 0,
               x.bit3     = 1,

       Methodsdefinedhere:
       ---------------------

       __init__(self,options)
       Initialize object's private data.

              options:
                     Unsigned integer of raw flags

       str_flags(self)
       Display the flag names which are set, e.g., in the above example
       the output will be "bit1,bit3" (bit1=1, bit3=1)
       Use "__str__ = OptionFlags.str_flags" to have it as the default
       string representation

   classRDMAbase(baseobj.BaseObj)
       RDMA base object

       Base class for an RDMA reduced payload object having RDMA write
       chunks. An application having a DDP (direct data placement) item
       must inherit this class and use the rdma_opaque method as a
       dissecting function.

       Usage:
           from packet.utils import RDMAbase

           # For an original class definition with DDP items
           class APPobj(BaseObj):
               def __init__(self, unpack):
                   self.test = nfs_bool(unpack)
                   self.data = unpack.unpack_opaque()

           # Class definition to access RDMA chunk writes
           class APPobj(RDMAbase):
               def __init__(self, unpack):
                   self.test = self.rdma_opaque(nfs_bool, unpack)
                   self.data = self.rdma_opaque(unpack.unpack_opaque)

       Methodsdefinedhere:
       ---------------------

       rdma_opaque(self,func,*kwts,**kwds)
           Dissecting method for a DDP item
           The first positional argument is the original dissecting
           function to be called when there is no RDMA write chunks.
           The rest of the arguments (positional or named) are passed
           directly to the dissecting function.

       Data and other attributes defined here:

       rdma_write_chunks = []

   classRPCload(baseobj.BaseObj)
       RPC load base object
       This is used as a base class for an RPC payload object

       Methodsdefinedhere:
       ---------------------

       __str__(self)
       Informal string representation

       main_op(self)
       Get the main NFS operation

       rpc_str(self,name=None)
       Display RPC string

   classShortHex(builtins.int)
       Short integer object which is displayed in hex

       Methodsdefinedhere:
       ---------------------

       __repr__=__str__(self)__str__(self)
       Return str(self).

   classStrHex(builtins.bytes)
       String object which is displayed in hex

       Methodsdefinedhere:
       ---------------------

       __str__(self)
       Return str(self).

       The  Packet  trace  utilities  module  has  classes  which augment functionality of basic data types like
       displaying integers as their hex equivalent.  It also includes an Enum  base  class  which  displays  the
       integer as its string representation given by a mapping dictionary. There is also a class to be used as a
       base  class  for  an  RPC  payload object.  This module also includes some module variables to change how
       certain objects are displayed.

bitmap_info(unpack,bitmap,key_enum=None,func_map=None)
       Returns a list of bits set on the bitmap or a dictionary where the
       key is the bit number given by bitmap and the value is the decoded
       value by evaluating the function used for that specific bit number

              unpack:
                     Unpack object

              bitmap:
                     Unsigned integer where a value must be decoded for every bit that
                     is set, starting from the least significant bit

              key_enum:
                     Use Enum for bit number so the key could be displayed as the bit
                     name instead of the bit number [default: None]

              func_map:
                     Dictionary which maps a bit number to the function to be used for
                     decoding the value for that bit number. The function must have
                     the "unpack" object as the only argument. If this is None a list
                     of bit attributes is returned instead [default: None]

       packet.utils - Pktt utilities module

baseobj(3),packet.unpack(3)