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))
