async def main(loop):
# Perform connection
connection = await connect("amqp://*****:*****@localhost/", loop=loop)
# Creating a channel
channel = await connection.channel()
routing_key = "typ-router-destination"
# routing_key = "typ-router-buyer"
# routing_key = "chiao"
# routing_key = "hi"
# routing_key = "test_queue"
# routing_key = "test_queue2"
# Sending the message
await channel.default_exchange.publish(
Message(b'{"session_id":100, "destinations": ["des11","des2"]}'),
routing_key=routing_key)
# await channel.default_exchange.publish(
# Message(b'{"session_id":100, "buyers": ["buyer1","buyer2"]}'),
# routing_key=routing_key
# )
print(" [x] Sent 'Hello World!'")
await connection.close()
async def test_simple_publish_without_confirm(self):
queue_name = self.get_random_name("test_connection")
routing_key = self.get_random_name()
channel = await self.create_channel(publisher_confirms=False)
exchange = await self.declare_exchange('direct',
auto_delete=True,
channel=channel)
queue = await self.declare_queue(queue_name,
auto_delete=True,
channel=channel)
await queue.bind(exchange, routing_key)
body = bytes(shortuuid.uuid(), 'utf-8')
result = await exchange.publish(
Message(body, content_type='text/plain', headers={'foo': 'bar'}),
routing_key)
self.assertIsNone(result)
incoming_message = await queue.get(timeout=5)
incoming_message.ack()
self.assertEqual(incoming_message.body, body)
await queue.unbind(exchange, routing_key)
async def test_simple_publish_and_receive_to_bound_exchange(self):
routing_key = self.get_random_name()
src_name = self.get_random_name("source", "exchange")
dest_name = self.get_random_name("destination", "exchange")
channel = await self.create_channel()
src_exchange = await self.declare_exchange(src_name,
auto_delete=True,
channel=channel)
dest_exchange = await self.declare_exchange(dest_name,
auto_delete=True,
channel=channel)
queue = await self.declare_queue(auto_delete=True, channel=channel)
await queue.bind(dest_exchange, routing_key)
await dest_exchange.bind(src_exchange, routing_key)
self.addCleanup(dest_exchange.unbind, src_exchange, routing_key)
body = bytes(shortuuid.uuid(), 'utf-8')
await src_exchange.publish(
Message(body, content_type='text/plain', headers={'foo': 'bar'}),
routing_key)
incoming_message = await queue.get(timeout=5)
incoming_message.ack()
self.assertEqual(incoming_message.body, body)
await queue.unbind(dest_exchange, routing_key)
async def test_purge_queue(self):
queue_name = self.get_random_name("test_connection4")
routing_key = self.get_random_name()
channel = await self.create_channel()
exchange = await channel.declare_exchange('direct', auto_delete=True)
queue = await channel.declare_queue(queue_name, auto_delete=True)
await queue.bind(exchange, routing_key)
try:
body = bytes(shortuuid.uuid(), 'utf-8')
await exchange.publish(
Message(body,
content_type='text/plain',
headers={'foo': 'bar'}), routing_key)
await queue.purge()
with pytest.raises(asyncio.TimeoutError):
await queue.get(timeout=1)
except aio_pika.exceptions.QueueEmpty:
await queue.unbind(exchange, routing_key)
await queue.delete()
async def publisher():
channel1 = await self.create_channel(connection=conn,
cleanup=False)
for i in range(messages):
await channel1.default_exchange.publish(
Message(body=str(i).encode()), routing_key=queue.name)
async def send_message(chat_id, text):
msg = {'message': text, 'chat_id': chat_id}
_msg = Message(body=dumps(msg).encode(),
delivery_mode=DeliveryMode.PERSISTENT)
await channel.default_exchange.publish(message=_msg,
routing_key=routing_key)
LOGGER.info(f'Sent message: {chat_id} -> {text}')
async def publish(self, msg: str, priority: int = 0) -> None:
await self.exchange.publish(Message(
msg.encode(),
priority=priority,
delivery_mode=DeliveryMode.PERSISTENT,
),
routing_key=self.routing_key)
async def main(loop):
connection = await connect_robust("amqp://*****:*****@127.0.0.1/",
loop=loop)
queue_name = "test_queue"
routing_key = "test_queue"
# Creating channel
channel = await connection.channel()
# Declaring exchange
exchange = await channel.declare_exchange('direct', auto_delete=True)
# Declaring queue
queue = await channel.declare_queue(queue_name, auto_delete=True)
# Binding queue
await queue.bind(exchange, routing_key)
await exchange.publish(
Message(bytes('Hello', 'utf-8'),
content_type='text/plain',
headers={'foo': 'bar'}), routing_key)
# Receiving message
incoming_message = await queue.get(timeout=5)
# Confirm message
incoming_message.ack()
await queue.unbind(exchange, routing_key)
await queue.delete()
await connection.close()
def test_simple_publish_and_receive(self):
queue_name = self.get_random_name("test_connection")
routing_key = self.get_random_name()
channel = yield from self.create_channel()
exchange = yield from self.declare_exchange('direct', auto_delete=True, channel=channel)
queue = yield from self.declare_queue(queue_name, auto_delete=True, channel=channel)
yield from queue.bind(exchange, routing_key)
body = bytes(shortuuid.uuid(), 'utf-8')
result = yield from exchange.publish(
Message(
body, content_type='text/plain',
headers={'foo': 'bar'}
),
routing_key
)
self.assertTrue(result)
incoming_message = yield from queue.get(timeout=5)
incoming_message.ack()
self.assertEqual(incoming_message.body, body)
yield from queue.unbind(exchange, routing_key)
async def get_homework_step_info(exchange: Exchange, message: IncomingMessage):
with message.process():
try:
data = json.loads(message.body.decode())
if not isinstance(data.get('homework_id', None), int):
response = {
'status': 400,
'description': 'invalid homework_id'
}
from .Step import views
homework_id = data['homework_id']
response = await views.get_homework_step_info(homework_id)
if response is None:
response = {
'status': 404,
'description': 'homework_step not found'
}
else:
response = {'status': 200, 'data': response}
except Exception as e:
response = {'status': 500, 'description': str(e)}
finally:
response = json.dumps(response).encode()
await exchange.publish(Message(
body=response, correlation_id=message.correlation_id),
routing_key=message.reply_to)
async def publish(self, content: Any):
if not hasattr(self, 'active_exchange'):
raise JSONQueueError('no active exchange set')
message = Message(bytes(json_encode(content), 'utf-8'),
content_type='application/json')
await self.active_exchange.publish(message, self.routing_key)
async def send_queue_to_amqp(meter_queue, url, exchange):
"""
Connect to AMQP and continuously sent meter values from `meter_queue`
"""
connection = await connect(url)
logger.info("Connection established")
async with connection:
channel = await connection.channel()
logger.info("Channel opened")
meter_exchange = await channel.declare_exchange(
exchange,
ExchangeType.FANOUT
)
logger.info(f"'{exchange}' exchange declared.")
logger.info("Starting sending of random meter values...")
while True:
time, meter = await meter_queue.get()
logger.debug(f"Sending meter value {meter}")
# unsure, whether sending meter timestamp as message timestamp violates the protocol?
message = Message(
timestamp=time,
body=json.dumps(meter, ensure_ascii=False).encode(),
content_type='application/json'
)
await asyncio.shield(
meter_exchange.publish(message, routing_key="")
)
meter_queue.task_done()
async def publish(self, routing_key, data, **kwargs):
reply_to = self.rpc_name if 'correlation_id' in kwargs else None
period = data.get('period')
delay = period or data.get('delay')
delayed = period or delay
exchange = self.exchange
headers = {}
if delayed:
exchange = self.exchange_delayed
headers = {
'x-delay': delay
}
routing_key = self.delayed_name
await exchange.publish(
Message(
body=schema.dumps(data),
content_type="application/json",
delivery_mode=DeliveryMode.PERSISTENT,
reply_to=reply_to,
headers=headers,
**kwargs
),
routing_key=routing_key
)
async def test_message_nack(self):
client = await self.create_connection()
queue_name = self.get_random_name("test_nack_queue")
body = uuid.uuid4().bytes
channel = await client.channel()
queue = await channel.declare_queue(queue_name, auto_delete=True)
await channel.default_exchange.publish(
Message(body=body), routing_key=queue_name
)
message = await queue.get() # type: aio_pika.IncomingMessage
self.assertEqual(message.body, body)
message.nack(requeue=True)
message = await queue.get()
self.assertTrue(message.redelivered)
self.assertEqual(message.body, body)
message.ack()
await queue.delete()
await wait((client.close(), client.closing), loop=self.loop)
async def test_reject_twice(
self,
channel: aio_pika.Channel,
add_cleanup: Callable,
declare_queue: Callable,
declare_exchange: Callable,
):
queue_name = get_random_name("test_connection")
routing_key = get_random_name()
exchange = await declare_exchange("direct", auto_delete=True)
queue = await declare_queue(queue_name, auto_delete=True)
await queue.bind(exchange, routing_key)
add_cleanup(queue.unbind, exchange, routing_key)
body = bytes(shortuuid.uuid(), "utf-8")
await exchange.publish(
Message(body, content_type="text/plain", headers={"foo": "bar"}),
routing_key,
)
incoming_message = await queue.get(timeout=5)
incoming_message.reject(requeue=False)
with pytest.raises(MessageProcessError):
incoming_message.reject(requeue=False)
assert incoming_message.body == body
def test_purge_queue(self):
queue_name = self.get_random_name("test_connection4")
routing_key = self.get_random_name()
channel = yield from self.create_channel()
exchange = yield from channel.declare_exchange('direct', auto_delete=True)
queue = yield from channel.declare_queue(queue_name, auto_delete=True)
yield from queue.bind(exchange, routing_key)
try:
body = bytes(shortuuid.uuid(), 'utf-8')
yield from exchange.publish(
Message(
body, content_type='text/plain',
headers={'foo': 'bar'}
),
routing_key
)
yield from queue.purge()
with self.assertRaises(asyncio.TimeoutError):
yield from queue.get(timeout=1)
except:
yield from queue.unbind(exchange, routing_key)
yield from queue.delete()
async def test_purge_queue(
self,
declare_queue: Callable,
declare_exchange: Callable,
channel: aio_pika.Channel,
):
queue_name = get_random_name("test_connection4")
routing_key = get_random_name()
exchange = await declare_exchange("direct", auto_delete=True)
queue = await declare_queue(queue_name, auto_delete=True)
await queue.bind(exchange, routing_key)
try:
body = bytes(shortuuid.uuid(), "utf-8")
await exchange.publish(
Message(
body, content_type="text/plain", headers={"foo": "bar"},
),
routing_key,
)
await queue.purge()
with pytest.raises(asyncio.TimeoutError):
await queue.get(timeout=1)
except aio_pika.exceptions.QueueEmpty:
await queue.unbind(exchange, routing_key)
await queue.delete()
def test_big_message(self):
client = yield from self.create_connection()
queue_name = self.get_random_name("test_big")
routing_key = self.get_random_name()
channel = yield from client.channel()
exchange = yield from channel.declare_exchange('direct', auto_delete=True)
queue = yield from channel.declare_queue(queue_name, auto_delete=True)
yield from queue.bind(exchange, routing_key)
body = bytes(shortuuid.uuid(), 'utf-8') * 9999999
yield from exchange.publish(
Message(
body, content_type='text/plain',
headers={'foo': 'bar'}
),
routing_key
)
incoming_message = yield from queue.get(timeout=5)
incoming_message.ack()
self.assertEqual(incoming_message.body, body)
yield from queue.unbind(exchange, routing_key)
yield from queue.delete()
yield from wait((client.close(), client.closing), loop=self.loop)
async def _get_message(self,
body,
content_type: str,
type: str,
correlation_id: str,
identifier: str,
reply_to: str = None,
expiration: DateType = None) -> Message:
return Message(
body=body,
content_type=content_type,
type=type,
correlation_id=correlation_id,
reply_to=reply_to,
expiration=expiration,
headers={
'lang': 'py',
'method': identifier,
'x-cross-request-id': get_request_id(),
# 'id': correlation_id,
# 'shadow': shadow,
# 'countdown': countdown,
# 'eta': eta,
# 'group': group_id,
# 'retries': retries,
# 'timelimit': [time_limit, soft_time_limit],
# 'root_id': root_id,
# 'parent_id': parent_id,
'origin': self.get_nodename()
})
async def test_big_message(
self,
channel: aio_pika.Channel,
add_cleanup: Callable,
declare_queue,
declare_exchange,
):
queue_name = get_random_name("test_big")
routing_key = get_random_name()
exchange = await declare_exchange("direct", auto_delete=True)
queue = await declare_queue(queue_name, auto_delete=True)
await queue.bind(exchange, routing_key)
add_cleanup(queue.unbind, exchange, routing_key)
add_cleanup(queue.delete)
body = bytes(shortuuid.uuid(), "utf-8") * 1000000
await exchange.publish(
Message(body, content_type="text/plain", headers={"foo": "bar"}),
routing_key,
)
incoming_message = await queue.get(timeout=5)
incoming_message.ack()
assert incoming_message.body == body
async def test_consuming_not_coroutine(self):
client = await self.create_connection()
queue_name = self.get_random_name("tc2")
routing_key = self.get_random_name()
channel = await client.channel()
exchange = await channel.declare_exchange('direct', auto_delete=True)
queue = await channel.declare_queue(queue_name, auto_delete=True)
await queue.bind(exchange, routing_key)
body = bytes(shortuuid.uuid(), 'utf-8')
f = asyncio.Future(loop=self.loop)
def handle(message):
message.ack()
self.assertEqual(message.body, body)
self.assertEqual(message.routing_key, routing_key)
f.set_result(True)
await queue.consume(handle)
await exchange.publish(
Message(body, content_type='text/plain', headers={'foo': 'bar'}),
routing_key)
if not f.done():
await f
await queue.unbind(exchange, routing_key)
await exchange.delete()
await asyncio.wait((client.close(), client.closing), loop=self.loop)
async def test_declaration_result_with_messages(
self, connection, declare_queue, declare_exchange
):
channel1 = await self.create_channel(connection)
channel2 = await self.create_channel(connection)
queue_name = get_random_name("queue", "declaration-result")
queue1 = await declare_queue(
queue_name, auto_delete=True, channel=channel1,
)
await channel1.default_exchange.publish(
Message(body=b"test"), routing_key=queue1.name,
)
await asyncio.sleep(1)
queue2 = await declare_queue(
queue_name, passive=True, channel=channel2,
)
await queue2.get()
await queue2.delete()
assert queue2.declaration_result.consumer_count == 0
assert queue2.declaration_result.message_count == 1
async def test_internal_exchange(self):
client = await self.create_connection()
routing_key = self.get_random_name()
exchange_name = self.get_random_name("internal", "exchange")
channel = await client.channel()
exchange = await self.declare_exchange(exchange_name,
auto_delete=True,
internal=True,
channel=channel)
queue = await self.declare_queue(auto_delete=True, channel=channel)
await queue.bind(exchange, routing_key)
body = bytes(shortuuid.uuid(), 'utf-8')
with pytest.raises(ValueError):
f = exchange.publish(
Message(body,
content_type='text/plain',
headers={'foo': 'bar'}), routing_key)
await f
await queue.unbind(exchange, routing_key)
async def test_internal_exchange(
self, channel: aio_pika.Channel, declare_exchange, declare_queue
):
routing_key = get_random_name()
exchange_name = get_random_name("internal", "exchange")
exchange = await declare_exchange(
exchange_name, auto_delete=True, internal=True,
)
queue = await declare_queue(auto_delete=True)
await queue.bind(exchange, routing_key)
body = bytes(shortuuid.uuid(), "utf-8")
with pytest.raises(ValueError):
f = exchange.publish(
Message(
body, content_type="text/plain", headers={"foo": "bar"},
),
routing_key,
)
await f
await queue.unbind(exchange, routing_key)
def test_message_copy(self):
msg1 = Message(bytes(shortuuid.uuid(), 'utf-8'))
msg2 = copy(msg1)
msg1.lock()
self.assertFalse(msg2.locked)
async def test_simple_publish_without_confirm(
self,
connection: aio_pika.Connection,
declare_exchange: Callable,
declare_queue: Callable,
):
queue_name = get_random_name("test_connection")
routing_key = get_random_name()
channel = await connection.channel(publisher_confirms=False)
exchange = await declare_exchange(
"direct", auto_delete=True, channel=channel,
)
queue = await declare_queue(
queue_name, auto_delete=True, channel=channel,
)
await queue.bind(exchange, routing_key)
body = bytes(shortuuid.uuid(), "utf-8")
result = await exchange.publish(
Message(body, content_type="text/plain", headers={"foo": "bar"}),
routing_key,
)
assert result is None
incoming_message = await queue.get(timeout=5)
incoming_message.ack()
assert incoming_message.body == body
await queue.unbind(exchange, routing_key)
async def test_simple_publish_and_receive_delivery_mode_explicitly(self):
queue_name = self.get_random_name("test_connection")
routing_key = self.get_random_name()
channel = await self.create_channel()
exchange = await self.declare_exchange('direct',
auto_delete=True,
channel=channel)
queue = await self.declare_queue(queue_name,
auto_delete=True,
channel=channel)
await queue.bind(exchange, routing_key)
body = bytes(shortuuid.uuid(), 'utf-8')
await exchange.publish(
Message(body,
content_type='text/plain',
headers={'foo': 'bar'},
delivery_mode=None), routing_key)
incoming_message = await queue.get(timeout=5)
incoming_message.ack()
self.assertEqual(incoming_message.body, body)
await queue.unbind(exchange, routing_key)
async def test_simple_publish_and_receive_to_bound_exchange(
self,
channel: aio_pika.Channel,
declare_exchange: Callable,
declare_queue: Callable,
add_cleanup: Callable,
):
routing_key = get_random_name()
src_name = get_random_name("source", "exchange")
dest_name = get_random_name("destination", "exchange")
src_exchange = await declare_exchange(src_name, auto_delete=True)
dest_exchange = await declare_exchange(dest_name, auto_delete=True)
queue = await declare_queue(auto_delete=True)
await queue.bind(dest_exchange, routing_key)
await dest_exchange.bind(src_exchange, routing_key)
add_cleanup(dest_exchange.unbind, src_exchange, routing_key)
body = bytes(shortuuid.uuid(), "utf-8")
await src_exchange.publish(
Message(body, content_type="text/plain", headers={"foo": "bar"}),
routing_key,
)
incoming_message = await queue.get(timeout=5)
incoming_message.ack()
assert incoming_message.body == body
await queue.unbind(dest_exchange, routing_key)
async def test_ack_twice(self):
client = await self.create_connection()
queue_name = self.get_random_name("test_connection")
routing_key = self.get_random_name()
channel = await client.channel()
exchange = await channel.declare_exchange('direct', auto_delete=True)
queue = await channel.declare_queue(queue_name, auto_delete=True)
await queue.bind(exchange, routing_key)
body = bytes(shortuuid.uuid(), 'utf-8')
await exchange.publish(
Message(body, content_type='text/plain', headers={'foo': 'bar'}),
routing_key)
incoming_message = await queue.get(timeout=5)
incoming_message.ack()
with pytest.raises(MessageProcessError):
incoming_message.ack()
self.assertEqual(incoming_message.body, body)
await queue.unbind(exchange, routing_key)
await queue.delete()
await wait((client.close(), client.closing), loop=self.loop)
async def test_queue_iterator_close_with_noack(self):
messages = []
queue_name = self.get_random_name("test_queue")
async def task_inner():
nonlocal messages
connection = await self.create_connection()
async with connection:
channel = await connection.channel()
queue = await channel.declare_queue(queue_name)
async with queue.iterator(no_ack=True) as q:
async for message in q:
messages.append(message)
return
connection = await self.create_connection()
channel = await connection.channel()
queue = await channel.declare_queue(queue_name)
await channel.default_exchange.publish(
Message(b'fooz'),
routing_key=queue_name,
)
task = self.loop.create_task(task_inner())
await task
assert messages
assert messages[0].body == b'fooz'
