def test_valid_types(self):
for arg, arg_type in (('1234567890', 'string'),
(Addr('1234567890'), 'Addr')):
try:
Addr(arg)
except: # @fixme Detect (i.e. raise) an MpxException.
raise 'Failed to use a valid %s argument.' % arg_type
def test_setattr(self):
s = '1234567890'
a = Addr()
a.address = s
if len(s) != a.length:
raise 'Incorrect length attribute value.'
if s != a.address:
raise 'Incorrect address arribute value.'
def test_boundaries(self):
Addr('123456789012345678901234567890')
Addr('1234567890123456789012345678901')
try:
Addr('12345678901234567890123456789012')
raise 'Failed to detect too long of an address.'
except EOverflow: # @fixme Detect (i.e. raise) an MpxException.
pass
except:
raise 'Unexpected exception when using too long of an address.'
def __init__(self):
self.type = "IP"
self.name = "fake"
self.interface_id = -1
self.network = 1
self.addr = Addr('\x0a\x00\x01\x50\xba\xc0')
self.broadcast = Addr('\x0a\x00\x01\xff\xba\xc0')
self.our_ip_address = 0x7f000001
self.our_ip_port = 0xbca0
self.is_open = 1
_test_case_support(self)
def test_item(self):
s = '012345'
for i in range(0,len(s)):
if s[i] != Addr(s)[i]:
raise 'Positive index mismatch.'
if s[-i] != Addr(s)[-i]:
raise 'Negative index mismatch.'
try:
Addr(s)[len(s)]
raise 'Failed to detect index out of range.'
except IndexError:
pass
except:
raise 'Wrong exception raised for index out of range.'
def test_ForwardedNPDU(self):
a = '\x81\x04\x00\x20\x55\xAA\x05\xA0\xBA\xC01234567890123456789012'
b = ForwardedNPDU(decode=a)
if b.encoding != a:
raise 'ForwardedNPDU failed to decode encoding'
if b.length != 32:
raise 'ForwardedNPDU failed to decode length'
if b.originating_address.address != Addr('\x55\xAA\x05\xA0\xBA\xC0').address:
raise 'ForwardedNPDU failed to decode address'
if b.npdu != a[10:]:
raise 'ForwardedNPDU failed to decode ndpu'
c = ForwardedNPDU(Addr('\x55\xAA\x05\xA0\xBA\xC0'), a[10:])
if c.encoding != a:
raise 'ForwardedNPDU failed to encode'
pass
def test_invalid_types(self):
for arg, arg_type in ((1, 'integer'), ((1,2,3), 'tuple'), ([1], 'list')):
try:
Addr(arg)
except: # @fixme Detect (i.e. raise) an MpxException.
continue
raise 'Failed to detect an invalid %s argument.' % arg_type
def decode(self, buffer):
if len(buffer) != 10:
raise ETypeError('BDT entries must be 10 octets long')
self.encoding = buffer
self.addr = Addr(self.encoding[0:6])
self.ttl = _str_as_ushort(self.encoding[6:8])
self.seconds_remaining = _str_as_ushort(self.encoding[8:10]) + 30
def get_bdt_from(self, network, ip_address, ip_port):
a = _ip_format_str_as_ulong(ip_address)
p = int(ip_port)
addr = Addr(_ulong_as_str(a) + _ushort_as_str(p))
try:
_module_lock.acquire()
self.reports = {}
finally:
_module_lock.release()
if debug > 1:
_dump_send(network, addr.address,
ReadBroadcastDistributionTable().encoding)
send(network, addr.address, ReadBroadcastDistributionTable().encoding)
timeout = 0
_module_lock.acquire()
try:
while (len(self.reports.values()) < 1) and (timeout < 10):
_module_lock.release()
pause(0.5)
timeout += 1
_module_lock.acquire()
finally:
try:
_module_lock.release()
except:
pass
_module_lock.acquire()
try:
if (len(self.reports.values()) > 0):
self.entries = self.reports.values()[0]
finally:
_module_lock.release()
return self.report(network)
def test_FDT(self):
n = network.open_interface('IP', 'lo', 1)
a = '\x81\x05\x00\x06\x00\x05'
b = Addr('\x55\xAA\x05\xA0\xBA\xC0')
c = RegisterForeignDevice(b, decode=a)
f = ForeignDeviceTable()
f.register_foreign_device(c)
for x in range(30):
pause(1.0)
if len(f.entries) == 0:
raise 'Foreign device table tick failure, early removal'
pause(10.0)
if len(f.entries) != 0:
raise 'Foreign device table tick failure to remove device'
#e = '\x81\x0B\x20\x000123456789012345678901234567'
#o = OriginalBroadcastNPDU(decode=e)
#r = Addr('\xAA\x55\x05\xA0\xBA\xC0')
#f.forward_original_broadcast_message(n.network, r, o.npdu)
#how do I check to see if it made it?
#g = '\x81\x04\x20\x00\x55\xAA\x05\xA0\xBA\xC01234567890123456789012'
#h = ForwardedNPDU(decode=g)
#f.broadcast_forwarded_message(n.network, r, h)
#f.distribute(n.network, r, h)
f._stop_ticking()
network.close_interface(n)
pass
def test_repr(self):
import mpx.lib.bacnet.npdu
a = Addr('1234')
r = repr(a)
b = eval(r)
# @fixme Add direct support for the comparision operator.
if a.address != b.address:
raise 'eval(Repr(a)) failed to generate a reasonable clone.'
def test_len(self):
for s in ('', '1', '12345', '1234567890',
'12345678901234567890',
'123456789012345678901234567890',
'1234567890123456789012345678901'):
a = Addr(s)
if len(s) != len(a):
raise 'Incorrect len() calculated.'
def test_ReadForeignDeviceTableAck(self):
a = Addr('\x55\xAA\x05\xA0\xBA\xC0')
b = RegisterForeignDevice(a, 255)
c = ForeignDeviceTable()
c.register_foreign_device(b)
d = c.read_table()
e = '\x81\x07\x00\x0e\x55\xaa\x05\xa0\xba\xc0\x00\xff\x01\x1d'
if d.encoding <> e:
raise 'ReadForeignDeviceTableAck failure'
pass
def test_DeleteForeignDeviceTableEntry(self):
a = Addr('\x55\xAA\x05\xA0\xBA\xC0')
b = RegisterForeignDevice(a, 255)
c = ForeignDeviceTable()
c.register_foreign_device(b)
d = '\x81\x08\x00\x0a\x55\xAA\x05\xA0\xBA\xC0'
d = DeleteForeignDeviceTableEntry(decode=d)
e = c.delete_entry(d)
if e.encoding != Result(0x0000).encoding:
raise 'DeleteForeignDeviceTableEntry failed to delete'
e = c.delete_entry(d)
if e.encoding != Result(0x0050).encoding:
raise 'DeleteForeignDeviceTableEntry deleted the same object twice'
pass
def test_RegisterForeignDevice(self):
a = '\x81\x05\x00\x06\x00\xff'
b = Addr('\x55\xAA\x05\xA0\xBA\xC0')
c = RegisterForeignDevice(b, decode=a)
if c.encoding != a:
raise 'RegisterForeignDevice failed to decode encoding'
if c.foreign_device_address.address != b.address:
raise 'RegisterForeignDevice failed to decode addr'
if c.time_to_live != 255:
raise 'RegisterForeignDevice failed to decode time_to_live'
d = RegisterForeignDevice(b, 255)
if d.encoding != a:
raise 'RegisterForeignDevice failed to encode encoding'
if d.foreign_device_address.address != b.address:
raise 'RegisterForeignDevice failed to encode addr'
if d.time_to_live != 255:
raise 'RegisterForeignDevice failed to encode time_to_live'
pass
def test_server(self):
msg = TEST.example_confirmed_request_npdu()
#print msg
source = Addr()
_network = 1111
node = FakeNode()
node.instance = 1
the_device = server._DeviceInfo()
the_device.instance_number = node.instance
the_device.node = node
the_device.network = _network
the_device.mac_network = _network
the_device.address = '127.0.0.1'
the_device.mac_address = the_device.address
the_device.find_bacnet_object = find_bacnet_object
server.the_device = the_device
#tag.decode(msg.data)
rsp = _bacnet.server_read_property(the_device, msg)
if msg.sspec != rsp.dspec:
raise 'the source spec and destination spec do not match'
def test_slice(self):
s = '012345'
Addr(s)[:]
Addr(s)[0:]
Addr(s)[1:]
Addr(s)[:6]
Addr(s)[:5]
Addr(s)[-1000000000000L:]
Addr(s)[:1000000000000L]
Addr(s)[-1000000000000L:1000000000000L]
Addr(s)[1000000000000L:-1000000000000L]
Addr(s)[0:6]
Addr(s)[1:-1]
Addr(s)[-1:1]
def test_str(self):
s = "Addr: 74 68 69 73 20 69 73 20 61 20 73 74 72 69 6e 67\n" + \
" 20 74 65 73 74"
a = Addr('this is a string test')
if str(a) != s:
raise 'An unexpected string was generated.'
def decode(self, buffer):
self.encoding = buffer
self.length = _bvlc_length(buffer)
self.originating_address = Addr(buffer[4:10])
self.npdu = buffer[10:]
def decode(self, buffer):
self.encoding = buffer
self.foreign_device_address = Addr(buffer[4:10])
def asBBMDaddress(self):
ip = long(self.ip_address) | (0xffffffffL ^ long(self.ip_mask))
ip &= 0xffffffffL
return Addr(struct.pack('!LH', ip, self.ip_port)) #six byte
def _dump_send(network, address, msg):
print "BBMD send: network =", network
print "BBMD send: address =", Addr(address)
dump(msg, "BBMD send:")
def _service_bbmd_queue(BBMD_queue):
#loop forever getting messages from the queue and servicing them
global _module_lock
while 1:
# a tuple of network number, Addr, string
a_message = BBMD_queue.get()
#process the incoming message
answer = None
network = a_message[0]
addr = Addr(a_message[1])
message_string = a_message[2]
if debug > 1:
print "BBMD recv: network=", network
print "BBMD recv: from=", addr
dump(message_string, "BBMD recv")
if not BBMD_servers.has_key(network):
continue
bbmd = BBMD_servers[network]
bdt = bbmd.bdt
fdt = bbmd.fdt
if ord(message_string[0]) != 0x81: #not bvlc frame
# @fixme Just log it and toss the message.
raise EInvalidValue('frame_type',
ord(message_string[0]),
text='Not a BVLC frame')
# extract the 'BVLC Function' octet
bvlc_function = ord(message_string[1])
if (bvlc_function == 0x0A): #OriginalUnicastNPDU
if debug > 2:
print "BBMD rcvd: OriginalUnicastNPDU:", network
elif (bvlc_function == 0x0B): #OriginalBroadcastNPDU
if debug > 2:
print "BBMD rcvd: OriginalBroadcastNPDU:", network
if bbmd.enable:
obn = OriginalBroadcastNPDU(decode=message_string).npdu
if debug > 2:
print "BBMD send: ForwardedNPDU network:", network
print "BBMD send: for=", addr
dump(obn, "BBMD npdu")
bdt.forward_original_broadcast_message(network, addr, obn)
fdt.forward_original_broadcast_message(network, addr, obn)
elif (bvlc_function == 0x00): #Result
if debug > 2:
print "BBMD rcvd: Result:", network
pass
elif (bvlc_function == 0x01): #WriteBroadcastDistributionTable
if debug > 2:
print "BBMD rcvd: WriteBroadcastDistributionTable:", network
answer = bdt.write_new_table_contents(
WriteBroadcastDistributionTable(decode=message_string))
elif (bvlc_function == 0x02): #ReadBroadcastDistributionTable
if debug > 2:
print "BBMD rcvd: ReadBroadcastDistributionTable:", network
answer = bdt.read_table()
elif (bvlc_function == 0x03): #ReadBroadcastDistributionTableAck
if debug > 2:
print "BBMD rcvd: ReadBroadcastDistributionTableAck:", network
if bbmd.report_bdt:
bbmd.report_bdt.read_broadcast_distributioan_table_ack(
network, addr,
ReadBroadcastDistributionTableAck(decode=message_string))
elif (bvlc_function == 0x04): #ForwardedNPDU
if debug > 2:
print "BBMD rcvd: ForwardedNPDU network", network
if bbmd.enable:
fnpdu = ForwardedNPDU(decode=message_string)
if debug > 2:
print "BBMD Broadcast ForwardedNPDU network", network
print "BBMD broadcast for=", fnpdu.originating_address
dump(fnpdu.npdu, "BBMD npdu")
bdt.broadcast_forwarded_message(network, fnpdu)
fdt.broadcast_forwarded_message(network, fnpdu)
elif (bvlc_function == 0x05): #RegisterForeignDevice
if debug > 2:
print "BBMD rcvd: RegisterForeignDevice network", network
if bbmd.enable:
answer = fdt.register_foreign_device(
RegisterForeignDevice(addr, decode=message_string))
elif (bvlc_function == 0x06): #ReadForeignDeviceTable
answer = fdt.read_table()
elif (bvlc_function == 0x07): #ReadForeignDeviceTableAck
pass
elif (bvlc_function == 0x08): #DeleteForeignDeviceTableEntry
answer = fdt.delete_entry(
DeleteForeignDeviceTableEntry(decode=message_string))
elif (bvlc_function == 0x09): #DistributeBroadcastToNetwork
if debug > 2:
print "BBMD rcvd: DistributeBroadcastToNetwork network",\
network
if bbmd.enable:
try:
dbtn = DistributeBroadcastToNetwork(decode=message_string)
answer = ForwardedNPDU(addr, dbtn.npdu)
bdt.distribute(network, addr, answer)
fdt.distribute(network, addr, answer)
#locally broadcast the forwared npdu
addr = Addr(bbmd.broadcast_address)
except:
msglog.exception()
answer = Result(0x0060)
else:
if debug > 2:
print "BBMD rcvd: Unknown message"
if (answer):
if debug > 1:
_dump_send(network, addr.address, answer.encoding)
send(network, addr.address, answer.encoding)
def test_empty(self):
Addr()
