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