def test_event_hubs_filter_receive(live_eventhub_config):
plain_auth = authentication.SASLPlain(
live_eventhub_config['hostname'],
live_eventhub_config['key_name'],
live_eventhub_config['access_key'])
source_url = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format(
live_eventhub_config['hostname'],
live_eventhub_config['event_hub'],
live_eventhub_config['consumer_group'],
live_eventhub_config['partition'])
source = address.Source(source_url)
source.set_filter(b"amqp.annotation.x-opt-enqueuedtimeutc > 1518731960545")
with uamqp.ReceiveClient(source, auth=plain_auth, timeout=50, prefetch=50) as receive_client:
log.info("Created client, receiving...")
batch = receive_client.receive_message_batch(max_batch_size=10)
while batch:
for message in batch:
annotations = message.annotations
log.info("Partition Key: {}".format(annotations.get(b'x-opt-partition-key')))
log.info("Sequence Number: {}".format(annotations.get(b'x-opt-sequence-number')))
log.info("Offset: {}".format(annotations.get(b'x-opt-offset')))
log.info("Enqueued Time: {}".format(annotations.get(b'x-opt-enqueued-time')))
log.info("Message format: {}".format(message._message.message_format))
log.info("{}".format(list(message.get_data())))
batch = receive_client.receive_message_batch(max_batch_size=10)
log.info("Finished receiving")
async def test_event_hubs_iter_receive_no_shutdown_after_timeout_async(
live_eventhub_config):
uri = "sb://{}/{}".format(live_eventhub_config['hostname'],
live_eventhub_config['event_hub'])
sas_auth = authentication.SASTokenAsync.from_shared_access_key(
uri, live_eventhub_config['key_name'],
live_eventhub_config['access_key'])
source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format(
live_eventhub_config['hostname'], live_eventhub_config['event_hub'],
live_eventhub_config['consumer_group'],
live_eventhub_config['partition'])
source = address.Source(source)
source.set_filter(b"amqp.annotation.x-opt-offset > '@latest'")
receive_client = uamqp.ReceiveClientAsync(source,
auth=sas_auth,
timeout=5000,
debug=False,
shutdown_after_timeout=False)
count = 0
try:
await receive_client.open_async()
while not await receive_client.client_ready_async():
await asyncio.sleep(0.05)
await asyncio.sleep(1) # sleep for 1s
await receive_client._connection.work_async(
) # do a single connection iteration to see if there're incoming transfers
# make sure no messages are received
assert not receive_client._was_message_received
assert receive_client._received_messages.empty()
gen = receive_client.receive_messages_iter_async()
send_single_message(live_eventhub_config,
live_eventhub_config['partition'], 'message')
async for message in gen:
log.info(message.annotations.get(b'x-opt-sequence-number'))
log.info(str(message))
count += 1
assert count == 1
count = 0
message_handler_before = receive_client.message_handler
send_single_message(live_eventhub_config,
live_eventhub_config['partition'], 'message')
gen = receive_client.receive_messages_iter_async()
async for message in gen:
log.info(message.annotations.get(b'x-opt-sequence-number'))
log.info(str(message))
count += 1
assert count == 1
message_handler_after = receive_client.message_handler
assert message_handler_before == message_handler_after
finally:
await receive_client.close_async()
async def test_event_hubs_batch_receive_async_no_shutdown_after_timeout_sync(live_eventhub_config):
uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub'])
sas_auth = authentication.SASTokenAsync.from_shared_access_key(
uri, live_eventhub_config['key_name'], live_eventhub_config['access_key'])
source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format(
live_eventhub_config['hostname'],
live_eventhub_config['event_hub'],
live_eventhub_config['consumer_group'],
live_eventhub_config['partition'])
source = address.Source(source)
source.set_filter(b"amqp.annotation.x-opt-offset > '@latest'")
async with uamqp.ReceiveClientAsync(source, auth=sas_auth, timeout=3000, prefetch=10, shutdown_after_timeout=False) as receive_client:
received_cnt = 0
received_cnt += len(await receive_client.receive_message_batch_async(10))
assert received_cnt == 0
message_handler_before = receive_client.message_handler
send_single_message(live_eventhub_config, live_eventhub_config['partition'], 'message')
received_cnt += len(await receive_client.receive_message_batch_async(10))
assert received_cnt == 1
received_cnt += len(await receive_client.receive_message_batch_async(10))
assert received_cnt == 1
send_single_message(live_eventhub_config, live_eventhub_config['partition'], 'message')
received_cnt += len(await receive_client.receive_message_batch_async(10))
message_handler_after = receive_client.message_handler
assert message_handler_before == message_handler_after
assert received_cnt == 2
def test_event_hubs_iter_receive_no_shutdown_after_timeout_sync(
live_eventhub_config):
uri = "sb://{}/{}".format(live_eventhub_config['hostname'],
live_eventhub_config['event_hub'])
sas_auth = authentication.SASTokenAuth.from_shared_access_key(
uri, live_eventhub_config['key_name'],
live_eventhub_config['access_key'])
source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format(
live_eventhub_config['hostname'], live_eventhub_config['event_hub'],
live_eventhub_config['consumer_group'],
live_eventhub_config['partition'])
source = address.Source(source)
source.set_filter(b"amqp.annotation.x-opt-offset > '@latest'")
receive_client = uamqp.ReceiveClient(source,
auth=sas_auth,
timeout=2000,
debug=False,
shutdown_after_timeout=False)
count = 0
receive_client.open()
while not receive_client.client_ready():
receive_client.do_work()
gen = receive_client.receive_messages_iter()
send_single_message(live_eventhub_config,
live_eventhub_config['partition'], 'message')
for message in gen:
log.info(message.annotations.get(b'x-opt-sequence-number'))
log.info(str(message))
count += 1
assert count == 1
count = 0
message_handler_before = receive_client.message_handler
send_single_message(live_eventhub_config,
live_eventhub_config['partition'], 'message')
gen = receive_client.receive_messages_iter()
for message in gen:
log.info(message.annotations.get(b'x-opt-sequence-number'))
log.info(str(message))
count += 1
assert count == 1
message_handler_after = receive_client.message_handler
assert message_handler_before == message_handler_after
receive_client.close()
def test_event_hubs_callback_receive_no_shutdown_after_timeout_sync(
live_eventhub_config):
received_cnt = {'cnt': 0}
def on_message_received(message):
annotations = message.annotations
log.info("Sequence Number: {}".format(
annotations.get(b'x-opt-sequence-number')))
log.info(str(message))
message.accept()
received_cnt['cnt'] += 1
uri = "sb://{}/{}".format(live_eventhub_config['hostname'],
live_eventhub_config['event_hub'])
sas_auth = authentication.SASTokenAuth.from_shared_access_key(
uri, live_eventhub_config['key_name'],
live_eventhub_config['access_key'])
source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format(
live_eventhub_config['hostname'], live_eventhub_config['event_hub'],
live_eventhub_config['consumer_group'],
live_eventhub_config['partition'])
source = address.Source(source)
source.set_filter(b"amqp.annotation.x-opt-offset > '@latest'")
receive_client = uamqp.ReceiveClient(source,
auth=sas_auth,
timeout=2000,
debug=False,
shutdown_after_timeout=False)
log.info("Created client, receiving...")
receive_client.open()
while not receive_client.client_ready():
receive_client.do_work()
send_single_message(live_eventhub_config,
live_eventhub_config['partition'], 'message')
receive_client.receive_messages(on_message_received)
message_handler_before = receive_client.message_handler
assert received_cnt['cnt'] == 1
send_single_message(live_eventhub_config,
live_eventhub_config['partition'], 'message')
receive_client.receive_messages(on_message_received)
message_handler_after = receive_client.message_handler
assert message_handler_before == message_handler_after
assert received_cnt['cnt'] == 2
log.info("Finished receiving")
receive_client.close()
async def test_event_hubs_callback_async_receive_no_shutdown_after_timeout(live_eventhub_config):
received_cnt = {'cnt': 0}
def on_message_received_internal(message):
annotations = message.annotations
log.info("Sequence Number: {}".format(annotations.get(b'x-opt-sequence-number')))
log.info(str(message))
message.accept()
received_cnt['cnt'] += 1
uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub'])
sas_auth = authentication.SASTokenAsync.from_shared_access_key(
uri, live_eventhub_config['key_name'], live_eventhub_config['access_key'])
source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format(
live_eventhub_config['hostname'],
live_eventhub_config['event_hub'],
live_eventhub_config['consumer_group'],
live_eventhub_config['partition'])
source = address.Source(source)
source.set_filter(b"amqp.annotation.x-opt-offset > '@latest'")
receive_client = uamqp.ReceiveClientAsync(source, auth=sas_auth, timeout=3000, prefetch=10, shutdown_after_timeout=False)
log.info("Created client, receiving...")
try:
await receive_client.open_async()
while not await receive_client.client_ready_async():
await asyncio.sleep(0.05)
await asyncio.sleep(1) # sleep for 1s
await receive_client._connection.work_async() # do a single connection iteration to see if there're incoming transfers
# make sure no messages are received
assert not receive_client._was_message_received
assert receive_client._received_messages.empty()
send_single_message(live_eventhub_config, live_eventhub_config['partition'], 'message')
await receive_client.receive_messages_async(on_message_received_internal)
message_handler_before = receive_client.message_handler
assert received_cnt['cnt'] == 1
send_single_message(live_eventhub_config, live_eventhub_config['partition'], 'message')
await receive_client.receive_messages_async(on_message_received_internal)
message_handler_after = receive_client.message_handler
assert message_handler_before == message_handler_after
assert received_cnt['cnt'] == 2
log.info("Finished receiving")
finally:
await receive_client.close_async()
async def test_event_hubs_filter_receive_async(live_eventhub_config):
plain_auth = authentication.SASLPlain(live_eventhub_config['hostname'],
live_eventhub_config['key_name'],
live_eventhub_config['access_key'])
source_url = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format(
live_eventhub_config['hostname'], live_eventhub_config['event_hub'],
live_eventhub_config['consumer_group'],
live_eventhub_config['partition'])
source = address.Source(source_url)
source.set_filter(b"amqp.annotation.x-opt-enqueuedtimeutc > 1518731960545")
receive_client = uamqp.ReceiveClientAsync(source,
auth=plain_auth,
timeout=5000)
await receive_client.receive_messages_async(on_message_received)
def test_event_hubs_client_receive_no_shutdown_after_timeout_sync(
live_eventhub_config):
uri = "sb://{}/{}".format(live_eventhub_config['hostname'],
live_eventhub_config['event_hub'])
sas_auth = authentication.SASTokenAuth.from_shared_access_key(
uri, live_eventhub_config['key_name'],
live_eventhub_config['access_key'])
source = "amqps://{}/{}/ConsumerGroups/{}/Partitions/{}".format(
live_eventhub_config['hostname'], live_eventhub_config['event_hub'],
live_eventhub_config['consumer_group'],
live_eventhub_config['partition'])
source = address.Source(source)
source.set_filter(b"amqp.annotation.x-opt-offset > '@latest'")
received_cnt = 0
with uamqp.ReceiveClient(source,
auth=sas_auth,
timeout=2000,
debug=False,
shutdown_after_timeout=False) as receive_client:
log.info("Created client, receiving...")
received_cnt += len(
receive_client.receive_message_batch(max_batch_size=10))
assert received_cnt == 0
message_handler_before = receive_client.message_handler
send_single_message(live_eventhub_config,
live_eventhub_config['partition'], 'message')
received_cnt += len(
receive_client.receive_message_batch(max_batch_size=10))
assert received_cnt == 1
received_cnt += len(
receive_client.receive_message_batch(max_batch_size=10))
assert received_cnt == 1
send_single_message(live_eventhub_config,
live_eventhub_config['partition'], 'message')
received_cnt += len(
receive_client.receive_message_batch(max_batch_size=10))
message_handler_after = receive_client.message_handler
assert message_handler_before == message_handler_after
assert received_cnt == 2
def __init__(self, source, auth=None, client_name=None, debug=False, timeout=0, **kwargs):
source = source if isinstance(source, address.Address) else address.Source(source)
self._timeout = timeout
self._message_receiver = None
self._last_activity_timestamp = None
self._was_message_received = False
self._message_received_callback = None
self._received_messages = None
# Receiver and Link settings
self._receive_settle_mode = kwargs.pop('receive_settle_mode', None) or constants.ReceiverSettleMode.PeekLock
self._max_message_size = kwargs.pop('max_message_size', None) or constants.MAX_MESSAGE_LENGTH_BYTES
self._prefetch = kwargs.pop('prefetch', None) or 300
self._link_properties = kwargs.pop('link_properties', None)
# AMQP object settings
self.receiver_type = receiver.MessageReceiver
super(ReceiveClient, self).__init__(source, auth=auth, client_name=client_name, debug=debug, **kwargs)
async def redirect_async(self, redirect, auth):
"""Redirect the client endpoint using a Link DETACH redirect
response.
:param redirect: The Link DETACH redirect details.
:type redirect: ~uamqp.errors.LinkRedirect
:param auth: Authentication credentials to the redirected endpoint.
:type auth: ~uamqp.authentication.common.AMQPAuth
"""
if self._ext_connection:
raise ValueError("Clients with a shared connection cannot be "
"automatically redirected.")
if self.message_handler:
await self.message_handler.destroy_async()
self.message_handler = None
self._shutdown = False
self._last_activity_timestamp = None
self._was_message_received = False
self._remote_address = address.Source(redirect.address)
await self._redirect_async(redirect, auth)
