async def test_sb_client_bad_entity_async(self):
fake_str = "Endpoint=sb://mock.servicebus.windows.net/;" \
"SharedAccessKeyName=mock;SharedAccessKey=mock;EntityPath=mockentity"
fake_client = ServiceBusClient.from_connection_string(fake_str)
with pytest.raises(ValueError):
fake_client.get_queue_sender('queue')
with pytest.raises(ValueError):
fake_client.get_queue_receiver('queue')
with pytest.raises(ValueError):
fake_client.get_topic_sender('topic')
with pytest.raises(ValueError):
fake_client.get_subscription_receiver('topic', 'subscription')
fake_client.get_queue_sender('mockentity')
fake_client.get_queue_receiver('mockentity')
fake_client.get_topic_sender('mockentity')
fake_client.get_subscription_receiver('mockentity', 'subscription')
fake_str = "Endpoint=sb://mock.servicebus.windows.net/;" \
"SharedAccessKeyName=mock;SharedAccessKey=mock"
fake_client = ServiceBusClient.from_connection_string(fake_str)
fake_client.get_queue_sender('queue')
fake_client.get_queue_receiver('queue')
fake_client.get_topic_sender('topic')
fake_client.get_subscription_receiver('topic', 'subscription')
def test_servicebusclient_from_conn_str_amqpoverwebsocket_async(
self, servicebus_namespace_connection_string, **kwargs):
sb_client = ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string)
assert sb_client.transport_type == TransportType.Amqp
websocket_sb_client = ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string +
';TransportType=AmqpOverWebsocket')
assert websocket_sb_client.transport_type == TransportType.AmqpOverWebsocket
async def example_create_servicebus_receiver_async():
servicebus_client = example_create_servicebus_client_async()
# [START create_servicebus_receiver_from_conn_str_async]
import os
from azure.servicebus.aio import ServiceBusReceiver
servicebus_connection_str = os.environ['SERVICE_BUS_CONNECTION_STR']
queue_name = os.environ['SERVICE_BUS_QUEUE_NAME']
queue_receiver = ServiceBusReceiver.from_connection_string(
conn_str=servicebus_connection_str, queue_name=queue_name)
# [END create_servicebus_receiver_from_conn_str_async]
# [START create_servicebus_receiver_async]
import os
from azure.servicebus.aio import ServiceBusReceiver, ServiceBusSharedKeyCredential
fully_qualified_namespace = os.environ[
'SERVICE_BUS_FULLY_QUALIFIED_NAMESPACE']
shared_access_policy = os.environ['SERVICE_BUS_SAS_POLICY']
shared_access_key = os.environ['SERVICE_BUS_SAS_KEY']
queue_name = os.environ['SERVICE_BUS_QUEUE_NAME']
queue_receiver = ServiceBusReceiver(
fully_qualified_namespace=fully_qualified_namespace,
credential=ServiceBusSharedKeyCredential(shared_access_policy,
shared_access_key),
queue_name=queue_name)
# [END create_servicebus_receiver_async]
# [START create_servicebus_receiver_from_sb_client_async]
import os
from azure.servicebus.aio import ServiceBusClient
servicebus_connection_str = os.environ['SERVICE_BUS_CONNECTION_STR']
queue_name = os.environ['SERVICE_BUS_QUEUE_NAME']
servicebus_client = ServiceBusClient.from_connection_string(
conn_str=servicebus_connection_str)
async with servicebus_client:
queue_receiver = servicebus_client.get_queue_receiver(
queue_name=queue_name)
# [END create_servicebus_receiver_from_sb_client_async]
# [START create_subscription_receiver_from_sb_client_async]
import os
from azure.servicebus import ServiceBusClient
servicebus_connection_str = os.environ['SERVICE_BUS_CONNECTION_STR']
topic_name = os.environ["SERVICE_BUS_TOPIC_NAME"]
subscription_name = os.environ["SERVICE_BUS_SUBSCRIPTION_NAME"]
servicebus_client = ServiceBusClient.from_connection_string(
conn_str=servicebus_connection_str)
async with servicebus_client:
subscription_receiver = servicebus_client.get_subscription_receiver(
topic_name=topic_name,
subscription_name=subscription_name,
)
# [END create_subscription_receiver_from_sb_client_async]
return queue_receiver
async def handle_filings_async(
handler: Callable[[Filing], None],
connection_string:
str = "Endpoint=sb://calcbench.servicebus.windows.net/;SharedAccessKeyName=public;SharedAccessKey=Cb7VhLR6eJxsurCSPtXQHOJvlkU84CCCx2oB+T/so6Q=",
subscription_name: str = None,
):
"""
https://github.com/Azure/azure-sdk-for-python/blob/master/sdk/servicebus/azure-servicebus/samples/async_samples/receive_subscription_async.py
"""
servicebus_client = AsyncServiceBusClient.from_connection_string(
conn_str=connection_string)
if not subscription_name:
raise ValueError("Need to supply subscription_name")
async with servicebus_client:
receiver = servicebus_client.get_subscription_receiver(
topic_name=TOPIC, subscription_name=subscription_name)
async with receiver:
while True:
received_msgs = await receiver.receive_messages()
for msg in received_msgs:
body_bytes = b"".join(msg.body)
try:
filing = Filing(**json.loads(body_bytes))
except Exception:
logger.exception(f"Exception Parsing {body_bytes}")
msg.abandon()
else:
logger.info(f"Handling {filing}")
handler(filing)
await msg.complete()
async def test_async_session_message_expiry(self, servicebus_namespace_connection_string, servicebus_queue, **kwargs):
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, logging_enable=False) as sb_client:
session_id = str(uuid.uuid4())
async with sb_client.get_queue_sender(servicebus_queue.name) as sender:
message = Message("Testing expired messages")
message.session_id = session_id
await sender.send_messages(message)
async with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id) as receiver:
messages = await receiver.receive_messages(max_wait_time=10)
assert len(messages) == 1
print_message(_logger, messages[0])
await asyncio.sleep(60) #TODO: Was 30, but then lock isn't expired.
with pytest.raises(TypeError):
messages[0]._lock_expired
with pytest.raises(TypeError):
await messages[0].renew_lock()
assert receiver.session._lock_expired
with pytest.raises(SessionLockExpired):
await messages[0].complete()
with pytest.raises(SessionLockExpired):
await receiver.session.renew_lock()
async with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id) as receiver:
messages = await receiver.receive_messages(max_wait_time=30)
assert len(messages) == 1
print_message(_logger, messages[0])
assert messages[0].delivery_count
await messages[0].complete()
async def test_async_session_by_servicebus_client_renew_client_locks(self, servicebus_namespace_connection_string, servicebus_queue, **kwargs):
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, logging_enable=False) as sb_client:
session_id = str(uuid.uuid4())
messages = []
locks = 3
async with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id, prefetch_count=10) as receiver:
async with sb_client.get_queue_sender(servicebus_queue.name) as sender:
for i in range(locks):
message = Message("Test message no. {}".format(i), session_id=session_id)
await sender.send_messages(message)
messages.extend(await receiver.receive_messages())
recv = True
while recv:
recv = await receiver.receive_messages(max_wait_time=5)
messages.extend(recv)
try:
for m in messages:
with pytest.raises(TypeError):
expired = m._lock_expired
assert m.locked_until_utc is None
assert m.lock_token is not None
time.sleep(5)
initial_expiry = receiver.session.locked_until_utc
await receiver.session.renew_lock()
assert (receiver.session.locked_until_utc - initial_expiry) >= timedelta(seconds=5)
finally:
await messages[0].complete()
await messages[1].complete()
time.sleep(70) #TODO: BUG: Was 40
with pytest.raises(SessionLockExpired):
await messages[2].complete()
async def test_async_queue_by_servicebus_conn_str_client_iter_messages_with_abandon(live_servicebus_config, standard_queue):
client = ServiceBusClient.from_connection_string(live_servicebus_config['conn_str'], debug=True)
queue_client = client.get_queue(standard_queue)
async with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
async with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Abandoned message no. {}".format(i))
await sender.send(message)
count = 0
async for message in receiver:
print_message(message)
if not message.header.delivery_count:
count += 1
await message.abandon()
else:
assert message.header.delivery_count == 1
await message.complete()
assert count == 10
async with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
count = 0
async for message in receiver:
print_message(message)
await message.complete()
count += 1
assert count == 0
async def example_receive_deadletter_async():
from azure.servicebus import SubQueue
servicebus_connection_str = os.environ['SERVICE_BUS_CONNECTION_STR']
queue_name = os.environ['SERVICE_BUS_QUEUE_NAME']
async with ServiceBusClient.from_connection_string(
conn_str=servicebus_connection_str) as servicebus_client:
async with servicebus_client.get_queue_sender(
queue_name) as servicebus_sender:
await servicebus_sender.send_messages(
ServiceBusMessage("Hello World"))
# [START receive_deadletter_async]
async with servicebus_client.get_queue_receiver(
queue_name) as servicebus_receiver:
messages = await servicebus_receiver.receive_messages(
max_wait_time=5)
for message in messages:
await servicebus_receiver.dead_letter_message(
message,
reason='reason for dead lettering',
error_description='description for dead lettering')
async with servicebus_client.get_queue_receiver(
queue_name, sub_queue=SubQueue.DeadLetter
) as servicebus_deadletter_receiver:
messages = await servicebus_deadletter_receiver.receive_messages(
max_wait_time=5)
for message in messages:
await servicebus_deadletter_receiver.complete_message(message)
async def renew_lock_on_message_received_from_non_sessionful_entity():
servicebus_client = ServiceBusClient.from_connection_string(
conn_str=CONNECTION_STR)
async with servicebus_client:
async with servicebus_client.get_queue_sender(
queue_name=QUEUE_NAME) as sender:
msgs_to_send = [
Message("session message: {}".format(i)) for i in range(10)
]
await sender.send_messages(msgs_to_send)
print('Send messages to non-sessionful queue.')
# Can also be called via "with AutoLockRenew() as renewer" to automate shutdown.
renewer = AutoLockRenew()
async with servicebus_client.get_queue_receiver(
queue_name=QUEUE_NAME, prefetch=10) as receiver:
received_msgs = await receiver.receive_messages(max_batch_size=10,
max_wait_time=5)
for msg in received_msgs:
# automatically renew the lock on each message for 100 seconds
renewer.register(msg, timeout=100)
print('Register messages into AutoLockRenew done.')
await asyncio.sleep(
100
) # message handling for long period (E.g. application logic)
for msg in received_msgs:
await msg.complete()
print('Complete messages.')
await renewer.close()
async def test_async_session_by_servicebus_client_session_pool(self, servicebus_namespace_connection_string, servicebus_queue, **kwargs):
messages = []
errors = []
async def message_processing(sb_client):
while True:
try:
async with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=NEXT_AVAILABLE, max_wait_time=5) as session:
async for message in session:
print("Message: {}".format(message))
messages.append(message)
await message.complete()
except NoActiveSession:
return
except Exception as e:
errors.append(e)
raise
concurrent_receivers = 5
sessions = [str(uuid.uuid4()) for i in range(concurrent_receivers)]
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, logging_enable=False) as sb_client:
for session_id in sessions:
async with sb_client.get_queue_sender(servicebus_queue.name) as sender:
await asyncio.gather(*[sender.send_messages(Message("Sample message no. {}".format(i), session_id=session_id)) for i in range(20)])
receive_sessions = [message_processing(sb_client) for _ in range(concurrent_receivers)]
await asyncio.gather(*receive_sessions, return_exceptions=True)
assert not errors
assert len(messages) == 100
async def test_async_session_by_session_client_conn_str_receive_handler_with_stop(self, servicebus_namespace_connection_string, servicebus_queue, **kwargs):
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, logging_enable=False) as sb_client:
session_id = str(uuid.uuid4())
async with sb_client.get_queue_sender(servicebus_queue.name) as sender:
for i in range(10):
message = Message("Stop message no. {}".format(i), session_id=session_id)
await sender.send_messages(message)
messages = []
session = sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id, max_wait_time=5)
async with session:
async for message in session:
assert session_id == session.session.session_id
assert session_id == message.session_id
messages.append(message)
await message.complete()
if len(messages) >= 5:
break
assert session._running
assert len(messages) == 5
async with session:
async for message in session:
assert session_id == session.session.session_id
assert session_id == message.session_id
messages.append(message)
await message.complete()
if len(messages) >= 5:
break
assert not session._running
assert len(messages) == 6
async def test_async_session_by_servicebus_client_list_sessions_with_client(
self, servicebus_namespace_connection_string, servicebus_queue,
**kwargs):
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string,
logging_enable=False) as sb_client:
sessions = []
start_time = utc_now()
for i in range(5):
sessions.append(str(uuid.uuid4()))
for session in sessions:
async with sb_client.get_queue_sender(
servicebus_queue.name) as sender:
for i in range(5):
message = Message("Test message no. {}".format(i),
session_id=session)
await sender.send(message)
for session in sessions:
async with sb_client.get_queue_session_receiver(
servicebus_queue.name, session_id=session) as receiver:
await receiver.session.set_session_state(
"SESSION {}".format(session))
current_sessions = await sb_client.list_sessions(
updated_since=start_time)
assert len(current_sessions) == 5
assert current_sessions == sessions
async def test_async_session_get_set_state_with_receiver(
self, servicebus_namespace_connection_string, servicebus_queue,
**kwargs):
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string,
logging_enable=False) as sb_client:
session_id = str(uuid.uuid4())
async with sb_client.get_queue_sender(
servicebus_queue.name) as sender:
for i in range(3):
message = Message("Handler message no. {}".format(i),
session_id=session_id)
await sender.send(message)
async with sb_client.get_queue_session_receiver(
servicebus_queue.name, session_id=session_id,
idle_timeout=5) as session:
assert await session.session.get_session_state() == None
await session.session.set_session_state("first_state")
count = 0
async for m in session:
assert m.properties.group_id == session_id.encode('utf-8')
count += 1
await session.session.get_session_state()
assert count == 3
async def test_async_session_by_session_client_conn_str_receive_handler_peeklock(
self, servicebus_namespace_connection_string, servicebus_queue,
**kwargs):
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string,
logging_enable=False) as sb_client:
session_id = str(uuid.uuid4())
async with sb_client.get_queue_sender(
servicebus_queue.name) as sender:
for i in range(3):
message = Message("Handler message no. {}".format(i),
session_id=session_id)
await sender.send(message)
with pytest.raises(ServiceBusConnectionError):
await sb_client.get_queue_receiver(
servicebus_queue.name, idle_timeout=5)._open_with_retry()
session = sb_client.get_queue_session_receiver(
servicebus_queue.name, session_id=session_id, idle_timeout=5)
count = 0
async for message in session:
print_message(_logger, message)
assert message.session_id == session_id
count += 1
await message.complete()
assert count == 3
async def test_async_session_by_servicebus_client_iter_messages_with_retrieve_deferred_client(
self, servicebus_namespace_connection_string, servicebus_queue,
**kwargs):
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string,
logging_enable=False) as sb_client:
deferred_messages = []
session_id = str(uuid.uuid4())
async with sb_client.get_queue_sender(
servicebus_queue.name) as sender:
for i in range(10):
message = Message("Deferred message no. {}".format(i),
session_id=session_id)
await sender.send(message)
session = sb_client.get_queue_session_receiver(
servicebus_queue.name, session_id=session_id, idle_timeout=5)
count = 0
async for message in session:
deferred_messages.append(message.sequence_number)
print_message(_logger, message)
count += 1
await message.defer()
assert count == 10
with pytest.raises(MessageSettleFailed):
await message.complete()
async def test_async_session_schedule_message(self, servicebus_namespace_connection_string, servicebus_queue, **kwargs):
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, logging_enable=False) as sb_client:
import uuid
session_id = str(uuid.uuid4())
enqueue_time = (utc_now() + timedelta(minutes=2)).replace(microsecond=0)
async with sb_client.get_queue_sender(servicebus_queue.name) as sender:
content = str(uuid.uuid4())
message_id = uuid.uuid4()
message = Message(content, session_id=session_id)
message.properties.message_id = message_id
message.scheduled_enqueue_time_utc = enqueue_time
await sender.send_messages(message)
messages = []
renewer = AutoLockRenew()
async with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id) as receiver:
renewer.register(receiver.session, timeout=140)
messages.extend(await receiver.receive_messages(max_wait_time=120))
messages.extend(await receiver.receive_messages(max_wait_time=5))
if messages:
data = str(messages[0])
assert data == content
assert messages[0].properties.message_id == message_id
assert messages[0].scheduled_enqueue_time_utc == enqueue_time
assert messages[0].scheduled_enqueue_time_utc == messages[0].enqueued_time_utc.replace(microsecond=0)
assert len(messages) == 1
else:
raise Exception("Failed to receive schdeduled message.")
await renewer.shutdown()
async def test_async_session_by_session_client_conn_str_receive_handler_with_no_session(self, servicebus_namespace_connection_string, servicebus_queue, **kwargs):
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, logging_enable=False) as sb_client:
session = sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=NEXT_AVAILABLE, max_wait_time=5)
with pytest.raises(NoActiveSession):
await session._open_with_retry()
async def test_async_session_by_queue_client_conn_str_receive_handler_receiveanddelete(self, servicebus_namespace_connection_string, servicebus_queue, **kwargs):
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, logging_enable=False) as sb_client:
session_id = str(uuid.uuid4())
async with sb_client.get_queue_sender(servicebus_queue.name) as sender:
for i in range(10):
message = Message("Handler message no. {}".format(i), session_id=session_id)
await sender.send_messages(message)
messages = []
session = sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id, receive_mode=ReceiveMode.ReceiveAndDelete, max_wait_time=5)
async for message in session:
messages.append(message)
assert session_id == session.session.session_id
assert session_id == message.session_id
with pytest.raises(MessageAlreadySettled):
await message.complete()
assert session._running
await session.close()
assert not session._running
assert len(messages) == 10
time.sleep(30)
messages = []
async with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id, receive_mode=ReceiveMode.ReceiveAndDelete, max_wait_time=5) as session:
async for message in session:
messages.append(message)
assert len(messages) == 0
async def test_async_session_by_servicebus_client_iter_messages_with_retrieve_deferred_receiver_deletemode(self, servicebus_namespace_connection_string, servicebus_queue, **kwargs):
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, logging_enable=False) as sb_client:
deferred_messages = []
session_id = str(uuid.uuid4())
async with sb_client.get_queue_sender(servicebus_queue.name) as sender:
for message in [Message("Deferred message no. {}".format(i), session_id=session_id) for i in range(10)]:
await sender.send_messages(message)
count = 0
async with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id, max_wait_time=5) as session:
async for message in session:
deferred_messages.append(message.sequence_number)
print_message(_logger, message)
count += 1
await message.defer()
assert count == 10
async with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id, max_wait_time=5, receive_mode=ReceiveMode.ReceiveAndDelete) as session:
deferred = await session.receive_deferred_messages(deferred_messages)
assert len(deferred) == 10
for message in deferred:
assert isinstance(message, ReceivedMessage)
with pytest.raises(MessageAlreadySettled):
await message.complete()
with pytest.raises(ServiceBusError):
deferred = await session.receive_deferred_messages(deferred_messages)
async def test_async_session_connection_failure_is_idempotent(self, servicebus_namespace_connection_string, servicebus_queue, **kwargs):
#Technically this validates for all senders/receivers, not just session, but since it uses session to generate a recoverable failure, putting it in here.
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, logging_enable=False) as sb_client:
# First let's just try the naive failure cases.
receiver = sb_client.get_queue_receiver("THIS_IS_WRONG_ON_PURPOSE")
with pytest.raises(ServiceBusAuthenticationError):
await receiver._open_with_retry()
assert not receiver._running
assert not receiver._handler
sender = sb_client.get_queue_sender("THIS_IS_WRONG_ON_PURPOSE")
with pytest.raises(ServiceBusAuthenticationError):
await sender._open_with_retry()
assert not receiver._running
assert not receiver._handler
# Then let's try a case we can recover from to make sure everything works on reestablishment.
receiver = sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=NEXT_AVAILABLE)
with pytest.raises(NoActiveSession):
await receiver._open_with_retry()
session_id = str(uuid.uuid4())
async with sb_client.get_queue_sender(servicebus_queue.name) as sender:
await sender.send_messages(Message("test session sender", session_id=session_id))
async with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=NEXT_AVAILABLE, max_wait_time=5) as receiver:
messages = []
async for message in receiver:
messages.append(message)
assert len(messages) == 1
async def test_async_session_by_servicebus_client_fetch_next_with_retrieve_deadletter(self, servicebus_namespace_connection_string, servicebus_queue, **kwargs):
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, logging_enable=False) as sb_client:
session_id = str(uuid.uuid4())
async with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id, max_wait_time=5, prefetch_count=10) as receiver:
async with sb_client.get_queue_sender(servicebus_queue.name) as sender:
for i in range(10):
message = Message("Dead lettered message no. {}".format(i), session_id=session_id)
await sender.send_messages(message)
count = 0
messages = await receiver.receive_messages()
while messages:
for message in messages:
print_message(_logger, message)
await message.dead_letter(reason="Testing reason", error_description="Testing description")
count += 1
messages = await receiver.receive_messages()
assert count == 10
async with sb_client.get_queue_receiver(servicebus_queue.name,
sub_queue = SubQueue.DeadLetter,
max_wait_time=5) as session:
count = 0
async for message in session:
print_message(_logger, message)
assert message.dead_letter_reason == 'Testing reason'
assert message.dead_letter_error_description == 'Testing description'
assert message.properties[b'DeadLetterReason'] == b'Testing reason'
assert message.properties[b'DeadLetterErrorDescription'] == b'Testing description'
await message.complete()
count += 1
assert count == 10
async def renew_lock_on_session_of_the_sessionful_entity():
servicebus_client = ServiceBusClient.from_connection_string(
conn_str=CONNECTION_STR)
async with servicebus_client:
async with servicebus_client.get_queue_sender(
queue_name=SESSION_QUEUE_NAME) as sender:
msgs_to_send = [
Message("session message: {}".format(i), session_id='SESSION')
for i in range(10)
]
await sender.send_messages(msgs_to_send)
print('Send messages to sessionful queue.')
renewer = AutoLockRenew()
async with servicebus_client.get_queue_session_receiver(
queue_name=SESSION_QUEUE_NAME, session_id='SESSION',
prefetch=10) as receiver:
# automatically renew the lock on the session for 100 seconds
renewer.register(receiver.session, timeout=100)
print('Register session into AutoLockRenew.')
received_msgs = await receiver.receive_messages(max_batch_size=10,
max_wait_time=5)
await asyncio.sleep(
100
) # message handling for long period (E.g. application logic)
for msg in received_msgs:
await msg.complete()
print('Complete messages.')
async def test_async_session_by_servicebus_client_browse_messages_client(self, servicebus_namespace_connection_string, servicebus_queue, **kwargs):
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, logging_enable=False) as sb_client:
session_id = str(uuid.uuid4())
async with sb_client.get_queue_sender(servicebus_queue.name) as sender:
for i in range(5):
message = Message("Test message no. {}".format(i), session_id=session_id)
await sender.send_messages(message)
session_id_2 = str(uuid.uuid4())
async with sb_client.get_queue_sender(servicebus_queue.name) as sender:
for i in range(3):
message = Message("Test message no. {}".format(i), session_id=session_id_2)
await sender.send_messages(message)
async with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id) as receiver:
messages = await receiver.peek_messages(5)
assert len(messages) == 5
assert all(isinstance(m, PeekedMessage) for m in messages)
for message in messages:
print_message(_logger, message)
with pytest.raises(AttributeError):
message.complete()
async with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id_2) as receiver:
messages = await receiver.peek_messages(5)
assert len(messages) == 3
async def test_subscription_by_subscription_client_conn_str_receive_basic(
self, servicebus_namespace_connection_string, servicebus_topic,
servicebus_subscription, **kwargs):
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string,
logging_enable=False) as sb_client:
async with sb_client.get_topic_sender(
topic_name=servicebus_topic.name) as sender:
message = ServiceBusMessage(b"Sample topic message")
await sender.send_messages(message)
with pytest.raises(ValueError):
sb_client.get_subscription_receiver(
topic_name=servicebus_topic.name,
subscription_name=servicebus_subscription.name,
max_wait_time=0)
async with sb_client.get_subscription_receiver(
topic_name=servicebus_topic.name,
subscription_name=servicebus_subscription.name,
max_wait_time=5) as receiver:
with pytest.raises(ValueError):
await receiver.receive_messages(max_wait_time=-1)
with pytest.raises(ValueError):
await receiver.get_streaming_message_iter(max_wait_time=0)
count = 0
async for message in receiver:
count += 1
await receiver.complete_message(message)
assert count == 1
async def test_async_session_cancel_scheduled_messages(self, servicebus_namespace_connection_string, servicebus_queue, **kwargs):
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, logging_enable=False) as sb_client:
session_id = str(uuid.uuid4())
enqueue_time = (utc_now() + timedelta(minutes=2)).replace(microsecond=0)
async with sb_client.get_queue_sender(servicebus_queue.name) as sender:
message_a = Message("Test scheduled message", session_id=session_id)
message_b = Message("Test scheduled message", session_id=session_id)
tokens = await sender.schedule_messages([message_a, message_b], enqueue_time)
assert len(tokens) == 2
await sender.cancel_scheduled_messages(tokens)
renewer = AutoLockRenew()
messages = []
async with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id) as receiver:
renewer.register(receiver.session, timeout=140)
messages.extend(await receiver.receive_messages(max_wait_time=120))
messages.extend(await receiver.receive_messages(max_wait_time=5))
try:
assert len(messages) == 0
except AssertionError:
for m in messages:
print(str(m))
await m.complete()
raise
await renewer.close()
async def test_async_session_schedule_multiple_messages(self, servicebus_namespace_connection_string, servicebus_queue, **kwargs):
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, logging_enable=False) as sb_client:
import uuid
session_id = str(uuid.uuid4())
enqueue_time = (utc_now() + timedelta(minutes=2)).replace(microsecond=0)
messages = []
async with sb_client.get_queue_sender(servicebus_queue.name) as sender:
content = str(uuid.uuid4())
message_id_a = uuid.uuid4()
message_a = Message(content, session_id=session_id)
message_a.message_id = message_id_a
message_id_b = uuid.uuid4()
message_b = Message(content, session_id=session_id)
message_b.message_id = message_id_b
tokens = await sender.schedule_messages([message_a, message_b], enqueue_time)
assert len(tokens) == 2
renewer = AutoLockRenew()
async with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id, prefetch_count=20) as receiver:
renewer.register(receiver.session, timeout=140)
messages.extend(await receiver.receive_messages(max_wait_time=120))
messages.extend(await receiver.receive_messages(max_wait_time=5))
if messages:
data = str(messages[0])
assert data == content
assert messages[0].message_id in (message_id_a, message_id_b)
assert messages[0].scheduled_enqueue_time_utc == enqueue_time
assert messages[0].scheduled_enqueue_time_utc == messages[0].enqueued_time_utc.replace(microsecond=0)
assert len(messages) == 2
else:
raise Exception("Failed to receive schdeduled message.")
await renewer.close()
async def test_async_session_by_servicebus_client_iter_messages_with_retrieve_deferred_receiver_complete(self, servicebus_namespace_connection_string, servicebus_queue, **kwargs):
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, logging_enable=False) as sb_client:
deferred_messages = []
session_id = str(uuid.uuid4())
async with sb_client.get_queue_sender(servicebus_queue.name) as sender:
for message in [Message("Deferred message no. {}".format(i), session_id=session_id) for i in range(10)]:
await sender.send_messages(message)
count = 0
async with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id, idle_timeout=5) as session:
async for message in session:
deferred_messages.append(message.sequence_number)
print_message(_logger, message)
count += 1
await message.defer()
assert count == 10
async with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id, idle_timeout=5) as session:
deferred = await session.receive_deferred_messages(deferred_messages)
assert len(deferred) == 10
for message in deferred:
assert isinstance(message, ReceivedMessage)
assert message.lock_token
assert not message.locked_until_utc
assert message._receiver
with pytest.raises(TypeError):
await message.renew_lock()
await message.complete()
async def test_async_queue_by_servicebus_conn_str_client_iter_messages_with_abandon(
live_servicebus_config, standard_queue):
client = ServiceBusClient.from_connection_string(
live_servicebus_config['conn_str'], debug=True)
queue_client = client.get_queue(standard_queue)
async with queue_client.get_receiver(
idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
async with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Abandoned message no. {}".format(i))
await sender.send(message)
count = 0
async for message in receiver:
print_message(message)
if not message.header.delivery_count:
count += 1
await message.abandon()
else:
assert message.header.delivery_count == 1
await message.complete()
assert count == 10
async with queue_client.get_receiver(
idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
count = 0
async for message in receiver:
print_message(message)
await message.complete()
count += 1
assert count == 0
async def main():
servicebus_client = ServiceBusClient.from_connection_string(
conn_str=CONNECTION_STR)
async with servicebus_client:
sender = servicebus_client.get_queue_sender(queue_name=QUEUE_NAME)
messages = [
ServiceBusMessage("Message to be deadlettered") for _ in range(10)
]
async with sender:
await sender.send_messages(messages)
print('dead lettering messages')
receiver = servicebus_client.get_queue_receiver(queue_name=QUEUE_NAME)
async with receiver:
received_msgs = await receiver.receive_messages(
max_message_count=10, max_wait_time=5)
for msg in received_msgs:
print(str(msg))
await receiver.dead_letter_message(msg)
print('receiving deadlettered messages')
dlq_receiver = servicebus_client.get_queue_receiver(
queue_name=QUEUE_NAME,
sub_queue=ServiceBusSubQueue.DEAD_LETTER,
prefetch_count=10)
async with dlq_receiver:
received_msgs = await dlq_receiver.receive_messages(
max_message_count=10, max_wait_time=5)
for msg in received_msgs:
print(str(msg))
await dlq_receiver.complete_message(msg)
async def main():
servicebus_client = ServiceBusClient.from_connection_string(
conn_str=CONNECTION_STR)
async with servicebus_client:
sender = servicebus_client.get_queue_sender(queue_name=QUEUE_NAME)
messages = [Message("Message to be deferred") for _ in range(10)]
async with sender:
await sender.send_messages(messages)
receiver = servicebus_client.get_queue_receiver(queue_name=QUEUE_NAME)
async with receiver:
received_msgs = await receiver.receive_messages(max_batch_size=10,
max_wait_time=5)
deferred_sequenced_numbers = []
for msg in received_msgs:
print("Deferring msg: {}".format(str(msg)))
deferred_sequenced_numbers.append(msg.sequence_number)
await msg.defer()
if deferred_sequenced_numbers:
received_deferred_msg = await receiver.receive_deferred_messages(
sequence_numbers=deferred_sequenced_numbers)
for msg in received_deferred_msg:
print("Completing deferred msg: {}".format(str(msg)))
await msg.complete()
else:
print("No messages received.")
def get_service(hass, config, discovery_info=None):
"""Get the notification service."""
connection_string = config[CONF_CONNECTION_STRING]
queue_name = config.get(CONF_QUEUE_NAME)
topic_name = config.get(CONF_TOPIC_NAME)
# Library can do synchronous IO when creating the clients.
# Passes in loop here, but can't run setup on the event loop.
servicebus = ServiceBusClient.from_connection_string(connection_string,
loop=hass.loop)
try:
if queue_name:
client = servicebus.get_queue(queue_name)
else:
client = servicebus.get_topic(topic_name)
except (ServiceBusConnectionError, ServiceBusResourceNotFound) as err:
_LOGGER.error(
"Connection error while creating client for queue/topic '%s'. %s",
queue_name or topic_name,
err,
)
return None
return ServiceBusNotificationService(client)
async def test_async_snippet_queues(live_servicebus_config, standard_queue):
# [START create_async_servicebus_client]
import os
from azure.servicebus.aio import ServiceBusClient, Message
namespace = os.environ['SERVICE_BUS_HOSTNAME']
shared_access_policy = os.environ['SERVICE_BUS_SAS_POLICY']
shared_access_key = os.environ['SERVICE_BUS_SAS_KEY']
client = ServiceBusClient(
service_namespace=namespace,
shared_access_key_name=shared_access_policy,
shared_access_key_value=shared_access_key)
# [END create_async_servicebus_client]
# [START create_async_servicebus_client_connstr]
connection_str = os.environ['SERVICE_BUS_CONNECTION_STR']
client = ServiceBusClient.from_connection_string(connection_str)
# [END create_async_servicebus_client_connstr]
# [START get_async_queue_client]
from azure.servicebus import ServiceBusResourceNotFound
try:
queue_client = client.get_queue("MyQueue")
except ServiceBusResourceNotFound:
pass
# [END get_async_queue_client]
try:
# [START create_queue_client]
import os
from azure.servicebus.aio import QueueClient
connection_str = os.environ['SERVICE_BUS_CONNECTION_STR']
queue_client = QueueClient.from_connection_string(connection_str, name="MyQueue")
queue_properties = queue_client.get_properties()
# [END create_queue_client]
except ServiceBusResourceNotFound:
pass
queue_client = client.get_queue(standard_queue)
# [START client_peek_messages]
peeked_messages = await queue_client.peek(count=5)
# [END client_peek_messages]
await queue_client.send(Message("a"))
try:
# [START client_defer_messages]
sequence_numbers = []
async with queue_client.get_receiver() as receiver:
async for message in receiver:
sequence_numbers.append(message.sequence_number)
await message.defer()
break
deferred = await queue_client.receive_deferred_messages(sequence_numbers)
# [END client_defer_messages]
except ValueError:
pass
await queue_client.send(Message("a"))
try:
sequence_numbers = []
async with queue_client.get_receiver(idle_timeout=2) as receiver:
async for message in receiver:
sequence_numbers.append(message.sequence_number)
await message.defer()
break
# [START client_settle_deferred_messages]
deferred = await queue_client.receive_deferred_messages(sequence_numbers)
await queue_client.settle_deferred_messages('completed', deferred)
# [END client_settle_deferred_messages]
except ValueError:
pass
# [START open_close_sender_directly]
from azure.servicebus.aio import Message
sender = queue_client.get_sender()
try:
await sender.open()
await sender.send(Message("foobar"))
finally:
await sender.close()
# [END open_close_sender_directly]
# [START queue_client_send]
from azure.servicebus.aio import Message
message = Message("Hello World")
await queue_client.send(message)
# [END queue_client_send]
# [START queue_client_send_multiple]
from azure.servicebus.aio import Message
messages = [Message("First"), Message("Second")]
await queue_client.send(messages, message_timeout=30)
# [END queue_client_send_multiple]
# [START open_close_receiver_directly]
receiver = queue_client.get_receiver()
async for message in receiver:
print(message)
break
await receiver.close()
# [END open_close_receiver_directly]
await queue_client.send(Message("a"))
# [START open_close_receiver_context]
async with queue_client.get_receiver() as receiver:
async for message in receiver:
await process_message(message)
# [END open_close_receiver_context]
break
# [START open_close_sender_context]
async with queue_client.get_sender() as sender:
await sender.send(Message("First"))
await sender.send(Message("Second"))
# [END open_close_sender_context]
# [START queue_sender_messages]
async with queue_client.get_sender() as sender:
sender.queue_message(Message("First"))
sender.queue_message(Message("Second"))
await sender.send_pending_messages()
# [END queue_sender_messages]
# [START schedule_messages]
async with queue_client.get_sender() as sender:
enqueue_time = datetime.now() + timedelta(minutes=10)
await sender.schedule(enqueue_time, Message("First"), Message("Second"))
# [END schedule_messages]
# [START cancel_schedule_messages]
async with queue_client.get_sender() as sender:
enqueue_time = datetime.now() + timedelta(minutes=10)
sequence_numbers = await sender.schedule(enqueue_time, Message("First"), Message("Second"))
await sender.cancel_scheduled_messages(*sequence_numbers)
# [END cancel_schedule_messages]
# [START receiver_peek_messages]
async with queue_client.get_receiver() as receiver:
pending_messages = await receiver.peek(count=5)
# [END receiver_peek_messages]
try:
await queue_client.send(Message("a"))
# [START receiver_defer_messages]
async with queue_client.get_receiver() as receiver:
async for message in receiver:
sequence_no = message.sequence_number
await message.defer()
break
message = await receiver.receive_deferred_messages([sequence_no])
# [END receiver_defer_messages]
except ServiceBusError:
pass
await queue_client.send(Message("a"))
# [START receiver_deadletter_messages]
async with queue_client.get_receiver(idle_timeout=5) as receiver:
async for message in receiver:
await message.dead_letter()
async with queue_client.get_deadletter_receiver() as receiver:
async for message in receiver:
await message.complete()
# [END receiver_deadletter_messages]
break
# [START receiver_fetch_batch]
async with queue_client.get_receiver(idle_timeout=5, prefetch=100) as receiver:
messages = await receiver.fetch_next(timeout=5)
await asyncio.gather(*[m.complete() for m in messages])
# [END receiver_fetch_batch]
# [START auto_lock_renew_async_message]
from azure.servicebus.aio import AutoLockRenew
lock_renewal = AutoLockRenew()
async with queue_client.get_receiver(idle_timeout=3) as queue_receiver:
async for message in queue_receiver:
lock_renewal.register(message, timeout=60)
await process_message(message)
await message.complete()