def test_execute_sync_during_callback(self):
event_topic = UuidGenerator.generate_id_as_string()
req_topic = UuidGenerator.generate_id_as_string()
with self.create_client() as client:
client.connect()
# callback
def event_callback(event):
try:
req = Request(destination_topic=req_topic)
client.sync_request(req)
except Exception, e:
self.exceptions.append(e)
raise e
ec = EventCallback()
ec.on_event = event_callback
client.add_event_callback(event_topic, ec)
time.sleep(self.SLEEP_TIME) # Check the time
evt = Event(destination_topic=event_topic)
client.send_event(evt)
time.sleep(self.SLEEP_TIME)
self.assertTrue(self.exceptions[0] is not None)
self.assertTrue("different thread" in self.exceptions[0].message)
def test_execute_sync_during_callback(self):
event_topic = UuidGenerator.generate_id_as_string()
req_topic = UuidGenerator.generate_id_as_string()
with self.create_client() as client:
client.connect()
# callback
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()
callback = EventCallback()
callback.on_event = event_callback
client.add_event_callback(event_topic, callback)
event = Event(destination_topic=event_topic)
client.send_event(event)
start = time.time()
with self.event_received_condition:
while (time.time() - start < self.MAX_WAIT) and \
not self.event_received:
self.event_received_condition.wait(self.MAX_WAIT)
self.assertIsNotNone(self.request_exception_message)
self.assertIn("different thread", self.request_exception_message)
def test_event(self):
source_client_guid = UuidGenerator.generate_id_as_string()
source_broker_guid = UuidGenerator.generate_id_as_string()
event = Event(destination_topic="")
event._source_client_id = source_client_guid
event._source_broker_id = source_broker_guid
event.broker_ids = ["{66000000-0000-0000-0000-000000000001}",
"{66000000-0000-0000-0000-000000000002}",
"{66000000-0000-0000-0000-000000000003}"]
event.client_ids = ["{25000000-0000-0000-0000-000000000001}",
"{25000000-0000-0000-0000-000000000002}",
"{25000000-0000-0000-0000-000000000003}"]
event.payload = str.encode("EVENT")
pp.pprint(vars(event))
message = event._to_bytes()
pp.pprint(message)
result = Message._from_bytes(message)
pp.pprint(vars(result))
assert result.source_client_id == source_client_guid
assert result.source_broker_id == source_broker_guid
assert result.broker_ids == ["{66000000-0000-0000-0000-000000000001}",
"{66000000-0000-0000-0000-000000000002}",
"{66000000-0000-0000-0000-000000000003}"]
assert result.client_ids == ["{25000000-0000-0000-0000-000000000001}",
"{25000000-0000-0000-0000-000000000002}",
"{25000000-0000-0000-0000-000000000003}"]
assert result.payload == str.encode("EVENT")
assert result.message_type == Message.MESSAGE_TYPE_EVENT
def test_event(self):
source_client_guid = UuidGenerator.generate_id_as_string()
source_broker_guid = UuidGenerator.generate_id_as_string()
source_broker_ids = ["{66000000-0000-0000-0000-000000000001}",
"{66000000-0000-0000-0000-000000000002}",
"{66000000-0000-0000-0000-000000000003}"]
source_client_ids = ["{25000000-0000-0000-0000-000000000001}",
"{25000000-0000-0000-0000-000000000002}",
"{25000000-0000-0000-0000-000000000003}"]
source_payload = "EVENT".encode()
event = Event(destination_topic="")
event._source_client_id = source_client_guid
event._source_broker_id = source_broker_guid
event.broker_ids = source_broker_ids
event.client_ids = source_client_ids
event.payload = source_payload
PP.pprint(vars(event))
message = event._to_bytes()
PP.pprint(message)
result = Message._from_bytes(message)
PP.pprint(vars(result))
self.assertEqual(source_client_guid, result.source_client_id)
self.assertEqual(source_broker_guid, result.source_broker_id)
self.assertEqual(source_broker_ids, result.broker_ids)
self.assertEqual(source_client_ids, result.client_ids)
self.assertEqual(source_payload, result.payload)
self.assertEqual(Message.MESSAGE_TYPE_EVENT, result.message_type)
def measure_performance(self, client, with_wildcard, topic_exists):
sub_count = 10000
query_multiplier = 10
topic_prefix = "/topic/" + UuidGenerator.generate_id_as_string() + "/"
event_count = [0]
message_ids = set()
payload = UuidGenerator.generate_id_as_string()
payload_as_bytes = payload.encode()
message_id_condition = Condition()
callback = EventCallback()
def on_event(event):
if event.payload == payload_as_bytes:
with message_id_condition:
event_count[0] += 1
message_ids.add(event.message_id)
message_id_condition.notify()
if len(message_ids) % sub_count == 0:
print("Messages size: " + str(len(message_ids)))
callback.on_event = on_event
client.add_event_callback("#", callback, False)
if with_wildcard:
client.subscribe(topic_prefix + "#")
for i in range(sub_count):
if i % 1000 == 0:
print("Subscribed: " + str(i))
client.subscribe(topic_prefix + str(i))
print("Subscribed.")
start_time = time.time()
for j in range(sub_count * query_multiplier):
evt = Event(topic_prefix +
str(j % sub_count +
(sub_count if not topic_exists else 0)))
evt.payload = payload
client.send_event(evt)
with message_id_condition:
while len(message_ids) != sub_count * query_multiplier \
or event_count[0] != sub_count * query_multiplier * (2 if with_wildcard and topic_exists else 1):
current_event = event_count[0]
message_id_condition.wait(5)
if current_event == event_count[0]:
self.fail("Event wait timeout")
self.assertEqual(sub_count * query_multiplier, len(message_ids))
self.assertEqual(
sub_count * query_multiplier *
(2 if with_wildcard and topic_exists else 1), event_count[0])
return time.time() - start_time
def measure_performance(self, client, with_wildcard, topic_exists):
SUB_COUNT = 10000
QUERY_MULTIPLIER = 10
TOPIC_PREFIX = "/topic/" + UuidGenerator.generate_id_as_string() + "/"
event_count = [0]
message_ids = set()
PAYLOAD = UuidGenerator.generate_id_as_string()
message_id_condition = Condition()
cb = EventCallback()
def on_event(event):
if event.payload == PAYLOAD:
with message_id_condition:
event_count[0] += 1
message_ids.add(event.message_id)
message_id_condition.notify()
if len(message_ids) % SUB_COUNT == 0:
print "Messages size: " + str(len(message_ids))
cb.on_event = on_event
client.add_event_callback("#", cb, False)
if with_wildcard:
client.subscribe(TOPIC_PREFIX + "#")
for i in range(SUB_COUNT):
if i % 1000 == 0:
print "Subscribed: " + str(i)
client.subscribe(TOPIC_PREFIX + str(i))
print "Subscribed."
start_time = time.time()
for j in range(SUB_COUNT * QUERY_MULTIPLIER):
evt = Event(TOPIC_PREFIX +
str(j % SUB_COUNT +
(SUB_COUNT if not topic_exists else 0)))
evt.payload = PAYLOAD
client.send_event(evt)
with message_id_condition:
while len(message_ids) != SUB_COUNT * QUERY_MULTIPLIER \
or event_count[0] != SUB_COUNT * QUERY_MULTIPLIER * (2 if with_wildcard and topic_exists else 1):
current_event = event_count[0]
message_id_condition.wait(5)
if current_event == event_count[0]:
self.fail("Event wait timeout")
self.assertEquals(SUB_COUNT * QUERY_MULTIPLIER, len(message_ids))
self.assertEquals(
SUB_COUNT * QUERY_MULTIPLIER *
(2 if with_wildcard and topic_exists else 1), event_count[0])
return time.time() - start_time
def test_subs_count(self):
clients = []
with self.create_client() as client:
client.connect()
for _ in range(6):
_client = self.create_client()
_client.connect()
clients.append(_client)
random1 = UuidGenerator.generate_id_as_string()
random2 = UuidGenerator.generate_id_as_string()
topic1 = "/foo/bar/" + random1 + "/" + random2
clients[0].subscribe(topic1)
clients[1].subscribe(topic1)
clients[2].subscribe(topic1)
clients[3].subscribe("/foo/bar/" + random1 + "/#")
clients[4].subscribe("/foo/+/" + random1 + "/#")
topic2 = "/foo/baz/" + random2
clients[1].subscribe(topic2)
clients[2].subscribe(topic2)
clients[5].subscribe("#")
def get_subs_count(topic):
req = Request("/mcafee/service/dxl/broker/subs")
req.payload = "{\"topic\":\"" + topic + "\"}"
resp = client.sync_request(req, 5)
return json.loads(
resp.payload.decode("utf8").rstrip("\0"))["count"]
def loop_until_expected_subs_count(expected_topic_count, topic):
topic_count = get_subs_count(topic)
start = time.time()
while topic_count != expected_topic_count and \
time.time() - start < self.MAX_TIME:
time.sleep(0.1)
topic_count = get_subs_count(topic)
return topic_count
# Topic 1
expected_topic1_count = 6
self.assertEqual(
expected_topic1_count,
loop_until_expected_subs_count(expected_topic1_count, topic1))
# Topic 2
expected_topic2_count = 3
self.assertEqual(
expected_topic2_count,
loop_until_expected_subs_count(expected_topic2_count, topic2))
for _client in clients:
_client.destroy()
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_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_incoming_message_threading(self):
max_wait = 30
thread_count = 10
thread_name_condition = threading.Condition()
thread_name = set()
event_topic = UuidGenerator.generate_id_as_string()
with self.create_client(
incoming_message_thread_pool_size=thread_count) as client:
client.connect()
event_callback = EventCallback()
def on_event(_):
with thread_name_condition:
thread_name.add(threading.current_thread())
if len(thread_name) == thread_count:
thread_name_condition.notify_all()
event_callback.on_event = on_event
client.add_event_callback(event_topic, event_callback)
for _ in range(0, 1000):
evt = Event(event_topic)
client.send_event(evt)
start = time.time()
with thread_name_condition:
while (time.time() - start < max_wait) and \
len(thread_name) < thread_count:
thread_name_condition.wait(max_wait)
self.assertEqual(thread_count, len(thread_name))
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_current_request(self):
uid = UuidGenerator.generate_id_as_string()
self.rm.add_current_request(uid)
self.assertEquals(1, self.rm.get_current_request_queue_size())
self.assertTrue(uid in self.rm.current_request_message_ids)
self.rm.remove_current_request(uid)
self.assertEquals(0, self.rm.get_current_request_queue_size())
self.assertFalse(uid in self.rm.current_request_message_ids)
def test_subscribe_and_unsubscribe(self):
with self.create_client(max_retries=0) as client:
client.connect()
topic = UuidGenerator.generate_id_as_string()
client.subscribe(topic)
self.assertIn(topic, client.subscriptions)
client.unsubscribe(topic)
self.assertNotIn(topic, client.subscriptions)
def test_client_raises_exception_when_cannot_sync_connect_to_broker(self):
with self.create_client() as client:
broker = Broker("localhost", UuidGenerator.generate_id_as_string(), "127.0.0.1")
client._config.brokers = [broker]
with self.assertRaises(DxlException):
client.connect()
def test_round_robin_services(self):
service_count = 10
request_per_service_count = 10
request_to_send_count = service_count * request_per_service_count
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,
"round_robin_service")
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() # pylint: disable=unused-variable
for _ in range(service_count)]
with self.create_client() as request_client:
request_client.connect()
for _ in range(0, request_to_send_count):
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)
with request_lock:
self.assertEqual(0, request_to_wrong_service_id_count[0])
self.assertEqual(request_to_send_count,
request_received_count[0])
self.assertEqual(service_count, len(requests_by_service))
for service_request_count in requests_by_service.values():
self.assertEqual(request_per_service_count,
service_request_count)
def test_event_with_empty_broker_and_client_guids(self):
source_client_guid = UuidGenerator.generate_id_as_string()
source_broker_guid = UuidGenerator.generate_id_as_string()
event = Event(destination_topic="")
event._source_client_id = source_client_guid
event._source_broker_id = source_broker_guid
event.payload = "EVENT".encode()
PP.pprint(vars(event))
message = event._to_bytes()
PP.pprint(message)
result = Message._from_bytes(message)
PP.pprint(vars(result))
self.assertTrue(isinstance(result.broker_ids, list))
self.assertTrue(isinstance(result.client_ids, list))
def test_unsubscribe_for_unknown_topic_does_not_raise_error(self):
with self.create_client(max_retries=0) as client:
client.connect()
topic = UuidGenerator.generate_id_as_string()
client.subscribe(topic)
self.assertIn(topic, client.subscriptions)
client.unsubscribe(topic)
client.unsubscribe(topic)
self.assertNotIn(topic, client.subscriptions)
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 execute_subs__unsubs_test(self):
with self.create_client(max_retries=0) as client:
try:
client.connect()
topic = UuidGenerator.generate_id_as_string()
client.subscribe(topic)
time.sleep(0.5)
client.unsubscribe(topic)
client.disconnect()
except Exception, e:
print e.message
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_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 test_request(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_topic = 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 = str.encode("REQUEST")
pp.pprint(vars(request))
message = request._to_bytes()
pp.pprint(message)
result = Message._from_bytes(message)
pp.pprint(vars(result))
assert result.reply_to_topic == reply_to_channel
assert result.service_id == service_guid
assert result.source_client_id == source_client_guid
assert result.source_broker_id == source_broker_guid
assert result.broker_ids == ["{66000000-0000-0000-0000-000000000001}",
"{66000000-0000-0000-0000-000000000002}",
"{66000000-0000-0000-0000-000000000003}"]
assert result.client_ids == ["{25000000-0000-0000-0000-000000000001}",
"{25000000-0000-0000-0000-000000000002}",
"{25000000-0000-0000-0000-000000000003}"]
assert result.payload == str.encode("REQUEST")
assert result.message_type == Message.MESSAGE_TYPE_REQUEST
def test_subs_count(self):
clients = []
with self.create_client() as client:
client.connect()
for i in range(6):
c = self.create_client()
c.connect()
clients.append(c)
random1 = UuidGenerator.generate_id_as_string()
random2 = UuidGenerator.generate_id_as_string()
topic1 = "/foo/bar/" + random1 + "/" + random2
clients[0].subscribe(topic1)
clients[1].subscribe(topic1)
clients[2].subscribe(topic1)
clients[3].subscribe("/foo/bar/" + random1 + "/#")
clients[4].subscribe("/foo/+/" + random1 + "/#")
topic2 = "/foo/baz/" + random2
clients[1].subscribe(topic2)
clients[2].subscribe(topic2)
clients[5].subscribe("#")
# Topic 1
req = self._create_request(topic1)
resp = client.sync_request(req, 5)
pl = str(resp.payload)
self.assertTrue(":6}" in pl)
# Topic 2
req = self._create_request(topic2)
resp = client.sync_request(req, 5)
pl = str(resp.payload)
self.assertTrue(":3}" in pl)
print "Test passed!"
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 test_client_retries_defines_how_many_times_the_client_retries_connection(self, retries, connect_count):
# Client wont' connect ;)
self.client._client.connect = Mock(side_effect=Exception('Could not connect'))
# No delay between retries (faster unit tests)
self.client.config.reconnect_delay = 0
self.client._wait_for_policy_delay = 0
broker = Broker(host_name='localhost')
broker._parse(UuidGenerator.generate_id_as_string() + ";9999;localhost;127.0.0.1")
self.client.config.brokers = [broker]
self.client.config.connect_retries = retries
with self.assertRaises(DxlException):
self.client.connect()
self.assertEqual(self.client._client.connect.call_count, connect_count)
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_execute_events(self):
with self.create_client(max_retries=0) as client:
try:
client.connect()
topic = UuidGenerator.generate_id_as_string()
# Create and register an event callback. Ensure that all sent events are received
# (via the outstanding events set). Also, track the number of total events received.
def event_callback(event):
with self.event_condition:
# Increment count of responses received
self.event_count += 1
# Remove from outstanding events
self.remove_outstanding_event(event.message_id)
# Notify that a response has been received (are we done yet?)
self.event_condition.notify_all()
callback = EventCallback()
callback.on_event = event_callback
client.add_event_callback(topic, callback)
for _ in range(0, self.EVENT_COUNT):
event = Event(topic)
self.append_outstanding_event(event.message_id)
client.send_event(event)
with self.event_condition:
while self.event_count != self.EVENT_COUNT:
current_count = self.event_count
self.event_condition.wait(self.MAX_EVENT_WAIT)
if current_count == self.event_count:
self.fail("Event wait timeout.")
self.assertEqual(0, len(self.outstanding_events))
print("Events test: PASSED")
except Exception as ex:
print(ex)
raise ex
def test_execute_message_other_fields(self):
with self.create_client(max_retries=0) as client:
client.connect()
topic = UuidGenerator.generate_id_as_string()
def on_event(event):
with self.event_received_condition:
try:
self.event_received = event
except Exception as ex: # pylint: disable=broad-except
print(ex)
self.event_received_condition.notify_all()
event_callback = EventCallback()
event_callback.on_event = on_event
client.add_event_callback(topic, event_callback)
event = Event(destination_topic=topic)
event.other_fields = {"key" + str(i): "value" + str(i)
for i in range(self.OTHER_FIELDS_COUNT)}
event.other_fields[b"key_as_bytes"] = b"val_as_bytes"
client.send_event(event)
# Bytes values for other field keys/values are expected to be
# converted to unicode strings as received from the DXL fabric.
del event.other_fields[b"key_as_bytes"]
event.other_fields[u"key_as_bytes"] = u"val_as_bytes"
start = time.time()
with self.event_received_condition:
while (time.time() - start < self.MAX_WAIT) and \
not self.event_received:
self.event_received_condition.wait(self.MAX_WAIT)
self.assertIsNotNone(self.event_received)
self.assertIsNotNone(self.event_received.other_fields)
for i in range(self.OTHER_FIELDS_COUNT):
self.assertEqual(
event.other_fields["key" + str(i)],
self.event_received.other_fields.get("key" + str(i), ""))
self.assertEqual(event.other_fields["key_as_bytes"],
self.event_received.other_fields.get(
"key_as_bytes", ""))
