class AzureStorageQueue(Common.Contracts.Queue): def __init__(self, queue_name, config: AzureStorageConfig): self._queue_name = queue_name self._queue_service = QueueService(account_name=config.account_name, account_key=config.account_key) self._queue_service.encode_function = QueueMessageFormat.text_base64encode self._queue_service.decode_function = QueueMessageFormat.text_base64decode def push(self, message): self._queue_service.create_queue(self._queue_name) self._queue_service.put_message(self._queue_name, message) def pop(self): self._queue_service.create_queue(self._queue_name) messages = self._queue_service.peek_messages(self._queue_name) for message in messages: result = message.content self._queue_service.delete_message(self._queue_name, message.id, message.pop_receipt) return result def peek(self): self._queue_service.create_queue(self._queue_name) messages = self._queue_service.peek_messages(self._queue_name) for message in messages: return message.content
def test_sas_read(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recording_file(self.test_mode): return # Arrange queue_name = self._create_queue() self.qs.put_message(queue_name, u'message1') token = self.qs.generate_queue_shared_access_signature( queue_name, QueuePermissions.READ, datetime.utcnow() + timedelta(hours=1), datetime.utcnow() - timedelta(minutes=5) ) # Act service = QueueService( account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, ) self._set_service_options(service, self.settings) result = service.peek_messages(queue_name) # Assert self.assertIsNotNone(result) self.assertEqual(1, len(result)) message = result[0] self.assertIsNotNone(message) self.assertNotEqual('', message.id) self.assertEqual(u'message1', message.content)
def test_sas_read(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange queue_name = self._create_queue() self.qs.put_message(queue_name, u'message1') token = self.qs.generate_queue_shared_access_signature( queue_name, QueuePermissions.READ, datetime.utcnow() + timedelta(hours=1), datetime.utcnow() - timedelta(minutes=5)) # Act service = QueueService( account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, ) self._set_service_options(service, self.settings) result = service.peek_messages(queue_name) # Assert self.assertIsNotNone(result) self.assertEqual(1, len(result)) message = result[0] self.assertIsNotNone(message) self.assertNotEqual('', message.id) self.assertEqual(u'message1', message.content)
def test_sas_read(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange self.qs.put_message(self.test_queues[0], 'message1') token = self.qs.generate_shared_access_signature( self.test_queues[0], self._get_shared_access_policy(QueueSharedAccessPermissions.READ), ) # Act service = QueueService( account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, ) self._set_service_options(service, self.settings) result = service.peek_messages(self.test_queues[0]) # Assert self.assertIsNotNone(result) self.assertEqual(1, len(result)) message = result[0] self.assertIsNotNone(message) self.assertNotEqual('', message.message_id) self.assertEqual('message1', message.message_text)
def test_sas_read(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange self.qs.put_message(self.test_queues[0], 'message1') token = self.qs.generate_shared_access_signature( self.test_queues[0], self._get_shared_access_policy(QueueSharedAccessPermissions.READ), ) # Act service = QueueService( account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, ) self._set_service_options(service, self.settings) result = service.peek_messages(self.test_queues[0]) # Assert self.assertIsNotNone(result) self.assertEqual(1, len(result)) message = result[0] self.assertIsNotNone(message) self.assertNotEqual('', message.message_id) self.assertEqual('message1', message.message_text)
class AzureStorageQueue(Queue): """Interface for interacting with an Azure Storage Queue (through the Queue contract)""" def __init__(self, queue_name, config: AzureStorageConfig): """Initializes the storage queue. :param queue_name: The name of the queue to access. If a queue with this name doesn't already exist on the storage account, the queue will be created on the first operation. :param config: AzureStorageConfig with a valid account name and account key """ self._queue_name = queue_name self._queue_service = QueueService(account_name=config.account_name, account_key=config.account_key) self._queue_service.encode_function = \ QueueMessageFormat.text_base64encode self._queue_service.decode_function = \ QueueMessageFormat.text_base64decode def push(self, message): """Pushes a new message onto the queue.""" self._queue_service.create_queue(self._queue_name) self._queue_service.put_message(self._queue_name, message) def pop(self): """Pops the first message from the queue and returns it.""" self._queue_service.create_queue(self._queue_name) # get_messages prevents another client from getting the message # before we've had a chance to delete it. The visibility_timeout # prevents the message from being seen by other clients # for X seconds. messages = self._queue_service.get_messages(self._queue_name, visibility_timeout=30) for message in messages: result = message.content self._queue_service.delete_message(self._queue_name, message.id, message.pop_receipt) return result def peek(self): """Peeks the fist message from the queue and returns it.""" self._queue_service.create_queue(self._queue_name) messages = self._queue_service.peek_messages(self._queue_name) for message in messages: return message.content @staticmethod def create(queue_name: str): """Helper function for creating a Azure Storage Queue from the storage_config property defined inside of AzureConfig.""" azure_config = AzureConfig() return AzureStorageQueue(queue_name, azure_config.storage_config)
def get_queue_details(creds, resource_group_name, account_name, queue_name): keys = _get_storage_account_keys(creds, resource_group_name, account_name) queue_service = QueueService(account_name, keys.key1) model = StorageAccountQueueDetails() model.queue_name = queue_name model.metadata = queue_service.get_queue_metadata(queue_name) count = int(model.metadata.get("x-ms-approximate-messages-count", "0")) model.messages = queue_service.peek_messages(queue_name, count) if count else [] for msg in model.messages: try: msg.decoded_text = b64decode(msg.message_text).decode() except: msg.decoded_text = None return model
def get_queue_details(creds, resource_group_name, account_name, queue_name): keys = _get_storage_account_keys(creds, resource_group_name, account_name) queue_service = QueueService(account_name, keys.key1) model = StorageAccountQueueDetails() model.queue_name = queue_name model.metadata = queue_service.get_queue_metadata(queue_name) count = int(model.metadata.get('x-ms-approximate-messages-count', '0')) model.messages = queue_service.peek_messages(queue_name, count) if count else [] for msg in model.messages: try: msg.decoded_text = b64decode(msg.message_text).decode() except: msg.decoded_text = None return model
def test_sas_signed_identifier(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange si = SignedIdentifier() si.id = 'testid' si.access_policy.start = '2011-10-11' si.access_policy.expiry = '2018-10-12' si.access_policy.permission = QueueSharedAccessPermissions.READ identifiers = SignedIdentifiers() identifiers.signed_identifiers.append(si) resp = self.qs.set_queue_acl(self.test_queues[0], identifiers) self.qs.put_message(self.test_queues[0], 'message1') token = self.qs.generate_shared_access_signature( self.test_queues[0], SharedAccessPolicy(signed_identifier=si.id), ) # Act service = QueueService( account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, ) self._set_service_options(service, self.settings) result = service.peek_messages(self.test_queues[0]) # Assert self.assertIsNotNone(result) self.assertEqual(1, len(result)) message = result[0] self.assertIsNotNone(message) self.assertNotEqual('', message.message_id) self.assertEqual('message1', message.message_text)
def test_sas_signed_identifier(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recording_file(self.test_mode): return # Arrange access_policy = AccessPolicy() access_policy.start = '2011-10-11' access_policy.expiry = '2018-10-12' access_policy.permission = QueuePermissions.READ identifiers = {'testid': access_policy} queue_name = self._create_queue() resp = self.qs.set_queue_acl(queue_name, identifiers) self.qs.put_message(queue_name, u'message1') token = self.qs.generate_queue_shared_access_signature( queue_name, id='testid' ) # Act service = QueueService( account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, ) self._set_service_options(service, self.settings) result = service.peek_messages(queue_name) # Assert self.assertIsNotNone(result) self.assertEqual(1, len(result)) message = result[0] self.assertIsNotNone(message) self.assertNotEqual('', message.id) self.assertEqual(u'message1', message.content)
def test_sas_signed_identifier(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange si = SignedIdentifier() si.id = 'testid' si.access_policy.start = '2011-10-11' si.access_policy.expiry = '2018-10-12' si.access_policy.permission = QueueSharedAccessPermissions.READ identifiers = SignedIdentifiers() identifiers.signed_identifiers.append(si) resp = self.qs.set_queue_acl(self.test_queues[0], identifiers) self.qs.put_message(self.test_queues[0], 'message1') token = self.qs.generate_shared_access_signature( self.test_queues[0], SharedAccessPolicy(signed_identifier=si.id), ) # Act service = QueueService( account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, ) self._set_service_options(service, self.settings) result = service.peek_messages(self.test_queues[0]) # Assert self.assertIsNotNone(result) self.assertEqual(1, len(result)) message = result[0] self.assertIsNotNone(message) self.assertNotEqual('', message.message_id) self.assertEqual('message1', message.message_text)
def test_sas_signed_identifier(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recording_file(self.test_mode): return # Arrange access_policy = AccessPolicy() access_policy.start = '2011-10-11' access_policy.expiry = '2018-10-12' access_policy.permission = QueuePermissions.READ identifiers = {'testid': access_policy} queue_name = self._create_queue() resp = self.qs.set_queue_acl(queue_name, identifiers) self.qs.put_message(queue_name, u'message1') token = self.qs.generate_queue_shared_access_signature( queue_name, id='testid' ) # Act service = QueueService( account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, ) self._set_test_proxy(service, self.settings) result = service.peek_messages(queue_name) # Assert self.assertIsNotNone(result) self.assertEqual(1, len(result)) message = result[0] self.assertIsNotNone(message) self.assertNotEqual('', message.id) self.assertEqual(u'message1', message.content)
# Azure storage account and secret key azure_storage_account = "" key="" import random, string from azure.storage.queue import QueueService # Initialize the service queue_service = QueueService(account_name=azure_storage_account, account_key=key) # Create a new queue queue_service.create_queue('testqueue') # Put a message into the queue rnd = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(32)) print (rnd) queue_service.put_message('testqueue', rnd) # Peek at all messages in the queue - without dequeuing or deleting messages = queue_service.peek_messages('testqueue') for message in messages: print ("expiration_time: " + message.expiration_time) print ("insertion_time: " + message.insertion_time) print ("message_id: " + message.message_id) print ("message_text: " + message.message_text) print ("expiration_time: " + message.expiration_time) print ("pop_receipt: " + message.pop_receipt) print ("time_next_visible: " + message.time_next_visible)
class StorageQueueContext(): """Initializes the repository with the specified settings dict. Required settings in config dict are: - AZURE_STORAGE_NAME - AZURE_STORAGE_KEY """ _models = [] _service = None _storage_key = '' _storage_name = '' def __init__(self, **kwargs): self._storage_name = kwargs.get('AZURE_STORAGE_NAME', '') self._storage_key = kwargs.get('AZURE_STORAGE_KEY', '') """ service init """ if self._storage_key != '' and self._storage_name != '': self._service = QueueService(account_name = self._storage_name, account_key = self._storage_key, protocol='https') """ registered models """ self._models = [] """ encrypt queue service """ if kwargs.get('AZURE_REQUIRE_ENCRYPTION', False): # Create the KEK used for encryption. # KeyWrapper is the provided sample implementation, but the user may use their own object as long as it implements the interface above. kek = KeyWrapper(kwargs.get('AZURE_KEY_IDENTIFIER', 'otrrentapi'), kwargs.get('SECRET_KEY', 'super-duper-secret')) # Key identifier # Create the key resolver used for decryption. # KeyResolver is the provided sample implementation, but the user may use whatever implementation they choose so long as the function set on the service object behaves appropriately. key_resolver = KeyResolver() key_resolver.put_key(kek) # Set the require Encryption, KEK and key resolver on the service object. self._service.require_encryption = True self._service.key_encryption_key = kek self._service.key_resolver_funcion = key_resolver.resolve_key pass def __create__(self, queue) -> bool: if (not self._service is None): try: self._service.create_queue(queue) return True except AzureException as e: log.error('failed to create {} with error {}'.format(queue, e)) return False else: return True pass def register_model(self, storagemodel:object): modelname = storagemodel.__class__.__name__ if isinstance(storagemodel, StorageQueueModel): if (not modelname in self._models): self.__create__(storagemodel._queuename) self._models.append(modelname) log.info('model {} registered successfully. Models are {!s}'.format(modelname, self._models)) pass def put(self, storagemodel:object) -> StorageQueueModel: """ insert queue message into storage """ modelname = storagemodel.__class__.__name__ if isinstance(storagemodel, StorageQueueModel): if (modelname in self._models): """ peek first message in queue """ try: message = self._service.put_message(storagemodel._queuename, storagemodel.getmessage()) storagemodel.mergemessage(message) except AzureException as e: log.error('can not save queue message: queue {} with message {} because {!s}'.format(storagemodel._queuename, storagemodel.content, e)) storagemodel = None else: log.info('please register model {} first'.format(modelname)) storagemodel = None else: log.info('model {} is not a Queue Model'.format(modelname)) storagemodel = None return storagemodel def peek(self, storagemodel:object) -> StorageQueueModel: """ lookup the next message in queue """ modelname = storagemodel.__class__.__name__ if isinstance(storagemodel, StorageQueueModel): if (modelname in self._models): """ peek first message in queue """ try: messages = self._service.peek_messages(storagemodel._queuename, num_messages=1) """ parse retrieved message """ for message in messages: storagemodel.mergemessage(message) """ no message retrieved ?""" if storagemodel.id is None: storagemodel = None except AzureException as e: log.error('can not peek queue message: queue {} with message {} because {!s}'.format(storagemodel._queuename, storagemodel.content, e)) storagemodel = None else: log.info('please register model {} first'.format(modelname)) storagemodel = None else: log.info('model {} is not a Queue Model'.format(modelname)) storagemodel = None return storagemodel def get(self, storagemodel:object, hide = 0) -> StorageQueueModel: """ lookup the next message in queue """ modelname = storagemodel.__class__.__name__ if isinstance(storagemodel, StorageQueueModel): if (modelname in self._models): """ get first message in queue """ try: if hide > 0: messages = self._service.get_messages(storagemodel._queuename, num_messages=1, visibility_timeout = hide) else: messages = self._service.get_messages(storagemodel._queuename, num_messages=1) """ parse retrieved message """ for message in messages: storagemodel.mergemessage(message) """ no message retrieved ?""" if storagemodel.id is None: storagemodel = None except AzureException as e: log.error('can not get queue message: queue {} with message {} because {!s}'.format(storagemodel._queuename, storagemodel.content, e)) storagemodel = None else: log.info('please register model {} first'.format(modelname)) storagemodel = None else: log.info('model {} is not a Queue Model'.format(modelname)) storagemodel = None return storagemodel def update(self, storagemodel:object, hide = 0) -> StorageQueueModel: """ update the message in queue """ modelname = storagemodel.__class__.__name__ if isinstance(storagemodel, StorageQueueModel): if (modelname in self._models): """ check if message in queue """ if (storagemodel.id != '') and (storagemodel.pop_receipt != '') and (not storagemodel.id is None) and (not storagemodel.pop_receipt is None): try: content = storagemodel.getmessage() message = self._service.update_message(storagemodel._queuename, storagemodel.id, storagemodel.pop_receipt, visibility_timeout = hide, content=content) storagemodel.content = content storagemodel.pop_receipt = message.pop_receipt except AzureException as e: log.error('can not update queue message: queue {} with message.id {!s} because {!s}'.format(storagemodel._queuename, storagemodel.id, e)) storagemodel = None else: log.info('cant update queuemessage {} due to missing id and pop_receipt'.format(modelname)) storagemodel = None else: log.info('please register model {} first'.format(modelname)) storagemodel = None else: log.info('model {} is not a Queue Model'.format(modelname)) storagemodel = None return storagemodel def delete(self, storagemodel:object) -> bool: """ delete the message in queue """ modelname = storagemodel.__class__.__name__ deleted = False if isinstance(storagemodel, StorageQueueModel): if (modelname in self._models): """ check if message in queue """ if (storagemodel.id != '') and (storagemodel.pop_receipt != '') and (not storagemodel.id is None) and (not storagemodel.pop_receipt is None): try: self._service.delete_message(storagemodel._queuename, storagemodel.id, storagemodel.pop_receipt) deleted = True except AzureException as e: log.error('can not delete queue message: queue {} with message.id {!s} because {!s}'.format(storagemodel._queuename, storagemodel.id, e)) else: log.info('cant update queuemessage {} due to missing id and pop_receipt'.format(modelname)) else: log.info('please register model {} first'.format(modelname)) else: log.info('model {} is not a Queue Model'.format(modelname)) return deleted
class Queue: def __init__(self, account_name, account_key, queue_name="logqueue"): """Initialiaze a queue. The type is set by the 'ACS_LOGGING_QUEUE_TYPE' environment variable. If it is set to 'AzureStorageQueue' then values must be provided for 'account_name' and 'account_key' which are values associated with the Azure Storage account. 'queue_name' is optional and defaults to 'logqueue'. """ self.log = Log() self.queue_type = config.ACS_LOGGING_QUEUE_TYPE self.queue_name = queue_name # self.log.debug("Queue type: " + self.queue_type + " / " + self.queue_name) if self.queue_type == "AzureStorageQueue": self.createAzureQueues(account_name, account_key) elif self.queue_type == "LocalFile": self.file_queue = open(config.UNPROCESSED_LOG_FILE, 'w+') else: self.log.error("Unknown queue type: " + queue_type) def getName(self): return self.queue_name def createAzureQueues(self, account_name, account_key): """ Create a queue for unprocessed log messages. Entries in the queue will be dequeued, processed and deleted upon success. """ self.queue_service = QueueService(account_name, account_key) self.queue_service.create_queue(self.queue_name) def close(self): """Perform any necessary clearnup on the queue at the end of a run. """ if self.queue_type == "AzureStorageQueue": pass elif self.queue_type == "LocalFile": self.file_queue.close() else: self.log.error("Unknown queue type: " + queue_type) def enqueue(self, msg): if self.queue_type == "LocalFile": file_queue.write(msg + '\n') elif self.queue_type == "AzureStorageQueue": self.queue_service.put_message(self.queue_name, msg) else: self.log.error("We don't know how to handle queues of type " + self.queue_type) self.log.debug(msg) def dequeue(self): messages = [] if self.queue_type == "LocalFile": with open(config.UNPROCESSED_LOG_FILE, 'r') as f: messages = f.readlines()[1] elif self.queue_type == "AzureStorageQueue": messages = self.queue_service.get_messages(self.queue_name) return messages def delete(self, message): self.queue_service.delete_message(self.queue_name, message.message_id, message.pop_receipt) # with open(config.PROCESSED_LOG_FILE, 'a') as processed: # processed.write(log) # os.remove(config.UNPROCESSED_LOG_FILE) def delete_queue(self, queue_name): self.queue_service.delete_queue(queue_name, False) def getLength(self): """ Get the approximate length of the queue """ queue_metadata = self.queue_service.get_queue_metadata(self.queue_name) count = queue_metadata['x-ms-approximate-messages-count'] return int(count) def peek_messages(self, num_messages): """ Peek at the top messages in the queue. This method does not remove the messages from the queue. """ return self.queue_service.peek_messages(self.queue_name, num_messages)
from azure.storage.queue import QueueService queue_service = QueueService(account_name='xxx', account_key='xxx') print("messages from queue 01") messages = queue_service.peek_messages('queue01') for message in messages: print(message.content) print("") print("messages from queue 02") messages = queue_service.peek_messages('queue02') for message in messages: print(message.content)
from azure.storage.queue import QueueService quename = "mytestqueue" message = [u"Hello, World!", u"Hello, House!", u"Hello, God!"] accountname = "xxxx" accountkey = "xxxx" queue_service = QueueService(account_name=accountname, account_key=accountkey) queue_service.create_queue(quename) for x in message: queue_service.put_message(quename,x) messages = queue_service.peek_messages(quename) for message in messages: print(message.content) metadata = queue_service.get_queue_metadata(quename) count = metadata.approximate_message_count print(count)
class Queue: def __init__(self, account_name, account_key, queue_name="logqueue"): """Initialiaze a queue. The type is set by the 'ACS_LOGGING_QUEUE_TYPE' environment variable. If it is set to 'AzureStorageQueue' then values must be provided for 'account_name' and 'account_key' which are values associated with the Azure Storage account. 'queue_name' is optional and defaults to 'logqueue'. """ self.log = Log() self.queue_type = config.ACS_LOGGING_QUEUE_TYPE self.queue_name = queue_name # self.log.debug("Queue type: " + self.queue_type + " / " + self.queue_name) if self.queue_type == "AzureStorageQueue": self.createAzureQueues(account_name, account_key) elif self.queue_type == "LocalFile": self.file_queue = open(config.UNPROCESSED_LOG_FILE, 'w+') else: self.log.error("Unknown queue type: " + queue_type) def createAzureQueues(self, account_name, account_key): """ Create a queue for unprocessed log messages. Entries in the queue will be dequeued, processed and deleted upon success. """ self.queue_service = QueueService(account_name, account_key) self.queue_service.create_queue(self.queue_name) def close(self): """Perform any necessary clearnup on the queue at the end of a run. """ if self.queue_type == "AzureStorageQueue": pass elif self.queue_type == "LocalFile": self.file_queue.close() else: self.log.error("Unknown queue type: " + queue_type) def enqueue(self, msg): if self.queue_type == "LocalFile": file_queue.write(msg + '\n') elif self.queue_type == "AzureStorageQueue": self.queue_service.put_message(self.queue_name, msg) else: self.log.error("We don't know how to handle queues of type " + self.queue_type) self.log.debug(msg) def dequeue(self): messages = [] if self.queue_type == "LocalFile": with open(config.UNPROCESSED_LOG_FILE, 'r') as f: messages = f.readlines()[1] elif self.queue_type == "AzureStorageQueue": messages = self.queue_service.get_messages(self.queue_name) return messages def delete(self, message): self.queue_service.delete_message(self.queue_name, message.message_id, message.pop_receipt) # with open(config.PROCESSED_LOG_FILE, 'a') as processed: # processed.write(log) # os.remove(config.UNPROCESSED_LOG_FILE) def delete_queue(self, queue_name): self.queue_service.delete_queue(queue_name, False) def getLength(self): """ Get the approximate length of the queue """ queue_metadata = self.queue_service.get_queue_metadata(self.queue_name) count = queue_metadata['x-ms-approximate-messages-count'] return count def peek_messages(self, num_messages): """ Peek at the top messages in the queue. This method does not remove the messages from the queue. """ return self.queue_service.peek_messages(self.queue_name, num_messages)
(config.job_status_queue_name, config.job_status_queue_sas_token), (config.logger_queue_name, config.logger_queue_sas), (config.metrics_queue_name, config.metrics_sas_token), (config.results_queue_name, config.results_queue_sas_token), (config.workload_tracker_queue_name, config.workload_tracker_sas_token) ] print "Clearing all queues" for queue in queues: storage_service_queue = QueueService( account_name=config.storage_account_name, sas_token=queue[1]) print "\tClearing " + queue[0] while True: try: storage_service_queue.clear_messages(queue[0], timeout=300) if not storage_service_queue.peek_messages(queue[0]): break except: print "\t Still clearing" pass print "\t" + queue[0] + " cleared." storage_service = BlockBlobService( account_name=config.storage_account_name, sas_token=config.results_container_sas_token) print "Deleting container: " + config.results_container_name storage_service.delete_container(config.results_container_name) print "\tAttempting to recreate the container: " + config.results_container_name
queue_service.put_message('umairqueue', u'#1 Message from Deep Azure Class!!') queue_service.put_message('umairqueue', u'#2 Message from Deep Azure Class!!') queue_service.put_message('umairqueue', u'#3 Message from Deep Azure Class!!') queue_service.put_message('umairqueue', u'#4 Message from Deep Azure Class!!') queue_service.put_message('umairqueue', u'#5 Message from Deep Azure Class!!') print("\n\nDe-queue two of those messages and print their content... \n") messages = queue_service.get_messages('umairqueue', num_messages=2, visibility_timeout=10) for message in messages: print(message.content) queue_service.delete_message('umairqueue', message.id, message.pop_receipt) print("\n\nPeek into the next message.. \n") messages = queue_service.peek_messages('umairqueue') for messages in messages: print(messages.content) print("\n\nUpdate the contents of the message to 'Updated Message NOW!!!' ") print("and update the message visibility for 5 sec") messages = queue_service.get_messages('umairqueue', num_messages=1, visibility_timeout=1) for message in messages: queue_service.update_message('umairqueue', message.id, message.pop_receipt, 5, u'Updated Message NOW!!!') print( "\n\nTry to dequeue that message right away. Report error or system message received.\n" ) try: