async def test_async_queue_by_queue_client_conn_str_receive_handler_receiveanddelete( live_servicebus_config, standard_queue): queue_client = QueueClient.from_connection_string( live_servicebus_config['conn_str'], name=standard_queue, debug=True) queue_client.get_properties() async with queue_client.get_sender() as sender: for i in range(10): message = Message("Handler message no. {}".format(i)) message.enqueue_sequence_number = i await sender.send(message) messages = [] receiver = queue_client.get_receiver( mode=ReceiveSettleMode.ReceiveAndDelete, idle_timeout=5) async for message in receiver: messages.append(message) with pytest.raises(MessageAlreadySettled): await message.complete() assert not receiver.running assert len(messages) == 10 time.sleep(30) messages = [] receiver = queue_client.get_receiver( mode=ReceiveSettleMode.ReceiveAndDelete, idle_timeout=5) async for message in receiver: messages.append(message) assert len(messages) == 0
async def main(): queue_client = QueueClient.from_connection_string( receiver_constr, 'simplequeue') async with queue_client.get_receiver(idle_timeout=2) as receiver: async for message in receiver: await process_message(message)
async def test_async_session_by_session_client_conn_str_receive_handler_with_stop( live_servicebus_config, session_queue): queue_client = QueueClient.from_connection_string( live_servicebus_config['conn_str'], name=session_queue, debug=True) session_id = str(uuid.uuid4()) async with queue_client.get_sender(session=session_id) as sender: for i in range(10): message = Message("Stop message no. {}".format(i)) await sender.send(message) messages = [] session = queue_client.get_receiver(session=session_id, idle_timeout=5) async for message in session: assert session_id == 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_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_queue_client_conn_str_receive_handler_receiveanddelete(live_servicebus_config, session_queue): queue_client = QueueClient.from_connection_string( live_servicebus_config['conn_str'], name=session_queue, debug=True) queue_client.get_properties() session_id = str(uuid.uuid4()) async with queue_client.get_sender(session=session_id) as sender: for i in range(10): message = Message("Handler message no. {}".format(i)) await sender.send(message) messages = [] session = queue_client.get_receiver(session=session_id, mode=ReceiveSettleMode.ReceiveAndDelete, idle_timeout=5) async for message in session: messages.append(message) assert session_id == session.session_id assert session_id == message.session_id with pytest.raises(MessageAlreadySettled): await message.complete() assert not session.running assert len(messages) == 10 time.sleep(30) messages = [] session = queue_client.get_receiver(session=session_id, mode=ReceiveSettleMode.ReceiveAndDelete, idle_timeout=5) async for message in session: messages.append(message) assert len(messages) == 0
async def test_async_session_by_session_client_conn_str_receive_handler_peeklock(live_servicebus_config, session_queue): queue_client = QueueClient.from_connection_string( live_servicebus_config['conn_str'], name=session_queue, debug=True) queue_client.get_properties() session_id = str(uuid.uuid4()) async with queue_client.get_sender(session=session_id) as sender: for i in range(3): message = Message("Handler message no. {}".format(i)) await sender.send(message) with pytest.raises(ValueError): session = queue_client.get_receiver(idle_timeout=5) session = queue_client.get_receiver(session=session_id, idle_timeout=5) count = 0 async for message in session: print_message(message) assert message.session_id == session_id count += 1 await message.complete() assert count == 3
async def test_async_queue_by_queue_client_conn_str_receive_handler_receiveanddelete(live_servicebus_config, standard_queue): queue_client = QueueClient.from_connection_string( live_servicebus_config['conn_str'], name=standard_queue, debug=True) queue_client.get_properties() async with queue_client.get_sender() as sender: for i in range(10): message = Message("Handler message no. {}".format(i)) message.enqueue_sequence_number = i await sender.send(message) messages = [] receiver = queue_client.get_receiver(mode=ReceiveSettleMode.ReceiveAndDelete, idle_timeout=5) async for message in receiver: messages.append(message) with pytest.raises(MessageAlreadySettled): await message.complete() assert not receiver.running assert len(messages) == 10 time.sleep(30) messages = [] receiver = queue_client.get_receiver(mode=ReceiveSettleMode.ReceiveAndDelete, idle_timeout=5) async for message in receiver: messages.append(message) assert len(messages) == 0
async def test_async_session_get_set_state_with_receiver( self, servicebus_namespace_connection_string, servicebus_queue, **kwargs): queue_client = QueueClient.from_connection_string( servicebus_namespace_connection_string, name=servicebus_queue.name, debug=False) session_id = str(uuid.uuid4()) queue_client.get_properties() async with queue_client.get_sender(session=session_id) as sender: for i in range(3): message = Message("Handler message no. {}".format(i)) await sender.send(message) async with queue_client.get_receiver(session=session_id, idle_timeout=5) as session: assert await session.get_session_state() == None await 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 with pytest.raises(InvalidHandlerState): await session.get_session_state() assert count == 3
async def test_async_queue_by_queue_client_conn_str_receive_handler_with_stop( live_servicebus_config, standard_queue): queue_client = QueueClient.from_connection_string( live_servicebus_config['conn_str'], name=standard_queue, debug=True) async with queue_client.get_sender() as sender: for i in range(10): message = Message("Stop message no. {}".format(i)) await sender.send(message) messages = [] receiver = queue_client.get_receiver(idle_timeout=5) async for message in receiver: messages.append(message) await message.complete() if len(messages) >= 5: break assert receiver.running assert len(messages) == 5 async with receiver: async for message in receiver: messages.append(message) await message.complete() if len(messages) >= 5: break assert not receiver.running assert len(messages) == 6
async def test_async_queue_by_queue_client_conn_str_receive_handler_with_stop(live_servicebus_config, standard_queue): queue_client = QueueClient.from_connection_string( live_servicebus_config['conn_str'], name=standard_queue, debug=True) async with queue_client.get_sender() as sender: for i in range(10): message = Message("Stop message no. {}".format(i)) await sender.send(message) messages = [] receiver = queue_client.get_receiver(idle_timeout=5) async for message in receiver: messages.append(message) await message.complete() if len(messages) >= 5: break assert receiver.running assert len(messages) == 5 async with receiver: async for message in receiver: messages.append(message) await message.complete() if len(messages) >= 5: break assert not receiver.running assert len(messages) == 6
async def test_async_session_by_session_client_conn_str_receive_handler_with_no_session( live_servicebus_config, session_queue): queue_client = QueueClient.from_connection_string( live_servicebus_config['conn_str'], name=session_queue, debug=True) session = queue_client.get_receiver(session=NEXT_AVAILABLE, idle_timeout=5) with pytest.raises(NoActiveSession): await session.open()
async def test_async_session_by_conn_str_receive_handler_with_autolockrenew( self, servicebus_namespace_connection_string, servicebus_queue, **kwargs): session_id = str(uuid.uuid4()) queue_client = QueueClient.from_connection_string( servicebus_namespace_connection_string, name=servicebus_queue.name, debug=False) async with queue_client.get_sender(session=session_id) as sender: for i in range(10): message = Message("{}".format(i)) await sender.send(message) renewer = AutoLockRenew() messages = [] async with queue_client.get_receiver(session=session_id, idle_timeout=5, mode=ReceiveSettleMode.PeekLock, prefetch=20) as session: renewer.register(session, timeout=60) print("Registered lock renew thread", session.locked_until, datetime.now()) with pytest.raises(SessionLockExpired): async for message in session: if not messages: await asyncio.sleep(45) print("First sleep {}".format(session.locked_until - datetime.now())) assert not session.expired with pytest.raises(TypeError): message.expired assert message.locked_until is None with pytest.raises(TypeError): await message.renew_lock() assert message.lock_token is None await message.complete() messages.append(message) elif len(messages) == 1: await asyncio.sleep(45) print("Second sleep {}".format(session.locked_until - datetime.now())) assert session.expired assert isinstance(session.auto_renew_error, AutoLockRenewTimeout) try: await message.complete() raise AssertionError( "Didn't raise SessionLockExpired") except SessionLockExpired as e: assert isinstance(e.inner_exception, AutoLockRenewTimeout) messages.append(message) await renewer.shutdown() assert len(messages) == 2
async def test_async_session_by_session_client_conn_str_receive_handler_with_no_session(live_servicebus_config, session_queue): queue_client = QueueClient.from_connection_string( live_servicebus_config['conn_str'], name=session_queue, debug=True) session = queue_client.get_receiver(session=NEXT_AVAILABLE, idle_timeout=5) with pytest.raises(NoActiveSession): await session.open()
async def main(count: int): queue_client: QueueClient = QueueClient.from_connection_string( sender_constr, 'simplequeue') msg = Message(body='This is the message content') for index in range(count): msg = Message(f'New Message {index}') msg.properties.content_type = 'text/plain' msg.properties.message_id = uuid.uuid4().hex await queue_client.send(msg)
async def test_async_session_by_session_client_conn_str_receive_handler_with_no_session( self, servicebus_namespace_connection_string, servicebus_queue, **kwargs): queue_client = QueueClient.from_connection_string( servicebus_namespace_connection_string, name=servicebus_queue.name, debug=False) session = queue_client.get_receiver(session=NEXT_AVAILABLE, idle_timeout=5) with pytest.raises(NoActiveSession): await session.open()
async def test_async_session_by_session_client_conn_str_receive_handler_with_inactive_session(live_servicebus_config, session_queue): queue_client = QueueClient.from_connection_string( live_servicebus_config['conn_str'], name=session_queue, debug=True) session_id = str(uuid.uuid4()) messages = [] session = queue_client.get_receiver(session=session_id, mode=ReceiveSettleMode.ReceiveAndDelete, idle_timeout=5) async for message in session: messages.append(message) assert not session.running assert len(messages) == 0
async def test_async_queue_by_queue_client_conn_str_receive_handler_with_autolockrenew( live_servicebus_config, standard_queue): queue_client = QueueClient.from_connection_string( live_servicebus_config['conn_str'], name=standard_queue, debug=True) async with queue_client.get_sender() as sender: for i in range(10): message = Message("{}".format(i)) await sender.send(message) renewer = AutoLockRenew() messages = [] async with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock, prefetch=10) as receiver: async for message in receiver: if not messages: messages.append(message) assert not message.expired renewer.register(message, timeout=60) print("Registered lock renew thread", message.locked_until, datetime.now()) await asyncio.sleep(50) print("Finished first sleep", message.locked_until) assert not message.expired await asyncio.sleep(25) print("Finished second sleep", message.locked_until, datetime.now()) assert message.expired try: await message.complete() raise AssertionError("Didn't raise MessageLockExpired") except MessageLockExpired as e: assert isinstance(e.inner_exception, AutoLockRenewTimeout) else: if message.expired: print("Remaining messages", message.locked_until, datetime.now()) assert message.expired with pytest.raises(MessageLockExpired): await message.complete() else: assert message.header.delivery_count >= 1 print("Remaining messages", message.locked_until, datetime.now()) messages.append(message) await message.complete() await renewer.shutdown() assert len(messages) == 11
async def test_async_session_by_conn_str_receive_handler_with_autolockrenew(live_servicebus_config, session_queue): session_id = str(uuid.uuid4()) queue_client = QueueClient.from_connection_string( live_servicebus_config['conn_str'], name=session_queue, debug=True) async with queue_client.get_sender(session=session_id) as sender: for i in range(10): message = Message("{}".format(i)) await sender.send(message) renewer = AutoLockRenew() messages = [] async with queue_client.get_receiver(session=session_id, idle_timeout=5, mode=ReceiveSettleMode.PeekLock, prefetch=20) as session: renewer.register(session, timeout=60) print("Registered lock renew thread", session.locked_until, datetime.now()) with pytest.raises(SessionLockExpired): async for message in session: if not messages: await asyncio.sleep(45) print("First sleep {}".format(session.locked_until - datetime.now())) assert not session.expired with pytest.raises(TypeError): message.expired assert message.locked_until is None with pytest.raises(TypeError): await message.renew_lock() assert message.lock_token is None await message.complete() messages.append(message) elif len(messages) == 1: await asyncio.sleep(45) print("Second sleep {}".format(session.locked_until - datetime.now())) assert session.expired assert isinstance(session.auto_renew_error, AutoLockRenewTimeout) try: await message.complete() raise AssertionError("Didn't raise SessionLockExpired") except SessionLockExpired as e: assert isinstance(e.inner_exception, AutoLockRenewTimeout) messages.append(message) await renewer.shutdown() assert len(messages) == 2
async def test_async_queue_by_queue_client_conn_str_receive_handler_with_autolockrenew(live_servicebus_config, standard_queue): queue_client = QueueClient.from_connection_string( live_servicebus_config['conn_str'], name=standard_queue, debug=True) async with queue_client.get_sender() as sender: for i in range(10): message = Message("{}".format(i)) await sender.send(message) renewer = AutoLockRenew() messages = [] async with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock, prefetch=10) as receiver: async for message in receiver: if not messages: messages.append(message) assert not message.expired renewer.register(message, timeout=60) print("Registered lock renew thread", message.locked_until, datetime.now()) await asyncio.sleep(50) print("Finished first sleep", message.locked_until) assert not message.expired await asyncio.sleep(25) print("Finished second sleep", message.locked_until, datetime.now()) assert message.expired try: await message.complete() raise AssertionError("Didn't raise MessageLockExpired") except MessageLockExpired as e: assert isinstance(e.inner_exception, AutoLockRenewTimeout) else: if message.expired: print("Remaining messages", message.locked_until, datetime.now()) assert message.expired with pytest.raises(MessageLockExpired): await message.complete() else: assert message.header.delivery_count >= 1 print("Remaining messages", message.locked_until, datetime.now()) messages.append(message) await message.complete() await renewer.shutdown() assert len(messages) == 11
async def test_async_queue_by_queue_client_conn_str_receive_handler_peeklock( live_servicebus_config, standard_queue): queue_client = QueueClient.from_connection_string( live_servicebus_config['conn_str'], name=standard_queue, debug=True) queue_client.get_properties() async with queue_client.get_sender() as sender: for i in range(10): message = Message("Handler message no. {}".format(i)) message.enqueue_sequence_number = i await sender.send(message) with pytest.raises(ValueError): queue_client.get_receiver(session="test", idle_timeout=5) receiver = queue_client.get_receiver(idle_timeout=5) count = 0 async for message in receiver: print_message(message) count += 1 await message.complete() assert count == 10
async def test_async_session_get_set_state_with_receiver(live_servicebus_config, session_queue): queue_client = QueueClient.from_connection_string( live_servicebus_config['conn_str'], name=session_queue, debug=True) session_id = str(uuid.uuid4()) queue_client.get_properties() async with queue_client.get_sender(session=session_id) as sender: for i in range(3): message = Message("Handler message no. {}".format(i)) await sender.send(message) async with queue_client.get_receiver(session=session_id, idle_timeout=5) as session: assert await session.get_session_state() == None await 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 with pytest.raises(InvalidHandlerState): await session.get_session_state() assert count == 3
async def test_async_queue_by_queue_client_conn_str_receive_handler_peeklock(live_servicebus_config, standard_queue): queue_client = QueueClient.from_connection_string( live_servicebus_config['conn_str'], name=standard_queue, debug=True) queue_client.get_properties() async with queue_client.get_sender() as sender: for i in range(10): message = Message("Handler message no. {}".format(i)) message.enqueue_sequence_number = i await sender.send(message) with pytest.raises(ValueError): queue_client.get_receiver(session="test", idle_timeout=5) receiver = queue_client.get_receiver(idle_timeout=5) count = 0 async for message in receiver: print_message(message) count += 1 await message.complete() assert count == 10
async def test_async_session_by_session_client_conn_str_receive_handler_with_stop(live_servicebus_config, session_queue): queue_client = QueueClient.from_connection_string( live_servicebus_config['conn_str'], name=session_queue, debug=True) session_id = str(uuid.uuid4()) async with queue_client.get_sender(session=session_id) as sender: for i in range(10): message = Message("Stop message no. {}".format(i)) await sender.send(message) messages = [] session = queue_client.get_receiver(session=session_id, idle_timeout=5) async for message in session: assert session_id == 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_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
def __init__(self): self.connection_string = os.environ['SB_CONNECTION_STRING'] self._scrape_client = QueueClient.from_connection_string(self.connection_string, SCRAPE_QUEUE_NAME)
async def test_async_snippet_sessions(live_servicebus_config, session_queue): queue_client = QueueClient.from_connection_string( live_servicebus_config['conn_str'], name=session_queue) queue_client.get_properties() # [START open_close_session_sender_context] from azure.servicebus.aio import Message async with queue_client.get_sender(session="MySessionID") as sender: await sender.send(Message("First")) await sender.send(Message("Second")) # [END open_close_session_sender_context] # [START queue_session_sender_messages] async with queue_client.get_sender(session="MySessionID") as sender: sender.queue_message(Message("First")) sender.queue_message(Message("Second")) await sender.send_pending_messages() # [END queue_session_sender_messages] # [START schedule_session_messages] async with queue_client.get_sender(session="MySessionID") as sender: enqueue_time = datetime.now() + timedelta(minutes=10) await sender.schedule(enqueue_time, Message("First"), Message("Second")) # [END schedule_session_messages] # [START open_close_receiver_session_context] async with queue_client.get_receiver(session="MySessionID") as session: async for message in session: await process_message(message) # [END open_close_receiver_session_context] break # [START open_close_receiver_session_nextavailable] from azure.servicebus import NEXT_AVAILABLE, NoActiveSession try: async with queue_client.get_receiver(session=NEXT_AVAILABLE, idle_timeout=5) as receiver: async for message in receiver: await process_message(message) except NoActiveSession: pass # [END open_close_receiver_session_nextavailable] # [START set_session_state] async with queue_client.get_receiver(session="MySessionID", idle_timeout=5) as session: current_state = await session.get_session_state() if not current_state: await session.set_session_state("OPENED") # [END set_session_state] try: # [START receiver_peek_session_messages] async with queue_client.get_receiver(session=NEXT_AVAILABLE, idle_timeout=5) as receiver: pending_messages = await receiver.peek(count=5) # [END receiver_peek_session_messages] except NoActiveSession: pass await queue_client.send([ Message("a"), Message("b"), Message("c"), Message("d"), Message("e"), Message("f") ], session="MySessionID") try: # [START receiver_defer_session_messages] async with queue_client.get_receiver(session="MySessionID", idle_timeout=5) as receiver: sequence_numbers = [] async for message in receiver: sequence_numbers.append(message.sequence_number) await message.defer() break message = await receiver.receive_deferred_messages(sequence_numbers ) # [END receiver_defer_session_messages] except ServiceBusError: pass # [START receiver_renew_session_lock] async with queue_client.get_receiver(session="MySessionID", idle_timeout=5) as session: async for message in session: await process_message(message) await session.renew_lock() # [END receiver_renew_session_lock] break # [START auto_lock_renew_async_session] from azure.servicebus.aio import AutoLockRenew lock_renewal = AutoLockRenew() async with queue_client.get_receiver(session="MySessionID", idle_timeout=3) as session: lock_renewal.register(session) async for message in session: await process_message(message) await message.complete() # [END auto_lock_renew_async_session] break
async def test_async_snippet_sessions(live_servicebus_config, session_queue): queue_client = QueueClient.from_connection_string( live_servicebus_config['conn_str'], name=session_queue) queue_client.get_properties() # [START open_close_session_sender_context] from azure.servicebus.aio import Message async with queue_client.get_sender(session="MySessionID") as sender: await sender.send(Message("First")) await sender.send(Message("Second")) # [END open_close_session_sender_context] # [START queue_session_sender_messages] async with queue_client.get_sender(session="MySessionID") as sender: sender.queue_message(Message("First")) sender.queue_message(Message("Second")) await sender.send_pending_messages() # [END queue_session_sender_messages] # [START schedule_session_messages] async with queue_client.get_sender(session="MySessionID") as sender: enqueue_time = datetime.now() + timedelta(minutes=10) await sender.schedule(enqueue_time, Message("First"), Message("Second")) # [END schedule_session_messages] # [START open_close_receiver_session_context] async with queue_client.get_receiver(session="MySessionID") as session: async for message in session: await process_message(message) # [END open_close_receiver_session_context] break # [START open_close_receiver_session_nextavailable] from azure.servicebus import NEXT_AVAILABLE, NoActiveSession try: async with queue_client.get_receiver(session=NEXT_AVAILABLE, idle_timeout=5) as receiver: async for message in receiver: await process_message(message) except NoActiveSession: pass # [END open_close_receiver_session_nextavailable] # [START set_session_state] async with queue_client.get_receiver(session="MySessionID", idle_timeout=5) as session: current_state = await session.get_session_state() if not current_state: await session.set_session_state("OPENED") # [END set_session_state] try: # [START receiver_peek_session_messages] async with queue_client.get_receiver(session=NEXT_AVAILABLE, idle_timeout=5) as receiver: pending_messages = await receiver.peek(count=5) # [END receiver_peek_session_messages] except NoActiveSession: pass await queue_client.send([Message("a"), Message("b"), Message("c"), Message("d"), Message("e"), Message("f")], session="MySessionID") try: # [START receiver_defer_session_messages] async with queue_client.get_receiver(session="MySessionID", idle_timeout=5) as receiver: sequence_numbers = [] async for message in receiver: sequence_numbers.append(message.sequence_number) await message.defer() break message = await receiver.receive_deferred_messages(sequence_numbers) # [END receiver_defer_session_messages] except ServiceBusError: pass # [START receiver_renew_session_lock] async with queue_client.get_receiver(session="MySessionID", idle_timeout=5) as session: async for message in session: await process_message(message) await session.renew_lock() # [END receiver_renew_session_lock] break # [START auto_lock_renew_async_session] from azure.servicebus.aio import AutoLockRenew lock_renewal = AutoLockRenew() async with queue_client.get_receiver(session="MySessionID", idle_timeout=3) as session: lock_renewal.register(session) async for message in session: await process_message(message) await message.complete() # [END auto_lock_renew_async_session] break
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()
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()
async def send_response(self, original_message_id: str, reply_to: str, reply_content: str): complete_client = QueueClient.from_connection_string(self.connection_string, reply_to) async with complete_client.get_sender() as reply_sender: reply_msg = Message(reply_content) reply_msg.properties.correlation_id = original_message_id await reply_sender.send(reply_msg)