class PgsqlQueueConsumer(AbstractConsumer):
"""Base class for consumers of events sent from PostgreSQL via rabbitmq.
This class is intended to be used in a completely "stand-alone" manner, such as
inside a script being run separately as a background job. As such, it also includes
connecting to rabbitmq, declaring the underlying queue and bindings, and
(optionally) connecting to the database to be able to fetch and modify data as
necessary. It relies on the environment variable INI_FILE being set.
Note that all messages received by these consumers are expected to be in JSON
format.
"""
PGSQL_EXCHANGE_NAME = "pgsql_events"
def __init__(self,
queue_name: str,
routing_keys: Sequence[str],
uses_db: bool = True):
"""Initialize a new queue, bindings, and consumer for it."""
self.connection = Connection()
self.channel = self.connection.channel()
self.channel.queue_declare(queue_name, durable=True, auto_delete=False)
for routing_key in routing_keys:
self.channel.queue_bind(queue_name,
exchange=self.PGSQL_EXCHANGE_NAME,
routing_key=routing_key)
if uses_db:
self.db_session = get_session_from_config(os.environ["INI_FILE"])
else:
self.db_session = None
super().__init__(self.channel, queue_name)
def consume_queue(self) -> None:
"""Declare the consumer and consume messages indefinitely."""
self.declare()
self.connection.loop()
@abstractmethod
def run(self, msg: Message) -> None:
"""Process a delivered message (subclasses must implement)."""
pass
def start(self, msg: Message) -> None:
"""Setup/teardown for message-processing (wraps run())."""
# decode the msg body from JSON
msg.body = json.loads(msg.body)
# process the message, will call run()
super().start(msg)
# after processing is finished, commit the transaction and ack the msg
if self.db_session:
self.db_session.commit()
msg.ack()
def amqp_reinit():
global amqp_conn
global amqp_channel
dbg('amqp_reinit')
amqp_conn = Connection(host=MQ_SERVER_IP) # mqtt broker 1
amqp_channel = amqp_conn.channel()
# declare an exchange and queue, and bind the queue to the exchange
amqp_channel.exchange_declare('mqtt.exchange',
'direct',
durable=True,
auto_delete=False)
amqp_channel.queue_declare('mqtt.q', durable=True, auto_delete=False)
amqp_channel.queue_bind('mqtt.q',
exchange='mqtt.exchange',
routing_key='mqtt.q')
# device coin check
amqp_channel.exchange_declare('coincheck.exchange',
'direct',
durable=True,
auto_delete=False)
amqp_channel.queue_declare('coincheck.q', durable=True, auto_delete=False)
amqp_channel.queue_bind('coincheck.q',
exchange='coincheck.exchange',
routing_key='coincheck.q')
def __init__(
self,
queue_name: str,
routing_keys: Sequence[str],
uses_db: bool = True,
) -> None:
"""Initialize a new queue, bindings, and consumer for it."""
self.connection = Connection()
self.channel = self.connection.channel()
self.channel.queue_declare(queue_name, durable=True, auto_delete=False)
for routing_key in routing_keys:
self.channel.queue_bind(
queue_name,
exchange=self.PGSQL_EXCHANGE_NAME,
routing_key=routing_key,
)
if uses_db:
self.db_session = get_session_from_config(os.environ['INI_FILE'])
else:
self.db_session = None
super().__init__(self.channel, queue_name)
async def get_review_messages(self):
class Consumer(AbstractConsumer):
def __init__(self, channel, queue_name, plugin):
self.plugin = plugin
super().__init__(channel, queue_name)
def run(self, message: Message):
"""Dispatch the message to the correct handler."""
msg = json.loads(message.body)
if msg['_meta']['routing_key'] == 'mozreview.commits.published':
asyncio.ensure_future(self.plugin.handle_review_requested(message), loop=self.plugin.bot.loop)
elif msg['_meta']['routing_key'] == 'mozreview.review.published':
asyncio.ensure_future(self.plugin.handle_reviewed(message), loop=self.plugin.bot.loop)
conn = Connection(host=self.host, port=self.port, ssl=self.ssl, userid=self.userid, password=self.password,
virtual_host=self.vhost)
channel = conn.channel()
channel.queue_declare(queue=self.queue_name, durable=True, auto_delete=False)
channel.queue_bind(self.queue_name, exchange=self.exchange_name, routing_key=self.routing_key)
consumer = Consumer(channel, self.queue_name, self)
consumer.declare()
while True:
if getattr(self.bot, 'protocol', None) and irc_channel in self.bot.channels: break # Check if connected to IRC
else: await asyncio.sleep(.001, loop=self.bot.loop)
while True:
try:
conn.drain_events(timeout=self.timeout)
except Timeout:
await asyncio.sleep(.001, loop=self.bot.loop)
def amqp_reinit():
global amqp_conn
global amqp_channel
amqp_conn = Connection(host = MQ_SERVER_IP) # mqtt broker 1
amqp_channel = amqp_conn.channel()
# declare an exchange and queue, and bind the queue to the exchange
amqp_channel.exchange_declare('mqtt_client_status.e', 'direct', durable = True, auto_delete = False)
amqp_channel.queue_declare('mqtt_client_status.q', durable = True, auto_delete = False)
amqp_channel.queue_bind('mqtt_client_status.q', exchange = 'mqtt_client_status.e', routing_key = 'mqtt_client_status.k')
async def get_review_messages(self):
class Consumer(AbstractConsumer):
def __init__(self, channel, queue_name, plugin):
self.plugin = plugin
super().__init__(channel, queue_name)
def run(self, message: Message):
"""Dispatch the message to the correct handler."""
msg = json.loads(message.body)
if msg['_meta'][
'routing_key'] == 'mozreview.commits.published':
asyncio.ensure_future(
self.plugin.handle_review_requested(message),
loop=self.plugin.bot.loop)
elif msg['_meta'][
'routing_key'] == 'mozreview.review.published':
asyncio.ensure_future(self.plugin.handle_reviewed(message),
loop=self.plugin.bot.loop)
conn = Connection(host=self.host,
port=self.port,
ssl=self.ssl,
userid=self.userid,
password=self.password,
virtual_host=self.vhost)
channel = conn.channel()
channel.queue_declare(queue=self.queue_name,
durable=True,
auto_delete=False)
channel.queue_bind(self.queue_name,
exchange=self.exchange_name,
routing_key=self.routing_key)
consumer = Consumer(channel, self.queue_name, self)
consumer.declare()
while True:
if getattr(self.bot, 'protocol',
None) and irc_channel in self.bot.channels:
break # Check if connected to IRC
else:
await asyncio.sleep(.001, loop=self.bot.loop)
while True:
try:
conn.drain_events(timeout=self.timeout)
except Timeout:
await asyncio.sleep(.001, loop=self.bot.loop)
class RabbitPipe(GenericPipe):
def __init__(self, ip_rabbit, port_rabbit, listen_queue_name, callback_func):
self.listen_queue_name = listen_queue_name
self.conn = Connection(host=ip_rabbit, port=port_rabbit)
self.ch = self.conn.channel()
self.ch.queue_declare(self.listen_queue_name + '.q', durable=True, auto_delete=False)
self.r_listen = RabbitListener(callback_func, self.ch, self.listen_queue_name + '.q')
def start(self):
self.r_listen.declare()
# wait for events, which will receive delivered messages and call any consumer callbacks
while True:
self.conn.drain_events(timeout=None)
def recover_unacked(self):
self.ch.basic_recover(requeue=True)
def purge(self):
self.ch.queue_purge(self.listen_queue_name)
def __init__(self, ip_rabbit, port_rabbit, name):
super().__init__()
self.name = name
self.ip = ip_rabbit
self.port = port_rabbit
self.conn = Connection(host=ip_rabbit, port=port_rabbit)
self.ch = self.conn.channel()
self.ch.exchange_declare(self.name + '.exchange', 'direct', durable=True)
self.ch.queue_declare(self.name + '.q', durable=True, auto_delete=False)
self.ch.queue_bind(self.name + '.q', exchange=self.name + '.exchange', routing_key=self.name + '.q')
class RabbitTalker(object):
def __init__(self, ip_rabbit, port_rabbit, name):
super().__init__()
self.name = name
self.ip = ip_rabbit
self.port = port_rabbit
self.conn = Connection(host=ip_rabbit, port=port_rabbit)
self.ch = self.conn.channel()
self.ch.exchange_declare(self.name + '.exchange', 'direct', durable=True)
self.ch.queue_declare(self.name + '.q', durable=True, auto_delete=False)
self.ch.queue_bind(self.name + '.q', exchange=self.name + '.exchange', routing_key=self.name + '.q')
def publish_message(self, data):
self.ch.basic_publish(Message(data), exchange=self.name + '.exchange', routing_key=self.name + '.q')
def __init__(self, ip_rabbit, port_rabbit, listen_queue_name, callback_func):
self.listen_queue_name = listen_queue_name
self.conn = Connection(host=ip_rabbit, port=port_rabbit)
self.ch = self.conn.channel()
self.ch.queue_declare(self.listen_queue_name + '.q', durable=True, auto_delete=False)
self.r_listen = RabbitListener(callback_func, self.ch, self.listen_queue_name + '.q')
import json
from amqpy import Connection, Message, AbstractConsumer, Timeout
conn = Connection() # connect to guest:guest@localhost:5672 by default
ch = conn.channel()
class Consumer(AbstractConsumer):
def run(self, msg: Message):
#print('Received a message: {}'.format(msg.body))
mesajprimit = json.loads(msg.body)
print("mesaj primit de la: "+mesajprimit['from'])
print("mesajul contine:"+mesajprimit['body'])
msg.ack()
consumer = Consumer(ch, 'test.q')
consumer.declare()
# wait for events, which will receive delivered messages and call any consumer callbacks
while True:
conn.drain_events(timeout=None)
from amqpy import Connection, Message, AbstractConsumer, Timeout
conn = Connection() # connect to guest:guest@localhost:5672 by default
ch = conn.channel()
# declare an exchange and queue, and bind the queue to the exchange
ch.exchange_declare('test.exchange', 'direct')
ch.queue_declare('test.q')
ch.queue_bind('test.q', exchange='test.exchange', routing_key='test.q')
# publish a few messages, which will get routed to the queue bound to the routing key "test.q"
ch.basic_publish(Message('hello world 1'), exchange='test.exchange', routing_key='test.q')
ch.basic_publish(Message('hello world 2'), exchange='test.exchange', routing_key='test.q')
ch.basic_publish(Message('hello world 3'), exchange='test.exchange', routing_key='test.q')
# get a message from the queue
msg = ch.basic_get('test.q')
# don't forget to acknowledge it
msg.ack()
