def on_amqpstorm_message_received(amqpstormMessage: amqpstorm.Message):
# Create custom message object and call cbf of subscription
on_message_received(
Message.from_amqpstorm_message(amqpstormMessage))
# Acknowledge the message
amqpstormMessage.ack()
def __call__(self, message: amqpstorm.Message):
"""Process the Payload.
:param Message message:
:return:
"""
try:
message.ack()
message = json.loads(message.body)
self.message_handler.handle(message)
except json.JSONDecodeError:
self.logger.error("Expected JSON Message")
except Exception as error:
self.logger.error(error.__repr__())
def __call__(self, message: Message) -> None:
"""Process the message body."""
try:
self.handle_message(message)
except (ValidationError, Exception) as error:
try:
self._error_message(message, f"Exception occurred: {error}")
except ValidationError:
LOG.error(
"Could not validate the error message. Not properly formatted."
)
except Exception as error:
LOG.error(f"Exception occurred: {error}")
finally:
message.reject(requeue=False)
else:
message.ack()
def callback_impl(self, message: AMQPStormMessage):
"""
callback function, which will be called
everytime a new message is consumed by the pika/amqp library
"""
LOGGER.debug('body: %s' % message.body)
if len(message.body) <= 0:
message.ack() # ignore empty messages
return
new_message: Message = Message(
message.body,
message.channel,
message.delivery_tag
)
if self.callback is not None:
LOGGER.debug('invoking registered callback method')
# start_new_thread(self._start_callback_thread, (new_message, ))
self._start_callback_thread(new_message)
def _on_message(self, handler: type, queue: str, msg: amqpstorm.Message):
self._logger.info("Received Message from %s." % queue)
payload = msg.body
# If the message is of a known Content-Type, decode it automatically.
if msg.content_type == "application/json":
payload = Message.from_json(msg.body)
self._logger.debug("Message Content: %s" % str(payload))
try:
self._logger.debug("Dispatching message to %s." % handler.__name__)
self._logger.info(self._injector)
impl = self._injector.get(handler)
assert isinstance(impl, Handler)
impl.handle_message(payload)
self._logger.info("%s completed without error, ACKing message." %
handler.__name__)
msg.ack()
except RollbackException as e:
self._logger.info("%s failed: %s." % (handler.__name__, str(e)))
self._logger.info("%s failed, Rolling back..." % handler.__name__)
if e.rollback_strategy == RollbackStrategy.NONE:
raise
elif e.rollback_strategy == RollbackStrategy.RETRY_NOW:
msg.nack(requeue=True)
elif e.rollback_strategy == RollbackStrategy.RETRY_LATER:
msg.reject(requeue=True)
elif e.rollback_strategy == RollbackStrategy.QUARANTINE:
raise NotImplementedError("RollbackStrategy.QUARANTINE")
else:
raise Exception("no rollback stragy")
except Exception as e:
self._logger.info("%s failed: %s." % (handler.__name__, str(e)))
msg.reject(requeue=True)
