def _add_on_channel_close_callback(self, channel):
"""
Esse método informa para o pika que o método on_channel_closed deve ser chamado quando
o RabbitMq fecha o canal de forma inesperada.
"""
LOGGER.debug(
'Adicionando uma callback de fechamento de canal do Consumer')
channel.add_on_close_callback(self._on_channel_closed)
def _on_exchange_declareok(self, unused_frame):
"""Invocado pelo pika quando o RabbitMQ termina o Exchange.Declare RPC
command.
:param pika.Frame.Method unused_frame: Exchange.DeclareOk response frame
"""
LOGGER.debug('Exchange do Publisher declarado.')
#
self._setup_queue(queue=self._queue)
def _setup_queue(self, queue):
"""
Configurando a fila no RabbitMQ chamando o RPC Queue.Declare.
Quando estiver completo, o método on_queue_declareok será invocado por pika
:param str|unicode queue_name: The name of the queue to declare.
"""
LOGGER.debug('Declarando Producer Queue (%s)', queue)
self._channel.queue_declare(queue,
durable=True,
callback=self._on_queue_declareok)
def _setup_exchange(self):
"""Configure o exchange no RabbitMQ invocando o RPC Exchange.Declare
comando. Quando estiver completo, o método on_exchange_declareok
será invocado por pika.
:param str|unicode exchange_name: The name of the exchange to declare
"""
LOGGER.debug('Declarando Exchange do Producer: (%s)', self._exchange)
self._channel.exchange_declare(self._exchange,
self._exchange_type,
durable=True,
callback=self._on_exchange_declareok)
def on_channel_open(self, channel):
"""Este método é invocado pelo pika quando o canal foi aberto.
O objeto do canal é passado para que possamos usá-lo.
Como o canal agora está aberto, declaramos o exchange também.
:param pika.channel.Channel channel: The channel object
"""
LOGGER.debug('Canal Consumer Aberto') #{}'.format(channel))
self._channel = channel
self._add_on_channel_close_callback(channel)
# Definindo o Exchange:
self._setup_exchange()
def _on_queue_declareok(self, method_frame):
"""Método invocado pelo pika quando a chamada RPC Queue.Declare feita em
setup_queue foi concluída. Neste método, vamos ligar a fila
e exchange junto com a chave de roteamento emitindo o QueueBind
Comando RPC. Quando este comando estiver completo, o método on_bindok
ser invocado pelo pika.
:param pika.frame.Method method_frame: The Queue.DeclareOk frame
"""
QUEUE = method_frame.method.queue
#TODO: Trocar Routing Key - Cada consumidor pode ter o seu;
LOGGER.debug('Linkando (%s) para (%s) com (%s)', self._exchange, QUEUE,
self._server.ROUTING_KEY)
self._channel.queue_bind(QUEUE,
self._exchange,
self._server.ROUTING_KEY,
callback=self._on_bindok)
self._start_consuming(QUEUE)