def __init__ (self, msgdict=None, msgbytes=None):
if not (msgdict or msgbytes):
raise LLRPError('Provide either a message dict or a sequence' \
' of bytes.')
if msgdict:
self.msgdict = LLRPMessageDict(msgdict)
if not msgbytes:
self.serialize()
if msgbytes:
self.msgbytes = copy.copy(msgbytes)
if not msgdict:
self.remainder = self.deserialize()
def __init__(self, msgdict=None, msgbytes=None):
if not (msgdict or msgbytes):
raise LLRPError("Provide either a message dict or a sequence" " of bytes.")
if msgdict:
self.msgdict = LLRPMessageDict(msgdict)
if not msgbytes:
self.serialize()
if msgbytes:
self.msgbytes = msgbytes
if not msgdict:
self.deserialize()
self.peername = None
class LLRPMessage:
hdr_fmt = '!HI'
hdr_len = struct.calcsize(hdr_fmt) # == 6 bytes
full_hdr_fmt = hdr_fmt + 'I'
full_hdr_len = struct.calcsize(full_hdr_fmt) # == 10 bytes
msgdict = None
msgbytes = None
def __init__ (self, msgdict=None, msgbytes=None):
if not (msgdict or msgbytes):
raise LLRPError('Provide either a message dict or a sequence' \
' of bytes.')
if msgdict:
self.msgdict = LLRPMessageDict(msgdict)
if not msgbytes:
self.serialize()
if msgbytes:
self.msgbytes = msgbytes
if not msgdict:
self.deserialize()
self.peername = None
def serialize (self):
if self.msgdict is None:
raise LLRPError('No message dict to serialize.')
name = self.msgdict.keys()[0]
logger.debug('serializing %s command', name)
ver = self.msgdict[name]['Ver'] & BITMASK(3)
msgtype = self.msgdict[name]['Type'] & BITMASK(10)
msgid = self.msgdict[name]['ID']
try:
encoder = Message_struct[name]['encode']
except KeyError:
raise LLRPError('Cannot find encoder for message type '
'{}'.format(name))
data = encoder(self.msgdict[name])
self.msgbytes = struct.pack(self.full_hdr_fmt,
(ver << 10) | msgtype,
len(data) + self.full_hdr_len,
msgid) + data
logger.debug('serialized bytes: %s', hexlify(self.msgbytes))
logger.debug('done serializing %s command', name)
def deserialize (self):
"""Turns a sequence of bytes into a message dictionary."""
if self.msgbytes is None:
raise LLRPError('No message bytes to deserialize.')
data = ''.join(self.msgbytes)
msgtype, length, msgid = struct.unpack(self.full_hdr_fmt,
data[:self.full_hdr_len])
ver = (msgtype >> 10) & BITMASK(3)
msgtype = msgtype & BITMASK(10)
try:
name = Message_Type2Name[msgtype]
logger.debug('deserializing %s command', name)
decoder = Message_struct[name]['decode']
except KeyError:
raise LLRPError('Cannot find decoder for message type '
'{}'.format(msgtype))
body = data[self.full_hdr_len:length]
try:
self.msgdict = {
name: dict(decoder(body))
}
self.msgdict[name]['Ver'] = ver
self.msgdict[name]['Type'] = msgtype
self.msgdict[name]['ID'] = msgid
logger.debug('done deserializing %s command', name)
except LLRPError as e:
logger.exception('Problem with %s message format', name)
return ''
return ''
def isSuccess (self):
if not self.msgdict:
return False
success = False
msgName = self.getName()
md = self.msgdict[msgName]
try:
if msgName == 'READER_EVENT_NOTIFICATION':
return md['ReaderEventNotificationData']\
['ConnectionAttemptEvent']['Status'] == 'Success'
elif 'LLRPStatus' in md:
return md['LLRPStatus']['StatusCode'] == 'Success'
except KeyError as KE:
logger.exception('failed to parse status from %s', msgName)
return False
def getName (self):
if not self.msgdict:
return None
return self.msgdict.keys()[0]
def __repr__ (self):
try:
ret = llrp_data2xml(self.msgdict)
except TypeError as te:
logger.exception(te)
ret = ''
return ret
class LLRPMessage:
hdr_fmt = '!HI'
hdr_len = struct.calcsize(hdr_fmt) # == 6 bytes
full_hdr_fmt = hdr_fmt + 'I'
full_hdr_len = struct.calcsize(full_hdr_fmt) # == 10 bytes
msgdict = None
msgbytes = None
remainder = None
def __init__ (self, msgdict=None, msgbytes=None):
if not (msgdict or msgbytes):
raise LLRPError('Provide either a message dict or a sequence' \
' of bytes.')
if msgdict:
self.msgdict = LLRPMessageDict(msgdict)
if not msgbytes:
self.serialize()
if msgbytes:
self.msgbytes = copy.copy(msgbytes)
if not msgdict:
self.remainder = self.deserialize()
def serialize (self):
if self.msgdict is None:
raise LLRPError('No message dict to serialize.')
name = self.msgdict.keys()[0]
logger.debug('serializing {} command'.format(name))
ver = self.msgdict[name]['Ver'] & BITMASK(3)
msgtype = self.msgdict[name]['Type'] & BITMASK(10)
msgid = self.msgdict[name]['ID']
try:
encoder = Message_struct[name]['encode']
except KeyError:
raise LLRPError('Cannot find encoder for message type '
'{}'.format(name))
data = encoder(self.msgdict[name])
self.msgbytes = struct.pack(self.full_hdr_fmt,
(ver << 10) | msgtype,
len(data) + self.full_hdr_len,
msgid) + data
logger.debug('serialized bytes: {}'.format(hexlify(self.msgbytes)))
logger.debug('done serializing {} command'.format(name))
def deserialize (self):
"""Turns a sequence of bytes into a message dictionary. Any leftover
data in the sequence is returned as the remainder."""
if self.msgbytes is None:
raise LLRPError('No message bytes to deserialize.')
data = ''.join(self.msgbytes)
remainder = ''
msgtype, length, msgid = struct.unpack(self.full_hdr_fmt,
data[:self.full_hdr_len])
ver = (msgtype >> 10) & BITMASK(3)
msgtype = msgtype & BITMASK(10)
try:
name = Message_Type2Name[msgtype]
logger.debug('deserializing {} command'.format(name))
decoder = Message_struct[name]['decode']
except KeyError:
raise LLRPError('Cannot find decoder for message type '
'{}'.format(msgtype))
body = data[self.full_hdr_len:length]
try:
self.msgdict = {
name: dict(decoder(body))
}
self.msgdict[name]['Ver'] = ver
self.msgdict[name]['Type'] = msgtype
self.msgdict[name]['ID'] = msgid
logger.debug('done deserializing {} command'.format(name))
except LLRPError as e:
logger.warning('Problem with {} message format: {}'.format(name, e))
return ''
if length < len(data):
remainder = data[length:]
logger.debug('{} bytes of data remaining'.format(len(remainder)))
return remainder
return ''
def getName (self):
if not self.msgdict:
return None
return self.msgdict.keys()[0]
def __repr__ (self):
try:
ret = llrp_data2xml(self.msgdict)
except TypeError as te:
logger.exception(te)
ret = ''
return ret
class LLRPMessage:
hdr_fmt = '!HI'
hdr_len = struct.calcsize(hdr_fmt) # == 6 bytes
full_hdr_fmt = hdr_fmt + 'I'
full_hdr_len = struct.calcsize(full_hdr_fmt) # == 10 bytes
msgdict = None
msgbytes = None
def __init__ (self, msgdict=None, msgbytes=None):
if not (msgdict or msgbytes):
raise LLRPError('Provide either a message dict or a sequence' \
' of bytes.')
if msgdict:
self.msgdict = LLRPMessageDict(msgdict)
if not msgbytes:
self.serialize()
if msgbytes:
self.msgbytes = msgbytes
if not msgdict:
self.deserialize()
self.peername = None
def serialize (self):
if self.msgdict is None:
raise LLRPError('No message dict to serialize.')
name = self.msgdict.keys()[0]
logger.debug('serializing {} command'.format(name))
ver = self.msgdict[name]['Ver'] & BITMASK(3)
msgtype = self.msgdict[name]['Type'] & BITMASK(10)
msgid = self.msgdict[name]['ID']
try:
encoder = Message_struct[name]['encode']
except KeyError:
raise LLRPError('Cannot find encoder for message type '
'{}'.format(name))
data = encoder(self.msgdict[name])
self.msgbytes = struct.pack(self.full_hdr_fmt,
(ver << 10) | msgtype,
len(data) + self.full_hdr_len,
msgid) + data
logger.debug('serialized bytes: {}'.format(hexlify(self.msgbytes)))
logger.debug('done serializing {} command'.format(name))
def deserialize (self):
"""Turns a sequence of bytes into a message dictionary."""
if self.msgbytes is None:
raise LLRPError('No message bytes to deserialize.')
data = ''.join(self.msgbytes)
msgtype, length, msgid = struct.unpack(self.full_hdr_fmt,
data[:self.full_hdr_len])
ver = (msgtype >> 10) & BITMASK(3)
msgtype = msgtype & BITMASK(10)
try:
name = Message_Type2Name[msgtype]
logger.debug('deserializing {} command'.format(name))
decoder = Message_struct[name]['decode']
except KeyError:
raise LLRPError('Cannot find decoder for message type '
'{}'.format(msgtype))
body = data[self.full_hdr_len:length]
try:
self.msgdict = {
name: dict(decoder(body))
}
self.msgdict[name]['Ver'] = ver
self.msgdict[name]['Type'] = msgtype
self.msgdict[name]['ID'] = msgid
logger.debug('done deserializing {} command'.format(name))
except LLRPError as e:
logger.warning('Problem with {} message format: {}'.format(name, e))
return ''
return ''
def isSuccess (self):
if not self.msgdict:
return False
success = False
msgName = self.getName()
md = self.msgdict[msgName]
try:
if msgName == 'READER_EVENT_NOTIFICATION':
return md['ReaderEventNotificationData']\
['ConnectionAttemptEvent']['Status'] == 'Success'
elif 'LLRPStatus' in md:
return md['LLRPStatus']['StatusCode'] == 'Success'
except KeyError as KE:
logger.error('failed to parse status from {}: {}'.format(msgName,
KE))
return False
def getName (self):
if not self.msgdict:
return None
return self.msgdict.keys()[0]
def __repr__ (self):
try:
ret = llrp_data2xml(self.msgdict)
except TypeError as te:
logger.exception(te)
ret = ''
return ret
class LLRPMessage(object):
hdr_fmt = "!HI"
hdr_len = struct.calcsize(hdr_fmt) # == 6 bytes
full_hdr_fmt = hdr_fmt + "I"
full_hdr_len = struct.calcsize(full_hdr_fmt) # == 10 bytes
msgdict = None
msgbytes = None
def __init__(self, msgdict=None, msgbytes=None):
if not (msgdict or msgbytes):
raise LLRPError("Provide either a message dict or a sequence" " of bytes.")
if msgdict:
self.msgdict = LLRPMessageDict(msgdict)
if not msgbytes:
self.serialize()
if msgbytes:
self.msgbytes = msgbytes
if not msgdict:
self.deserialize()
self.peername = None
def serialize(self):
if self.msgdict is None:
raise LLRPError("No message dict to serialize.")
name = self.msgdict.keys()[0]
logger.debug("serializing %s command", name)
ver = self.msgdict[name]["Ver"] & BITMASK(3)
msgtype = self.msgdict[name]["Type"] & BITMASK(10)
msgid = self.msgdict[name]["ID"]
try:
encoder = Message_struct[name]["encode"]
except KeyError:
raise LLRPError("Cannot find encoder for message type " "{}".format(name))
data = encoder(self.msgdict[name])
self.msgbytes = (
struct.pack(self.full_hdr_fmt, (ver << 10) | msgtype, len(data) + self.full_hdr_len, msgid) + data
)
logger.debug("serialized bytes: %s", hexlify(self.msgbytes))
logger.debug("done serializing %s command", name)
def deserialize(self):
"""Turns a sequence of bytes into a message dictionary."""
if self.msgbytes is None:
raise LLRPError("No message bytes to deserialize.")
data = "".join(self.msgbytes)
msgtype, length, msgid = struct.unpack(self.full_hdr_fmt, data[: self.full_hdr_len])
ver = (msgtype >> 10) & BITMASK(3)
msgtype = msgtype & BITMASK(10)
try:
name = Message_Type2Name[msgtype]
logger.debug("deserializing %s command", name)
decoder = Message_struct[name]["decode"]
except KeyError:
raise LLRPError("Cannot find decoder for message type " "{}".format(msgtype))
body = data[self.full_hdr_len : length]
try:
self.msgdict = {name: dict(decoder(body))}
self.msgdict[name]["Ver"] = ver
self.msgdict[name]["Type"] = msgtype
self.msgdict[name]["ID"] = msgid
logger.debug("done deserializing %s command", name)
except LLRPError:
logger.exception("Problem with %s message format", name)
return ""
return ""
def isSuccess(self):
if not self.msgdict:
return False
msgName = self.getName()
md = self.msgdict[msgName]
try:
if msgName == "READER_EVENT_NOTIFICATION":
ev = md["ReaderEventNotificationData"]
if "ConnectionAttemptEvent" in ev:
return ev["ConnectionAttemptEvent"]["Status"] == "Success"
elif "AntennaEvent" in ev:
return ev["AntennaEvent"]["EventType"] == "Connected"
elif "LLRPStatus" in md:
return md["LLRPStatus"]["StatusCode"] == "Success"
except KeyError:
logger.exception("failed to parse status from %s", msgName)
return False
def getName(self):
if not self.msgdict:
return None
return self.msgdict.keys()[0]
def __repr__(self):
try:
ret = llrp_data2xml(self.msgdict)
except TypeError as te:
logger.exception(te)
ret = ""
return ret
