def confirmed_service_indication(network, the_device, msg):
import _bacnet
try:
if msg.choice == BACNET_READ_PROPERTY:
response = _bacnet.server_read_property(the_device.node, msg)
elif msg.choice == BACNET_READ_PROPERTY_MULTIPLE:
response = _bacnet.server_read_property_multiple(
the_device.node, msg)
elif msg.choice == BACNET_WRITE_PROPERTY:
response = _bacnet.server_write_property(the_device.node, msg)
elif msg.choice == BACNET_WRITE_PROPERTY_MULTIPLE:
response = _bacnet.server_write_property_multiple(
the_device.node, msg)
elif msg.choice == BACNET_CONFIRMED_COV_NOTIFICATION:
response = server_cov_notification_msg(the_device.node, \
msg, confirmed = True)
else: #reject amything else
raise ENotImplemented('bacnet server', msg.choice,
'service choice not supported')
if response and (not _is_master_server(the_device, network)):
response.sspec = 1
response.slen = 6 #what should we chose?
response.sadr = utils.bytes_as_string_of_hex_values(
the_device.instance_number, response.slen)
response.snet = the_device.network #correct local copy?
except Exception, e:
msglog.exception()
rp = npdu.NPDU()
rp.pdu_type = BACNET_REJECT_PDU
rp.version = 1
rp.invoke_id = msg.invoke_id
rp.reason = 9 # Unsupported-Service
response = rp
def read_including(self, buffer, list, timeout):
if self.raw_mode:
raise ENotImplemented(self.read_including,'Not available in raw mode.')
if self.debug:
offset = len(buffer)
c = self._safe_apply(self._read_including, buffer, list, timeout)
if self.debug:
self.dump(buffer, ' < ', offset)
return c
def decode_character_string(buffer):
"""##
# Return the Python native representation of the BACnet character string
# encoded in the octets of <code>buffer</code>.
# @param buffer A string or array of bytes (types \'c\', \'b\', or \'B\').
# @return An appropriate CharacterString instance."""
character_set = ord(buffer[0])
if character_set == ANSI_X3dot4:
return ANSI_String(decode=buffer)
elif character_set == DBCS:
return DBCS_String(decode=buffer)
raise ENotImplemented("%s character set is not supported." % \
character_set_name(character_set))
def decode(self, buffer):
if type(buffer) is array.ArrayType:
buffer = buffer.tostring()
if len(buffer) < 1:
raise EInvalidValue('buffer length must be at least one byte long')
character_set = ord(buffer[0])
if character_set == ANSI_X3dot4:
self._decode_to_ansi(buffer)
elif character_set == DBCS:
self._decode_to_dbcs(buffer)
else:
raise ENotImplemented(character_set_name(self.character_set))
return
def __call__(self, *args):
argv = self.arguments()
if len(argv) not in (1, 2):
raise EArgument(
"mpxadmin rename: Must be called with one or two arguments.\n"
" mpxadmin [old-user-name] new-user-name\n"
" 'mpxadmin user rename --help' for more "
" information.")
elif len(argv) == 1:
old_user_name = argv[0]
new_user_name = self.current_user()
elif len(argv) == 2:
old_user_name = argv[0]
new_user_name = argv[1]
else:
raise EInternalError("Exectuted unreachable code.")
raise ENotImplemented("Renaming user %r to %r not implemented." %
(old_user_name, new_user_name))
return
def seek(self,offset,whence=0):
raise ENotImplemented(self._file.seek)
def xreadlines(self):
raise ENotImplemented(self._file.xreadlines)
def readlines(self,sizehint=None,timeout=None):
raise ENotImplemented(self._file.readlines)
def current_id(klass, **keywords):
raise ENotImplemented(klass.current_id)
def password(self):
raise ENotImplemented(self.password)
def match(self, path):
raise ENotImplemented()
def set_gids(self, gids):
raise ENotImplemented(self.set_gids)
def __len__(self):
if (self.__getitem__ is self._raise_error):
return 0
raise ENotImplemented()
def _get_status(self):
raise ENotImplemented()
def _shell_handler(self, *args):
raise ENotImplemented("--shell not implemented")
def _groups_handler(self, *args):
raise ENotImplemented("--groups not implemented")
def _uid_handler(self, *args):
raise ENotImplemented("--uid not implemented")
def tell(self):
raise ENotImplemented(self._file.tell)
def encode(self):
raise ENotImplemented('Only concrete CharacterString instances ' +
'can provide an encoding')
def set_type(self, type):
raise ENotImplemented(self.set_type)
def __len__(self):
if self.get_length == None:
raise ENotImplemented()
return self.get_length(self)
def __init__(self):
raise ENotImplemented(Digest)
def create_from_string(instring, outfile, keyfile):
ENotImplemented('Use the create from file function instead')
def handle_request(self, request):
raise ENotImplemented()
def time_tuple(self, using=None):
raise ENotImplemented()
def set_timeout(self, timeout):
if self.sock is not None:
raise ENotImplemented(
'set_timeout', 'Can only call set_timeout'
' before a connection has been made')
self._timeout = timeout
def new_user(self, name):
raise ENotImplemented(self.new_user)
