class MessageBusService(object): _uri: str _connection: Connection _connection_producer: Connection _consuming: bool = False _producer: Producer _producer_reply_to_consumer: Consumer _future: StandardQueue _logger: Optional[logging.Logger] def __init__(self, uri: str, logger: Optional[logging.Logger] = None): self._uri = uri self._logger = logger self._future = StandardQueue() self.connect() def connect(self): self._connection = Connection(self._uri) self._connection.connect() self._connection_producer = self._connection.clone() self._producer = Producer(self._connection_producer) # reply_queue = Queue( channel=self._producer.channel, name="amq.rabbitmq.reply-to", no_ack=True, durable=False, ) self._producer_reply_to_consumer = self._producer.channel.Consumer( queues=[reply_queue], no_ack=True, auto_declare=True, callbacks=[self.on_reply_to_message], accept=["json"], ) self._producer_reply_to_consumer.consume(no_ack=True) def disconnect(self): self._producer.close() self._connection_producer.close() self._connection.close() def start_consuming( self, callback: Callable, queue_name: str, prefetch_count: int = 1, no_ack: bool = False, expires: int = None, callback_ready: Callable = None, ): if self._logger is not None: self._logger.debug("Start consuming queue: %s" % queue_name) self._consuming = True while self._consuming: revived_connection = self._connection.clone() revived_connection.ensure_connection() channel = revived_connection.channel() channel.basic_qos(0, prefetch_count, True) queues = [] queue_obj = Queue( channel=channel, name=queue_name, no_ack=no_ack, durable=False, expires=expires, queue_arguments={"x-max-priority": 255}, ) queue_obj.declare() queues.append(queue_obj) consumer = Consumer( revived_connection, queues, callbacks=[callback], accept=["json"], auto_declare=False, prefetch_count=prefetch_count, ) consumer.revive(channel) consumer.consume() while self._consuming: callback_ready is not None and callback_ready() try: revived_connection.drain_events(timeout=2) except socket.timeout: revived_connection.heartbeat_check() except self._connection.connection_errors + ( AMQPError, ConnectionForced, ConnectionError, ): # pragma: no cover if self._logger is not None: self._logger.exception("Connection error", stack_info=True) break def start_consuming_replies( self, callback: Callable, prefetch_count: int = 1, no_ack: bool = False ): self._consuming = True while self._consuming: revived_connection = self._connection_producer.clone() revived_connection.ensure_connection() while self._consuming: try: revived_connection.drain_events(timeout=2) except socket.timeout: revived_connection.heartbeat_check() except self._connection.connection_errors + ( AMQPError, ConnectionForced, ConnectionError, ): # pragma: no cover if self._logger is not None: self._logger.exception("Connection error", stack_info=True) break def stop_consuming(self): if self._logger is not None: self._logger.debug("Stop consuming...") self._consuming = False def publish( self, body: dict, exchange: str = "", queue_name: str = "", priority: int = None, reply_to: str = None, expiration: int = None, correlation_id: str = None, ): while True: try: self._connection_producer.ensure_connection() self._producer.publish( body=body, exchange=exchange, routing_key=queue_name, priority=priority, reply_to=str(reply_to) if reply_to is not None else None, expiration=expiration if expiration is not None else None, correlation_id=str(correlation_id) if correlation_id is not None else None, ) except self._connection_producer.connection_errors + ( AMQPError, ConnectionForced, ConnectionError, ): # pragma: no cover self._connection_producer = self._connection.clone() self._producer.revive(self._connection_producer) else: break def on_reply_to_message(self, body, message): self._future.put(body) def publish_and_get_reply(self, *args, timeout: int = 1, **kw) -> Optional[dict]: kw['reply_to'] = "amq.rabbitmq.reply-to" self.publish(*args, **kw) try: self._producer_reply_to_consumer.connection.drain_events(timeout=timeout) except socket.timeout: # pragma: no cover return None # return self._future.get(block=False)
from kombu.connection import Connection from kombu import Producer from time import sleep from config import settings data = settings() connection,exchange,task_queue1,task_queue2,task_queue3 = data.get_settings() publisher = Producer(connection,exchange=exchange) #publisher.publish("dta22") for i in range(10000): if i%2==0: #publisher.publish(str(i),routing_key=task_queue1.routing_key) print("Towards Consumer 1 with data as %d"%i) elif i%3==0: #publisher.publish(str(i),routing_key=task_queue2.routing_key) print("Towards Consumer 2 with data as %d"%i) else: publisher.publish(str(i),routing_key=task_queue3.routing_key) #print("Towards Consumer 3 with data as %d"%i) sleep(.1) publisher.close() connection.close()