def main():
# Set tornado to listen to healthcheck endpoint
app = make_app()
server = tornado.httpserver.HTTPServer(app)
server.bind(os.getenv('PORT', '8080'))
server.start(1)
rp = ResponseProcessor("outbound")
quarantine_publisher = QueuePublisher(
[Config.RABBIT_URL],
os.getenv('RABBIT_QUARANTINE_QUEUE', 'QUARANTINE_TEST'),
)
message_consumer = MessageConsumer(
durable_queue=True,
exchange=os.getenv('RABBIT_EXCHANGE', 'test'),
exchange_type=os.getenv('EXCHANGE_TYPE', 'topic'),
rabbit_queue=os.getenv('RABBIT_QUEUE', 'test'),
rabbit_urls=[Config.RABBIT_URL],
quarantine_publisher=quarantine_publisher,
process=rp.process,
check_tx_id=False,
)
message_consumer.run()
return 0
def run():
logging.basicConfig(format=settings.LOGGING_FORMAT,
datefmt="%Y-%m-%dT%H:%M:%S",
level=settings.LOGGING_LEVEL)
logging.getLogger("sdc.rabbit").setLevel(logging.DEBUG)
logger.info("Starting SDX Receipt RRM", version=__version__)
response_processor = ResponseProcessor(logger)
quarantine_publisher = QueuePublisher(
urls=settings.RABBIT_URLS, queue=settings.RABBIT_QUARANTINE_QUEUE)
message_consumer = MessageConsumer(
durable_queue=True,
exchange=settings.RABBIT_EXCHANGE,
exchange_type="topic",
rabbit_queue=settings.RABBIT_QUEUE,
rabbit_urls=settings.RABBIT_URLS,
quarantine_publisher=quarantine_publisher,
process=response_processor.process)
try:
logger.info("Starting consumer")
if settings.SDX_RECEIPT_RRM_SECRET is None:
logger.error("No SDX_RECEIPT_RRM_SECRET env var supplied")
sys.exit(1)
message_consumer.run()
except KeyboardInterrupt:
message_consumer.stop()
def run():
logging.basicConfig(format=settings.LOGGING_FORMAT,
datefmt="%Y-%m-%dT%H:%M:%S",
level=settings.LOGGING_LEVEL)
logging.getLogger('sdc.rabbit').setLevel(logging.INFO)
# These structlog settings allow bound fields to persist between classes
structlog.configure(logger_factory=LoggerFactory(), context_class=wrap_dict(dict))
logger = structlog.getLogger()
logger.info('Starting SDX Downstream', version=__version__)
message_processor = MessageProcessor()
quarantine_publisher = QueuePublisher(
urls=settings.RABBIT_URLS,
queue=settings.RABBIT_QUARANTINE_QUEUE
)
message_consumer = MessageConsumer(
durable_queue=True,
exchange=settings.RABBIT_EXCHANGE,
exchange_type='topic',
rabbit_queue=settings.RABBIT_QUEUE,
rabbit_urls=settings.RABBIT_URLS,
quarantine_publisher=quarantine_publisher,
process=message_processor.process
)
try:
message_consumer.run()
except KeyboardInterrupt:
message_consumer.stop()
def run(): # pragma: no cover
logging.basicConfig(format=settings.LOGGING_FORMAT,
datefmt="%Y-%m-%dT%H:%M:%S",
level=settings.LOGGING_LEVEL)
logging.getLogger("sdc.rabbit").setLevel(logging.DEBUG)
logger.info("Starting SDX Collect", version=__version__)
response_processor = ResponseProcessor()
quarantine_publisher = QueuePublisher(
urls=settings.RABBIT_URLS, queue=settings.RABBIT_QUARANTINE_QUEUE)
message_consumer = MessageConsumer(
durable_queue=True,
exchange=settings.RABBIT_EXCHANGE,
exchange_type="topic",
rabbit_queue=settings.RABBIT_QUEUE,
rabbit_urls=settings.RABBIT_URLS,
quarantine_publisher=quarantine_publisher,
process=response_processor.process)
try:
message_consumer.run()
except KeyboardInterrupt:
message_consumer.stop()
def run(): # pragma: no cover
logging.basicConfig(format=settings.LOGGING_FORMAT,
datefmt="%Y-%m-%dT%H:%M:%S",
level=settings.LOGGING_LEVEL)
logging.getLogger("sdc.rabbit").setLevel(logging.DEBUG)
logger.info("Starting SDX Collect", version=__version__)
response_processor = ResponseProcessor()
quarantine_publisher = QueuePublisher(
urls=settings.RABBIT_URLS,
queue=settings.RABBIT_QUARANTINE_QUEUE
)
message_consumer = MessageConsumer(
durable_queue=True,
exchange=settings.RABBIT_EXCHANGE,
exchange_type="topic",
rabbit_queue=settings.RABBIT_QUEUE,
rabbit_urls=settings.RABBIT_URLS,
quarantine_publisher=quarantine_publisher,
process=response_processor.process
)
try:
message_consumer.run()
except KeyboardInterrupt:
message_consumer.stop()
def run():
logging.basicConfig(format=app.settings.LOGGING_FORMAT,
datefmt="%Y-%m-%dT%H:%M:%S",
level=app.settings.LOGGING_LEVEL)
logging.getLogger('sdc.rabbit').setLevel(logging.INFO)
message_processor = MessageProcessor()
quarantine_publisher = QueuePublisher(
urls=app.settings.RABBIT_URLS,
queue=app.settings.RABBIT_QUARANTINE_QUEUE
)
message_consumer = MessageConsumer(
durable_queue=False,
exchange=app.settings.RABBIT_EXCHANGE,
exchange_type='topic',
rabbit_queue=app.settings.RABBIT_QUEUE,
rabbit_urls=app.settings.RABBIT_URLS,
quarantine_publisher=quarantine_publisher,
process=message_processor.process
)
try:
message_consumer.run()
except KeyboardInterrupt:
message_consumer.stop()
class Bridge:
"""A Bridge object that takes from one queue and publishes to another."""
def __init__(self):
"""Initialise a Bridge object."""
self._eq_queue_hosts = [
settings.SDX_GATEWAY_EQ_RABBITMQ_HOST,
settings.SDX_GATEWAY_EQ_RABBITMQ_HOST2
]
self._eq_queue_port = settings.SDX_GATEWAY_EQ_RABBIT_PORT
self._eq_queue_user = settings.SDX_GATEWAY_EQ_RABBITMQ_USER
self._eq_queue_password = settings.SDX_GATEWAY_EQ_RABBITMQ_PASSWORD
self._sdx_queue_port = settings.SDX_GATEWAY_SDX_RABBITMQ_PORT
self._sdx_queue_user = settings.SDX_GATEWAY_SDX_RABBITMQ_USER
self._sdx_queue_password = settings.SDX_GATEWAY_SDX_RABBITMQ_PASSWORD
self._sdx_queue_host = settings.SDX_GATEWAY_SDX_RABBITMQ_HOST
self._eq_queue_urls = [
'amqp://{}:{}@{}:{}/%2f'.format(self._eq_queue_user,
self._eq_queue_password,
self._eq_queue_hosts[0],
self._eq_queue_port),
'amqp://{}:{}@{}:{}/%2f'.format(self._eq_queue_user,
self._eq_queue_password,
self._eq_queue_hosts[1],
self._eq_queue_port),
]
self._sdx_queue_url = [
'amqp://{}:{}@{}:{}/%2f'.format(self._sdx_queue_user,
self._sdx_queue_password,
self._sdx_queue_host,
self._sdx_queue_port)
]
self.publisher = QueuePublisher(
self._sdx_queue_url,
settings.COLLECT_QUEUE,
)
self.quarantine_publisher = QueuePublisher(
urls=self._sdx_queue_url,
queue=settings.QUARANTINE_QUEUE,
)
self.consumer = MessageConsumer(
durable_queue=True,
exchange=settings.RABBIT_EXCHANGE,
exchange_type="topic",
rabbit_queue=settings.EQ_QUEUE,
rabbit_urls=self._eq_queue_urls,
quarantine_publisher=self.quarantine_publisher,
process=self.process,
)
def process(self, message, tx_id=None):
try:
self.publisher.publish_message(message, headers={'tx_id': tx_id})
except PublishMessageError:
logger.exception('Unsuccessful publish.', tx_id=tx_id)
raise RetryableError
except:
logger.exception(
'Unknown exception occurred during publish. Retrying.',
tx_id=tx_id)
raise RetryableError
def run(self):
"""Run this object's MessageConsumer. Stops on KeyboardInterrupt."""
logger.info("Starting consumer")
self.consumer.run()
def stop(self):
logger.info("Stopping consumer")
self.consumer.stop()