def enqueue(self, message: dramatiq.Message, *, delay: Optional[int] = None) -> dramatiq.Message:
queue_name = message.queue_name
if delay is None:
queue = self.queues[queue_name]
delay_seconds = 0
elif delay <= 900000:
queue = self.queues[queue_name]
delay_seconds = int(delay / 1000)
else:
raise ValueError("Messages in SQS cannot be delayed for longer than 15 minutes.")
encoded_message = b64encode(message.encode()).decode()
if len(encoded_message) > MAX_MESSAGE_SIZE:
raise RuntimeError("Messages in SQS can be at most 256KiB large.")
self.logger.debug("Enqueueing message %r on queue %r.", message.message_id, queue_name)
self.emit_before("enqueue", message, delay)
send_message_args = {
"MessageBody": encoded_message,
"DelaySeconds": delay_seconds
}
message_group_id = message.options.get("message_group_id")
if message_group_id is not None:
send_message_args["MessageGroupId"] = message_group_id
queue.send_message({**queue_args})
self.emit_after("enqueue", message, delay)
return message
def enqueue(self,
message: dramatiq.Message,
*,
delay: Optional[int] = None) -> dramatiq.Message:
queue_name = message.queue_name
if delay is None:
queue = self.queues[queue_name]
delay_seconds = 0
elif delay <= 900000:
queue = self.queues[queue_name]
delay_seconds = int(delay / 1000)
else:
raise ValueError(
"Messages in SQS cannot be delayed for longer than 15 minutes."
)
encoded_message = b64encode(message.encode()).decode()
if len(encoded_message) > MAX_MESSAGE_SIZE:
raise RuntimeError("Messages in SQS can be at most 256KiB large.")
self.logger.debug("Enqueueing message %r on queue %r.",
message.message_id, queue_name)
self.emit_before("enqueue", message, delay)
if is_fifo(queue_name):
message_group_id = message.kwargs.get("message_group_id",
DEFAULT_MESSAGE_GROUP_ID)
message_deduplication_id = message.kwargs.get(
"message_deduplication_id")
if message_deduplication_id:
queue.send_message(
MessageBody=encoded_message,
MessageGroupId=message_group_id,
MessageDeduplicationId=message_deduplication_id)
else:
queue.send_message(MessageBody=encoded_message,
MessageGroupId=message_group_id)
else:
queue.send_message(
MessageBody=encoded_message,
DelaySeconds=delay_seconds,
)
self.emit_after("enqueue", message, delay)
return message
def enqueue(self,
message: dramatiq.Message,
*,
delay: Optional[int] = None) -> dramatiq.Message:
queue_name = message.queue_name
queue = self.queues[queue_name]
queue_url = queue.url
if not queue_url.endswith(".fifo"):
if delay is None:
delay_seconds = 0
elif delay <= 900000:
delay_seconds = int(delay / 1000)
else:
raise ValueError(
"Messages in SQS cannot be delayed for longer than 15 minutes."
)
encoded_message = b64encode(message.encode()).decode()
if len(encoded_message) > MAX_MESSAGE_SIZE:
raise RuntimeError("Messages in SQS can be at most 256KiB large.")
self.logger.debug("Enqueueing message %r on queue %r.",
message.message_id, queue_name)
self.emit_before("enqueue", message, delay)
if queue_url.endswith(".fifo"):
queue.send_message(
MessageBody=encoded_message,
MessageGroupId="4", # 4 is a great number
)
else:
queue.send_message(
MessageBody=encoded_message,
DelaySeconds=delay_seconds,
)
self.emit_after("enqueue", message, delay)
return message
def create_message(cls, actor, *args, **kwargs):
"""Prepare a message and add an entry in the Message Model
:param actor: an Actor instance
:param delay: use for postcommit hook send2broker
:param _*args: args of the actor
:param _*_*kwargs: kwargs of the actor
:rtype: dramatiq message instance
"""
delay = kwargs.pop('delay', None)
run_at = kwargs.pop('run_at', None)
if not isinstance(actor, Actor):
logger.warning("[create_message] can't work without an actor")
return None
message = DramatiqMessage(queue_name=actor.queue_name,
actor_name=actor.actor_name,
args=args,
kwargs=kwargs,
options=dict())
message.broker = actor.broker
cls.Message.insert(id=message.message_id,
message=loads(message.encode()))
cls.postcommit_hook('send2broker', message, delay=delay, run_at=run_at)
return message