async def test_update_message(self, resource_group, location,
storage_account, storage_account_key):
# Instantiate a queue client
from azure.storage.queue.aio import QueueClient
queue = QueueClient.from_connection_string(
self.connection_string(storage_account, storage_account_key),
"asyncupdatequeue")
# Create the queue
await queue.create_queue()
try:
# [START async_update_message]
# Send a message
await queue.send_message(u"update me")
# Receive the message
messages = queue.receive_messages()
# Update the message
async for message in messages:
message = await queue.update_message(message,
visibility_timeout=0,
content=u"updated")
# [END async_update_message]
assert message.content == "updated"
break
finally:
# Delete the queue
await queue.delete_queue()
async def test_queue_metadata(self, resource_group, location,
storage_account, storage_account_key):
# Instantiate a queue client
from azure.storage.queue.aio import QueueClient
queue = QueueClient.from_connection_string(
self.connection_string(storage_account, storage_account_key),
"asyncmetaqueue")
# Create the queue
await queue.create_queue()
try:
# [START async_set_queue_metadata]
metadata = {'foo': 'val1', 'bar': 'val2', 'baz': 'val3'}
await queue.set_queue_metadata(metadata=metadata)
# [END async_set_queue_metadata]
# [START async_get_queue_properties]
response = await queue.get_queue_properties()
# [END async_get_queue_properties]
assert response.metadata == metadata
finally:
# Delete the queue
await queue.delete_queue()
async def _test_update_message(self):
# Instantiate a queue client
from azure.storage.queue.aio import QueueClient
queue = QueueClient.from_connection_string(self.connection_string,
"asyncupdatequeue")
# Create the queue
await queue.create_queue()
try:
# [START async_update_message]
# Enqueue a message
await queue.enqueue_message(u"update me")
# Receive the message
messages = queue.receive_messages()
# Update the message
async for message in messages:
message = await queue.update_message(message,
visibility_timeout=0,
content=u"updated")
# [END update_message]
assert message.content == "updated"
break
finally:
# Delete the queue
await queue.delete_queue()
async def test_peek_messages(self, resource_group, location,
storage_account, storage_account_key):
# Instantiate a queue client
from azure.storage.queue.aio import QueueClient
queue = QueueClient.from_connection_string(
self.connection_string(storage_account, storage_account_key),
"asyncpeekqueue")
# Create the queue
await queue.create_queue()
try:
# Send messages
await asyncio.gather(queue.send_message(u"message1"),
queue.send_message(u"message2"),
queue.send_message(u"message3"),
queue.send_message(u"message4"),
queue.send_message(u"message5"))
# [START async_peek_message]
# Peek at one message at the front of the queue
msg = await queue.peek_messages()
# Peek at the last 5 messages
messages = await queue.peek_messages(max_messages=5)
# Print the last 5 messages
for message in messages:
print(message.content)
# [END async_peek_message]
finally:
# Delete the queue
await queue.delete_queue()
async def update_message_async(self):
# Instantiate a queue client
from azure.storage.queue.aio import QueueClient
queue = QueueClient.from_connection_string(self.connection_string,
"myqueue6")
# Create the queue
async with queue:
await queue.create_queue()
try:
# [START async_update_message]
# Send a message
await queue.send_message(u"update me")
# Receive the message
messages = queue.receive_messages()
# Update the message
async for message in messages:
message = await queue.update_message(message,
visibility_timeout=0,
content=u"updated")
# [END async_update_message]
break
finally:
# Delete the queue
await queue.delete_queue()
async def _test_delete_and_clear_messages(self):
# Instantiate a queue client
from azure.storage.queue.aio import QueueClient
queue = QueueClient.from_connection_string(self.connection_string,
"asyncdelqueue")
# Create the queue
await queue.create_queue()
try:
# Enqueue messages
await asyncio.gather(queue.enqueue_message(u"message1"),
queue.enqueue_message(u"message2"),
queue.enqueue_message(u"message3"),
queue.enqueue_message(u"message4"),
queue.enqueue_message(u"message5"))
# [START async_delete_message]
# Get the message at the front of the queue
messages = queue.receive_messages()
async for msg in messages:
# Delete the specified message
await queue.delete_message(msg)
# [END async_delete_message]
# [START async_clear_messages]
await queue.clear_messages()
# [END async_clear_messages]
finally:
# Delete the queue
await queue.delete_queue()
async def peek_messages_async(self):
# Instantiate a queue client
from azure.storage.queue.aio import QueueClient
queue = QueueClient.from_connection_string(self.connection_string,
"myqueue5")
# Create the queue
async with queue:
await queue.create_queue()
try:
# Send messages
await asyncio.gather(queue.send_message(u"message1"),
queue.send_message(u"message2"),
queue.send_message(u"message3"),
queue.send_message(u"message4"),
queue.send_message(u"message5"))
# [START async_peek_message]
# Peek at one message at the front of the queue
msg = await queue.peek_messages()
# Peek at the last 5 messages
messages = await queue.peek_messages(max_messages=5)
# Print the last 5 messages
for message in messages:
print(message.content)
# [END async_peek_message]
finally:
# Delete the queue
await queue.delete_queue()
async def _test_queue_and_messages_example(self):
# Instantiate the QueueClient from a connection string
from azure.storage.queue.aio import QueueClient
queue = QueueClient.from_connection_string(self.connection_string,
"myasyncqueue")
# Create the queue
# [START async_create_queue]
await queue.create_queue()
# [END async_create_queue]
try:
# Enqueue messages
await asyncio.gather(
queue.enqueue_message(u"I'm using queues!"),
queue.enqueue_message(u"This is my second message"))
# Receive the messages
response = queue.receive_messages(messages_per_page=2)
# Print the content of the messages
async for message in response:
print(message.content)
finally:
# [START async_delete_queue]
await queue.delete_queue()
async def receive_one_message_from_queue(self):
# Instantiate a queue client
from azure.storage.queue.aio import QueueClient
queue = QueueClient.from_connection_string(self.connection_string,
"myqueue3")
# Create the queue
async with queue:
await queue.create_queue()
try:
await asyncio.gather(queue.send_message(u"message1"),
queue.send_message(u"message2"),
queue.send_message(u"message3"))
# [START receive_one_message]
# Pop two messages from the front of the queue
message1 = await queue.receive_message()
message2 = await queue.receive_message()
# We should see message 3 if we peek
message3 = await queue.peek_messages()
print(message1.content)
print(message2.content)
print(message3[0].content)
# [END receive_one_message]
finally:
await queue.delete_queue()
async def test_set_access_policy(self, resource_group, location,
storage_account, storage_account_key):
connection_string = self.connection_string(storage_account,
storage_account_key)
storage_url = self._account_url(storage_account.name)
# [START async_create_queue_client_from_connection_string]
from azure.storage.queue.aio import QueueClient
queue_client = QueueClient.from_connection_string(
self.connection_string(storage_account, storage_account_key),
"asyncqueuetest")
# [END async_create_queue_client_from_connection_string]
# Create the queue
try:
await queue_client.create_queue()
except ResourceExistsError:
pass
await queue_client.send_message(u"hello world")
try:
# [START async_set_access_policy]
# Create an access policy
from azure.storage.queue import AccessPolicy, QueueSasPermissions
access_policy = AccessPolicy()
access_policy.start = datetime.utcnow() - timedelta(hours=1)
access_policy.expiry = datetime.utcnow() + timedelta(hours=1)
access_policy.permission = QueueSasPermissions(read=True)
identifiers = {'my-access-policy-id': access_policy}
# Set the access policy
await queue_client.set_queue_access_policy(identifiers)
# [END async_set_access_policy]
# Use the access policy to generate a SAS token
from azure.storage.queue import generate_queue_sas
sas_token = generate_queue_sas(queue_client.account_name,
queue_client.queue_name,
queue_client.credential.account_key,
policy_id='my-access-policy-id')
# [END async_set_access_policy]
# Authenticate with the sas token
# [START async_create_queue_client]
from azure.storage.queue.aio import QueueClient
q = QueueClient.from_queue_url(queue_url=queue_client.url,
credential=sas_token)
# [END async_create_queue_client]
# Use the newly authenticated client to receive messages
my_messages = q.receive_messages()
finally:
# Delete the queue
await queue_client.delete_queue()
def __init__(self, queues_storage_connection_string: str, queue_name: str):
if not queues_storage_connection_string:
raise Exception(
"queues_storage_connection_string cannot be empty.")
if not queue_name:
raise Exception("queue_name cannot be empty.")
self.__queue_client = QueueClient.from_connection_string(
queues_storage_connection_string, queue_name)
self.__initialized = False
async def test_send_and_receive_messages(self, resource_group, location,
storage_account,
storage_account_key):
# Instantiate a queue client
from azure.storage.queue.aio import QueueClient
queue = QueueClient.from_connection_string(
self.connection_string(storage_account, storage_account_key),
"asyncmessagequeue")
# Create the queue
await queue.create_queue()
try:
# [START async_send_messages]
await asyncio.gather(
queue.send_message(u"message1"),
queue.send_message(
u"message2",
visibility_timeout=30), # wait 30s before becoming visible
queue.send_message(u"message3"),
queue.send_message(u"message4"),
queue.send_message(u"message5"))
# [END async_send_messages]
# [START async_receive_messages]
# Receive messages one-by-one
messages = queue.receive_messages()
async for msg in messages:
print(msg.content)
# Receive messages by batch
messages = queue.receive_messages(messages_per_page=5)
async for msg_batch in messages.by_page():
for msg in msg_batch:
print(msg.content)
await queue.delete_message(msg)
# [END async_receive_messages]
# Only prints 4 messages because message 2 is not visible yet
# >>message1
# >>message3
# >>message4
# >>message5
finally:
# Delete the queue
await queue.delete_queue()
async def set_access_policy_async(self):
# [START async_create_queue_client_from_connection_string]
from azure.storage.queue.aio import QueueClient
queue = QueueClient.from_connection_string(self.connection_string,
"myqueue1")
# [END async_create_queue_client_from_connection_string]
# Create the queue
async with queue:
await queue.create_queue()
# Send a message
await queue.send_message(u"hello world")
try:
# [START async_set_access_policy]
# Create an access policy
from azure.storage.queue import AccessPolicy, QueueSasPermissions
access_policy = AccessPolicy()
access_policy.start = datetime.utcnow() - timedelta(hours=1)
access_policy.expiry = datetime.utcnow() + timedelta(hours=1)
access_policy.permission = QueueSasPermissions(read=True)
identifiers = {'my-access-policy-id': access_policy}
# Set the access policy
await queue.set_queue_access_policy(identifiers)
# [END async_set_access_policy]
# Use the access policy to generate a SAS token
from azure.storage.queue import generate_queue_sas
sas_token = generate_queue_sas(queue.account_name,
queue.queue_name,
queue.credential.account_key,
policy_id='my-access-policy-id')
# Authenticate with the sas token
# [START async_create_queue_client]
token_auth_queue = QueueClient.from_queue_url(
queue_url=queue.url, credential=sas_token)
# [END async_create_queue_client]
# Use the newly authenticated client to receive messages
my_messages = token_auth_queue.receive_messages()
finally:
# Delete the queue
await queue.delete_queue()
async def _test_set_access_policy(self):
# [START async_create_queue_client_from_connection_string]
from azure.storage.queue.aio import QueueClient
queue_client = QueueClient.from_connection_string(
self.connection_string, "asyncqueuetest")
# [END async_create_queue_client_from_connection_string]
# Create the queue
try:
await queue_client.create_queue()
except ResourceExistsError:
pass
await queue_client.enqueue_message(u"hello world")
try:
# [START async_set_access_policy]
# Create an access policy
from azure.storage.queue.aio import AccessPolicy, QueuePermissions
access_policy = AccessPolicy()
access_policy.start = datetime.utcnow() - timedelta(hours=1)
access_policy.expiry = datetime.utcnow() + timedelta(hours=1)
access_policy.permission = QueuePermissions.READ
identifiers = {'my-access-policy-id': access_policy}
# Set the access policy
await queue_client.set_queue_access_policy(identifiers)
# [END async_set_access_policy]
# Use the access policy to generate a SAS token
sas_token = queue_client.generate_shared_access_signature(
policy_id='my-access-policy-id')
# [END async_set_access_policy]
# Authenticate with the sas token
# [START async_create_queue_client]
from azure.storage.queue.aio import QueueClient
q = QueueClient(queue_url=queue_client.url, credential=sas_token)
# [END async_create_queue_client]
# Use the newly authenticated client to receive messages
my_messages = q.receive_messages()
finally:
# Delete the queue
await queue_client.delete_queue()
async def queue_metadata(self):
# Instantiate a queue client
from azure.storage.queue.aio import QueueClient
queue = QueueClient.from_connection_string(self.connection_string,
"my_queue")
# Create the queue
await queue.create_queue()
try:
# [START async_set_queue_metadata]
metadata = {'foo': 'val1', 'bar': 'val2', 'baz': 'val3'}
await queue.set_queue_metadata(metadata=metadata)
# [END async_set_queue_metadata]
# [START async_get_queue_properties]
properties = await queue.get_queue_properties()
# [END async_get_queue_properties]
finally:
# Delete the queue
await queue.delete_queue()