def test_pqueue_by_servicebus_conn_str_client_iter_messages_with_abandon(live_servicebus_config, partitioned_queue):
client = ServiceBusClient.from_connection_string(live_servicebus_config['conn_str'], debug=True)
queue_client = client.get_queue(partitioned_queue)
with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Abandoned message no. {}".format(i))
sender.send(message)
count = 0
for message in receiver:
print_message(message)
if not message.header.delivery_count:
count += 1
message.abandon()
else:
assert message.header.delivery_count == 1
message.complete()
assert count == 10
with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
count = 0
for message in receiver:
print_message(message)
message.complete()
count += 1
assert count == 0
def test_example_create_servicebus_client(live_servicebus_config):
client = create_servicebus_client()
# [START create_servicebus_client_connstr]
from azure.servicebus import ServiceBusClient
connection_str = os.environ['SERVICE_BUS_CONNECTION_STR']
client = ServiceBusClient.from_connection_string(connection_str)
# [END create_servicebus_client_connstr]
try:
# [START get_queue_client]
# Queue Client can be used to send and receive messages
# from an Azure ServiceBus Service
queue_name = 'MyQueue'
queue_client = client.get_queue(queue_name)
# [END get_queue_client]
except ServiceBusResourceNotFound:
pass
# [START list_queues]
queues = client.list_queues()
# Process the queues
for queue_client in queues:
print(queue_client.name)
# [END list_queues]
try:
# [START get_topic_client]
# Topic Client can be used to send messages to an Azure ServiceBus Service
topic_name = 'MyTopic'
topic_client = client.get_topic(topic_name)
# [END get_topic_client]
except ServiceBusResourceNotFound:
pass
# [START list_topics]
topics = client.list_topics()
# Process topics
for topic_client in topics:
print(topic_client.name)
# [END list_topics]
try:
# [START get_subscription_client]
# Subscription client can receivce messages from Azure Service Bus subscription
subscription_name = 'MySubscription'
subscription_client = client.get_subscription(topic_name, subscription_name)
# [END get_subscription_client]
except ServiceBusResourceNotFound:
pass
# [START list_subscriptions]
subscriptions = client.list_subscriptions(topic_name)
# Process subscriptions
for sub_client in subscriptions:
print(sub_client.name)
def test_sb_client_readonly_credentials(servicebus_conn_str_readonly, standard_queue):
client = ServiceBusClient.from_connection_string(servicebus_conn_str_readonly, debug=True)
with pytest.raises(AzureHttpError):
client.get_queue(standard_queue)
client = QueueClient.from_connection_string(servicebus_conn_str_readonly, name=standard_queue)
with client.get_receiver(idle_timeout=5) as receiver:
messages = receiver.fetch_next()
with pytest.raises(ServiceBusAuthorizationError):
client.send(Message("test"))
def test_stress_queue_check_for_dropped_messages(
self, servicebus_namespace_connection_string, servicebus_queue):
sb_client = ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, debug=False)
stress_test = ServiceBusQueueStressTests.DroppedMessageCheckerStressTestRunner(
senders=[sb_client.get_queue_sender(servicebus_queue.name)],
receivers=[sb_client.get_queue_receiver(servicebus_queue.name)],
receive_type=ReceiveType.pull,
duration=timedelta(seconds=3000))
result = stress_test.run()
assert (result.total_sent > 0)
assert (result.total_received > 0)
def send_service_bus_message(service_bus_connection_string, service_bus_queue_name, correlation_id):
with open(CREATE_WORKSPACE_REQUEST_DATA_FILE, "r") as file:
data = file.read().replace('\n', '')
service_bus_client = ServiceBusClient.from_connection_string(
conn_str=service_bus_connection_string, logging_enable=True)
with service_bus_client:
queue_sender = service_bus_client.get_queue_sender(queue_name=service_bus_queue_name)
with queue_sender:
message = ServiceBusMessage(body=data, correlation_id=correlation_id)
queue_sender.send_messages(message)
print(f"Service Bus message sent to queue: {data}")
def test_stress_queue_send_and_receive(
self, servicebus_namespace_connection_string, servicebus_queue):
sb_client = ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string,
logging_enable=LOGGING_ENABLE)
stress_test = StressTestRunner(
senders=[sb_client.get_queue_sender(servicebus_queue.name)],
receivers=[sb_client.get_queue_receiver(servicebus_queue.name)],
duration=timedelta(seconds=60))
result = stress_test.run()
assert (result.total_sent > 0)
assert (result.total_received > 0)
def test_stress_queue_long_renew_send_and_receive(
self, servicebus_namespace_connection_string, servicebus_queue):
sb_client = ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, debug=False)
stress_test = ServiceBusQueueStressTests.LongRenewStressTestRunner(
senders=[sb_client.get_queue_sender(servicebus_queue.name)],
receivers=[sb_client.get_queue_receiver(servicebus_queue.name)],
duration=timedelta(seconds=3000),
send_delay=300)
result = stress_test.run()
assert (result.total_sent > 0)
assert (result.total_received > 0)
def test_sb_client_readonly_credentials(
self, servicebus_authorization_rule_connection_string,
servicebus_queue, **kwargs):
client = ServiceBusClient.from_connection_string(
servicebus_authorization_rule_connection_string)
with client:
with client.get_queue_receiver(servicebus_queue.name) as receiver:
messages = receiver.receive_messages(max_message_count=1,
max_wait_time=1)
with pytest.raises(ServiceBusAuthorizationError):
with client.get_queue_sender(servicebus_queue.name) as sender:
sender.send_messages(ServiceBusMessage("test"))
def test_session_by_servicebus_client_renew_client_locks(
self, servicebus_namespace_connection_string, servicebus_queue,
**kwargs):
with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string,
logging_enable=False) as sb_client:
session_id = str(uuid.uuid4())
messages = []
locks = 3
with sb_client.get_queue_receiver(servicebus_queue.name,
session_id=session_id,
prefetch=10) as receiver:
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)
sender.send(message)
messages.extend(receiver.receive())
recv = True
while recv:
recv = receiver.receive(max_wait_time=5)
messages.extend(recv)
try:
for m in messages:
with pytest.raises(TypeError):
expired = m.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
receiver.session.renew_lock()
assert (receiver.session._locked_until_utc -
initial_expiry) >= timedelta(seconds=5)
finally:
messages[0].complete()
messages[1].complete()
# This magic number is because of a 30 second lock renewal window. Chose 31 seconds because at 30, you'll see "off by .05 seconds" flaky failures
# potentially as a side effect of network delays/sleeps/"typical distributed systems nonsense." In a perfect world we wouldn't have a magic number/network hop but this allows
# a slightly more robust test in absence of that.
assert (receiver.session._locked_until_utc -
utc_now()) <= timedelta(seconds=60)
time.sleep((receiver.session._locked_until_utc -
utc_now()).total_seconds())
with pytest.raises(SessionLockExpired):
messages[2].complete()
def test_sb_client_readonly_credentials(servicebus_conn_str_readonly,
standard_queue):
client = ServiceBusClient.from_connection_string(
servicebus_conn_str_readonly, debug=True)
with pytest.raises(AzureHttpError):
client.get_queue(standard_queue)
client = QueueClient.from_connection_string(servicebus_conn_str_readonly,
name=standard_queue)
with client.get_receiver(idle_timeout=5) as receiver:
messages = receiver.fetch_next()
with pytest.raises(ServiceBusAuthorizationError):
client.send(Message("test"))
def test_sb_client_bad_entity(self, servicebus_namespace_connection_string, **kwargs):
client = ServiceBusClient.from_connection_string(servicebus_namespace_connection_string)
with client:
with pytest.raises(ServiceBusAuthenticationError):
with client.get_queue_sender("invalid") as sender:
sender.send_messages(ServiceBusMessage("test"))
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 example_create_servicebus_sender_sync():
servicebus_client = example_create_servicebus_client_sync()
# [START create_servicebus_sender_from_conn_str_sync]
import os
from azure.servicebus import ServiceBusSender
servicebus_connection_str = os.environ['SERVICE_BUS_CONNECTION_STR']
queue_name = os.environ['SERVICE_BUS_QUEUE_NAME']
queue_sender = ServiceBusSender._from_connection_string(
conn_str=servicebus_connection_str, queue_name=queue_name)
# [END create_servicebus_sender_from_conn_str_sync]
# [START create_servicebus_sender_from_sb_client_sync]
import os
from azure.servicebus 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)
with servicebus_client:
queue_sender = servicebus_client.get_queue_sender(
queue_name=queue_name)
# [END create_servicebus_sender_from_sb_client_sync]
# [START create_topic_sender_from_sb_client_sync]
import os
from azure.servicebus import ServiceBusClient
servicebus_connection_str = os.environ['SERVICE_BUS_CONNECTION_STR']
topic_name = os.environ['SERVICE_BUS_TOPIC_NAME']
servicebus_client = ServiceBusClient.from_connection_string(
conn_str=servicebus_connection_str)
with servicebus_client:
topic_sender = servicebus_client.get_topic_sender(
topic_name=topic_name)
# [END create_topic_sender_from_sb_client_sync]
queue_sender = servicebus_client.get_queue_sender(queue_name=queue_name)
return queue_sender
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(Message("message"))
with AutoLockRenew() 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(
msg,
timeout=90,
on_lock_renew_failure=on_lock_renew_failure_callback)
print('Register messages into AutoLockRenew 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:
msg.complete()
except MessageLockExpired as e:
print(
'Messages cannot be settled if they have timed out. (This is expected)'
)
print('Lock renew failure demonstration complete.')
def notification():
if request.method == 'POST':
notification = Notification()
notification.message = request.form['message']
notification.subject = request.form['subject']
notification.status = 'Notifications submitted'
notification.submitted_date = datetime.utcnow()
try:
db.session.add(notification)
db.session.commit()
##################################################
# TODO: Refactor This logic into an Azure Function
# Code below will be replaced by a message queue
#################################################
# attendees = Attendee.query.all()
# for attendee in attendees:
# subject = '{}: {}'.format(attendee.first_name, notification.subject)
# send_email(attendee.email, subject, notification.message)
# notification.completed_date = datetime.utcnow()
# notification.status = 'Notified {} attendees'.format(len(attendees))
# db.session.commit()
# TODO Call servicebus queue_client to enqueue notification ID
notification_id = notification.id
servicebus_client = ServiceBusClient.from_connection_string(
conn_str=app.config.get("SERVICE_BUS_CONNECTION_STRING"),
logging_enable=True)
with servicebus_client:
sender = servicebus_client.get_queue_sender(
queue_name=app.config.get("SERVICE_BUS_QUEUE_NAME"))
with sender:
message = ServiceBusMessage(str(notification_id))
sender.send_messages(message)
logging.info("MSG Queue sent")
#################################################
# END of TODO
#################################################
return redirect('/Notifications')
except:
logging.error('log unable to save notification')
else:
return render_template('notification.html')
def handle_filings(handler,
connection_string,
subscription_name,
filter_expression="1=1"):
"""Listen for new filings from Calcbench
Pass in a function that process each filing.
Usage::
>>> def filing_handler(filing):
>>> accession_id = filing['calcbench_id']
>>> data = point_in_time(
>>> accession_id=accession_id
>>> all_face=True,
>>> all_footnotes=True,
>>> )
>>> print(data)
>>>
>>> handle_filings(
>>> filing_handler,
>>> connection_string=connection_string,
>>> subscription_name=subscription,
>>> filter_expression="FilingType = 'annualQuarterlyReport'",
>>> )
"""
sb_client = ServiceBusClient.from_connection_string(connection_string)
subscription = sb_client.get_subscription(TOPIC, subscription_name)
_create_filter(
sb_client.mgmt_client,
subscription_name=subscription_name,
filter_expression=filter_expression,
)
for message in subscription.get_receiver():
try:
body_bytes = b"".join(message.body)
filing = json.loads(body_bytes)
except Exception:
logger.exception(f"Exception Parsing {body_bytes}")
message.complete()
else:
try:
handler(filing)
except Exception:
logger.exception(f"Exception handling {filing}")
else:
message.complete()
def test_session_by_session_client_conn_str_receive_handler_with_inactive_session(self, servicebus_namespace_connection_string, servicebus_queue, **kwargs):
with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, logging_enable=False) as sb_client:
session_id = str(uuid.uuid4())
messages = []
with sb_client.get_queue_session_receiver(servicebus_queue.name,
session_id=session_id,
mode=ReceiveSettleMode.ReceiveAndDelete,
idle_timeout=5) as session:
for message in session:
messages.append(message)
assert not session._running
assert len(messages) == 0
def test_stress_queue_peek_messages(self,
servicebus_namespace_connection_string,
servicebus_queue):
sb_client = ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, debug=False)
stress_test = ServiceBusQueueStressTests.Peekon_receiveStressTestRunner(
senders=[sb_client.get_queue_sender(servicebus_queue.name)],
receivers=[sb_client.get_queue_receiver(servicebus_queue.name)],
duration=timedelta(seconds=300),
receive_delay=30,
receive_type=ReceiveType.none)
result = stress_test.run()
assert (result.total_sent > 0)
async def receiveMessage():
with ServiceBusClient.from_connection_string(
EQUINIX_OUTGOING_QUEUE_CONNECTION_STRING) as client:
# max_wait_time specifies how long the receiver should wait with no incoming messages before stopping receipt.
# Default is None; to receive forever.
with client.get_queue_receiver(EQUINIX_OUTGOING_QUEUE) as receiver:
for msg in receiver: # ServiceBusReceiver instance is a generator.
task = json.loads(json.loads(str(msg))['Task'])
body = task["Body"]
if 'Attachments' in body and len(body['Attachments']) > 0:
body['Attachments'] = await downloadAllAttachments(
body['Attachments'])
# Complete the message
# receiver.complete_message(msg)
print(body)
def test_stress_queue_close_and_reopen():
sb_client = ServiceBusClient.from_connection_string(
SERVICE_BUS_CONNECTION_STR, logging_enable=LOGGING_ENABLE)
stress_test = RestartHandlerStressTestRunner(
senders=[sb_client.get_queue_sender(SERVICEBUS_QUEUE_NAME)],
receivers=[sb_client.get_queue_receiver(SERVICEBUS_QUEUE_NAME)],
duration=timedelta(seconds=300),
receive_delay=30,
send_delay=10,
azure_monitor_metric=AzureMonitorMetric(
"test_stress_queue_close_and_reopen"))
result = stress_test.run()
assert (result.total_sent > 0)
assert (result.total_received > 0)
def test_stress_queue_pull_receive_timeout():
sb_client = ServiceBusClient.from_connection_string(
SERVICE_BUS_CONNECTION_STR, logging_enable=LOGGING_ENABLE)
stress_test = ReceiverTimeoutStressTestRunner(
senders=[sb_client.get_queue_sender(SERVICEBUS_QUEUE_NAME)],
receivers=[sb_client.get_queue_receiver(SERVICEBUS_QUEUE_NAME)],
max_wait_time=5,
receive_type=ReceiveType.pull,
duration=timedelta(seconds=600),
azure_monitor_metric=AzureMonitorMetric(
"test_stress_queue_pull_receive_timeout"))
result = stress_test.run()
assert (result.total_sent > 0)
assert (result.total_received > 0)
def result_collector(self):
servicebus_client = SyncClient.from_connection_string(
conn_str=self.conn_string)
self._no_fail_create_queue(servicebus_client, self.name)
queue_client = servicebus_client.get_queue(self.name)
with queue_client.get_receiver(idle_timeout=0,
mode=ReceiveSettleMode.ReceiveAndDelete,
prefetch=1) as receiver:
# Receive messages as a continuous generator
for message in receiver:
print("Recieved result: {}".format(message))
json_data = json.loads(str(message))
self.results.append(json_data)
def test_session_by_servicebus_client_session_pool(
self, servicebus_namespace_connection_string, servicebus_queue,
**kwargs):
messages = []
errors = []
concurrent_receivers = 5
def message_processing(sb_client):
while True:
try:
with sb_client.get_queue_receiver(
servicebus_queue.name,
session_id=NEXT_AVAILABLE,
idle_timeout=5) as session:
for message in session:
print("Message: {}".format(message))
messages.append(message)
message.complete()
except NoActiveSession:
return
except Exception as e:
errors.append(e)
raise
with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string,
logging_enable=False) as sb_client:
sessions = [str(uuid.uuid4()) for i in range(concurrent_receivers)]
for session_id in sessions:
with sb_client.get_queue_sender(
servicebus_queue.name) as sender:
for i in range(20):
message = Message("Test message no. {}".format(i),
session_id=session_id)
sender.send(message)
futures = []
with concurrent.futures.ThreadPoolExecutor(
max_workers=concurrent_receivers) as thread_pool:
for _ in range(concurrent_receivers):
futures.append(
thread_pool.submit(message_processing, sb_client))
concurrent.futures.wait(futures)
assert not errors
assert len(messages) == 100
def test_session_by_conn_str_receive_handler_with_autolockrenew(self, servicebus_namespace_connection_string, servicebus_queue, **kwargs):
session_id = str(uuid.uuid4())
with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, logging_enable=False) as sb_client:
with sb_client.get_queue_sender(servicebus_queue.name) as sender:
for i in range(10):
message = Message("{}".format(i), session_id=session_id)
sender.send(message)
renewer = AutoLockRenew()
messages = []
with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id, idle_timeout=5, mode=ReceiveSettleMode.PeekLock, prefetch=10) as receiver:
renewer.register(receiver.session, timeout=60)
print("Registered lock renew thread", receiver.session._locked_until_utc, utc_now())
with pytest.raises(SessionLockExpired):
for message in receiver:
if not messages:
print("Starting first sleep")
time.sleep(40)
print("First sleep {}".format(receiver.session._locked_until_utc - utc_now()))
assert not receiver.session.expired
with pytest.raises(TypeError):
message.expired
assert message.locked_until_utc is None
with pytest.raises(TypeError):
message.renew_lock()
assert message.lock_token is not None
message.complete()
messages.append(message)
elif len(messages) == 1:
print("Starting second sleep")
time.sleep(40) # ensure renewer expires
print("Second sleep {}".format(receiver.session._locked_until_utc - utc_now()))
sleep_until_expired(receiver.session) # and then ensure it didn't slip a renew under the wire.
assert receiver.session.expired
assert isinstance(receiver.session.auto_renew_error, AutoLockRenewTimeout)
try:
message.complete()
raise AssertionError("Didn't raise SessionLockExpired")
except SessionLockExpired as e:
assert isinstance(e.inner_exception, AutoLockRenewTimeout)
messages.append(message)
renewer.shutdown()
assert len(messages) == 2
def example_session_ops_sync():
servicebus_connection_str = os.environ['SERVICE_BUS_CONNECTION_STR']
queue_name = os.environ['SERVICE_BUS_QUEUE_NAME']
session_id = "<your session id>"
with ServiceBusClient.from_connection_string(
conn_str=servicebus_connection_str) as servicebus_client:
# [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_session_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_state = session.set_session_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_state = session.renew_lock()
# [END session_renew_lock_sync]
# [START auto_lock_renew_session_sync]
from azure.servicebus import AutoLockRenew
lock_renewal = AutoLockRenew(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(session, timeout=120)
for message in receiver:
process_message(message)
message.complete()
# [END auto_lock_renew_session_sync]
break
def test_stress_queue_pull_receive_timeout(
self, servicebus_namespace_connection_string, servicebus_queue):
sb_client = ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string,
logging_enable=LOGGING_ENABLE)
stress_test = ServiceBusQueueStressTests.ReceiverTimeoutStressTestRunner(
senders=[sb_client.get_queue_sender(servicebus_queue.name)],
receivers=[sb_client.get_queue_receiver(servicebus_queue.name)],
max_wait_time=5,
receive_type=ReceiveType.pull,
duration=timedelta(seconds=600))
result = stress_test.run()
assert (result.total_sent > 0)
assert (result.total_received > 0)
def test_sb_client_readonly_credentials(
self, servicebus_authorization_rule_connection_string,
servicebus_queue, **kwargs):
client = ServiceBusClient.from_connection_string(
servicebus_authorization_rule_connection_string, debug=False)
with pytest.raises(AzureHttpError):
client.get_queue(servicebus_queue.name)
client = QueueClient.from_connection_string(
servicebus_authorization_rule_connection_string,
name=servicebus_queue.name)
with client.get_receiver(idle_timeout=5) as receiver:
messages = receiver.fetch_next()
with pytest.raises(ServiceBusAuthorizationError):
client.send(Message("test"))
def test_stress_queue_unsettled_messages(
self, servicebus_namespace_connection_string, servicebus_queue):
sb_client = ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, debug=False)
stress_test = StressTestRunner(
senders=[sb_client.get_queue_sender(servicebus_queue.name)],
receivers=[sb_client.get_queue_receiver(servicebus_queue.name)],
duration=timedelta(seconds=350),
should_complete_messages=False)
result = stress_test.Run()
# This test is prompted by reports of an issue where enough unsettled messages saturate a service-side cache
# and prevent further receipt.
assert (result.total_sent > 2500)
assert (result.total_received > 2500)
def test_session_by_session_client_conn_str_receive_handler_peeklock_abandon(self, servicebus_namespace_connection_string, servicebus_queue, **kwargs):
with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, logging_enable=False) as sb_client:
session_id = str(uuid.uuid4())
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)
sender.send(message)
with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id, prefetch=0) as receiver:
message = receiver.next()
assert message.sequence_number == 1
message.abandon()
second_message = receiver.next()
assert second_message.sequence_number == 1
def test_stress_queue_unsettled_messages():
sb_client = ServiceBusClient.from_connection_string(
SERVICE_BUS_CONNECTION_STR, logging_enable=LOGGING_ENABLE)
stress_test = StressTestRunner(
senders=[sb_client.get_queue_sender(SERVICEBUS_QUEUE_NAME)],
receivers=[sb_client.get_queue_receiver(SERVICEBUS_QUEUE_NAME)],
duration=timedelta(seconds=350),
should_complete_messages=False,
azure_monitor_metric=AzureMonitorMetric(
"test_stress_queue_unsettled_messages"))
result = stress_test.run()
# This test is prompted by reports of an issue where enough unsettled messages saturate a service-side cache
# and prevent further receipt.
assert (result.total_sent > 2500)
assert (result.total_received > 2500)
def send_users(users):
servicebus_client = ServiceBusClient.from_connection_string(conn_str=CONNECTION_STR, logging_enable=False)
with servicebus_client:
sender = servicebus_client.get_queue_sender(queue_name=QUEUE_NAME)
with sender:
batch_message = sender.create_message_batch()
for user in users:
try:
mapped_user = {"id": user["id"], "name": user["displayName"], "email": user["mail"], "jobTitle": user["jobTitle"]}
batch_message.add_message(ServiceBusMessage(json.dumps(mapped_user)))
print(mapped_user)
except ValueError:
# ServiceBusMessageBatch object reaches max_size.
# New ServiceBusMessageBatch object can be created here to send more data.
break
sender.send_messages(batch_message)
def send_and_receive_defensively():
servicebus_client = ServiceBusClient.from_connection_string(
conn_str=CONNECTION_STR, logging_enable=True)
for _ in range(3): # Connection retries.
try:
print("Opening")
with servicebus_client:
sender = servicebus_client.get_queue_sender(
queue_name=QUEUE_NAME)
try:
with sender:
print("Sending")
send_batch_messages(sender)
except ValueError:
# Handler was shut down previously. (Cannot happen in this example, shown for completeness.)
pass
receiver = servicebus_client.get_queue_receiver(
queue_name=QUEUE_NAME)
try:
with receiver:
print("Receiving")
receive_messages(receiver)
except ValueError:
# Handler was shut down previously. (Cannot happen in this example, shown for completeness.)
pass
return
except ServiceBusConnectionError:
# An error occurred in the connection to the service.
# This may have been caused by a transient network issue or service problem. It is recommended to retry.
continue
except ServiceBusAuthorizationError:
# An error occurred when authorizing the connection to the service.
# This may have been caused by the credentials not having the right permission to perform the operation.
# It is recommended to check the permission of the credentials.
raise
except ServiceBusAuthenticationError:
# An error occurred when authenticate the connection to the service.
# This may have been caused by the credentials being incorrect. It is recommended to check the credentials.
raise
except ServiceBusCommunicationError:
# Unable to communicate with the specified servicebus. Ensure that the FQDN is correct,
# and that there is no firewall or network issue preventing connectivity.
raise
def test_stress_queue_receive_large_batch_size(
self, servicebus_namespace_connection_string, servicebus_queue):
sb_client = ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, debug=False)
stress_test = StressTestRunner(
senders=[sb_client.get_queue_sender(servicebus_queue.name)],
receivers=[
sb_client.get_queue_receiver(servicebus_queue.name,
prefetch=50)
],
duration=timedelta(seconds=60),
max_batch_size=50)
result = stress_test.Run()
assert (result.total_sent > 0)
assert (result.total_received > 0)
def test_stress_queue_receive_large_batch_size():
sb_client = ServiceBusClient.from_connection_string(
SERVICE_BUS_CONNECTION_STR, logging_enable=LOGGING_ENABLE)
stress_test = StressTestRunner(
senders=[sb_client.get_queue_sender(SERVICEBUS_QUEUE_NAME)],
receivers=[
sb_client.get_queue_receiver(SERVICEBUS_QUEUE_NAME,
prefetch_count=50)
],
duration=timedelta(seconds=60),
max_message_count=50,
azure_monitor_metric=AzureMonitorMetric(
"test_stress_queue_receive_large_batch_size"))
result = stress_test.run()
assert (result.total_sent > 0)
assert (result.total_received > 0)
def test_sb_client_writeonly_credentials(servicebus_conn_str_writeonly, standard_queue):
client = ServiceBusClient.from_connection_string(servicebus_conn_str_writeonly)
with pytest.raises(AzureHttpError):
client.get_queue(standard_queue)
client = QueueClient.from_connection_string(servicebus_conn_str_writeonly, name=standard_queue, debug=True)
with pytest.raises(ServiceBusAuthorizationError):
with client.get_receiver(idle_timeout=5) as receiver:
messages = receiver.fetch_next()
client.send([Message("test1"), Message("test2")])
with pytest.raises(TypeError):
client.send("cat")
with pytest.raises(TypeError):
client.send(1234)
with pytest.raises(TypeError):
client.send([1,2,3])
with pytest.raises(TypeError):
client.send([Message("test1"), "test2"])
def test_sb_client_wrong_conn_str(queue_servicebus_conn_str, standard_queue):
client = ServiceBusClient.from_connection_string(queue_servicebus_conn_str)
with pytest.raises(AzureHttpError):
client.get_queue(standard_queue)
