Provided by: nfstest_3.2-2_all 
NAME
packet.utils - Pktt utilities module
DESCRIPTION
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.
CLASSES
class BitmapInval(builtins.Exception)
Exception for an invalid bit number
class ByteHex(builtins.int)
Byte integer object which is displayed in hex
Methods defined here:
---------------------
__repr__ = __str__(self)
__str__(self)
Return str(self).
class DateStr(builtins.float)
Floating point object which is displayed as a date
Methods defined here:
---------------------
__str__(self)
Return str(self).
class Enum(builtins.int)
Enum base object
This should only be used as a base class where the class attributes
should be initialized
Methods defined here:
---------------------
__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
Static methods defined here:
----------------------------
__new__(cls, unpack)
Constructor which checks if integer is a valid enum value
class EnumInval(builtins.Exception)
Exception for an invalid enum value
class IntHex(builtins.int)
Integer object which is displayed in hex
Methods defined here:
---------------------
__repr__ = __str__(self)
__str__(self)
Return str(self).
class LongHex(builtins.int)
Long integer object which is displayed in hex
Methods defined here:
---------------------
__repr__ = __str__(self)
__str__(self)
Return str(self).
class OptionFlags(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,
Methods defined here:
---------------------
__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
class RDMAbase(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)
Methods defined here:
---------------------
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 = []
class RPCload(baseobj.BaseObj)
RPC load base object
This is used as a base class for an RPC payload object
Methods defined here:
---------------------
__str__(self)
Informal string representation
main_op(self)
Get the main NFS operation
rpc_str(self, name=None)
Display RPC string
class ShortHex(builtins.int)
Short integer object which is displayed in hex
Methods defined here:
---------------------
__repr__ = __str__(self)
__str__(self)
Return str(self).
class StrHex(builtins.bytes)
String object which is displayed in hex
Methods defined here:
---------------------
__str__(self)
Return str(self).
FUNCTIONS
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]
SEE ALSO
baseobj(3), packet.unpack(3)
BUGS
No known bugs.
AUTHOR
Jorge Mora (mora@netapp.com)