class StringApi(Microservice):
name = "string_api"
amqp = AMQPResource(
outputs=[
AMQPOutput(queue='upper_operator', codec=JsonCodec),
AMQPOutput(queue='lower_operator', codec=JsonCodec)
]
)
string_api_http_server = HTTPServerResource()
async def upper_handler(self, request):
self.logger.info(f"Received request in upper endpoint: {request.body}")
upper_operator_output = microservice.amqp.outputs.get('upper_operator')
response = await upper_operator_output.request(request.body)
self.logger.info(f"Sending response in upper endpoint {response}")
return text(response)
async def lower_handler(self, request):
self.logger.info(f"Received request in lower endpoint: {request.body}")
lower_operator_output = microservice.amqp.outputs.get('lower_operator')
response = await lower_operator_output.request(request.body)
self.logger.info(f"Sending response in lower endpoint {response}")
return text(response)
async def start(self):
self.string_api_http_server.add_endpoint("/upper", self.upper_endpoint)
self.string_api_http_server.add_endpoint("/lower", self.lower_endpoint)
await super().start()
async def test_input_request_async_iterator(aconnection, task_manager):
queue = "cats"
@AMQPRequestInput(queue=queue)
async def consume_cats(message, response):
await response.send_response(message)
output = AMQPOutput(queue=queue)
await aconnection.register(consume_cats, output)
task_manager.start_task("consumer",
consume_cats.callback_trigger(task_manager))
message = "test message"
await asyncio.wait_for(output.request(message), 1)
async def test_output_request_with_codec(aconnection, task_manager):
queue = "cats"
@AMQPRequestInput(queue=queue, codec=JsonCodec)
async def consume_cats(message, response):
await response.send_response(message)
output = AMQPOutput(queue=queue, codec=JsonCodec)
await aconnection.register(consume_cats, output)
task_manager.start_task("consumer",
consume_cats.callback_trigger(task_manager))
message = {"message": "test"}
response = await output.request(message)
assert response
async def test_output_request(event_loop, aconnection, task_manager):
queue = "cats"
@AMQPRequestInput(queue=queue)
async def consume_cats(message, response):
await response.send_response(message)
output = AMQPOutput(queue=queue)
await aconnection.register(consume_cats, output)
task_manager.start_task("consumer",
consume_cats.callback_trigger(task_manager))
message = "test message"
response = await output.request(message)
assert response
async def test_output_push(event_loop, aconnection, task_manager):
message_received_future = asyncio.Future(loop=event_loop)
queue = "cats"
@AMQPPullInput(queue=queue)
async def consume_cats(message):
message_received_future.set_result(message)
output = AMQPOutput(queue=queue)
await aconnection.register(consume_cats, output)
task_manager.start_task("consumer",
consume_cats.callback_trigger(task_manager))
message = "test message"
await output.push(message)
await asyncio.wait_for(message_received_future, 1, loop=event_loop)
class MyMicroservice(Microservice):
name = "amqp_example"
extra_loggers_names = {name, "asyncio", "tamarco"}
def __init__(self):
super().__init__()
self.settings.update_internal({
"system": {
"deploy_name": "test",
"logging": {
"profile": "PRODUCTION"
},
"resources": {
"amqp": {
"host": "127.0.0.1",
"port": 5672,
"vhost": "/",
"user": "******",
"password": "******",
"connection_timeout": 10,
}
},
}
})
amqp = AMQPResource(
inputs=[AMQPSubscriptionInput(queue="cows", codec=JsonCodec)],
outputs=[AMQPOutput(queue="cows", codec=JsonCodec)],
)
@task
async def produce_cows(self):
cows_output = self.amqp.outputs["cows"]
while True:
await asyncio.sleep(1)
message = {"cow": "MOOOO"}
await cows_output.publish(message)
self.logger.info(f"Sent message {message} to cows queue")
@task
async def consume_cows(self):
cows_stream = self.amqp.inputs["cows"]
async for message in cows_stream:
self.logger.info(f"Consumed message from cows queue: {message}")
class MyMicroservice(Microservice):
name = "amqp_example"
extra_loggers_names = {name, "asyncio", "tamarco"}
def __init__(self):
super().__init__()
self.settings.update_internal({
"system": {
"deploy_name": "test",
"logging": {
"profile": "PRODUCTION"
},
"resources": {
"amqp": {
"host": "127.0.0.1",
"port": 5672,
"vhost": "/",
"user": "******",
"password": "******",
"connection_timeout": 10,
}
},
}
})
amqp = AMQPResource(outputs=[AMQPOutput(queue="cows", codec=JsonCodec)])
@task
async def produce_cows(self):
cows_output = self.amqp.outputs["cows"]
while True:
await asyncio.sleep(1)
message = {"cow": "MOOOO"}
response = await cows_output.request(message)
self.logger.info(
f"Sent message to cows {message} with response {response}")
@AMQPRequestInput(resource=amqp, queue="cows", codec=JsonCodec)
async def consume_messages(self, message, response_handler):
self.logger.info(f"Consumed message from cows queue: {message}")
await response_handler.send_response({"cat": "MEOW"})