def create_msg(body, type): try: url = 'amqp://' + setting.MQUSER + ':' + setting.MQPASSWORD + '@' + setting.MQSERVER + ':' + setting.MQPORT + '/%2f' with rabbitpy.Connection(url) as conn: with conn.channel() as channel: exchange = rabbitpy.Exchange(channel=channel, name=setting.MQEXCHANGENAME, durable=True) exchange.declare() queue = rabbitpy.Queue(channel=channel, name=setting.MQQUEUENAME, durable=True) queue.declare() # Bind the queue queue.bind(exchange, setting.MQROUTINGKEY) message = rabbitpy.Message( channel, body, { 'content_type': 'text/plain', 'delivery_mode': 2, 'message_type': type }) message.publish(exchange, setting.MQROUTINGKEY) except: pass
def __init__(self, rabbit_connection: RabbitConnection, name: str, routing_key: str, exchange_name: str, exchange_type: str = 'topic', callback: Callable = None): self._rabbit_connection = rabbit_connection self._subscriber_name = name self._routing_key = routing_key self._exchange_name = exchange_name + "_events" self._callback = callback self._queue = None with self._rabbit_connection.connection.channel() as channel: self._exchange = rabbitpy.Exchange(channel=channel, name=self._exchange_name, exchange_type=exchange_type, durable=True, auto_delete=False) self._exchange.declare() print(f"Subscriber created successfully with name {name}")
def __init__(self, b_rabbit, publisher_name: str, exchange_type: str = 'topic', external: bool = False): """ Internal event publisher, which sends events to all subscribers. Parameters: :param str publisher_name: Name of publisher """ if not b_rabbit.connection: raise Exception( 'Create Instance of Class RabbitMqCommunicationInterface first' ) try: self.b_rabbit = b_rabbit with b_rabbit.connection.channel() as channel: self.channel = channel self.exchange_name = publisher_name + '_events' if not external else 'External' + publisher_name + '_events' self.exchange = rabbitpy.Exchange( channel=channel, name=self.exchange_name, exchange_type=exchange_type, durable=True) self.exchange.declare() logger.info( f'Exchange is declared with the name: {self.exchange_name}' ) except Exception as e: logger.exception(e)
def __init__(self, exchange_name, uri=DEFAULT_RABBIT_URI): self.conn = rabbitpy.Connection(uri) self.channel = self.conn.channel() self.exchange = rabbitpy.Exchange(self.channel, exchange_name, exchange_type='fanout') self.exchange.declare() self.queue = rabbitpy.Queue(self.channel, exclusive=True) self.queue.declare() self.queue.bind(self.exchange)
def __init__(self, b_rabbit, routing_key: str, publisher_name: str, exchange_type: str = 'topic', external: bool = False, important_subscription: bool = True, event_listener: Callable = None): """ Subscribe to events send by publisher Parameters: :param str routing_key: Routing Key which was set for event by Publisher :param str publisher_name: Name of publisher :param str exchange_type: Type of exchange :param bool external: Is Publisher external? :param callable event_listener: User event listener (eventListener(body)) """ if not b_rabbit.connection: raise Exception( 'Create Instance of Class RabbitMqCommunicationInterface first' ) self.b_rabbit = b_rabbit self.publisher_name = publisher_name with b_rabbit.connection.channel() as channel: self.exchange_name = 'External_' + publisher_name + '_events' if external else publisher_name + '_events' self.exchange = rabbitpy.Exchange(channel=channel, name=self.exchange_name, exchange_type=exchange_type, durable=True) self.exchange.declare() logger.info( f'Exchange is declared Successfully from Subscriber: {__name__} | with the name: {self.exchange_name}' ) subscriber_name = self.exchange_name + '_' + routing_key + '_' + self.__get_subscriber_name( ) + '_queue' logger.info(f'subscriber name: {subscriber_name}') queue = rabbitpy.Queue(channel, name=subscriber_name, durable=important_subscription, message_ttl=self.__msg_lifetime(), exclusive=False) queue.declare() logger.info( f'{queue.name} was successfully declared from subscriber: {subscriber_name}' ) queue.bind(self.exchange_name, routing_key) self.queue_name = queue.name self.event_listener = event_listener
def factory(exchange_name, name): channel = rabbitmq.channel() exchange = rabbitpy.Exchange(channel, exchange_name, auto_delete=False, durable=True) exchange.declare() queue = rabbitpy.Queue(channel, name, auto_delete=False, durable=True) queue.declare() queue.bind(exchange, routing_key=name) return queue, exchange
def _declare_exchange(self, exchange_name, exchange_type='direct', auto_delete=False, durable=False): self._exchange = rabbitpy.Exchange(self._channel, exchange_name, exchange_type=exchange_type, auto_delete=auto_delete, durable=durable) self._exchange.declare()
def setup(self): self.connection = rabbitpy.Connection(config.get(AMQP_URI_KEY)) self.channel = self.connection.channel() self.exchange = rabbitpy.Exchange(self.channel, 'exch_pi') self.exchange.declare() queue = rabbitpy.Queue( self.channel, 'q_pi_buzzer', arguments={'x-message-ttl': 3600000}) # 1h queue.declare() queue.bind(self.exchange, ROUTING_KEY)
def _connect(self): self._connection = rabbitpy.Connection() self._channel = self._connection.channel() self._channel.enable_publisher_confirms() self._exchange = rabbitpy.Exchange(self._channel, self.EXCHANGE_NAME, self.EXCHANGE_TYPE) self._exchange.declare() self._queue = rabbitpy.Queue(self._channel, self.QUEUE_NAME) self._queue.declare() self._queue.bind(self._exchange, self.ROUTING_KEY)
def __init__(self, rabbit_connection: RabbitConnection, exchange_name: str, exchange_type: str = 'topic'): self._rabbit_connection = rabbit_connection self._exchange_name = exchange_name + "_events" with self._rabbit_connection.connection.channel() as channel: self._exchange = rabbitpy.Exchange(channel=channel, name=self._exchange_name, exchange_type=exchange_type, durable=True, auto_delete=False) self._exchange.declare() print("Publisher created successfully")
def __init__(self, exchange_name, queue_name): self.exchange_name = exchange_name self.queue_name = queue_name self.routing_key = queue_name self.connection = rabbitpy.Connection(RABITMQ_URL) self.channel = self.connection.channel() self.exchange = rabbitpy.Exchange( self.channel, self.exchange_name, durable=True) self.exchange.declare() self.queue = rabbitpy.Queue( self.channel, self.queue_name, durable=True) self.queue.declare() self.queue.bind(self.exchange_name, routing_key=self.routing_key)
def __init__(self, rabbit_connection: RabbitConnection, server_name: str, routing_key: str, callback: Callable = None): self._rabbit_connection = rabbit_connection self._server_name = server_name self._routing_key = routing_key self._callback = callback self.correlation_id = None with self._rabbit_connection.connection.channel() as channel: self._exchange_name = server_name + '_jobs' self._exchange = rabbitpy.Exchange(channel=channel, name=self._exchange_name, exchange_type='direct', auto_delete=False) self._exchange.declare() print(f"Client created successfully with exchange: {self._exchange.name}")
import rabbitpy url = 'amqp://*****:*****@url:5672/%2F' connection = rabbitpy.Connection(url) channel = connection.channel() exchange = rabbitpy.Exchange(channel, 'exchage.01') exchange.declare() queue = rabbitpy.Queue(channel, 'queue.01') queue.declare() queue.bind(exchange, 'example-routing-key') message = rabbitpy.Message(channel, 'Test message', {'content_type': 'text/plain'}, opinionated=True) message.publish(exchange, 'example-routing-key') connection.close()
#!/usr/bin/env python import rabbitpy import logging logging.basicConfig(level=logging.DEBUG) # Use a new connection as a context manager with rabbitpy.Connection('amqp://*****:*****@localhost:5672/%2f') as conn: # Use the channel as a context manager with conn.channel() as channel: # Create the exchange exchange = rabbitpy.Exchange(channel, 'example_exchange') exchange.declare() # Create the queue queue = rabbitpy.Queue(channel, 'example') queue.declare() # Bind the queue queue.bind(exchange, 'test-routing-key') # Create the msg by passing channel, message and properties (as a dict) message = rabbitpy.Message( channel, 'Lorem ipsum dolor sit amet, consectetur ' 'adipiscing elit.', { 'content_type': 'text/plain', 'delivery_mode': 1, 'message_type': 'Lorem ipsum' })
import rabbitpy with rabbitpy.Connection() as connection: with connection.channel() as channel: exchange = rabbitpy.Exchange(channel, 'fanout-rpc-requests', exchange_type='fanout') exchange.declare()
# Import the RabbitMQ Client Library import rabbitpy # Specify the URL to connect to # url = 'amqp://*****:*****@localhost:5672/%2F' url = 'amqp://*****:*****@192.168.10.200:5672/%2F' # Connect to RabbitMQ using the URL above connection = rabbitpy.Connection(url) # Open a new channel on the connection channel = connection.channel() # Create a new exchange object, passing in the channel to use exchange = rabbitpy.Exchange(channel, 'chapter2-example') # Declare the exchange on the RabbitMQ server exchange.declare() # Create a new queue object, passing in the channel to use queue = rabbitpy.Queue(channel, 'example') # Declare the queue on the RabbitMQ server queue.declare() # Bind the queue to the exchange on the RabbitMQ server queue.bind(exchange, 'example-routing-key') # Send 10 messages for message_number in range(0, 10):
import rabbitpy with rabbitpy.Connection() as connection: with connection.channel() as channel: exchange = rabbitpy.Exchange(channel, 'image-storage', exchange_type='x-consistent-hash', arguments={'hash-header': 'image-hash'}) exchange.declare()
import rabbitpy with rabbitpy.Connection() as connection: with connection.channel() as channel: my_ae = rabbitpy.Exchange(channel, 'my-ae', exchange_type='fanout') my_ae.declare() args = {'alternate-exchange': my_ae.name} exchange = rabbitpy.Exchange(channel, 'graphite', exchange_type='topic', arguments=args) exchange.declare() queue = rabbitpy.Queue(channel, 'unroutable-messages') queue.declare() if queue.bind(my_ae, '#'): print('Queue bound to alternate-exchange')
def declare_exchange(channel, name, **kw_args): exchange = rabbitpy.Exchange(channel, name, **kw_args) exchange.declare() return exchange
def __iter__(self): for item in self.previous: yield item options = dict([(k.replace('-', '_'), v) for k, v in self.options.items()]) amqp_uri = options.get('amqp_uri', 'amqp://*****:*****@localhost:5672/%2f') queue = options.get('queue', '') exchange = options.get('exchange', 'amq.topic') routing_key = options.get('routing_key', '*') exchange_options = {} for k, v in options.items(): v = to_boolean_when_looks_boolean(v) if k.startswith('exchange_'): exchange_options[k[len('exchange_'):]] = v queue_options = {'auto_declare': True, 'auto_delete': True} # Should the message be acked; False is useful during development ack = to_boolean_when_looks_boolean(options.get('ack', 'true')) for k, v in options.items(): v = to_boolean_when_looks_boolean(v) if k.startswith('queue_'): queue_options[k[len('queue_'):]] = v key = self.options.get('key') # Connect to RabbitMQ on localhost, port 5672 as guest/guest with rabbitpy.Connection(amqp_uri) as conn1, \ rabbitpy.Connection(amqp_uri) as conn2: # Open the channel to communicate with RabbitMQ with conn1.channel() as channel1, \ conn2.channel() as channel2: if ack: channel1.prefetch_count(1) exchange_declare = exchange_options.pop('auto_declare', False) if exchange_declare: exchange = rabbitpy.Exchange(channel1, **exchange_options) exchange.declare() queue_declare = queue_options.pop('auto_declare', True) queue1 = rabbitpy.Queue(channel1, queue, **queue_options) queue2 = rabbitpy.Queue(channel2, queue, **queue_options) if queue_declare: queue1.declare() queue1.bind(exchange, routing_key) # Exit on CTRL-C or queue1 empty for 30 sec counter = 0 length = len(queue1) try: # Consume the message print('Waiting for a new message...') for message in queue1: counter += 1 print(('Received a new message ({0:d}). ' 'Processing...'.format(counter))) if ack: length = len(queue2) else: length -= 1 if key: yield {key: get_item(message)} else: yield get_item(message) if ack: message.ack() if ack and not length: print('Waiting for a new message...') # Break when no new messages in 30 seconds if ack: grace = 30 while grace > 0 and not (length or len(queue2)): grace -= 1 time.sleep(1) if grace < 1: break except KeyboardInterrupt: print('Consumer stopped. Exiting...') except Exception: raise Exception(traceback.format_exc())
import rabbitpy with rabbitpy.Connection() as connection: with connection.channel() as channel: exchange = rabbitpy.Exchange(channel, 'stomp-routing') exchange.declare() queue = rabbitpy.Queue(channel, 'bound-queue', arguments={'x-max-length': 10}) queue.declare() queue.bind(exchange, 'example')
import rabbitpy with rabbitpy.Connection() as connection: with connection.channel() as channel: exchange = rabbitpy.Exchange(channel, 'direct-example', exchange_type='direct') exchange.declare()
import rabbitpy with rabbitpy.Connection() as connection: with connection.channel() as channel: exchange = rabbitpy.Exchange(channel, 'headers-rpc-requests', exchange_type='headers') exchange.declare()
import rabbitpy with rabbitpy.Connection() as connection: with connection.channel() as channel: for exchange_name in ['rpc-replies', 'direct-rpc-requests']: exchange = rabbitpy.Exchange(channel, exchange_name, exchange_type='direct') exchange.declare()
import rabbitpy with rabbitpy.Connection() as connection: with connection.channel() as channel: exchange = rabbitpy.Exchange(channel, 'image-storage', exchange_type='x-consistent-hash') exchange.declare()
import rabbitpy with rabbitpy.Connection() as connection: with connection.channel() as channel: tpc = rabbitpy.Exchange(channel, 'events', exchange_type='topic') tpc.declare() xch = rabbitpy.Exchange(channel, 'distributed-events', exchange_type='x-consistent-hash') xch.declare() xch.bind(foo, '#')
# Build the message body payload = { 'container': recepient, 'object': filename, 'etag': etag, 'mail_to': mail_to, 'call_data': call_data} # Post the message with rabbitpy.Connection('amqp://*****:*****@white-swan.rmq.cloudamqp.com/eovnztng') as conn: with conn.channel() as channel: # Create the exchange exchange = rabbitpy.Exchange(channel, EXCHANGE) exchange.declare() # Create the queue queue = rabbitpy.Queue(channel, QUEUE) queue.declare() # Bind the queue queue.bind(exchange, ROUTING_KEY) # Create and start the transaction tx = rabbitpy.Tx(channel) tx.select() # Create the message message = rabbitpy.Message(channel,
def declare_exchange(channel, exchange_type): print('Creating the %s exchange' % exchange_type) exchange = rabbitpy.Exchange(channel, 'benchmark_%s' % exchange_type, exchange_type) exchange.declare() return exchange
def __iter__(self): options = dict([(key.replace('-', '_'), value) for key, value in self.options.items()]) # Serializer default_serializer = options.get('serializer', 'json') # URI amqp_uri = options.get('amqp_uri', 'amqp://*****:*****@localhost:5672/%2f') # Exchange exchange = options.get('exchange', 'amq.topic') exchange_options = {} for k, v in options.items(): v = to_boolean_when_looks_boolean(v) if k.startswith('exchange_'): exchange_options[k[len('exchange_'):]] = v # Queue queue = options.get('queue', '') queue_options = {'auto_declare': True, 'auto_delete': True} for k, v in options.items(): v = to_boolean_when_looks_boolean(v) if k.startswith('queue_'): queue_options[k[len('queue_'):]] = v # Publisher confirms publisher_confirms = to_boolean_when_looks_boolean( options.get('publisher_confirms')) # Routing key routing_key = options.get('routing_key', '*') # Item key key = options.get('key') # Or multiple keys keys = options.get('keys') # Connect to RabbitMQ on localhost, port 5672 as guest/guest with rabbitpy.Connection(amqp_uri) as conn: # Open the channel to communicate with RabbitMQ with conn.channel() as channel: # Turn on publisher confirmations if publisher_confirms: channel.enable_publisher_confirms() # Declare exchange exchange_declare = exchange_options.pop('auto_declare', False) if exchange_declare: exchange = rabbitpy.Exchange(channel, **exchange_options) exchange.declare() # Declare queue if queue: queue_declare = queue_options.pop('auto_declare', True) queue = rabbitpy.Queue(channel, queue, **queue_options) if queue_declare: queue.declare() queue.bind(exchange, routing_key) # Publish try: for item in self.previous: if self.condition(item): if key is not None: message = create_message( channel, item[key], default_serializer) elif keys is not None: message = create_message( channel, dict([(k, v) for k, v in item.items() if k in keys]), default_serializer) else: message = create_message( channel, item, default_serializer) if publisher_confirms: if not message.publish(exchange, routing_key): raise Exception('NO ROUTE') else: message.publish(exchange, routing_key) yield item except Exception: raise Exception(traceback.format_exc())
import rabbitpy with rabbitpy.Connection() as connection: with connection.channel() as channel: rabbitpy.Exchange(channel, 'rejected-messages').declare() queue = rabbitpy.Queue(channel, 'dlx-example', dead_letter_exchange='rejected-messages') queue.declare()