def on_receive(self, state, received_message, receiver):
'''Called on every successful receive'''
renewer = AutoLockRenewer()
renewer.register(receiver,
received_message,
max_lock_renewal_duration=300)
time.sleep(300)
def example_session_ops_sync():
servicebus_connection_str = os.environ['SERVICE_BUS_CONNECTION_STR']
queue_name = os.environ['SERVICE_BUS_SESSION_QUEUE_NAME']
session_id = "<your session id>"
with ServiceBusClient.from_connection_string(
conn_str=servicebus_connection_str) as servicebus_client:
with servicebus_client.get_queue_sender(
queue_name=queue_name) as sender:
sender.send_messages(
ServiceBusMessage('msg', session_id=session_id))
# [START get_session_sync]
with servicebus_client.get_queue_receiver(
queue_name=queue_name, session_id=session_id) as receiver:
session = receiver.session
# [END get_session_sync]
# [START get_session_state_sync]
with servicebus_client.get_queue_receiver(
queue_name=queue_name, session_id=session_id) as receiver:
session = receiver.session
session_state = session.get_state()
# [END get_session_state_sync]
# [START set_session_state_sync]
with servicebus_client.get_queue_receiver(
queue_name=queue_name, session_id=session_id) as receiver:
session = receiver.session
session.set_state("START")
# [END set_session_state_sync]
# [START session_renew_lock_sync]
with servicebus_client.get_queue_receiver(
queue_name=queue_name, session_id=session_id) as receiver:
session = receiver.session
session.renew_lock()
# [END session_renew_lock_sync]
# [START auto_lock_renew_session_sync]
from azure.servicebus import AutoLockRenewer
lock_renewal = AutoLockRenewer(max_workers=4)
with servicebus_client.get_queue_receiver(
queue_name=queue_name, session_id=session_id) as receiver:
session = receiver.session
# Auto renew session lock for 2 minutes
lock_renewal.register(receiver,
session,
max_lock_renewal_duration=120)
for message in receiver:
process_message(message)
receiver.complete_message(message)
# [END auto_lock_renew_session_sync]
break
def on_receive(self, state, received_message, receiver):
'''Called on every successful receive'''
renewer = AutoLockRenewer()
def on_fail(renewable, error):
print("FAILED AUTOLOCKRENEW: " + str(error))
renewer.register(receiver,
receiver.session,
max_lock_renewal_duration=600,
on_lock_renew_failure=on_fail)
def receive_process_and_complete_message(client, queue_name):
queue_client = client.get_queue(queue_name)
lock_renewal = AutoLockRenewer(max_workers=4)
lock_renewal.renew_period = 120
with queue_client.get_receiver() as queue_receiver:
for message in queue_receiver:
print("Received message: ", message)
lock_renewal.register(message, timeout=10800)
process_message(message)
print("Completing message")
message.complete()
break
def message_processing(sb_client, queue_name, messages):
while True:
try:
with sb_client.get_queue_receiver(
queue_name, max_wait_time=1,
session_id=NEXT_AVAILABLE_SESSION) as receiver:
renewer = AutoLockRenewer()
renewer.register(receiver.session)
receiver.session.set_state("OPEN")
for message in receiver:
messages.append(message)
print("Message: {}".format(message))
print("Time to live: {}".format(message.time_to_live))
print("Sequence number: {}".format(
message.sequence_number))
print("Enqueue Sequence number: {}".format(
message.enqueued_sequence_number))
print("Partition Key: {}".format(message.partition_key))
print("Locked until: {}".format(message.locked_until_utc))
print("Lock Token: {}".format(message.lock_token))
print("Enqueued time: {}".format(
message.enqueued_time_utc))
message.complete()
if str(message) == 'shutdown':
receiver.session.set_state("CLOSED")
renewer.close()
except NoActiveSession:
print(
"There are no non-empty sessions remaining; exiting. This may present as a UserError in the azure portal."
)
return
def renew_lock_on_session_of_the_sessionful_entity():
servicebus_client = ServiceBusClient.from_connection_string(conn_str=CONNECTION_STR)
with servicebus_client:
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)]
sender.send_messages(msgs_to_send)
print('Send messages to sessionful queue.')
renewer = AutoLockRenewer()
with servicebus_client.get_queue_session_receiver(
queue_name=SESSION_QUEUE_NAME,
session_id='SESSION',
prefetch_count=10
) as receiver:
# automatically renew the lock on the session for 100 seconds
renewer.register(receiver.session, timeout=100)
print('Register session into AutoLockRenewer.')
received_msgs = receiver.receive_messages(max_message_count=10, max_wait_time=5)
time.sleep(100) # message handling for long period (E.g. application logic)
for msg in received_msgs:
msg.complete()
print('Complete messages.')
renewer.close()
def renew_lock_on_message_received_from_non_sessionful_entity():
servicebus_client = ServiceBusClient.from_connection_string(conn_str=CONNECTION_STR)
with servicebus_client:
with servicebus_client.get_queue_sender(queue_name=QUEUE_NAME) as sender:
msgs_to_send = [Message("message: {}".format(i)) for i in range(10)]
sender.send_messages(msgs_to_send)
print('Send messages to non-sessionful queue.')
# Can also be called via "with AutoLockRenewer() as renewer" to automate shutdown.
renewer = AutoLockRenewer()
with servicebus_client.get_queue_receiver(queue_name=QUEUE_NAME, prefetch_count=10) as receiver:
received_msgs = receiver.receive_messages(max_message_count=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 AutoLockRenewer done.')
time.sleep(100) # message handling for long period (E.g. application logic)
for msg in received_msgs:
msg.complete() # Settling the message deregisters it from the AutoLockRenewer
print('Complete messages.')
renewer.close()
def renew_lock_with_lock_renewal_failure_callback():
servicebus_client = ServiceBusClient.from_connection_string(
conn_str=CONNECTION_STR)
with servicebus_client:
with servicebus_client.get_queue_sender(
queue_name=QUEUE_NAME) as sender:
sender.send_messages(ServiceBusMessage("message"))
with AutoLockRenewer() as renewer:
# For this sample we're going to set the renewal recurrence of the autolockrenewer to greater than the
# service side message lock duration, to demonstrate failure. Normally, this should not be adjusted.
renewer._sleep_time = 40
with servicebus_client.get_queue_receiver(
queue_name=QUEUE_NAME, prefetch_count=10) as receiver:
def on_lock_renew_failure_callback(renewable, error):
# If auto-lock-renewal fails, this function will be called.
# If failure is due to an error, the second argument will be populated, otherwise
# it will default to `None`.
# This callback can be an ideal location to log the failure, or take action to safely
# handle any processing on the message or session that was in progress.
print("Intentionally failed to renew lock on {} due to {}".
format(renewable, error))
received_msgs = receiver.receive_messages(max_message_count=1,
max_wait_time=5)
for msg in received_msgs:
# automatically renew the lock on each message for 120 seconds
renewer.register(
receiver,
msg,
max_lock_renewal_duration=90,
on_lock_renew_failure=on_lock_renew_failure_callback)
print('Register messages into AutoLockRenewer done.')
# Cause the messages and autorenewal to time out.
# Other reasons for renew failure could include a network or service outage.
time.sleep(80)
try:
for msg in received_msgs:
receiver.complete_message(msg)
except ServiceBusError as e:
print(
'Messages cannot be settled if they have timed out. (This is expected)'
)
print('Lock renew failure demonstration complete.')
def example_send_and_receive_sync():
servicebus_sender = example_create_servicebus_sender_sync()
servicebus_receiver = example_create_servicebus_receiver_sync()
from azure.servicebus import ServiceBusMessage
# [START send_sync]
with servicebus_sender:
message = ServiceBusMessage("Hello World")
servicebus_sender.send_messages(message)
# [END send_sync]
servicebus_sender.send_messages([ServiceBusMessage("Hello World")] * 5)
# [START create_batch_sync]
with servicebus_sender:
batch_message = servicebus_sender.create_message_batch()
batch_message.add_message(
ServiceBusMessage("Single message inside batch"))
# [END create_batch_sync]
# [START send_complex_message]
message = ServiceBusMessage("Hello World!!",
session_id="MySessionID",
partition_key="UsingSpecificPartition",
user_properties={'data': 'custom_data'},
time_to_live=datetime.timedelta(seconds=30),
label='MyLabel')
# [END send_complex_message]
# [START peek_messages_sync]
with servicebus_receiver:
messages = servicebus_receiver.peek_messages()
for message in messages:
print(str(message))
# [END peek_messages_sync]
# [START auto_lock_renew_message_sync]
from azure.servicebus import AutoLockRenewer
lock_renewal = AutoLockRenewer(max_workers=4)
with servicebus_receiver:
for message in servicebus_receiver:
# Auto renew message for 1 minute.
lock_renewal.register(servicebus_receiver,
message,
max_lock_renewal_duration=60)
process_message(message)
servicebus_receiver.complete_message(message)
# [END auto_lock_renew_message_sync]
break
# [START receive_sync]
with servicebus_receiver:
messages = servicebus_receiver.receive_messages(max_wait_time=5)
for message in messages:
print(str(message))
servicebus_receiver.complete_message(message)
# [END receive_sync]
# [START receive_complex_message]
messages = servicebus_receiver.receive_messages(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("Enqueued Sequence numger: {}".format(
message.enqueued_sequence_number))
print("Partition Key: {}".format(message.partition_key))
print("Application Properties: {}".format(
message.application_properties))
print("Delivery count: {}".format(message.delivery_count))
print("Message ID: {}".format(message.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))
# [END receive_complex_message]
# [START abandon_message_sync]
messages = servicebus_receiver.receive_messages(max_wait_time=5)
for message in messages:
servicebus_receiver.abandon_message(message)
# [END abandon_message_sync]
# [START complete_message_sync]
messages = servicebus_receiver.receive_messages(max_wait_time=5)
for message in messages:
servicebus_receiver.complete_message(message)
# [END complete_message_sync]
# [START defer_message_sync]
messages = servicebus_receiver.receive_messages(max_wait_time=5)
for message in messages:
servicebus_receiver.defer_message(message)
# [END defer_message_sync]
# [START dead_letter_message_sync]
messages = servicebus_receiver.receive_messages(max_wait_time=5)
for message in messages:
servicebus_receiver.dead_letter_message(message)
# [END dead_letter_message_sync]
# [START renew_message_lock_sync]
messages = servicebus_receiver.receive_messages(max_wait_time=5)
for message in messages:
servicebus_receiver.renew_message_lock(message)
# [END renew_message_lock_sync]
# [START receive_forever]
with servicebus_receiver:
for message in servicebus_receiver.get_streaming_message_iter():
print(str(message))
servicebus_receiver.complete_message(message)
# [END receive_forever]
break
