amq-adapter-python/amqp/router/router_consumer.py

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.<init>")

    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)