def test_multiple_registrations(self): service_registration_count = 10 request_received_count = [0] topic = UuidGenerator.generate_id_as_string() with self.create_client() as service_client: service_client.connect() def my_request(request): request_received_count[0] += 1 response = Response(request) service_client.send_response(response) reg_info = ServiceRegistrationInfo(service_client, "multiple_registrations_test") callback = RequestCallback() callback.on_request = my_request reg_info.add_topic(topic, callback) with self.create_client() as request_client: request_client.connect() for _ in range(0, service_registration_count): service_client.register_service_sync(reg_info, self.DEFAULT_TIMEOUT) request = Request(topic) response = request_client.sync_request( request, timeout=self.RESPONSE_WAIT) self.assertNotIsInstance(response, ErrorResponse) self.assertEqual(request.message_id, response.request_message_id) service_client.unregister_service_sync(reg_info, self.DEFAULT_TIMEOUT) self.assertEqual(service_registration_count, request_received_count[0])
def test_error_message(self): with self.create_client() as client: test_service = TestService(client, 1) client.connect() error_code = 9090 error_message = "My error message" topic = UuidGenerator.generate_id_as_string() # # Create a test service that returns error messages # reg_info = ServiceRegistrationInfo(client, "testErrorMessageService") reg_info.add_topic(topic, test_service) client.register_service_sync(reg_info, self.DEFAULT_TIMEOUT) test_service.return_error = True test_service.error_code = error_code test_service.error_message = error_message client.add_request_callback(topic, test_service) # Send a request and ensure the response is an error message response = client.sync_request(Request(topic)) self.assertIsInstance(response, ErrorResponse, msg="Response is not an ErrorResponse") self.assertEqual(error_code, response.error_code) self.assertEqual(error_message, response.error_message)
def create_service_reg_info(): reg_info = ServiceRegistrationInfo( service_client, "registry_specified_service_id_test") callback = RequestCallback() callback.on_request = \ lambda request: my_request(reg_info.service_id, request) reg_info.add_topic(topic, callback) service_client.register_service_sync(reg_info, self.DEFAULT_TIMEOUT) return reg_info
def test_response_service_not_found_no_service_id_at_client(self): request_received = [False] topic = UuidGenerator.generate_id_as_string() with self.create_client() as service_client: service_client.connect() def my_request(request): request_received[0] = True service_client.send_response(Response(request)) reg_info = ServiceRegistrationInfo( service_client, "response_service_not_found_no_service_id_at_client_test") callback = RequestCallback() callback.on_request = my_request reg_info.add_topic(topic, callback) reg_info.add_topic(topic, callback) service_client.register_service_sync(reg_info, self.DEFAULT_TIMEOUT) self.assertIsNotNone( self.query_service_registry_by_service( service_client, reg_info)) with self.create_client() as request_client: request_client.connect() # Remove the service's registration with the client-side # ServiceManager, avoiding unregistration of the service from # the broker. This should allow the broker to forward the # request on to the service client. registered_services = service_client._service_manager.services service = registered_services[reg_info.service_id] del registered_services[reg_info.service_id] request = Request(topic) response = request_client.sync_request( request, timeout=self.RESPONSE_WAIT) # Re-register the service with the internal ServiceManager so # that its resources (TTL timeout, etc.) can be cleaned up # properly at shutdown. registered_services[reg_info.service_id] = service # The request should receive an 'unavailable service' error # response because the service client should be unable to route # the request to an internally registered service. self.assertFalse(request_received[0]) self.assertIsInstance(response, ErrorResponse) self.assertEqual(reg_info.service_id, response.service_id) self.assertEqual( self.DXL_SERVICE_UNAVAILABLE_ERROR_CODE, BrokerServiceRegistryTest.normalized_error_code(response)) self.assertEqual(self.DXL_SERVICE_UNAVAILABLE_ERROR_MESSAGE, response.error_message) self.assertIsNone(self.query_service_registry_by_service( service_client, reg_info))
def test_execute_async_callback_timeout(self): # TODO: Set SYSPROP_ASYNC_CALLBACK_CHECK_INTERVAL = 10000 when it is available def resp_callback(): pass cb = ResponseCallback() cb.on_response = resp_callback with self.create_client() as client: client.connect() req_topic = UuidGenerator.generate_id_as_string() missing_topic = UuidGenerator.generate_id_as_string() test_service = TestService(client, 1) def empty_on_request(request): pass test_service.on_request = empty_on_request reg_info = ServiceRegistrationInfo(client, "async_callback_test_service") reg_info.add_topic(req_topic, test_service) # Register the service client.register_service_sync(reg_info, self.DEFAULT_TIMEOUT) async_req = Request(destination_topic=req_topic) client.async_request( async_req, cb) # TODO: Use the method with timeout when is will available for i in range(0, 10): req = Request(destination_topic=req_topic) client.async_request( req, cb ) # TODO: Use the updated method with timeout when it is available req_for_error = Request(destination_topic=missing_topic) client.async_request(req_for_error) async_callback_count = client._get_async_callback_count() self.assertEquals(11, async_callback_count) for i in range(0, 20): print "asyncCallbackCount = " + str( client._get_async_callback_count()) time.sleep(1) req = Request(destination_topic=req_topic) client.async_request(req, cb) self.assertEquals(1, async_callback_count)
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_execute_message_payload(self): # Create a server that handles a request, unpacks the payload, and # asserts that the information in the payload was delivered successfully. with self.create_client(max_retries=0) as service_client: service_client.connect() topic = UuidGenerator.generate_id_as_string() reg_info = ServiceRegistrationInfo( service_client, "message_payload_runner_service") # callback definition def on_request(request): with self.request_complete_condition: try: self.request_received = request except Exception as ex: # pylint: disable=broad-except print(ex) self.request_complete_condition.notify_all() request_callback = RequestCallback() request_callback.on_request = on_request reg_info.add_topic(topic, request_callback) # Register the service service_client.register_service_sync(reg_info, self.DEFAULT_TIMEOUT) with self.create_client() as request_client: request_client.connect() packer = msgpack.Packer() # Send a request to the server with information contained # in the payload request = Request(destination_topic=topic) request.payload = packer.pack(self.TEST_STRING) request.payload += packer.pack(self.TEST_BYTE) request.payload += packer.pack(self.TEST_INT) request_client.async_request(request, request_callback) start = time.time() # Wait until the request has been processed with self.request_complete_condition: while (time.time() - start < self.MAX_WAIT) and \ not self.request_received: self.request_complete_condition.wait(self.MAX_WAIT) self.assertIsNotNone(self.request_received) unpacker = msgpack.Unpacker(file_like=BytesIO(request.payload)) self.assertEqual( next(unpacker).decode('utf8'), self.TEST_STRING) self.assertEqual(next(unpacker), self.TEST_BYTE) self.assertEqual(next(unpacker), self.TEST_INT)
def test_execute_message_payload(self): # Create a server that handles a request, unpacks the payload, and # asserts that the information in the payload was delivered successfully. with self.create_client(max_retries=0) as server: test_service = TestService(server, 1) server.connect() topic = UuidGenerator.generate_id_as_string() reg_info = ServiceRegistrationInfo( server, "message_payload_runner_service") # callback definition def on_request(request): unpacker = Unpacker( file_like=StringIO.StringIO(request.payload)) with self.request_complete_condition: try: self.assertEquals(unpacker.next(), self.TEST_STRING) self.assertEquals(unpacker.next(), self.TEST_BYTE) self.assertEquals(unpacker.next(), self.TEST_INT) self.received_request = True except Exception, e: print e.message self.request_complete_condition.notify_all() request_callback = RequestCallback() request_callback.on_request = on_request reg_info.add_topic(topic, request_callback) # Register the service server.register_service_sync(reg_info, self.DEFAULT_TIMEOUT) with self.create_client() as client: client.connect() packer = Packer() # Send a request to the server with information contained # in the payload request = Request(destination_topic=topic) request.payload = packer.pack(self.TEST_STRING) request.payload += packer.pack(self.TEST_BYTE) request.payload += packer.pack(self.TEST_INT) client.async_request(request, request_callback) with self.request_complete_condition: if not self.received_request: # Wait until the request has been processed self.request_complete_condition.wait(self.MAX_WAIT) if not self.received_request: self.fail("Request not received.")
def test_execute_sync_request(self): with self.create_client(max_retries=0) as client: # Create a test service that responds to requests on a particular topic. test_service = TestService(client, 1) client.connect() topic = "event_testing" # UuidGenerator.generate_id_as_string() reg_info = ServiceRegistrationInfo(client, "sync_request_runner_service") reg_info.add_topic(topic, test_service) # Register the service client.register_service_sync(reg_info, self.DEFAULT_TIMEOUT) executor = ThreadRunExecutor(self.REQUEST_COUNT) # Sends synchronous requests with a unique thread for each request. Ensure that the # response that is received corresponds with the request that was sent. Also, keep # track of the total number of responses received. def run(): try: request = Request(topic) response = client.sync_request(request, timeout=self.RESPONSE_WAIT) self.assertNotIsInstance(response, ErrorResponse) self.assertEqual(request.message_id, response.request_message_id) with self.response_count_condition: self.response_count += 1 if self.response_count % 100 == 0: print(self.response_count) self.response_count_condition.notify_all() except Exception as ex: print(ex) raise ex executor.execute(run) # Wait for all of the requests to complete with self.response_count_condition: while self.response_count != self.REQUEST_COUNT: current_count = self.response_count self.response_count_condition.wait(self.MAX_WAIT) if current_count == self.response_count: self.fail("Request wait timeout.") self.assertEqual(self.REQUEST_COUNT, self.response_count)
def test_multiple_services(self): with self.create_client() as service_client: service_client.connect() reg_info_topic_1 = "multiple_services_test_1_" + \ UuidGenerator.generate_id_as_string() reg_info_1 = ServiceRegistrationInfo( service_client, "multiple_services_test_1") def reg_info_request_1(request): response = Response(request) response.payload = "service1" service_client.send_response(response) reg_info_callback_1 = RequestCallback() reg_info_callback_1.on_request = reg_info_request_1 reg_info_1.add_topic(reg_info_topic_1, reg_info_callback_1) service_client.register_service_sync(reg_info_1, self.DEFAULT_TIMEOUT) reg_info_topic_2 = "multiple_services_test_2_" + \ UuidGenerator.generate_id_as_string() reg_info_2 = ServiceRegistrationInfo( service_client, "multiple_services_test_2") def reg_info_request_2(request): response = Response(request) response.payload = "service2" service_client.send_response(response) reg_info_callback_2 = RequestCallback() reg_info_callback_2.on_request = reg_info_request_2 reg_info_2.add_topic(reg_info_topic_2, reg_info_callback_2) service_client.register_service_sync(reg_info_2, self.DEFAULT_TIMEOUT) with self.create_client() as request_client: request_client.connect() response = request_client.sync_request( Request(reg_info_topic_1), self.DEFAULT_TIMEOUT) self.assertIsInstance(response, Response) self.assertEqual(response.payload.decode("utf8"), "service1") response = request_client.sync_request( Request(reg_info_topic_2), self.DEFAULT_TIMEOUT) self.assertIsInstance(response, Response) self.assertEqual(response.payload.decode("utf8"), "service2")
def test_response_service_not_found_no_channel(self): request_received = [False] topic = UuidGenerator.generate_id_as_string() with self.create_client() as service_client: service_client.connect() def my_request(request): request_received[0] = True service_client.send_response(Response(request)) reg_info = ServiceRegistrationInfo( service_client, "response_service_not_found_no_channel_test") callback = RequestCallback() callback.on_request = my_request reg_info.add_topic(topic, callback) service_client.register_service_sync(reg_info, self.DEFAULT_TIMEOUT) service_client.unsubscribe(topic) self.assertIsNotNone( self.query_service_registry_by_service( service_client, reg_info)) with self.create_client() as request_client: request_client.connect() request = Request(topic) response = request_client.sync_request( request, timeout=self.RESPONSE_WAIT) self.assertFalse(request_received[0]) self.assertIsInstance(response, ErrorResponse) self.assertEqual(reg_info.service_id, response.service_id) self.assertEqual( self.DXL_SERVICE_UNAVAILABLE_ERROR_CODE, BrokerServiceRegistryTest.normalized_error_code(response)) self.assertEqual(self.DXL_SERVICE_UNAVAILABLE_ERROR_MESSAGE, response.error_message) self.assertIsNone(self.query_service_registry_by_service( service_client, reg_info))
def test_wildcard_services(self): max_wait = 10 with self.create_client() as client: # The request message that the service receives service_request_message = [] # The request message corresponding to the response received by the client client_response_message_request = [] # The event that we received client_event_message = [] client_event_message_condition = Condition() # The payload that the service receives service_request_message_receive_payload = [] client.connect() info = ServiceRegistrationInfo(client, "myWildcardService") meta = {} # Transform events mapped to "test/#/" to "request/test/..." meta["EventToRequestTopic"] = "/test/#" meta["EventToRequestPrefix"] = "/request" info.metadata = meta rcb = RequestCallback() 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) rcb.on_request = on_request info.add_topic("/request/test/#", rcb) client.register_service_sync(info, 10) evt = Event("/test/bar") rcb = ResponseCallback() def on_response(response): # Only handle the response corresponding to the event we sent if response.request_message_id == evt.message_id: print("## received_response: " + response.request_message_id + ", " + response.__class__.__name__) print("## received_response_payload: " + response.payload) client_response_message_request[0] = response.request_message_id rcb.on_response = on_response client.add_response_callback("", rcb) ecb = EventCallback() def on_event(event): print("## received event: " + event.destination_topic + ", " + event.message_id) with client_event_message_condition: client_event_message.append(event.message_id) client_event_message_condition.notify_all() ecb.on_event = on_event client.add_event_callback("/test/#", ecb) # Send our event print("## Sending event: " + evt.destination_topic + ", " + evt.message_id) evt.payload = "Unit test payload" client.send_event(evt) start = time.time() with client_event_message_condition: while (time.time() - start < max_wait) and \ not client_event_message: client_event_message_condition.wait(max_wait) # # Make sure the service received the request properly # self.assertEqual(evt.message_id, service_request_message[0]) # # Make sure the service received the request payload from the event properly # self.assertEqual(evt.payload, service_request_message_receive_payload[0]) # Make sure the response we received was for the request message # self.assertEqual(evt.message_id, client_response_message_request[0]) # Make sure we received the correct event self.assertGreater(len(client_event_message), 0) self.assertEqual(evt.message_id, client_event_message[0])
def test_execute_async_request(self): # Create and register a response callback. Once the request has been processed # by the service, the requesting client will receive a notification via this # callback. At that point, we note that the request has been responded to (remove # it from the set of outstanding requests), and increment the count of responses # we have received via the callbacks. def my_response(response): with self.response_condition: # Increment count of responses received self.response_count += 1 # Remove from outstanding requests self.remove_outstanding_request(response.request_message_id) # Notify that a response has been received (are we done yet?) self.response_condition.notify_all() rc = ResponseCallback() rc.on_response = my_response with self.create_client(max_retries=0) as client: try: client.connect() # Create a test service that responds to requests on a particular topic. test_service = TestService(client, 1) topic = UuidGenerator.generate_id_as_string() reg_info = ServiceRegistrationInfo( client, "async_request_runner_service") reg_info.add_topic(topic, test_service) # Register the service client.register_service_sync(reg_info, self.DEFAULT_TIMEOUT) # Add a response callback (not channel-specific) client.add_response_callback("", rc) for i in range(0, self.REQ_COUNT): # Send a request without specifying a callback for the current request req = Request(topic) self.append_outstanding_request(req.message_id) client.async_request(req) # Send a request with a specific callback that is to receive the response. # The response will be received by two callbacks. req = Request(topic) self.append_outstanding_request(req.message_id) client.async_request(req, response_callback=rc) # Wait until all the responses are received via the response callbacks. # The "times 3" is due to the fact that 20000 requests were sent in total. # 20000 were handled via the global callback, an additional 10000 were handled # via the callback explicitly passed in the second set of requests. with self.response_condition: while self.response_count != self.REQ_COUNT * 3: current_count = self.response_count self.response_condition.wait(self.MAX_RESPONSE_WAIT) if current_count == self.response_count: self.fail("Response wait timeout") # Make sure there are no outstanding requests self.assertEqual(0, len(self.outstanding_requests)) print "Async request test: PASSED" except Exception, ex: print ex.message raise ex
def execute_t(self, client_factory): with client_factory() as server_client: test_service = TestService(server_client, 1) connect_time_start = time.time() server_client.connect() topic = UuidGenerator.generate_id_as_string() reg_info = ServiceRegistrationInfo( server_client, "syncRequestThroughputRunnerService") reg_info.add_topic(topic, test_service) server_client.register_service_sync(reg_info, self.DEFAULT_TIMEOUT) # # Create a thread for each request. Wait for all of the clients to connect # to the broker before starting to calculate response related statistics. # executor = ThreadRunExecutor(self.THREAD_COUNT) def run(): try: with client_factory(max_retries=0) as client: retries = self.MAX_CONNECT_RETRIES connected = False while not connected and retries > 0: try: client.connect() connected = True except Exception: # pylint: disable=broad-except if retries > 0: retries -= 1 self.connect_retries += 1 self.assertTrue(connected, "Unable to connect after retries") # Waiting all clients have connected with self.connect_condition: self.atomic_connect_count += 1 self.connect_condition.notify_all() while self.atomic_connect_count != self.THREAD_COUNT: curr_count = self.atomic_connect_count self.connect_condition.wait( self.MAX_CONNECT_WAIT) if self.atomic_connect_count == curr_count: self.fail( "Timeout waiting for all threads to connect" ) # Once all clients have connected, reset timing information if self.requests_start_time == 0: self.requests_start_time = time.time() self.connect_time = self.requests_start_time - connect_time_start for _ in range(0, self.REQUEST_COUNT): req = Request(topic) call_start_time = time.time() response = client.sync_request( req, timeout=self.DEFAULT_TIMEOUT) response_time = time.time() - call_start_time self.assertNotIsInstance(response, ErrorResponse) with self.response_count_condition: self.response_count += 1 count = self.response_count if (self.requests_end_time == 0) and \ (count == (self.THREAD_COUNT * self.REQUEST_COUNT)): self.requests_end_time = time.time() if count % 100 is 0: print( str(count) + ", " + str(time.time() - self.requests_start_time)) # Calulate and track response times self.cummulative_response_time = self.cummulative_response_time + response_time self.response_times.append(response_time) except Exception as ex: print(ex) logging.info(ex) raise ex executor.execute(run) if self.THREAD_COUNT != self.response_count / self.REQUEST_COUNT: print("Failed! responseCount=" + str(self.response_count)) self.assertEqual(self.THREAD_COUNT, self.response_count / self.REQUEST_COUNT) server_client.unregister_service_sync(reg_info, self.DEFAULT_TIMEOUT)
class RegisterServiceClientTest(BaseClientTest): SERVICE_REF_CLEANUP_DELAY = 30 info = None info_registered = False info_registrations = 0 info_unregistrations = 0 def add_client_callbacks(self, client, on_client_request_callback=None): request_callback = RequestCallback() 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)) request_callback.on_request = on_request self.info = ServiceRegistrationInfo(client, "/mcafee/service/JTI") self.info_registered = False self.info_registrations = 0 self.info_unregistrations = 0 service_id = self.info.service_id self.info.add_topic( "/mcafee/service/JTI/file/reputation/" + service_id, request_callback) self.info.add_topic( "/mcafee/service/JTI/cert/reputation/" + service_id, request_callback) def is_event_for_service(event): return json.loads(event.payload.decode("utf8").rstrip( "\0"))["serviceGuid"] == service_id class ServiceRegisteredCallback(EventCallback): def __init__(self, test): self.test = test super(ServiceRegisteredCallback, self).__init__() def on_event(self, event): if is_event_for_service(event): self.test.info_registrations += 1 self.test.info_registered = True class ServiceUnregisteredCallback(EventCallback): def __init__(self, test): self.test = test super(ServiceUnregisteredCallback, self).__init__() def on_event(self, event): if is_event_for_service(event): self.test.info_unregistrations += 1 self.test.info_registered = False client.add_event_callback(_ServiceManager.DXL_SERVICE_REGISTER_CHANNEL, ServiceRegisteredCallback(self)) client.add_event_callback( _ServiceManager.DXL_SERVICE_UNREGISTER_CHANNEL, ServiceUnregisteredCallback(self)) def wait_info_registered_state(self, new_register_state): start = time.time() while (self.info_registered != new_register_state) and \ (time.time() - start < self.REG_DELAY): if self.info_registered != new_register_state: time.sleep(0.1) return self.info_registered def wait_info_registered(self): return self.wait_info_registered_state(True) def wait_info_not_registered(self): return not self.wait_info_registered_state(False) @staticmethod def service_ref_valid(client, service_id): services = client._service_manager.services return service_id in services and \ services[service_id].get_service() is not None def wait_for_service_reference_to_be_freed(self, client, service_id): start = time.time() while self.service_ref_valid(client, service_id) and \ (time.time() - start < self.SERVICE_REF_CLEANUP_DELAY): time.sleep(0.1) return not self.service_ref_valid(client, service_id) @attr('system') def test_register_service_before_connect(self): with self.create_client() as client: self.add_client_callbacks(client) client.register_service_async(self.info) client.connect() self.assertTrue(self.wait_info_registered()) client.unregister_service_sync(self.info, self.REG_DELAY) self.assertTrue(self.wait_info_not_registered()) self.assertEqual(1, self.info_registrations) self.assertEqual(1, self.info_unregistrations) @attr('system') def test_register_service_after_connect(self): with self.create_client() as client: self.add_client_callbacks(client) client.connect() client.register_service_sync(self.info, self.REG_DELAY) self.assertTrue(self.wait_info_registered()) client.unregister_service_sync(self.info, self.REG_DELAY) self.assertTrue(self.wait_info_not_registered()) self.assertEqual(1, self.info_registrations) self.assertEqual(1, self.info_unregistrations) @attr('system') def test_register_service_never_connect(self): with self.create_client() as client: self.add_client_callbacks(client) client.register_service_async(self.info) client.unregister_service_async(self.info) self.assertEqual(0, self.info_registrations) self.assertEqual(0, self.info_unregistrations) @attr('system') def test_register_unregister_service_before_connect(self): with self.create_client() as client: self.add_client_callbacks(client) client.register_service_async(self.info) client.unregister_service_async(self.info) client.connect() self.assertEqual(0, self.info_registrations) self.assertEqual(0, self.info_unregistrations) @attr('system') def test_register_service_and_send_request(self): with self.create_client() as client: self.add_client_callbacks(client) client.register_service_async(self.info) client.connect() self.assertTrue(self.wait_info_registered()) request = Request("/mcafee/service/JTI/file/reputation/" + self.info.service_id) request.payload = "Test" response = client.sync_request(request, self.POST_OP_DELAY) logging.info("Response payload: %s", response.payload.decode("utf8")) self.assertEqual("Ok", response.payload.decode("utf8")) @attr('system') def test_register_service_call_from_request_callback(self): # While in the request callback for a service invocation, attempt to # register a second service. Confirm that a call to the second service # is successful. This test ensures that concurrent add/remove service # calls and processing of incoming messages do not produce deadlocks. with self.create_client(self.DEFAULT_RETRIES, 2) as client: expected_second_service_response_payload = \ "Second service request okay too" second_service_callback = RequestCallback() 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)) second_service_callback.on_request = on_second_service_request second_service_info = ServiceRegistrationInfo( client, "/mcafee/service/JTI2") second_service_info.add_topic( "/mcafee/service/JTI2/file/reputation/" + second_service_info.service_id, second_service_callback) def register_second_service(): client.register_service_sync(second_service_info, self.REG_DELAY) register_second_service_thread = threading.Thread( target=register_second_service) register_second_service_thread.daemon = True # Perform the second service registration from a separate thread # in order to ensure that locks taken by the callback and # service managers do not produce deadlocks between the # thread from which the service registration request is made and # any threads on which response messages are received from the # broker. def on_first_service_request(): register_second_service_thread.start() register_second_service_thread.join() self.add_client_callbacks(client, on_first_service_request) client.connect() client.register_service_sync(self.info, self.REG_DELAY) first_service_request = Request( "/mcafee/service/JTI/file/reputation/" + self.info.service_id) first_service_request.payload = "Test" first_service_response = client.sync_request( first_service_request, self.POST_OP_DELAY) first_service_response_payload = first_service_response. \ payload.decode("utf8") logging.info("First service response payload: %s", first_service_response_payload) self.assertEqual("Ok", first_service_response_payload) second_service_request = Request( "/mcafee/service/JTI2/file/reputation/" + second_service_info.service_id) second_service_request.payload = "Test" second_service_response = client.sync_request( second_service_request, self.POST_OP_DELAY) actual_second_service_response_payload = second_service_response. \ payload.decode("utf8") logging.info("Second service response payload: %s", actual_second_service_response_payload) self.assertEqual(expected_second_service_response_payload, actual_second_service_response_payload)
def test_register_service_call_from_request_callback(self): # While in the request callback for a service invocation, attempt to # register a second service. Confirm that a call to the second service # is successful. This test ensures that concurrent add/remove service # calls and processing of incoming messages do not produce deadlocks. with self.create_client(self.DEFAULT_RETRIES, 2) as client: expected_second_service_response_payload = \ "Second service request okay too" second_service_callback = RequestCallback() 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)) second_service_callback.on_request = on_second_service_request second_service_info = ServiceRegistrationInfo( client, "/mcafee/service/JTI2") second_service_info.add_topic( "/mcafee/service/JTI2/file/reputation/" + second_service_info.service_id, second_service_callback) def register_second_service(): client.register_service_sync(second_service_info, self.REG_DELAY) register_second_service_thread = threading.Thread( target=register_second_service) register_second_service_thread.daemon = True # Perform the second service registration from a separate thread # in order to ensure that locks taken by the callback and # service managers do not produce deadlocks between the # thread from which the service registration request is made and # any threads on which response messages are received from the # broker. def on_first_service_request(): register_second_service_thread.start() register_second_service_thread.join() self.add_client_callbacks(client, on_first_service_request) client.connect() client.register_service_sync(self.info, self.REG_DELAY) first_service_request = Request( "/mcafee/service/JTI/file/reputation/" + self.info.service_id) first_service_request.payload = "Test" first_service_response = client.sync_request( first_service_request, self.POST_OP_DELAY) first_service_response_payload = first_service_response. \ payload.decode("utf8") logging.info("First service response payload: %s", first_service_response_payload) self.assertEqual("Ok", first_service_response_payload) second_service_request = Request( "/mcafee/service/JTI2/file/reputation/" + second_service_info.service_id) second_service_request.payload = "Test" second_service_response = client.sync_request( second_service_request, self.POST_OP_DELAY) actual_second_service_response_payload = second_service_response. \ payload.decode("utf8") logging.info("Second service response payload: %s", actual_second_service_response_payload) self.assertEqual(expected_second_service_response_payload, actual_second_service_response_payload)
class AsyncFloodTest(BaseClientTest): # The count of requests to send REQUEST_COUNT = 1000 # Amount of time to wait for the test to succeed WAIT_TIME = 90 # The service registration information m_info = None resp_condition = Condition() response_count = 0 error_count = 0 @attr('system') def test_async_flood(self): channel = UuidGenerator.generate_id_as_string() with self.create_client() as client: self.m_info = ServiceRegistrationInfo(client, channel) client.connect() client.subscribe(channel) 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) req_callback = RequestCallback() req_callback.on_request = my_request_callback self.m_info.add_topic(channel, req_callback) client.register_service_sync(self.m_info, 10) with self.create_client() as client2: client2.connect() def my_response_callback(response): if response.message_type == Message.MESSAGE_TYPE_ERROR: print("Received error response: " + response._error_response) with self.resp_condition: self.error_count += 1 self.resp_condition.notify_all() else: with self.resp_condition: if self.response_count % 10 == 0: print("Received request " + str(self.response_count)) self.response_count += 1 self.resp_condition.notify_all() callback = ResponseCallback() callback.on_response = my_response_callback client2.add_response_callback("", callback) for i in range(0, self.REQUEST_COUNT): if i % 100 == 0: print("Sent: " + str(i)) request = Request(channel) request.payload = str(i) client2.async_request(request) if self.error_count > 0: break # Wait for all responses, an error to occur, or we timeout start_time = time.time() with self.resp_condition: while (self.response_count != self.REQUEST_COUNT) and ( self.error_count == 0) and ( time.time() - start_time < self.WAIT_TIME): self.resp_condition.wait(5) if self.error_count != 0: raise Exception("Received an error response!") self.assertEqual(self.REQUEST_COUNT, self.response_count, "Did not receive all messages!")