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()