async def test_check_route_registry_full_options(self):
expected_routes = ["/asgard/counts/ok"]
expected_vhost = "/"
@self.app.amqp.consume(
expected_routes,
vhost=expected_vhost,
options=AMQPRouteOptions(bulk_size=1024, bulk_flush_interval=120),
)
async def _handler(message):
return 42
self.assertIsNotNone(self.app.routes_registry)
expected_registry_entry = AMQPRoute(
type=RouteTypes.AMQP_RABBITMQ,
routes=expected_routes,
handler=_handler,
default_options={},
vhost=expected_vhost,
options={
"bulk_size": 1024,
"bulk_flush_interval": 120,
Events.ON_SUCCESS: Actions.ACK,
Events.ON_EXCEPTION: Actions.REQUEUE,
},
)
route = self.app.routes_registry.route_for(_handler)
self.assertEqual(expected_registry_entry, route)
self.assertEqual(42, await route["handler"](None))
async def test_on_success_requeue(self):
@self.app.amqp.consume(
["queue"], options=AMQPRouteOptions(on_success=Actions.REQUEUE))
async def _handler(messages):
return 42
route = self.app.routes_registry.amqp_routes[0]
consumer = Consumer(route, *self.connection_parameters)
await consumer.on_queue_message(msg=self.mock_message)
self.mock_message.reject.assert_awaited_once_with(requeue=True)
async def test_register_action_on_exception(self):
@self.app.amqp.consume(
["my-queue"], options=AMQPRouteOptions(on_exception=Actions.ACK))
async def _handler(message):
return 42
self.assertIsNotNone(self.app.routes_registry)
self.assertEqual(
Actions.ACK,
self.app.routes_registry[_handler]["options"][Events.ON_EXCEPTION],
)
async def test_register_action_on_success(self):
@self.app.amqp.consume(
["my-queue"], options=AMQPRouteOptions(on_success=Actions.REJECT))
async def _handler(message):
return 42
self.assertIsNotNone(self.app.routes_registry)
self.assertEqual(
Actions.REJECT,
self.app.routes_registry[_handler]["options"][Events.ON_SUCCESS],
)
async def test_on_exception_ack_message(self):
@self.app.amqp.consume(
["queue"], options=AMQPRouteOptions(on_exception=Actions.ACK))
async def _handler(messages):
raise Exception("BOOM!")
route = self.app.routes_registry.amqp_routes[0]
consumer = Consumer(route, *self.connection_parameters)
with self.assertRaises(Exception):
await consumer.on_queue_message(msg=self.mock_message)
self.mock_message.ack.assert_awaited_once()
async def test_register_bulk_size(self):
expected_bulk_size = 1024
@self.app.amqp.consume(
["my-queue"],
options=AMQPRouteOptions(bulk_size=expected_bulk_size))
async def _handler(message):
return 42
self.assertIsNotNone(self.app.routes_registry)
route = self.app.routes_registry.amqp_routes[0]
self.assertEqual(expected_bulk_size, route["options"]["bulk_size"])
self.assertEqual(42, await route["handler"](None))
async def test_on_exception_requeue_message(self):
"""
Confirma que em caso de exceção, será feito `message.reject(requeue=True)`
"""
@self.app.amqp.consume(
["queue"], options=AMQPRouteOptions(on_exception=Actions.REQUEUE))
async def _handler(messages):
raise Exception("BOOM!")
route = self.app.routes_registry.amqp_routes[0]
consumer = Consumer(route, *self.connection_parameters)
with self.assertRaises(Exception):
await consumer.on_queue_message(msg=self.mock_message)
self.mock_message.reject.assert_awaited_once_with(requeue=True)
async def test_register_bulk_flush_timeout(self):
expected_bulk_flush_interval = 120
@self.app.amqp.consume(
["my-queue"],
options=AMQPRouteOptions(
bulk_flush_interval=expected_bulk_flush_interval),
)
async def _handler(message):
return 42
self.assertIsNotNone(self.app.routes_registry)
route = self.app.routes_registry.amqp_routes[0]
self.assertEqual(
expected_bulk_flush_interval,
route["options"]["bulk_flush_interval"],
)
self.assertEqual(42, await route["handler"](None))
from datetime import datetime
from typing import List
from asyncworker import App
from asyncworker.connections import AMQPConnection
from asyncworker.rabbitmq import RabbitMQMessage, AMQPRouteOptions
amqp_conn = AMQPConnection(
hostname="127.0.0.1", username="******", password="******", prefetch=1024
)
app = App(connections=[amqp_conn])
@app.amqp.consume(
["queue"],
options=AMQPRouteOptions(bulk_size=1024 * 8, bulk_flush_interval=10),
)
async def _handler(msgs: List[RabbitMQMessage]):
print(f"Recv {len(msgs)} {datetime.now().isoformat()}")
@app.run_every(1)
async def produce(app: App):
await amqp_conn.put(data={"msg": "ok"}, routing_key="queue")
app.run()
"""
amqp_conn = AMQPConnection(hostname="127.0.0.1",
username="******",
password="******")
amqp_conn_2 = AMQPConnection(hostname="172.17.0.2",
username="******",
password="******")
app = App(connections=[amqp_conn, amqp_conn_2])
@app.amqp.consume(["queue"],
connection=amqp_conn,
options=AMQPRouteOptions(bulk_size=64))
async def _handler_broker_1(msgs: List[RabbitMQMessage]):
print(f"Broker 1 ({amqp_conn.hostname}): Recv: {len(msgs)}")
for m in msgs:
await amqp_conn_2["/"].put(serialized_data=m.serialized_data,
routing_key="queue")
@app.amqp.consume(["queue"],
connection=amqp_conn_2,
options=AMQPRouteOptions(bulk_size=128))
async def _handler_roker_2(msgs: List[RabbitMQMessage]):
print(f"Broker 2 ({amqp_conn_2.hostname}): Recv: {len(msgs)}")
@app.run_every(1)