def test_subscription_by_sas_token_credential_conn_str_send_basic( self, servicebus_namespace, servicebus_namespace_key_name, servicebus_namespace_primary_key, servicebus_topic, servicebus_subscription, **kwargs): fully_qualified_namespace = servicebus_namespace.name + '.servicebus.windows.net' with ServiceBusClient( fully_qualified_namespace=fully_qualified_namespace, credential=ServiceBusSharedKeyCredential( policy=servicebus_namespace_key_name, key=servicebus_namespace_primary_key), logging_enable=False) as sb_client: with sb_client.get_topic_sender( topic_name=servicebus_topic.name) as sender: message = Message(b"Sample topic message") sender.send_messages(message) with sb_client.get_subscription_receiver( topic_name=servicebus_topic.name, subscription_name=servicebus_subscription.name, max_wait_time=5) as receiver: count = 0 for message in receiver: count += 1 message.complete() assert count == 1
def sample_queue_send_receive_batch(sb_config, queue): client = ServiceBusClient( service_namespace=sb_config['hostname'], shared_access_key_name=sb_config['key_name'], shared_access_key_value=sb_config['access_key'], debug=True) queue_client = client.get_queue(queue) with queue_client.get_sender() as sender: for i in range(100): message = Message("Sample message no. {}".format(i)) sender.send(message) with queue_client.get_receiver(idle_timeout=1, mode=ReceiveSettleMode.PeekLock, prefetch=10) as receiver: total = 0 # Receive list of messages as a batch batch = receiver.fetch_next(max_batch_size=10) for message in batch: print("Message: {}".format(message)) print("Sequence number: {}".format(message.sequence_number)) message.complete() total += 1 # Receive messages as a continuous generator for message in receiver: print("Message: {}".format(message)) print("Sequence number: {}".format(message.sequence_number)) message.complete() total += 1 print("Received total {} messages".format(total))
def test_subscription_by_servicebus_client_receive_batch_with_deadletter( self, servicebus_namespace_connection_string, servicebus_topic, servicebus_subscription, **kwargs): with ServiceBusClient.from_connection_string( servicebus_namespace_connection_string, logging_enable=False) as sb_client: with sb_client.get_subscription_receiver( topic_name=servicebus_topic.name, subscription_name=servicebus_subscription.name, idle_timeout=5, mode=ReceiveSettleMode.PeekLock, prefetch=10) as receiver: with sb_client.get_topic_sender( servicebus_topic.name) as sender: for i in range(10): message = Message( "Dead lettered message no. {}".format(i)) sender.send_messages(message) count = 0 messages = receiver.receive_messages() while messages: for message in messages: print_message(_logger, message) count += 1 message.dead_letter(reason="Testing reason", description="Testing description") messages = receiver.receive_messages() assert count == 10 with sb_client.get_subscription_receiver( topic_name=servicebus_topic.name, subscription_name=servicebus_subscription.name, idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver: count = 0 for message in receiver: print_message(_logger, message) message.complete() count += 1 assert count == 0 with sb_client.get_subscription_deadletter_receiver( topic_name=servicebus_topic.name, subscription_name=servicebus_subscription.name, idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as dl_receiver: count = 0 for message in dl_receiver: message.complete() count += 1 assert message.user_properties[ b'DeadLetterReason'] == b'Testing reason' assert message.user_properties[ b'DeadLetterErrorDescription'] == b'Testing description' assert count == 10
def test_subscription_by_subscription_client_conn_str_receive_basic(self, servicebus_namespace_connection_string, servicebus_topic, servicebus_subscription, **kwargs): with ServiceBusClient.from_connection_string( servicebus_namespace_connection_string, logging_enable=False ) as sb_client: with sb_client.get_topic_sender(topic_name=servicebus_topic.name) as sender: message = Message(b"Sample topic message") sender.send(message) with sb_client.get_subscription_receiver( topic_name=servicebus_topic.name, subscription_name=servicebus_subscription.name, idle_timeout=5 ) as receiver: count = 0 for message in receiver: count += 1 message.complete() assert count == 1
def sample_session_send_receive_batch(sb_config, queue): session_id = str(uuid.uuid4()) client = ServiceBusClient(service_namespace=sb_config['hostname'], shared_access_key_name=sb_config['key_name'], shared_access_key_value=sb_config['access_key'], debug=False) queue_client = client.get_queue(queue) with queue_client.get_sender(session=session_id) as sender: for i in range(100): message = Message("Sample message no. {}".format(i)) sender.send(message) sender.send(Message("shutdown")) with queue_client.get_receiver(session=session_id) as session: session.set_session_state("START") for message in session: print(message) message.complete() if str(message) == "shutdown": session.set_session_state("END") break
def sample_session_send_receive_batch(sb_config, queue): session_id = str(uuid.uuid4()) client = ServiceBusClient( service_namespace=sb_config['hostname'], shared_access_key_name=sb_config['key_name'], shared_access_key_value=sb_config['access_key'], debug=True) queue_client = client.get_queue(queue) with queue_client.get_sender(session=session_id) as sender: for i in range(100): message = Message("Sample message no. {}".format(i)) sender.send(message) sender.send(Message("shutdown")) with queue_client.get_receiver(session=session_id) as session: session.set_session_state("START") for message in session: print(message) message.complete() if str(message) == "shutdown": session.set_session_state("END") break
def example_send_and_receive_sync(): servicebus_sender = example_create_servicebus_sender_sync() servicebus_receiver = example_create_servicebus_receiver_sync() from azure.servicebus import Message # [START send_sync] with servicebus_sender: message = Message("Hello World") servicebus_sender.send(message) # [END send_sync] # [START create_batch_sync] with servicebus_sender: batch_message = servicebus_sender.create_batch() batch_message.add(Message("Single message inside batch")) # [END create_batch_sync] # [START send_complex_message] message = Message("Hello World!!") message.session_id = "MySessionID" message.partition_key = "UsingSpecificPartition" message.user_properties = {'data': 'custom_data'} message.time_to_live = datetime.timedelta(seconds=30) # [END send_complex_message] # [START peek_messages_sync] with servicebus_receiver: messages = servicebus_receiver.peek() for message in messages: print(message) # [END peek_messages_sync] # [START auto_lock_renew_message_sync] from azure.servicebus import AutoLockRenew lock_renewal = AutoLockRenew(max_workers=4) with servicebus_receiver: for message in servicebus_receiver: # Auto renew message for 1 minute. lock_renewal.register(message, timeout=60) process_message(message) message.complete() # [END auto_lock_renew_message_sync] break # [START receive_sync] with servicebus_receiver: messages = servicebus_receiver.receive(max_wait_time=5) for message in messages: print(message) message.complete() # [END receive_sync] # [START receive_complex_message] messages = servicebus_receiver.receive(max_wait_time=5) for message in messages: print("Receiving: {}".format(message)) print("Time to live: {}".format(message.time_to_live)) print("Sequence number: {}".format(message.sequence_number)) print("Enqueue Sequence numger: {}".format( message.enqueue_sequence_number)) print("Partition ID: {}".format(message.partition_id)) print("Partition Key: {}".format(message.partition_key)) print("User Properties: {}".format(message.user_properties)) print("Annotations: {}".format(message.annotations)) print("Delivery count: {}".format(message.header.delivery_count)) print("Message ID: {}".format(message.properties.message_id)) print("Locked until: {}".format(message.locked_until_utc)) print("Lock Token: {}".format(message.lock_token)) print("Enqueued time: {}".format(message.enqueued_time_utc))
def test_example_send_receive_service_bus(live_servicebus_config, standard_queue, session_queue): import os import datetime from azure.servicebus import ServiceBusClient, ServiceBusResourceNotFound from azure.servicebus import Message client = create_servicebus_client() try: # [START create_queue_client_directly] import os from azure.servicebus 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_directly] except ServiceBusResourceNotFound: pass try: # [START create_topic_client_directly] import os from azure.servicebus import TopicClient connection_str = os.environ['SERVICE_BUS_CONNECTION_STR'] topic_client = TopicClient.from_connection_string(connection_str, name="MyTopic") properties = topic_client.get_properties() # [END create_topic_client_directly] except ServiceBusResourceNotFound: pass try: # [START create_sub_client_directly] import os from azure.servicebus import SubscriptionClient connection_str = os.environ['SERVICE_BUS_CONNECTION_STR'] subscription_client = SubscriptionClient.from_connection_string( connection_str, name="MySub", topic="MyTopic") properties = subscription_client.get_properties() # [END create_sub_client_directly] except ServiceBusResourceNotFound: pass queue_client = client.get_queue(standard_queue) session_client = client.get_queue(session_queue) # [START get_sender] with queue_client.get_sender() as queue_sender: queue_sender.send(Message("First")) queue_sender.send(Message("Second")) # [END get_sender] # [START send_message_service_bus_multiple] from azure.servicebus import Message message1 = Message("Hello World!") message2 = Message("How are you?") queue_client.send([message1, message2]) # [END send_message_service_bus_multiple] # [START send_complex_message] message = Message("Hello World!") message.session_id = "MySessionID" message.partition_key = "UsingSpecificPartition" message.user_properties = {'data': 'custom_data'} message.time_to_live = datetime.timedelta(seconds=30) queue_client.send(message) # [END send_complex_message] # [START send_batch_message] from azure.servicebus import BatchMessage def batched_data(): for i in range(100): yield "Batched Message no. {}".format(i) message = BatchMessage(batched_data()) results = queue_client.send(message) # [END send_batch_message] # [START send_message_service_bus] from azure.servicebus import Message message = Message("Hello World!") queue_client.send(message) # [END send_message_service_bus] # [START get_receiver] with queue_client.get_receiver() as queue_receiver: messages = queue_receiver.fetch_next(timeout=3) # [END get_receiver] # [START peek_messages_service_bus] # Specify the number of messages to peek at. pending_messages = queue_client.peek(count=5) # [END peek_messages_service_bus] # [START auto_lock_renew_message] from azure.servicebus import AutoLockRenew lock_renewal = AutoLockRenew(max_workers=4) with queue_client.get_receiver(idle_timeout=3) as queue_receiver: for message in queue_receiver: # Auto renew message for 1 minute. lock_renewal.register(message, timeout=60) process_message(message) message.complete() # [END auto_lock_renew_message] # [START auto_lock_renew_session] from azure.servicebus import AutoLockRenew lock_renewal = AutoLockRenew(max_workers=4) with session_client.get_receiver(session="MySessionID", idle_timeout=3) as session: # Auto renew session lock for 2 minutes lock_renewal.register(session, timeout=120) for message in session: process_message(message) message.complete() # [END auto_lock_renew_session] # [START list_sessions_service_bus] session_ids = session_client.list_sessions() # List sessions updated after specific time import datetime yesterday = datetime.datetime.today() - datetime.timedelta(days=1) session_ids = session_client.list_sessions(updated_since=yesterday) # [END list_sessions_service_bus] try: # [START receive_deferred_messages_service_bus] seq_numbers = [] with queue_client.get_receiver(idle_timeout=3) as queue_receiver: for message in queue_receiver: seq_numbers.append(message.sequence_number) message.defer() # Receive deferred messages - provide sequence numbers of # messages which were deferred. deferred = queue_client.receive_deferred_messages(sequence_numbers=seq_numbers) # [END receive_deferred_messages_service_bus] except ValueError: pass deferred = [] try: # [START settle_deferred_messages_service_bus] queue_client.settle_deferred_messages('completed', deferred) # [END settle_deferred_messages_service_bus] except ValueError: pass # [START get_dead_letter_receiver] # Get dead lettered messages with queue_client.get_deadletter_receiver(idle_timeout=1) as dead_letter_receiver: # Receive dead lettered message continuously for message in dead_letter_receiver: print(message) message.complete()