def test_session_by_servicebus_client_iter_messages_with_retrieve_deferred_client(live_servicebus_config, session_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(session_queue)
deferred_messages = []
session_id = str(uuid.uuid4())
with queue_client.get_sender(session=session_id) as sender:
for i in range(10):
message = Message("Deferred message no. {}".format(i))
sender.send(message)
session = queue_client.get_receiver(session=session_id, idle_timeout=5)
count = 0
for message in session:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
message.defer()
assert count == 10
with pytest.raises(ValueError):
deferred = queue_client.receive_deferred_messages(deferred_messages, session=session_id)
with pytest.raises(ValueError):
queue_client.settle_deferred_messages('completed', [message], session=session_id)
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_pqueue_message_time_to_live(live_servicebus_config, partitioned_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
import uuid
queue_client = client.get_queue(partitioned_queue)
with queue_client.get_sender() as sender:
content = str(uuid.uuid4())
message_id = uuid.uuid4()
message = Message(content)
message.time_to_live = timedelta(seconds=30)
sender.send(message)
time.sleep(30)
with queue_client.get_receiver() as receiver:
messages = receiver.fetch_next(timeout=10)
assert not messages
with queue_client.get_deadletter_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
count = 0
for message in receiver:
print_message(message)
message.complete()
count += 1
assert count == 1
def test_session_message_expiry(live_servicebus_config, session_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
session_id = str(uuid.uuid4())
queue_client = client.get_queue(session_queue)
with queue_client.get_sender() as sender:
message = Message("Testing expired messages")
message.session_id = session_id
sender.send(message)
with queue_client.get_receiver(session=session_id) as receiver:
messages = receiver.fetch_next(timeout=10)
assert len(messages) == 1
print_message(messages[0])
time.sleep(30)
with pytest.raises(TypeError):
messages[0].expired
with pytest.raises(TypeError):
messages[0].renew_lock()
assert receiver.expired
with pytest.raises(SessionLockExpired):
messages[0].complete()
with pytest.raises(SessionLockExpired):
receiver.renew_lock()
with queue_client.get_receiver(session=session_id) as receiver:
messages = receiver.fetch_next(timeout=30)
assert len(messages) == 1
print_message(messages[0])
#assert messages[0].header.delivery_count # TODO confirm this with service
messages[0].complete()
def test_session_by_servicebus_client_iter_messages_with_retrieve_deferred_receiver_complete(live_servicebus_config, session_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(session_queue)
deferred_messages = []
session_id = str(uuid.uuid4())
messages = [Message("Deferred message no. {}".format(i)) for i in range(10)]
results = queue_client.send(messages, session=session_id)
assert all(result[0] for result in results)
count = 0
session = queue_client.get_receiver(session=session_id, idle_timeout=5)
for message in session:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
message.defer()
assert count == 10
with queue_client.get_receiver(session=session_id, idle_timeout=5) as session:
deferred = session.receive_deferred_messages(deferred_messages)
assert len(deferred) == 10
for message in deferred:
assert isinstance(message, DeferredMessage)
assert message.lock_token
assert not message.locked_until
assert message._receiver
with pytest.raises(TypeError):
message.renew_lock()
message.complete()
def test_pqueue_by_servicebus_client_fail_send_messages(live_servicebus_config, partitioned_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(partitioned_queue)
too_large = "A" * 1024 * 512
try:
results = queue_client.send(Message(too_large))
except MessageSendFailed:
pytest.skip("Open issue for uAMQP on OSX")
assert len(results) == 1
assert not results[0][0]
assert isinstance(results[0][1], MessageSendFailed)
with queue_client.get_sender() as sender:
with pytest.raises(MessageSendFailed):
sender.send(Message(too_large))
with queue_client.get_sender() as sender:
sender.queue_message(Message(too_large))
results = sender.send_pending_messages()
assert len(results) == 1
assert not results[0][0]
assert isinstance(results[0][1], MessageSendFailed)
def test_pqueue_message_lock_renew(live_servicebus_config, partitioned_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
import uuid
queue_client = client.get_queue(partitioned_queue)
with queue_client.get_sender() as sender:
content = str(uuid.uuid4())
message = Message(content)
sender.send(message)
with queue_client.get_receiver() as receiver:
messages = receiver.fetch_next(timeout=10)
assert len(messages) == 1
time.sleep(15)
messages[0].renew_lock()
time.sleep(15)
messages[0].renew_lock()
time.sleep(15)
assert not messages[0].expired
messages[0].complete()
with queue_client.get_receiver() as receiver:
messages = receiver.fetch_next(timeout=10)
assert len(messages) == 0
def test_pqueue_message_expiry(live_servicebus_config, partitioned_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
import uuid
queue_client = client.get_queue(partitioned_queue)
with queue_client.get_sender() as sender:
content = str(uuid.uuid4())
message = Message(content)
sender.send(message)
with queue_client.get_receiver() as receiver:
messages = receiver.fetch_next(timeout=10)
assert len(messages) == 1
time.sleep(30)
assert messages[0].expired
with pytest.raises(MessageLockExpired):
messages[0].complete()
with pytest.raises(MessageLockExpired):
messages[0].renew_lock()
with queue_client.get_receiver() as receiver:
messages = receiver.fetch_next(timeout=30)
assert len(messages) == 1
print_message(messages[0])
assert messages[0].header.delivery_count > 0
messages[0].complete()
def test_pqueue_by_servicebus_client_iter_messages_simple(live_servicebus_config, partitioned_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
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("Iter message no. {}".format(i))
sender.send(message)
count = 0
for message in receiver:
print_message(message)
message.complete()
with pytest.raises(MessageAlreadySettled):
message.complete()
with pytest.raises(MessageAlreadySettled):
message.renew_lock()
count += 1
with pytest.raises(InvalidHandlerState):
next(receiver)
assert count == 10
def test_session_schedule_message(live_servicebus_config, session_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
import uuid
session_id = str(uuid.uuid4())
queue_client = client.get_queue(session_queue)
enqueue_time = (datetime.now() + timedelta(minutes=2)).replace(microsecond=0)
with queue_client.get_receiver(session=session_id) as receiver:
with queue_client.get_sender(session=session_id) as sender:
content = str(uuid.uuid4())
message_id = uuid.uuid4()
message = Message(content)
message.properties.message_id = message_id
message.schedule(enqueue_time)
sender.send(message)
messages = []
count = 0
while not messages and count < 12:
messages = receiver.fetch_next(timeout=10)
receiver.renew_lock()
count += 1
data = str(messages[0])
assert data == content
assert messages[0].properties.message_id == message_id
assert messages[0].scheduled_enqueue_time == enqueue_time
assert messages[0].scheduled_enqueue_time == messages[0].enqueued_time.replace(microsecond=0)
assert len(messages) == 1
def test_session_by_servicebus_client_list_sessions_with_client(live_servicebus_config, session_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(session_queue)
sessions = []
start_time = datetime.now()
for i in range(5):
sessions.append(str(uuid.uuid4()))
for session in sessions:
with queue_client.get_sender(session=session) as sender:
for i in range(5):
message = Message("Test message no. {}".format(i))
sender.send(message)
for session in sessions:
with queue_client.get_receiver(session=session) as receiver:
receiver.set_session_state("SESSION {}".format(session))
current_sessions = queue_client.list_sessions(updated_since=start_time)
assert len(current_sessions) == 5
assert current_sessions == sessions
def test_pqueue_by_servicebus_client_iter_messages_with_retrieve_deferred_receiver_deletemode(live_servicebus_config, partitioned_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(partitioned_queue)
deferred_messages = []
messages = [Message("Deferred message no. {}".format(i)) for i in range(10)]
for m in messages:
m.partition_key = "MyPartitionKey"
results = queue_client.send(messages)
assert all(result[0] for result in results)
count = 0
receiver = queue_client.get_receiver(idle_timeout=5)
for message in receiver:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
message.defer()
assert count == 10
with queue_client.get_receiver(idle_timeout=5) as receiver:
deferred = receiver.receive_deferred_messages(deferred_messages, mode=ReceiveSettleMode.ReceiveAndDelete)
assert len(deferred) == 10
for message in deferred:
assert isinstance(message, DeferredMessage)
with pytest.raises(MessageAlreadySettled):
message.complete()
with pytest.raises(ServiceBusError):
deferred = receiver.receive_deferred_messages(deferred_messages)
def test_pqueue_schedule_message(live_servicebus_config, partitioned_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
import uuid
queue_client = client.get_queue(partitioned_queue)
enqueue_time = (datetime.now() + timedelta(minutes=2)).replace(microsecond=0)
with queue_client.get_receiver() as receiver:
with queue_client.get_sender() as sender:
content = str(uuid.uuid4())
message_id = uuid.uuid4()
message = Message(content)
message.properties.message_id = message_id
message.schedule(enqueue_time)
sender.send(message)
messages = receiver.fetch_next(timeout=120)
if messages:
try:
data = str(messages[0])
assert data == content
assert messages[0].properties.message_id == message_id
assert messages[0].scheduled_enqueue_time == enqueue_time
assert messages[0].scheduled_enqueue_time == messages[0].enqueued_time.replace(microsecond=0)
assert len(messages) == 1
finally:
for m in messages:
m.complete()
else:
raise Exception("Failed to receive schdeduled message.")
def test_pqueue_by_servicebus_client_iter_messages_with_defer(live_servicebus_config, partitioned_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(partitioned_queue)
deferred_messages = []
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("Deferred message no. {}".format(i))
sender.send(message)
count = 0
for message in receiver:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
message.defer()
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_pqueue_cancel_scheduled_messages(live_servicebus_config, partitioned_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(partitioned_queue)
enqueue_time = (datetime.now() + timedelta(minutes=2)).replace(microsecond=0)
with queue_client.get_receiver() as receiver:
with queue_client.get_sender() as sender:
message_a = Message("Test scheduled message")
message_b = Message("Test scheduled message")
tokens = sender.schedule(enqueue_time, message_a, message_b)
assert len(tokens) == 2
sender.cancel_scheduled_messages(*tokens)
messages = receiver.fetch_next(timeout=120)
try:
assert len(messages) == 0
except AssertionError:
for m in messages:
print(str(m))
m.complete()
raise
def test_queue_by_servicebus_client_renew_message_locks(live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(standard_queue)
messages = []
locks = 3
with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock, prefetch=10) as receiver:
with queue_client.get_sender() as sender:
for i in range(locks):
message = Message("Test message no. {}".format(i))
sender.send(message)
messages.extend(receiver.fetch_next())
recv = True
while recv:
recv = receiver.fetch_next()
messages.extend(recv)
try:
assert not message.expired
for m in messages:
time.sleep(5)
initial_expiry = m.locked_until
m.renew_lock()
assert (m.locked_until - initial_expiry) >= timedelta(seconds=5)
finally:
messages[0].complete()
messages[1].complete()
time.sleep(30)
with pytest.raises(MessageLockExpired):
messages[2].complete()
def test_queue_by_servicebus_client_iter_messages_with_retrieve_deferred_receiver_complete(live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(standard_queue)
deferred_messages = []
messages = [Message("Deferred message no. {}".format(i)) for i in range(10)]
results = queue_client.send(messages, session="test_session")
assert all(result[0] for result in results)
with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
count = 0
for message in receiver:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
message.defer()
assert count == 10
with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
deferred = receiver.receive_deferred_messages(deferred_messages)
assert len(deferred) == 10
for message in deferred:
assert isinstance(message, DeferredMessage)
assert message.lock_token
assert message.locked_until
assert message._receiver
message.renew_lock()
message.complete()
def sample_session_send_receive_with_pool(sb_config, queue):
concurrent_receivers = 5
sessions = [str(uuid.uuid4()) for i in range(2 * concurrent_receivers)]
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)
for session_id in sessions:
with queue_client.get_sender(session=session_id) as sender:
for i in range(20):
message = Message("Sample message no. {}".format(i))
sender.send(message)
all_messages = []
futures = []
with concurrent.futures.ThreadPoolExecutor(max_workers=concurrent_receivers) as thread_pool:
for _ in range(concurrent_receivers):
futures.append(thread_pool.submit(message_processing, queue_client, all_messages))
concurrent.futures.wait(futures)
print("Received total {} messages across {} sessions.".format(len(all_messages), 2*concurrent_receivers))
def test_pqueue_by_servicebus_client_iter_messages_with_retrieve_deferred_not_found(live_servicebus_config, partitioned_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(partitioned_queue)
deferred_messages = []
with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
with queue_client.get_sender() as sender:
for i in range(3):
message = Message("Deferred message no. {}".format(i))
message.partition_key = "MyPartitionKey"
sender.send(message)
count = 0
for message in receiver:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
message.defer()
assert count == 3
with pytest.raises(ServiceBusError):
deferred = queue_client.receive_deferred_messages([3, 4], mode=ReceiveSettleMode.PeekLock)
with pytest.raises(ServiceBusError):
deferred = queue_client.receive_deferred_messages([5, 6, 7], mode=ReceiveSettleMode.PeekLock)
def test_pqueue_message_batch(live_servicebus_config, partitioned_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(partitioned_queue)
def message_content():
for i in range(5):
yield "Message no. {}".format(i)
with queue_client.get_sender() as sender:
message = BatchMessage(message_content())
sender.send(message)
with queue_client.get_receiver() as receiver:
messages =receiver.fetch_next(timeout=10)
recv = True
while recv:
recv = receiver.fetch_next(timeout=10)
messages.extend(recv)
assert len(messages) == 5
for m in messages:
print_message(m)
m.complete()
def test_qsession_by_servicebus_client_browse_messages_client(live_servicebus_config, partitioned_session_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(partitioned_session_queue)
session_id = str(uuid.uuid4())
with queue_client.get_sender(session=session_id) as sender:
for i in range(5):
message = Message("Test message no. {}".format(i))
message.partition_key = "MyPartitionKey"
sender.send(message)
with pytest.raises(ValueError):
messages = queue_client.peek(5)
messages = queue_client.peek(5, session=session_id)
assert len(messages) == 5
assert all(isinstance(m, PeekMessage) for m in messages)
for message in messages:
print_message(message)
with pytest.raises(TypeError):
message.complete()
def test_pqueue_message_receive_and_delete(live_servicebus_config, partitioned_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(partitioned_queue)
with queue_client.get_sender() as sender:
message = Message("Receive and delete test")
sender.send(message)
with queue_client.get_receiver(mode=ReceiveSettleMode.ReceiveAndDelete) as receiver:
messages = receiver.fetch_next(timeout=10)
assert len(messages) == 1
received = messages[0]
print_message(received)
with pytest.raises(MessageAlreadySettled):
received.complete()
with pytest.raises(MessageAlreadySettled):
received.abandon()
with pytest.raises(MessageAlreadySettled):
received.defer()
with pytest.raises(MessageAlreadySettled):
received.dead_letter()
with pytest.raises(MessageAlreadySettled):
received.renew_lock()
time.sleep(30)
with queue_client.get_receiver() as receiver:
messages = receiver.fetch_next(timeout=10)
for m in messages:
print_message(m)
assert len(messages) == 0
def test_session_cancel_scheduled_messages(live_servicebus_config, session_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
session_id = str(uuid.uuid4())
queue_client = client.get_queue(session_queue)
enqueue_time = (datetime.now() + timedelta(minutes=2)).replace(microsecond=0)
with queue_client.get_sender(session=session_id) as sender:
message_a = Message("Test scheduled message")
message_b = Message("Test scheduled message")
tokens = sender.schedule(enqueue_time, message_a, message_b)
assert len(tokens) == 2
sender.cancel_scheduled_messages(*tokens)
with queue_client.get_receiver(session=session_id) as receiver:
messages = []
count = 0
while not messages and count < 13:
messages = receiver.fetch_next(timeout=10)
receiver.renew_lock()
count += 1
assert len(messages) == 0
def test_pqueue_by_servicebus_client_fail_send_batch_messages(live_servicebus_config, partitioned_queue):
pytest.skip("TODO: Pending bugfix in uAMQP")
def batch_data():
for i in range(3):
yield str(i) * 1024 * 256
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(partitioned_queue)
results = queue_client.send(BatchMessage(batch_data()))
assert len(results) == 4
assert not results[0][0]
assert isinstance(results[0][1], MessageSendFailed)
with queue_client.get_sender() as sender:
with pytest.raises(MessageSendFailed):
sender.send(BatchMessage(batch_data()))
with queue_client.get_sender() as sender:
sender.queue_message(BatchMessage(batch_data()))
results = sender.send_pending_messages()
assert len(results) == 4
assert not results[0][0]
assert isinstance(results[0][1], MessageSendFailed)
def test_pqueue_by_servicebus_client_receive_batch_with_deadletter(live_servicebus_config, partitioned_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(partitioned_queue)
with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock, prefetch=10) as receiver:
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Dead lettered message no. {}".format(i))
sender.send(message)
count = 0
messages = receiver.fetch_next()
while messages:
for message in messages:
print_message(message)
count += 1
message.dead_letter(description="Testing")
messages = receiver.fetch_next()
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_sb_client_bad_credentials(live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name="invalid",
shared_access_key_value="invalid",
debug=True)
with pytest.raises(AzureHttpError):
client.get_queue(standard_queue)
def test_pqueue_by_servicebus_client_browse_empty_messages(live_servicebus_config, partitioned_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(partitioned_queue)
with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock, prefetch=10) as receiver:
messages = receiver.peek(10)
assert len(messages) == 0
def test_topic_by_servicebus_client_list_topics(live_servicebus_config, standard_topic):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
topics = client.list_topics()
assert len(topics) >= 1
assert all(isinstance(t, TopicClient) for t in topics)
def test_sb_client_bad_namespace(live_servicebus_config):
client = ServiceBusClient(
service_namespace="invalid",
shared_access_key_name="invalid",
shared_access_key_value="invalid",
debug=True)
with pytest.raises(ServiceBusConnectionError):
client.get_queue("testq")
def test_sb_client_entity_conflict(live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
with pytest.raises(AzureConflictHttpError):
client.create_queue(standard_queue)
with pytest.raises(AzureConflictHttpError):
client.create_queue(standard_queue, lock_duration=300)
def send_message_to_queue(payload):
servicebus_client = ServiceBusClient.from_connection_string(
conn_str=EQUINIX_INCOMING_QUEUE_CONNECTION_STRING, logging_enable=True)
with servicebus_client:
sender = servicebus_client.get_topic_sender(
topic_name=EQUINIX_INCOMING_QUEUE)
with sender:
message = ServiceBusMessage(payload)
sender.send_messages(message)
def create_recieve_queue(auth_uid: str, conn_string: str):
sbc = ServiceBusClient.from_connection_string(conn_string)
try:
sbc.create_queue(auth_uid)
except AzureConflictHttpError:
pass
except Exception:
logging.error("cannot create queue")
sys.exit(1)
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(message)
count = 0
messages = receiver.receive()
while messages:
for message in messages:
print_message(_logger, message)
count += 1
message.dead_letter(reason="Testing reason", description="Testing description")
messages = receiver.receive()
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_session_schedule_multiple_messages(
self, servicebus_namespace, servicebus_namespace_key_name,
servicebus_namespace_primary_key, servicebus_queue, **kwargs):
client = ServiceBusClient(
service_namespace=servicebus_namespace.name,
shared_access_key_name=servicebus_namespace_key_name,
shared_access_key_value=servicebus_namespace_primary_key,
debug=False)
import uuid
session_id = str(uuid.uuid4())
queue_client = client.get_queue(servicebus_queue.name)
enqueue_time = (datetime.utcnow() +
timedelta(minutes=2)).replace(microsecond=0)
with queue_client.get_receiver(session=session_id,
prefetch=20) as receiver:
with queue_client.get_sender(session=session_id) as sender:
content = str(uuid.uuid4())
message_id_a = uuid.uuid4()
message_a = Message(content)
message_a.properties.message_id = message_id_a
message_id_b = uuid.uuid4()
message_b = Message(content)
message_b.properties.message_id = message_id_b
tokens = sender.schedule(enqueue_time, message_a, message_b)
assert len(tokens) == 2
messages = []
count = 0
while len(messages) < 2 and count < 12:
receiver.renew_lock()
messages = receiver.fetch_next(timeout=15)
time.sleep(5)
count += 1
data = str(messages[0])
assert data == content
assert messages[0].properties.message_id in (message_id_a,
message_id_b)
assert messages[0].scheduled_enqueue_time == enqueue_time
assert messages[0].scheduled_enqueue_time == messages[
0].enqueued_time.replace(microsecond=0)
assert len(messages) == 2
def test_queue_by_servicebus_client_iter_messages_with_retrieve_deferred_receiver_deadletter(
live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=False)
queue_client = client.get_queue(standard_queue)
deferred_messages = []
messages = [
Message("Deferred message no. {}".format(i)) for i in range(10)
]
results = queue_client.send(messages)
assert all(result[0] for result in results)
with queue_client.get_receiver(
idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
count = 0
for message in receiver:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
message.defer()
assert count == 10
with queue_client.get_receiver(idle_timeout=5) as session:
deferred = session.receive_deferred_messages(deferred_messages)
assert len(deferred) == 10
for message in deferred:
assert isinstance(message, DeferredMessage)
message.dead_letter("something")
count = 0
with queue_client.get_deadletter_receiver(idle_timeout=5) as receiver:
for message in receiver:
count += 1
print_message(message)
assert message.user_properties[b'DeadLetterReason'] == b'something'
assert message.user_properties[
b'DeadLetterErrorDescription'] == b'something'
message.complete()
assert count == 10
def test_pqueue_by_servicebus_client_iter_messages_with_retrieve_deferred_client(
live_servicebus_config, partitioned_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=False)
queue_client = client.get_queue(partitioned_queue)
deferred_messages = []
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("Deferred message no. {}".format(i))
message.partition_key = "MyPartitionKey"
sender.send(message)
count = 0
for message in receiver:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
message.defer()
assert count == 10
deferred = queue_client.receive_deferred_messages(
deferred_messages, mode=ReceiveSettleMode.PeekLock)
assert len(deferred) == 10
for message in deferred:
assert isinstance(message, DeferredMessage)
with pytest.raises(ValueError):
message.complete()
with pytest.raises(ValueError):
queue_client.settle_deferred_messages('foo', message)
queue_client.settle_deferred_messages('completed', message)
with pytest.raises(ServiceBusError):
queue_client.receive_deferred_messages(deferred_messages)
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 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_batch_size=1, max_wait_time=1)
with pytest.raises(ServiceBusError):
with client.get_queue_sender(servicebus_queue.name) as sender:
sender.send_messages(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(ServiceBusConnectionError):
with client.get_queue_sender("invalid") as sender:
sender.send_messages(Message("test"))
def test_sb_client_incorrect_queue_conn_str(
self, servicebus_queue_authorization_rule_connection_string,
wrong_queue, **kwargs):
client = ServiceBusClient.from_connection_string(
servicebus_queue_authorization_rule_connection_string)
with client:
with pytest.raises(ServiceBusError):
with client.get_queue_sender(wrong_queue.name) as sender:
sender.send_messages(Message("test"))
def message_send_process(sb_config, queue, endtime):
def message_batch():
for i in range(5):
yield "Stress Test message no. {}".format(i)
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)
total = 0
queue_client = client.get_queue(queue)
with queue_client.get_sender() as sender:
while endtime > datetime.now():
message = BatchMessage(message_batch())
sender.send(message)
total += 5
time.sleep(0.01)
return total
def test_topic_by_servicebus_client_conn_str_send_basic(
self, servicebus_namespace_connection_string, servicebus_topic,
**kwargs):
with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string,
logging_enable=False) as sb_client:
with sb_client.get_topic_sender(servicebus_topic.name) as sender:
message = Message(b"Sample topic message")
sender.send_messages(message)
def test_qsession_by_servicebus_client_iter_messages_with_retrieve_deferred_receiver_deadletter(live_servicebus_config, partitioned_session_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(partitioned_session_queue)
deferred_messages = []
session_id = str(uuid.uuid4())
messages = [Message("Deferred message no. {}".format(i)) for i in range(10)]
for m in messages:
m.partition_key = "MyPartitionKey"
results = queue_client.send(messages, session=session_id)
assert all(result[0] for result in results)
count = 0
session = queue_client.get_receiver(session=session_id, idle_timeout=5)
for message in session:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
message.defer()
assert count == 10
with queue_client.get_receiver(session=session_id, idle_timeout=5) as session:
deferred = session.receive_deferred_messages(deferred_messages)
assert len(deferred) == 10
for message in deferred:
assert isinstance(message, DeferredMessage)
message.dead_letter("something")
count = 0
with queue_client.get_deadletter_receiver(idle_timeout=5) as receiver:
for message in receiver:
count += 1
print_message(message)
assert message.user_properties[b'DeadLetterReason'] == b'something'
assert message.user_properties[b'DeadLetterErrorDescription'] == b'something'
message.complete()
assert count == 10
def test_qsession_by_servicebus_client_renew_client_locks(
live_servicebus_config, partitioned_session_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(partitioned_session_queue)
session_id = str(uuid.uuid4())
messages = []
locks = 3
with queue_client.get_receiver(session=session_id,
prefetch=10) as receiver:
with queue_client.get_sender(session=session_id) as sender:
for i in range(locks):
message = Message("Test message no. {}".format(i))
sender.send(message)
messages.extend(receiver.fetch_next())
recv = True
while recv:
recv = receiver.fetch_next(timeout=5)
messages.extend(recv)
try:
for m in messages:
with pytest.raises(TypeError):
expired = m.expired
assert m.locked_until is None
assert m.lock_token is None
time.sleep(5)
initial_expiry = receiver.locked_until
receiver.renew_lock()
assert (receiver.locked_until -
initial_expiry) >= timedelta(seconds=5)
finally:
messages[0].complete()
messages[1].complete()
time.sleep(30)
with pytest.raises(SessionLockExpired):
messages[2].complete()
def test_qsession_by_servicebus_client_session_pool(live_servicebus_config, partitioned_session_queue):
messages = []
errors = []
concurrent_receivers = 5
def message_processing(queue_client):
while True:
try:
with queue_client.get_receiver(session=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
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(partitioned_session_queue)
sessions = [str(uuid.uuid4()) for i in range(concurrent_receivers)]
for session in sessions:
with queue_client.get_sender(session=session) as sender:
for i in range(20):
message = Message("Test message no. {}".format(i))
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, queue_client))
concurrent.futures.wait(futures)
assert not errors
assert len(messages) == 100
def test_sb_client_readonly_credentials(servicebus_conn_str_readonly, standard_queue):
client = ServiceBusClient.from_connection_string(servicebus_conn_str_readonly, debug=False)
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_session_by_session_client_conn_str_receive_handler_with_no_session(
self, servicebus_namespace_connection_string, servicebus_queue,
**kwargs):
with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string,
logging_enable=False) as sb_client:
with pytest.raises(NoActiveSession):
with sb_client.get_queue_receiver(servicebus_queue.name,
session_id=NEXT_AVAILABLE,
idle_timeout=5) as session:
session.open()
def message_receive_process(sb_config, queue, endtime):
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_receiver(
mode=ReceiveSettleMode.PeekLock) as receiver:
total = 0
batch = receiver.fetch_next()
while batch:
for message in batch:
message.complete()
total += 1
if endtime <= datetime.now():
break
batch = receiver.fetch_next()
return total
def test_sb_client_entity_delete(live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
with pytest.raises(ServiceBusResourceNotFound):
client.delete_queue("invalid", fail_not_exist=True)
client.delete_queue("invalid", fail_not_exist=False)
client.delete_queue(standard_queue)
def message_receive_process(sb_config, queue, endtime):
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_receiver(idle_timeout=10,
mode=ReceiveSettleMode.PeekLock,
prefetch=10) as receiver:
total = 0
for message in receiver:
message.complete()
total += 1
if total % 50 == 0:
print("Received {} messages".format(total))
if endtime <= datetime.now():
break
return total
def example_create_servicebus_client_sync():
# [START create_sb_client_from_conn_str_sync]
import os
from azure.servicebus import ServiceBusClient
servicebus_connection_str = os.environ['SERVICE_BUS_CONNECTION_STR']
servicebus_client = ServiceBusClient.from_connection_string(
conn_str=servicebus_connection_str)
# [END create_sb_client_from_conn_str_sync]
# [START create_sb_client_sync]
import os
from azure.identity import DefaultAzureCredential
from azure.servicebus import ServiceBusClient
fully_qualified_namespace = os.environ[
'SERVICE_BUS_FULLY_QUALIFIED_NAMESPACE']
servicebus_client = ServiceBusClient(
fully_qualified_namespace=fully_qualified_namespace,
credential=DefaultAzureCredential())
# [END create_sb_client_sync]
return servicebus_client
def test_stress_queue_receive_and_delete(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, receive_mode=ReceiveMode.ReceiveAndDelete)],
duration=timedelta(seconds=60))
result = stress_test.Run()
assert(result.total_sent > 0)
assert(result.total_received > 0)
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 message_receive_process(sb_config, queue, endtime):
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_receiver(idle_timeout=10,
mode=ReceiveSettleMode.ReceiveAndDelete,
prefetch=10) as receiver:
total = 0
batch = receiver.fetch_next()
while batch:
for _ in batch:
total += 1
if endtime <= datetime.now():
break
batch = receiver.fetch_next()
return total
def test_pqueue_by_servicebus_client_iter_messages_with_retrieve_deferred_receiver_complete(
live_servicebus_config, partitioned_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=False)
queue_client = client.get_queue(partitioned_queue)
deferred_messages = []
messages = [
Message("Deferred message no. {}".format(i)) for i in range(10)
]
for m in messages:
m.partition_key = "MyPartitionKey"
results = queue_client.send(messages, session="test_session")
assert all(result[0] for result in results)
with queue_client.get_receiver(
idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
count = 0
for message in receiver:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
message.defer()
assert count == 10
with queue_client.get_receiver(
idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
deferred = receiver.receive_deferred_messages(deferred_messages)
assert len(deferred) == 10
for message in deferred:
assert isinstance(message, DeferredMessage)
assert message.lock_token
assert message.locked_until
assert message._receiver
message.renew_lock()
message.complete()
def test_qsession_by_servicebus_client_iter_messages_with_retrieve_deferred_receiver_complete(
live_servicebus_config, partitioned_session_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(partitioned_session_queue)
deferred_messages = []
session_id = str(uuid.uuid4())
messages = [
Message("Deferred message no. {}".format(i)) for i in range(10)
]
for m in messages:
m.partition_key = "MyPartitionKey"
results = queue_client.send(messages, session=session_id)
assert all(result[0] for result in results)
count = 0
session = queue_client.get_receiver(session=session_id, idle_timeout=5)
for message in session:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
message.defer()
assert count == 10
with queue_client.get_receiver(session=session_id,
idle_timeout=5) as session:
deferred = session.receive_deferred_messages(deferred_messages)
assert len(deferred) == 10
for message in deferred:
assert isinstance(message, DeferredMessage)
assert message.lock_token
assert not message.locked_until
assert message._receiver
with pytest.raises(TypeError):
message.renew_lock()
message.complete()
def test_queue_by_servicebus_client_receive_batch_with_retrieve_deadletter(
live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=False)
queue_client = client.get_queue(standard_queue)
with queue_client.get_receiver(idle_timeout=5,
mode=ReceiveSettleMode.PeekLock,
prefetch=10) as receiver:
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Dead lettered message no. {}".format(i))
sender.send(message)
count = 0
messages = receiver.fetch_next()
while messages:
for message in messages:
print_message(message)
message.dead_letter(description="Testing queue deadletter")
count += 1
messages = receiver.fetch_next()
with pytest.raises(InvalidHandlerState):
receiver.fetch_next()
assert count == 10
with queue_client.get_deadletter_receiver(
idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
count = 0
for message in receiver:
print_message(message)
message.complete()
count += 1
assert count == 10
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, 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)
result = stress_test.run()
assert(result.total_sent > 0)
assert(result.total_received > 0)
def test_queue_message_connection_closed(live_servicebus_config,
standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=False)
import uuid
queue_client = client.get_queue(standard_queue)
with queue_client.get_sender() as sender:
content = str(uuid.uuid4())
message = Message(content)
sender.send(message)
with queue_client.get_receiver() as receiver:
messages = receiver.fetch_next(timeout=10)
assert len(messages) == 1
with pytest.raises(MessageSettleFailed):
messages[0].complete()
def example_create_servicebus_client_sync():
# [START create_sb_client_from_conn_str_sync]
import os
from azure.servicebus import ServiceBusClient
servicebus_connection_str = os.environ['SERVICE_BUS_CONNECTION_STR']
servicebus_client = ServiceBusClient.from_connection_string(
conn_str=servicebus_connection_str)
# [END create_sb_client_from_conn_str_sync]
# [START create_sb_client_sync]
import os
from azure.servicebus import ServiceBusClient, ServiceBusSharedKeyCredential
fully_qualified_namespace = os.environ['SERVICE_BUS_CONNECTION_STR']
shared_access_policy = os.environ['SERVICE_BUS_SAS_POLICY']
shared_access_key = os.environ['SERVICE_BUS_SAS_KEY']
servicebus_client = ServiceBusClient(
fully_qualified_namespace=fully_qualified_namespace,
credential=ServiceBusSharedKeyCredential(shared_access_policy,
shared_access_key))
# [END create_sb_client_sync]
return servicebus_client
