def mock_message(success):
m = QueueMessage()
m.id = uuid4()
m.insertion_time = time.time()
m.expiration_time = None
m.dequeue_count = None
if success:
content = {
"OperationId": str(m.id),
"Database": "db1",
"Table": "table1",
"IngestionSourceId": str(m.id),
"IngestionSourcePath": "blob/path",
"RootActivityId": "1",
"SucceededOn": time.time(),
}
else:
content = {
"OperationId": str(m.id),
"Database": "db1",
"Table": "table1",
"IngestionSourceId": str(m.id),
"IngestionSourcePath": "blob/path",
"RootActivityId": "1",
"FailedOn": time.time(),
"Details": "",
"ErrorCode": "1",
"FailureStatus": "",
"OriginatesFromUpdatePolicy": "",
"ShouldRetry": False,
}
m.content = str(
base64.b64encode(
json.dumps(content).encode("utf-8")).decode("utf-8"))
m.pop_receipt = None
m.time_next_visible = None
return m
async def update_message(
self,
message,
visibility_timeout=None,
pop_receipt=None, # type: ignore
content=None,
timeout=None,
**kwargs):
# type: (Any, int, Optional[str], Optional[Any], Optional[int], Any) -> QueueMessage
"""Updates the visibility timeout of a message. You can also use this
operation to update the contents of a message.
This operation can be used to continually extend the invisibility of a
queue message. This functionality can be useful if you want a worker role
to "lease" a queue message. For example, if a worker role calls :func:`~receive_messages()`
and recognizes that it needs more time to process a message, it can
continually extend the message's invisibility until it is processed. If
the worker role were to fail during processing, eventually the message
would become visible again and another worker role could process it.
If the key-encryption-key field is set on the local service object, this method will
encrypt the content before uploading.
:param str message:
The message object or id identifying the message to update.
:param int visibility_timeout:
Specifies the new visibility timeout value, in seconds,
relative to server time. The new value must be larger than or equal
to 0, and cannot be larger than 7 days. The visibility timeout of a
message cannot be set to a value later than the expiry time. A
message can be updated until it has been deleted or has expired.
The message object or message id identifying the message to update.
:param str pop_receipt:
A valid pop receipt value returned from an earlier call
to the :func:`~receive_messages` or :func:`~update_message` operation.
:param obj content:
Message content. Allowed type is determined by the encode_function
set on the service. Default is str.
:param int timeout:
The server timeout, expressed in seconds.
:return:
A :class:`~azure.storage.queue.models.QueueMessage` object. For convenience,
this object is also populated with the content, although it is not returned by the service.
:rtype: ~azure.storage.queue.models.QueueMessage
Example:
.. literalinclude:: ../tests/test_queue_samples_message.py
:start-after: [START update_message]
:end-before: [END update_message]
:language: python
:dedent: 12
:caption: Update a message.
"""
try:
message_id = message.id
message_text = content or message.content
receipt = pop_receipt or message.pop_receipt
insertion_time = message.insertion_time
expiration_time = message.expiration_time
dequeue_count = message.dequeue_count
except AttributeError:
message_id = message
message_text = content
receipt = pop_receipt
insertion_time = None
expiration_time = None
dequeue_count = None
if receipt is None:
raise ValueError("pop_receipt must be present")
if message_text is not None:
self._config.message_encode_policy.configure(
self.require_encryption, self.key_encryption_key,
self.key_resolver_function)
message_text = self._config.message_encode_policy(message_text)
updated = GenQueueMessage(message_text=message_text)
else:
updated = None # type: ignore
try:
response = await self._client.message_id.update(
queue_message=updated,
visibilitytimeout=visibility_timeout or 0,
timeout=timeout,
pop_receipt=receipt,
cls=return_response_headers,
queue_message_id=message_id,
**kwargs)
new_message = QueueMessage(content=message_text)
new_message.id = message_id
new_message.insertion_time = insertion_time
new_message.expiration_time = expiration_time
new_message.dequeue_count = dequeue_count
new_message.pop_receipt = response["popreceipt"]
new_message.time_next_visible = response["time_next_visible"]
return new_message
except StorageErrorException as error:
process_storage_error(error)
async def enqueue_message( # type: ignore
self,
content, # type: Any
visibility_timeout=None, # type: Optional[int]
time_to_live=None, # type: Optional[int]
timeout=None, # type: Optional[int]
**kwargs # type: Optional[Any]
):
# type: (...) -> QueueMessage
"""Adds a new message to the back of the message queue.
The visibility timeout specifies the time that the message will be
invisible. After the timeout expires, the message will become visible.
If a visibility timeout is not specified, the default value of 0 is used.
The message time-to-live specifies how long a message will remain in the
queue. The message will be deleted from the queue when the time-to-live
period expires.
If the key-encryption-key field is set on the local service object, this method will
encrypt the content before uploading.
:param obj content:
Message content. Allowed type is determined by the encode_function
set on the service. Default is str. The encoded message can be up to
64KB in size.
:param int visibility_timeout:
If not specified, the default value is 0. Specifies the
new visibility timeout value, in seconds, relative to server time.
The value must be larger than or equal to 0, and cannot be
larger than 7 days. The visibility timeout of a message cannot be
set to a value later than the expiry time. visibility_timeout
should be set to a value smaller than the time-to-live value.
:param int time_to_live:
Specifies the time-to-live interval for the message, in
seconds. The time-to-live may be any positive number or -1 for infinity. If this
parameter is omitted, the default time-to-live is 7 days.
:param int timeout:
The server timeout, expressed in seconds.
:return:
A :class:`~azure.storage.queue.models.QueueMessage` object.
This object is also populated with the content although it is not
returned from the service.
:rtype: ~azure.storage.queue.models.QueueMessage
Example:
.. literalinclude:: ../tests/test_queue_samples_message.py
:start-after: [START enqueue_messages]
:end-before: [END enqueue_messages]
:language: python
:dedent: 12
:caption: Enqueue messages.
"""
self._config.message_encode_policy.configure(
self.require_encryption, self.key_encryption_key,
self.key_resolver_function)
content = self._config.message_encode_policy(content)
new_message = GenQueueMessage(message_text=content)
try:
enqueued = await self._client.messages.enqueue(
queue_message=new_message,
visibilitytimeout=visibility_timeout,
message_time_to_live=time_to_live,
timeout=timeout,
**kwargs)
queue_message = QueueMessage(content=new_message.message_text)
queue_message.id = enqueued[0].message_id
queue_message.insertion_time = enqueued[0].insertion_time
queue_message.expiration_time = enqueued[0].expiration_time
queue_message.pop_receipt = enqueued[0].pop_receipt
queue_message.time_next_visible = enqueued[0].time_next_visible
return queue_message
except StorageErrorException as error:
process_storage_error(error)
