hub.hh

Go to the documentation of this file.

/*
 * hub.hh
 *
 *  Created on: Jan 7, 2016
 *      Author: N.S. Oblath
 */
 
#ifndef DRIPLINE_HUB_HH_
#define DRIPLINE_HUB_HH_
 
#include "service.hh"
 
#include "dripline_exceptions.hh"
 
#include <unordered_map>
 
namespace dripline
{
 
    class DRIPLINE_API hub : public service
    {
        private:
            typedef std::function< reply_ptr_t( const dripline::request_ptr_t ) > handler_func_t;
 
        public:
            /* 
               \brief Extracts necessary configuration and authentication information and prepares the hub to interact with the RabbitMQ broker. Does not initiate connection to the broker.
               @param a_config Dripline configuration object.  The `name` must be unique for each hub.  The `dripline.broker` (and `dripline.broker_port` if needed) should be made appropriate for the mesh.  
                 The other parameters can be left as their defaults, or should be made uniform across the mesh.
                 - *Service parameters*
                   - `name` (string; default: dlcpp_service) -- Name of the service and of the queue used by the service
                   - `enable-scheduling` (bool; default: false) -- Flag for enabling the scheduler
                   - `broadcast-key` (string; default: broadcast) -- Routing key used for broadcasts
                   - `loop-timeout-ms` (int; default: 1000) -- Maximum time used for listening timeouts (e.g. waiting for replies) in ms
                   - `message-wait-ms` (int; default: 1000) -- Maximum time used to wait for another AMQP message before declaring a DL message complete, in ms
                   - `heartbeat-interval-s` (int; default: 60) -- Interval between sending heartbeat messages in s
                 - *Dripline core parameters -- within the `dripline` config object*
                   - `dripline.broker` (string; default: localhost) -- Address of the RabbitMQ broker
                   - `dripline.broker_port` (int; default: 5672) -- Port used by the RabbitMQ broker
                   - `dripline.requests_exchange` (string; default: requests) -- Name of the exchange used for DL requests
                   - `dripline.alerts_exchange` (string; default: alerts) -- Name of the exchange used for DL alerts
                   - `dripline.heartbeat_routing_key` (string; default: heartbeat) -- Routing key used for sending heartbeats
                   - `dripline.max_payload_size` (int; default: DL_MAX_PAYLOAD_SIZE) -- Maximum size of payloads, in bytes
                   - `dripline.max_connection_attempts` (int; default: 10) -- Maximum number of attempts that will be made to connect to the broker
                   - `dripline.return_codes` (string or array of nodes; default: not present) -- Optional specification of additional return codes in the form of an array of nodes: `[{name: "<name>", value: <ret code>} <, ...>]`. 
                          If this is a string, it's treated as a file can be interpreted by the param system (e.g. YAML or JSON) using the previously-mentioned format
               @param a_auth Authentication object (type scarab::authentication); authentication specification should be processed, and the authentication data should include:
               @param a_make_connection Flag for whether or not to contact a broker; if true, this object operates in "dry-run" mode
             */
            hub( const scarab::param_node& a_config, const scarab::authentication& a_auth, const bool a_make_connection = true );
            hub( const hub& ) = delete;
            hub( hub&& ) = default;
            virtual ~hub() = default;
 
            hub& operator=( const hub& ) = delete;
            hub& operator=( hub&& );
 
            void set_run_handler( const handler_func_t& a_func );
            void register_get_handler( const std::string& a_key, const handler_func_t& a_func );
            void register_set_handler( const std::string& a_key, const handler_func_t& a_func );
            void register_cmd_handler( const std::string& a_key, const handler_func_t& a_func );
 
            void remove_get_handler( const std::string& a_key );
            void remove_set_handler( const std::string& a_key );
            void remove_cmd_handler( const std::string& a_key );
 
        private:
            //*************************
            // Hub request distributors
            //*************************
 
            virtual reply_ptr_t do_run_request( const request_ptr_t a_request );
            virtual reply_ptr_t do_get_request( const request_ptr_t a_request );
            virtual reply_ptr_t do_set_request( const request_ptr_t a_request );
            virtual reply_ptr_t do_cmd_request( const request_ptr_t a_request );
 
            handler_func_t f_run_handler;
 
            typedef std::unordered_map< std::string, handler_func_t > handler_funcs_t;
            handler_funcs_t f_get_handlers;
            handler_funcs_t f_set_handlers;
            handler_funcs_t f_cmd_handlers;
 
    };
 
} /* namespace dripline */
 
#endif /* DRIPLINE_HUB_HH_ */