def on_second_service_request(request): response = Response(request) response.payload = expected_second_service_response_payload try: client.send_response(response) except DxlException as ex: print("Failed to send response" + str(ex))
def on_second_service_request(request): response = Response(request) response.payload = bytes(second_service_response_payload) try: client.send_response(response) except DxlException, ex: print "Failed to send response" + str(ex)
def my_request_callback(request): try: time.sleep(0.05) resp = Response(request) resp.payload = request.payload client.send_response(resp) except Exception as ex: # pylint: disable=broad-except print(ex)
def my_request_callback(rq): # print "request: " + str(rq.version) try: time.sleep(0.05) resp = Response(rq) resp.payload = rq.payload client.send_response(resp) except Exception, e: print e.message
def on_request(request): print("## Request in service: " + request.destination_topic + ", " + str(request.message_id)) print("## Request in service - payload: " + request.payload) service_request_message.append(request.message_id) service_request_message_receive_payload.append(request.payload) response = Response(request) response.payload = "Request response - Event payload: " + request.payload client.send_response(response)
def on_request(request): logging.info(request.destination_topic) logging.info(request.payload) response = Response(request) response.payload = bytes("Ok") try: client.send_response(response) except DxlException, ex: print "Failed to send response" + str(ex)
def on_request(request): logging.info(request.destination_topic) logging.info(request.payload) if on_client_request_callback: on_client_request_callback() response = Response(request) response.payload = "Ok" try: client.send_response(response) except DxlException as ex: print("Failed to send response" + str(ex))
def test_async_request(self): request = Request(destination_topic="/test") class TestResponseCallback(ResponseCallback): def __init__(self): super(TestResponseCallback, self).__init__() self.response = None def on_response(self, response): self.response = response callback = TestResponseCallback() self.assertIsNone(callback.response) self.request_manager.async_request(request, callback) self.assertEqual(0, len(self.request_manager.sync_wait_message_ids)) self.assertEqual(0, len(self.request_manager.sync_wait_message_responses)) self.assertTrue( request.message_id in self.request_manager.callback_map) response = Response(request=request) self.request_manager.on_response(response) self.assertIsNotNone(callback.response) self.assertEqual(request.message_id, callback.response.request_message_id) self.assertEqual(0, len(self.request_manager.sync_wait_message_ids)) self.assertEqual(0, len(self.request_manager.sync_wait_message_responses)) self.assertFalse( request.message_id in self.request_manager.callback_map)
def test_client_send_response_publishes_message_to_dxl_fabric(self): self.client._client.publish = Mock(return_value=None) # Create and process Request msg = Response(request=None) self.client.send_response(msg) # Check that callback was called self.assertEqual(self.client._client.publish.call_count, 1)
def test_client_handle_message_with_response_calls_response_callback(self): callback = ResponseCallback() callback.on_response = Mock() self.client.add_response_callback(self.test_channel, callback) # Create and process Response msg = Response(request=None)._to_bytes() self.client._handle_message(self.test_channel, msg) # Check that callback was called self.assertEqual(callback.on_response.call_count, 1)
def my_request(callback_service_id, request): with request_lock: request_received_count[0] += 1 if request.service_id and \ (request.service_id != callback_service_id): request_to_wrong_service_id_count[0] += 1 if request.service_id in requests_by_service: requests_by_service[request.service_id] += 1 else: requests_by_service[request.service_id] = 1 response = Response(request) service_client.send_response(response)
def setUp(self): self.config = DxlClientConfig(broker_ca_bundle=get_ca_bundle_pem(), cert_file=get_cert_file_pem(), private_key=get_dxl_private_key(), brokers=[]) mqtt_client_patch = patch('paho.mqtt.client.Client') mqtt_client_patch.start() self.client = DxlClient(self.config) self.client._request_manager.wait_for_response = Mock(return_value=Response(request=None)) self.test_channel = '/test/channel'
def register_test_service(self, client, service_type=None): topic = "broker_service_registry_test_service_" + \ UuidGenerator.generate_id_as_string() reg_info = ServiceRegistrationInfo( client, service_type or "broker_service_registry_test_service_" + UuidGenerator.generate_id_as_string()) callback = RequestCallback() callback.on_request = \ lambda request: client.send_response(Response(request)) reg_info.add_topic(topic, callback) client.register_service_sync(reg_info, self.DEFAULT_TIMEOUT) return reg_info
def test_request_and_response(self): reply_to_channel = "/mcafee/client/" + UuidGenerator.generate_id_as_string() service_guid = UuidGenerator.generate_id_as_string() source_client_guid = UuidGenerator.generate_id_as_string() source_broker_guid = UuidGenerator.generate_id_as_string() request = Request(destination_topic="") request.reply_to_channel = reply_to_channel request.service_id = service_guid request._source_client_id = source_client_guid request._source_broker_id = source_broker_guid request.broker_ids = ["{66000000-0000-0000-0000-000000000001}", "{66000000-0000-0000-0000-000000000002}", "{66000000-0000-0000-0000-000000000003}"] request.client_ids = ["{25000000-0000-0000-0000-000000000001}", "{25000000-0000-0000-0000-000000000002}", "{25000000-0000-0000-0000-000000000003}"] request.payload = "REQUEST".encode() PP.pprint(vars(request)) message = request._to_bytes() PP.pprint(message) self.assertEqual(source_client_guid, request.source_client_id) result = Message._from_bytes(message) PP.pprint(vars(result)) response = Response(request=request) response.payload = "RESPONSE".encode() PP.pprint(vars(response)) message = response._to_bytes() PP.pprint(message) result = Message._from_bytes(message) PP.pprint(vars(result)) self.assertEqual(Message.MESSAGE_TYPE_RESPONSE, result.message_type)
def on_request(self, request): if self._return_error: response = ErrorResponse(request, error_code=self._error_code, error_message=self._error_message) else: response = Response(request) def run_task(): try: self.m_client.send_response(response) except Exception, e: logging.info(e.message) raise e
def on_request(self, request): if self._return_error: response = ErrorResponse(request, error_code=self._error_code, error_message=self._error_message) else: response = Response(request) def run_task(): try: self.m_client.send_response(response) except Exception as ex: logging.info(ex) raise ex self.m_executor.submit(run_task)
def test_on_response_for_sync_request(self): request = Request(destination_topic="/test") self.rm.register_wait_for_response(request) self.assertEquals(1, len(self.rm.sync_wait_message_ids)) self.assertTrue(request.message_id in self.rm.sync_wait_message_ids) response = Response(request=request) self.rm.on_response(response) self.assertEquals(0, len(self.rm.sync_wait_message_ids)) self.assertEquals(1, len(self.rm.sync_wait_message_responses)) self.assertTrue(request.message_id in self.rm.sync_wait_message_responses) result = self.rm.wait_for_response(request, 2) self.assertEquals(request.message_id, result.request_message_id)
def reg_info_request_2(request): response = Response(request) response.payload = "service2" service_client.send_response(response)
def _mcafee_publish_to_dxl_function(self, event, *args, **kwargs): """Function: A function which takes 3 inputs: mcafee_topic_name: String of the topic name. ie: /mcafee/service/epo/remote/epo1. mcafee_dxl_payload: The text of the payload to publish to the topic. mcafee_return_request: Specify whether or not to wait for and return the response. The function will publish the provided payload to the provided topic. Indicate whether acknowledgment response should be returned.""" try: yield StatusMessage("Starting...") # Get the function parameters: mcafee_topic_name = kwargs.get("mcafee_topic_name") # text if not mcafee_topic_name: yield FunctionError("mcafee_topic_name is required") mcafee_dxl_payload = kwargs.get("mcafee_dxl_payload") # text if not mcafee_dxl_payload: yield FunctionError("mcafee_dxl_payload is required") mcafee_publish_method = self.get_select_param( kwargs.get("mcafee_publish_method") ) # select, values: "Event", "Service" if not mcafee_publish_method: yield FunctionError("mcafee_publish_method is required") mcafee_wait_for_response = self.get_select_param( kwargs.get( "mcafee_wait_for_response")) # select, values: "Yes", "No" log.info("mcafee_topic_name: %s", mcafee_topic_name) log.info("mcafee_dxl_payload: %s", mcafee_dxl_payload) log.info("mcafee_publish_method: %s", mcafee_publish_method) log.info("mcafee_wait_for_response: %s", mcafee_wait_for_response) response = None # Publish Event if mcafee_publish_method == "Event": event = Event(mcafee_topic_name) event.payload = mcafee_dxl_payload yield StatusMessage("Publishing Event...") self.client.send_event(event) # Invoke Service else: req = Request(mcafee_topic_name) req.payload = mcafee_dxl_payload yield StatusMessage("Invoking Service...") if mcafee_wait_for_response == "No": self.client.async_request(req) else: response = Response( self.client.sync_request(req, timeout=300)) yield StatusMessage("Done...") r = { "mcafee_topic_name": mcafee_topic_name, "mcafee_dxl_payload": mcafee_dxl_payload, "mcafee_publish_method": mcafee_publish_method, "mcafee_wait_for_response": mcafee_wait_for_response } # Return response from publishing to topic if response is not None: r["response"] = vars(response) yield FunctionResult(r) else: yield FunctionResult(r) except Exception as e: yield FunctionError(e)
def my_request(request): request_received_count[0] += 1 response = Response(request) service_client.send_response(response)
def my_request(request): request_received[0] = True service_client.send_response(Response(request))