import logging from typing import Set from pika import spec from pika.adapters.blocking_connection import BlockingChannel from amqp.adapter.amq_route_factory import AMQRouteFactory from amqp.config.amq_configuration import AMQConfiguration from amqp.model.model import CleverMicroServiceMessage, ServiceMessageType, AMQRoute from amqp.router.router_base import CM_C_REQ_QUEUE, CM_REQUEST_EXCHANGE, CM_RESPONSE_EXCHANGE, ANY_RECIPIENT from amqp.router.router_producer import RouterProducer class RouterConsumer(RouterProducer): """ * Contains Consumer logic. The logic here: * Sets a listener on CM_C_REQ_QUEUE queue to receive routing data requests * Upon receipt of routing data request, responds on CM_RESPONSE_EXCHANGE with local routing data. * It also proactively pushes the local routing data to CM_RESPONSE_EXCHANGE on startup to * notify the other (excluding self) Producers about its presence. * * Consumer is also Producer (Consumer sits alongside the CM Service, and anytime the Service needs * to communicate with other Service, it can do so via the Adapter). Therefore, the Producer * capability is also required. """ def __init__(self, configuration: AMQConfiguration): super().__init__(configuration) self.amqRouteFactory = AMQRouteFactory() logging.info(" [*] RouterConsumer.") def init_routing_paths_consumer(self, _channel: BlockingChannel): """ * Initialize router according to Consumer mode. """ self.init_routing_paths(_channel) logging.info(" [*] RouterConsumer.initConsumerRouter, channel open::", self.is_open(_channel)) if self.is_open(_channel): try: # 1. declare a Queue that gives the RoutingDAta requests cm_request_queue: str = self.amq_configuration.amq_adapter.adapter_prefix() + CM_C_REQ_QUEUE self.channel.queue_declare(cm_request_queue, durable=True, exclusive=False, auto_delete=False) # 1a. bind queue to CM_RESPONSE_EXCHANGE w/o any conditions (empty routing key) self.channel.queue_bind(queue=cm_request_queue, exchange=CM_REQUEST_EXCHANGE, routing_key="") # 1b. Service adapter mode - listens on Request queue and replies to Response queue logging.info(" [*] RouterConsumer listens for RouteDataRequests on:", cm_request_queue) self.channel.basic_consume(queue=cm_request_queue, auto_ack=False, on_message_callback=self.handle_routing_data_request_message) except Exception as ioe: logging.error(" [E] RouterConsumer FATAL: cannot initialize, %s", ioe) else: logging.error(" [E] RouterConsumer FATAL: cannot initialize, RabbitMQ channel is not open.") """ * ServiceMessageType.ROUTING_DATA_REQUEST handler listening on queue 'CleverMicroRequest' """ def handle_routing_data_request_message(self, ch: BlockingChannel, method: spec.Basic.Deliver, properties: spec.BasicProperties, body: bytes): # some debug statements, TODO - remove for prod release delivery_tag = method.delivery_tag debug = "Delivery.Properties = " + properties.__str__() logging.info(" [DBG] ******[%] (ROUTING_DATA_REQ) tag: %s, env: %s, props: %s", delivery_tag, method.consumer_tag, method.get_properties(), debug) self.channel.basic_ack(delivery_tag, False) message: CleverMicroServiceMessage = self.service_message_factory.from_bytes(body) route_mapping: str = self.wrap_own_routes() logging.info(" [DBG] ******[%s] (ROUTING_DATA_REQ) msg=%, routeMap=[{]", delivery_tag, self.service_message_factory.to_string(message), route_mapping) # Reply only if self adapter has own routeMapping (e.g. API-gateway-side adapter has none) if message.is_valid() and message.message_type == ServiceMessageType.ROUTING_DATA_REQUEST and route_mapping: try: service_message: CleverMicroServiceMessage = self.service_message_factory.of( ServiceMessageType.ROUTING_DATA, route_mapping, message.reply_to ) self.publish_service_message(service_message, CM_RESPONSE_EXCHANGE) except Exception as err: logging.error(" [E] ******[%s] (ROUTING_DATA_REQ) Response to queue: %s failed: %s", delivery_tag, CM_RESPONSE_EXCHANGE, err) else: logging.error(" [E] ******[%s] (ROUTING_DATA_REQ) [%s] produces invalid or no CM msg type.", delivery_tag, str(body)) def register_route(self, route: AMQRoute): """ * Called in Consumer (Service Adapter) context. Registers the routing data for self Service * with the Master router by sending own routing data to Master via CleverMicroResponse queue. * :param route: route to register with Master """ try: if self.is_open(self.channel) and route.queue: serviceMessage: CleverMicroServiceMessage = self.service_message_factory.of( ServiceMessageType.ROUTING_DATA, route.as_string(), ANY_RECIPIENT ) self.publish_service_message(serviceMessage, CM_RESPONSE_EXCHANGE) self.add_own_route(route) logging.info(" [DBG] RouterConsumer registered Route::", route) else: logging.warning(" [W] RouterConsumer couldn't register route data: %s channel isn't open.", CM_RESPONSE_EXCHANGE) except Exception as ioe: logging.error(" [E] RouterConsumer failed register route data: %s", ioe) def remove_route_on_cleanup(self, route: AMQRoute) -> bool: """ * Unregister / remove route from the list * :param route: route to remove * :return result of remove operation """ logging.info(" [DBG] RouterConsumer.removeRoute, route::", route.as_string()) try: service_message: CleverMicroServiceMessage = self.service_message_factory.of( ServiceMessageType.ROUTING_DATA_REMOVE, route.as_string(), ANY_RECIPIENT ) if not self.publish_service_message(service_message, CM_RESPONSE_EXCHANGE): logging.warning(" [W] RouterConsumer couldn't remove current route: %s, channel not open.", route) except Exception as ioe: logging.error(" [E] RouterConsumer failed remove current route: %s", ioe) result: bool = self.remove_route(route) return result def cleanup(self): """ * Cleanup - de-register routes with master. """ routes: Set[AMQRoute] = self.get_routes() logging.info(" [DBG] RouterConsumer.cleanup() [%d]: %s", len(routes), self.wrap_routes()) not_removed = sum(1 for r in (self.remove_route_on_cleanup(route) for route in routes) if not r) if not_removed > 0: logging.info(" [W] %d route(s) not removed. self may lead to failed delivery on self route", not_removed)