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()
