def query_service_registry(self, client, query):
request = Request(self.DXL_SERVICE_REGISTRY_QUERY_TOPIC)
if not query:
query = {}
request.payload = json.dumps(query)
response = client.sync_request(request, timeout=self.RESPONSE_WAIT)
return json.loads(
response.payload.decode("utf8").rstrip("\0"))["services"]
def test_specify_service_in_request(self):
service_count = 10
request_count = 100
request_received_count = [0]
request_to_wrong_service_id_count = [0]
requests_by_service = {}
request_lock = threading.Lock()
topic = UuidGenerator.generate_id_as_string()
with self.create_client() as service_client:
service_client.connect()
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 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
reg_infos = [create_service_reg_info()
for _ in range(service_count)]
with self.create_client() as request_client:
request_client.connect()
for _ in range(0, request_count):
request = Request(topic)
request.service_id = reg_infos[0].service_id
response = request_client.sync_request(
request, timeout=self.RESPONSE_WAIT)
self.assertNotIsInstance(response, ErrorResponse)
self.assertEqual(request.message_id,
response.request_message_id)
with request_lock:
self.assertEqual(0, request_to_wrong_service_id_count[0])
self.assertEqual(request_count, request_received_count[0])
self.assertEqual(1, len(requests_by_service))
self.assertIn(reg_infos[0].service_id, requests_by_service)
self.assertEqual(
request_count, requests_by_service[reg_infos[0].service_id])
def set_certificate_reputation(self, trust_level, sha1, public_key_sha1=None, comment=""):
"""
Sets the "Enterprise" reputation (`trust level`) of a specified certificate (as identified by hashes).
.. note::
**Client Authorization**
The OpenDXL Python client invoking this method must have permission to send messages to the
``/mcafee/service/tie/cert/reputation/set`` topic which is part of the
``TIE Server Set Enterprise Reputation`` authorization group.
The following page provides an example of authorizing a Python client to send messages to an
`authorization group`. While the example is based on McAfee Active Response (MAR), the
instructions are the same with the exception of swapping the ``TIE Server Set Enterprise Reputation``
`authorization group` in place of ``Active Response Server API``:
`<https://opendxl.github.io/opendxl-client-python/pydoc/marsendauth.html>`_
**Example Usage**
.. code-block:: python
# Set the enterprise reputation (trust level) for the certificate to Known Trusted
tie_client.set_certificate_reputation(
TrustLevel.KNOWN_TRUSTED,
"1C26E2037C8E205B452CAB3565D696512207D66D",
public_key_sha1="B4C3B2D596D1461C1BB417B92DCD74817ABB829D",
comment="Reputation set via OpenDXL")
:param trust_level: The new `trust level` for the file. The list of standard `trust levels` can be found in the
:class:`dxltieclient.constants.TrustLevel` constants class.
:param sha1: The SHA-1 of the certificate
:param public_key_sha1: The SHA-1 of the certificate's public key (optional)
:param comment: A comment to associate with the certificate (optional)
"""
# Create the request message
req = Request(TIE_SET_CERT_REPUTATION_TOPIC)
# Create a dictionary for the payload
payload_dict = {
"trustLevel": trust_level,
"providerId": CertProvider.ENTERPRISE,
"comment": comment,
"hashes": [
{"type": "sha1", "value": base64.b64encode(sha1.decode('hex'))}
]}
# Add public key SHA-1 (if specified)
if public_key_sha1:
payload_dict["publicKeySha1"] = base64.b64encode(public_key_sha1.decode('hex'))
# Set the payload
req.payload = json.dumps(payload_dict).encode(encoding="UTF-8")
# Send the request
self.__dxl_sync_request(req)
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 test_execute_registry_query(self):
with self.create_client() as client:
client.connect()
topic = "/mcafee/service/dxl/brokerregistry/query"
req = Request(topic)
req.payload = "{}"
response = client.sync_request(req)
self.assertNotIsInstance(response, ErrorResponse)
print("## sourceBrokerGuid: " + str(response.source_broker_id))
print("## sourceClientGuid: " + str(response.source_client_id))
print(str(response.payload))
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_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 _invoke_mar_search_api(self, payload_dict):
"""
Executes a query against the MAR search API
:param payload_dict: The payload
:return: A dictionary containing the results of the query
"""
# Create the request message
req = Request(MAR_SEARCH_TOPIC)
# Set the payload
req.payload = json.dumps(payload_dict).encode(encoding="UTF-8")
# Display the request that is going to be sent
logger.debug(
"Request:\n%s",
json.dumps(payload_dict,
sort_keys=True,
indent=4,
separators=(',', ': ')))
# Send the request and wait for a response (synchronous)
res = self._dxl_sync_request(req)
# Return a dictionary corresponding to the response payload
resp_dict = MessageUtils.json_payload_to_dict(res)
# Display the response
logger.debug(
"Response:\n%s",
json.dumps(resp_dict,
sort_keys=True,
indent=4,
separators=(',', ': ')))
if "code" in resp_dict:
code = resp_dict['code']
if code < 200 or code >= 300:
if "body" in resp_dict and "applicationErrorList" in \
resp_dict["body"]:
error = resp_dict["body"]["applicationErrorList"][0]
raise Exception(error["message"] + ": " +
str(error["code"]))
elif "body" in resp_dict:
raise Exception(resp_dict["body"] + ": " + str(code))
else:
raise Exception("Error: Received failure response code: " +
str(code))
else:
raise Exception("Error: unable to find response code")
return resp_dict
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_callback_parkeddomain(self):
with BaseClientTest.create_client(max_retries=0) as dxl_client:
dxl_client.connect()
with MockServerRunner() as server_runner:
with ApiVoidService(TEST_FOLDER) as apivoid_service:
apivoid_service._dxl_client = dxl_client
apivoid_service.API_VOID_URL_FORMAT = "http://127.0.0.1:" \
+ str(server_runner.mock_server_port) \
+ "/{0}/v1/pay-as-you-go/{1}"
apivoid_service.run()
request_topic = ApiVoidService.REQ_TOPIC_PARKED_DOMAIN
req = Request(request_topic)
MessageUtils.dict_to_json_payload(
req, {ApiVoidCallback.PARAM_HOST: SAMPLE_HOST})
res = apivoid_service._dxl_client.sync_request(req,
timeout=30)
res_dict = MessageUtils.json_payload_to_dict(res)
self.assertDictEqual(SAMPLE_PARKED_DOMAIN, res_dict)
def test_callback_statsremained(self):
with MockServerRunner() as server_runner:
with UrlVoidApiService(TEST_FOLDER) as urlvoid_service:
urlvoid_service.URL_VOID_API_URL_FORMAT = "http://127.0.0.1:" \
+ str(server_runner.mock_server_port) \
+ "/api1000/{0}/"
urlvoid_service.run()
request_topic = UrlVoidApiService.REQ_TOPIC_STATS_REMAINED
req = Request(request_topic)
MessageUtils.dict_to_json_payload(
req,
{
UrlVoidApiCallback.PARAM_HOST: SAMPLE_HOST
}
)
res = urlvoid_service._dxl_client.sync_request(req, timeout=30)
self.assertEqual(
dicttoxml(
SAMPLE_REMAINED_OUTPUT,
custom_root=XML_ROOT_RESPONSE,
attr_type=False
),
res.payload
)
def lookup_epo_unique_identifiers(dxl_client,
response_timeout=DEFAULT_RESPONSE_TIMEOUT
):
"""
Returns a ``set`` containing the unique identifiers for the ePO servers that are currently
exposed to the DXL fabric
:param dxl_client: The DXL client with which to perform the request
:param response_timeout: (optional) The maximum amount of time to wait for a response
:return: A ``set`` containing the unique identifiers for the ePO servers that are currently
exposed to the DXL fabric.
"""
res = EpoClient._sync_request(
dxl_client, Request("/mcafee/service/dxl/svcregistry/query"),
response_timeout, {"serviceType": EpoClient.DXL_SERVICE_TYPE})
res_dict = json.loads(res.rstrip("\0"))
ret_ids = set()
if "services" in res_dict:
for service in res_dict["services"].values():
if "requestChannels" in service:
channels = service['requestChannels']
for channel in channels:
if channel.startswith(EpoClient.DXL_REQUEST_PREFIX):
ret_ids.add(
channel[len(EpoClient.DXL_REQUEST_PREFIX):])
return ret_ids
def event_callback(event):
try:
req = Request(destination_topic=req_topic)
client.sync_request(req)
except Exception, e:
self.exceptions.append(e)
raise e
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 test_register_service_and_send_request(self):
with self.create_client() as client:
self.add_client_callbacks(client)
client.register_service_async(self.info)
time.sleep(self.POST_OP_DELAY)
client.connect()
time.sleep(self.POST_OP_DELAY)
request = Request("/mcafee/service/JTI/file/reputation/" + self.info.service_id)
request.payload = bytes("Test")
response = client.sync_request(request, self.POST_OP_DELAY)
logging.info("Response payload: {0}".format(str(response.payload)))
self.assertEquals("Ok", str(response.payload))
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_request_publishes_message_to_dxl_fabric(self):
self.client._client.publish = Mock(return_value=None)
# Create and process Request
msg = Request(destination_topic="")
self.client._send_request(msg)
# Check that callback was called
self.assertEqual(self.client._client.publish.call_count, 1)
def test_sync_request(self):
request = Request(destination_topic="/test")
with self.assertRaises(exceptions.WaitTimeoutException):
self.rm.sync_request(request, 2)
self.assertEquals(0, len(self.rm.sync_wait_message_ids))
self.assertEquals(0, len(self.rm.sync_wait_message_responses))
def test_register_async_callback(self):
request = Request(destination_topic="/test")
cb = MockResponseCallback()
self.rm.register_async_callback(request, cb)
self.assertTrue(request.message_id in self.rm.callback_map)
self.rm.unregister_async_callback(request.message_id)
self.assertFalse(request.message_id in self.rm.callback_map)
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"))
def test_register_wait_for_response(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)
self.rm.unregister_wait_for_response(request)
self.assertEquals(0, len(self.rm.sync_wait_message_ids))
self.assertFalse(request.message_id in self.rm.sync_wait_message_ids)
def event_callback(_):
with self.event_received_condition:
self.event_received = True
try:
req = Request(destination_topic=req_topic)
client.sync_request(req)
except Exception as ex: # pylint: disable=broad-except
self.request_exception_message = str(ex)
self.event_received_condition.notify_all()
def test_client_handle_message_with_request_calls_request_callback(self):
req_callback = RequestCallback()
req_callback.on_request = Mock()
self.client.add_request_callback(self.test_channel, req_callback)
# Create and process Request
req = Request(destination_topic=self.test_channel)._to_bytes()
self.client._handle_message(self.test_channel, req)
# Check that callback was called
self.assertEqual(req_callback.on_request.call_count, 1)
def test_register_service_weak_reference_after_connect_and_send_request(
self):
with self.create_client() as client:
self.add_client_callbacks(client)
ref = weakref.ref(self.info)
client.register_service_async(self.info)
client.connect()
info_guid = self.info.service_id
# Theoretically, sending the destroy method when creating the weakref
# would made the magic of calling that method when info get unref
self.info._destroy()
# Deleted the service registration
self.info = 1
time.sleep(self.POST_OP_DELAY * 2)
# Enforce garbage collection
gc.collect()
# Weak reference should now be null
self.assertEquals(None, ref())
# Sending an request should result in a WaitTimeoutException since the destroy() method
# of ServiceRegistrationInfo will unregister the service
request = Request("/mcafee/service/JTI/file/reputation/" +
info_guid)
request.payload = bytes("Test")
try:
response = client.sync_request(request, 2)
# Depending upon the timing, the broker can respond with 404 or the request might timeout
# self.assertIsInstance(response, ErrorResponse, "response is instance of ErrorResponse")
self.assertTrue(isinstance(response, ErrorResponse),
response.__class__)
except WaitTimeoutException as ex:
assert (ex.message.__contains__(request.message_id))
self.assertEquals(1, self.register_callback.get())
logging.debug("Waiting for unregister event...")
ttw = 30
while self.unregister_callback.get() < 1 and ttw > 0:
time.sleep(self.POST_OP_DELAY)
ttw -= 1
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 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 == 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
def _invoke_epo_service(self, payload_dict):
"""
Invokes the ePO DXL service for the purposes of executing a remote command
:param payload_dict: The dictionary (``dict``) to use as the payload of the DXL request
:return: The result of the remote command execution
"""
return self._sync_request(
self._dxl_client,
Request(self.DXL_REQUEST_FORMAT.format(self._epo_unique_id)),
self._response_timeout, payload_dict)
def test_client_receives_error_response_on_request_to_unknown_service(self):
"""
The idea of this test is to send a sync request to an unknown service
and get a "unable to locate service" error response.
"""
with self.create_client() as client:
test_topic = '/test/doesntexists/' + client.config._client_id
client.connect()
time.sleep(2)
self.assertTrue(client.connected)
# Send request thru dxl fabric to a service which doesn't exists
msg = Request(destination_topic=test_topic)
msg.service_id = UuidGenerator.generate_id_as_string()
response = client.sync_request(msg, 1)
# Check that we have an error response for our request
self.assertTrue(isinstance(response, ErrorResponse))
self.assertEqual(response.service_id, msg.service_id)
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_messages_are_fired_with_wildcards_enabled(self):
with DxlClient(self.config) as dxl_client:
dxl_client.add_request_callback("/this/channel/has/wildcard/#",
self.req_callback)
dxl_client.add_request_callback("/this/channel/has/wildcard/not/",
self.req_callback)
# Create and process Request
req = Request(destination_topic=
"/this/channel/has/wildcard/not/")._to_bytes()
dxl_client._handle_message("/this/channel/has/wildcard/not/", req)
# Check that callback was called
self.assertEqual(self.req_callback.on_request.call_count, 2)
