def _get_response_message(self): """ Returns the IPC response message read from the socket. :param timeout: Alternative timeout value :return: (object) Message instance :since: v0.3.00 """ # pylint: disable=broad-except if (self.log_handler is not None): self.log_handler.debug("#echo(__FILEPATH__)# -{0!r}._get_message()- (#echo(__LINE__)#)", self, context = "pas_bus") data_unread = 16 message_data = Binary.BYTES_TYPE() message_size = 0 timeout_time = time() + self.timeout while ((data_unread > 0 or message_size == 0) and time() < timeout_time): select([ self.socket.fileno() ], [ ], [ ], self.timeout) data = self.socket.recv(data_unread) if (len(data) > 0): message_data += data if (message_size < 1): try: message_size = Message.get_marshaled_message_size(message_data) data_unread = (message_size - len(message_data)) except IOException: pass else: data_unread -= len(data) # # if (message_size == 0): raise IOException("Timeout occurred before message size was calculable") elif (len(message_data) < message_size): raise IOException("Timeout occurred before expected message size of {0:d} bytes was received".format(message_size)) return Message.unmarshal(message_data)
def test_simple_marshaled_data(self): test_data = Binary.bytes( "l\x01\x03\x01\x03\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00\x01\x01o\x00\x02\x00\x00\x00/t\x00\x00\x00\x00\x00\x00\x03\x01s\x00\x04\x00\x00\x00test\x00\x00\x00\x00\x08\x01g\x00\x03yyy\x00llo" ) self.assertEqual(60, Message.get_marshaled_message_size(test_data)) result_data = Message.unmarshal_data("yyyyuua(yv)yyy", test_data, True) self.assertEqual(10, len(result_data)) self.assertIs(list, type(result_data[6])) self.assertEqual(3, len(result_data[6])) self.assertIs(list, type(result_data[6][0])) self.assertEqual(2, len(result_data[6][0])) self.assertEqual(Message.HEADER_FIELD_PATH, result_data[6][0][0]) self.assertEqual("/t", Binary.str(result_data[6][0][1])) message = Message.unmarshal(test_data) self.assertEqual(Message.TYPE_METHOD_CALL, message.get_type()) self.assertEqual((Message.FLAG_NO_REPLY_EXPECTED | Message.FLAG_NO_AUTO_START), message.get_flags()) self.assertEqual("/t", message.get_object_path()) self.assertEqual("test", message.get_object_member()) self.assertEqual(1, message.get_serial())
def _thread_run(self): """ Active conversation :since: v0.3.00 """ # pylint: disable=broad-except if self.log_handler is not None: self.log_handler.debug( "#echo(__FILEPATH__)# -{0!r}._thread_run()- (#echo(__LINE__)#)", self, context="pas_bus" ) data = Binary.BYTES_TYPE() while self.socket is not None: try: data += self.get_data(16) request_message_size = 0 try: request_message_size = Message.get_marshaled_message_size(data) except IOException: pass if request_message_size > 0 and len(data) >= request_message_size: request_message_data = data[:request_message_size] self._set_data(data[request_message_size:]) data = Binary.BYTES_TYPE() request = BusRequest(self, request_message_data) if request.is_close_requested(): self.stop() else: request.execute() # except Exception as handled_exception: if self.log_handler is not None: self.log_handler.error( "#echo(__FILEPATH__)# -Connection._thread_run()- reporting: Error {1!r} occurred", self, handled_exception, context="pas_bus", )
def __init__(self, connection): """ Constructor __init__(BusResponse) :param handler: IPC client handler :since: v0.3.00 """ AbstractResponse.__init__(self) self.connection = connection """ IPC connection to send the result to. """ self.message = Message() """
def _get_message_call_template(self): """ Returns a D-Bus message prepared to be used for IPC communication. :return: (object) Message instance :since: v0.3.00 """ _return = Message(Message.TYPE_METHOD_CALL) _return.set_body_signature("a{sv}") _return.set_object_interface("de.direct-netware.pas.Bus1") _return.set_object_member("call") _return.set_object_path("/de/direct-netware/pas/Bus") _return.set_serial(1) return _return
class BusResponse(AbstractResponse): """ Bus response sends the result for one executed bus result. :author: direct Netware Group et al. :copyright: (C) direct Netware Group - All rights reserved :package: pas :subpackage: bus :since: v0.3.00 :license: https://www.direct-netware.de/redirect?licenses;mpl2 Mozilla Public License, v. 2.0 """ def __init__(self, connection): """ Constructor __init__(BusResponse) :param handler: IPC client handler :since: v0.3.00 """ AbstractResponse.__init__(self) self.connection = connection """ IPC connection to send the result to. """ self.message = Message() """ Result message to be send """ # def handle_critical_error(self, message): """ "handle_critical_error()" is called to send a critical error message. :param message: Message (will be translated if possible) :since: v0.3.00 """ self.handle_error(message) # def handle_error(self, message): """ "handle_error()" is called to send a error message. :param message: Message (will be translated if possible) :since: v0.3.00 """ self.message.set_type(Message.TYPE_ERROR) self.message.set_error_name("de.direct-netware.pas.Bus.Error") self.message.set_body(message) # def handle_exception(self, message, exception): """ "handle_exception()" is called if an exception occurs and should be send. :param message: Message (will be translated if possible) :param exception: Original exception or formatted string (should be shown in dev mode) :since: v0.3.00 """ self.handle_error("{0!r}".format(exception) if (message is None) else message ) # def send(self): """ Sends the prepared response. :since: v0.3.00 """ self.message.set_reply_serial(1) self.connection.write_data(self.message.marshal(2)) # def set_result(self, result): """ Sets the encoded message to be send based on the result given. :param result: Result data :since: v0.3.00 """ self.message.set_type(Message.TYPE_METHOD_REPLY) if (result is not None): self.message.set_body(result)