application.hpp

Go to the documentation of this file.

#pragma once
#include <appbase/plugin.hpp>
#include <appbase/channel.hpp>
#include <appbase/method.hpp>
#include <appbase/execution_priority_queue.hpp>
#include <boost/filesystem/path.hpp>
#include <boost/core/demangle.hpp>
#include <typeindex>
 
namespace appbase {
   namespace bpo = boost::program_options;
   namespace bfs = boost::filesystem;
 
   using config_comparison_f = std::function<bool(const boost::any& a, const boost::any& b)>;
 
   class application
   {
      public:
         ~application();
 
 
         void set_version(uint64_t version);
         uint64_t version() const;
         string version_string() const;
         void set_version_string(std::string v);
         string full_version_string() const;
         void set_full_version_string(std::string v);
         void set_default_data_dir(const bfs::path& data_dir = "data-dir");
         bfs::path data_dir() const;
         void set_default_config_dir(const bfs::path& config_dir = "etc");
         bfs::path config_dir() const;
         bfs::path get_logging_conf() const;
         bfs::path full_config_file_path() const;
          void set_sighup_callback(std::function<void()> callback);
         template<typename... Plugin>
         bool                 initialize(int argc, char** argv) {
            return initialize_impl(argc, argv, {find_plugin<Plugin>()...});
         }
 
         void                  startup();
         void                  shutdown();
 
         void                 exec();
         void                 quit();
 
         bool                 is_quiting()const;
 
         template <typename T> void register_config_type() {
            register_config_type_comparison(typeid(T), [](const auto& a, const auto& b) {
               return boost::any_cast<const T&>(a) == boost::any_cast<const T&>(b);
            });
         }
         void register_config_type_comparison(std::type_index, config_comparison_f comp);
 
         static application&  instance();
 
         abstract_plugin* find_plugin(const string& name)const;
         abstract_plugin& get_plugin(const string& name)const;
 
         template<typename Plugin>
         auto& register_plugin() {
            auto existing = find_plugin<Plugin>();
            if(existing)
               return *existing;
 
            auto plug = new Plugin();
            plugins[plug->name()].reset(plug);
            plug->register_dependencies();
            return *plug;
         }
 
         template<typename Plugin>
         Plugin* find_plugin()const {
            string name = boost::core::demangle(typeid(Plugin).name());
            return dynamic_cast<Plugin*>(find_plugin(name));
         }
 
         template<typename Plugin>
         Plugin& get_plugin()const {
            auto ptr = find_plugin<Plugin>();
            return *ptr;
         }
 
         template<typename MethodDecl>
         auto get_method() -> std::enable_if_t<is_method_decl<MethodDecl>::value, typename MethodDecl::method_type&>
         {
            using method_type = typename MethodDecl::method_type;
            auto key = std::type_index(typeid(MethodDecl));
            auto itr = methods.find(key);
            if(itr != methods.end()) {
               return *method_type::get_method(itr->second);
            } else {
               methods.emplace(std::make_pair(key, method_type::make_unique()));
               return  *method_type::get_method(methods.at(key));
            }
         }
 
         template<typename ChannelDecl>
         auto get_channel() -> std::enable_if_t<is_channel_decl<ChannelDecl>::value, typename ChannelDecl::channel_type&>
         {
            using channel_type = typename ChannelDecl::channel_type;
            auto key = std::type_index(typeid(ChannelDecl));
            auto itr = channels.find(key);
            if(itr != channels.end()) {
               return *channel_type::get_channel(itr->second);
            } else {
               channels.emplace(std::make_pair(key, channel_type::make_unique()));
               return  *channel_type::get_channel(channels.at(key));
            }
         }
 
         boost::asio::io_service& get_io_service() { return *io_serv; }
 
         template <typename Func>
         auto post( int priority, Func&& func ) {
            return boost::asio::post(*io_serv, pri_queue.wrap(priority, std::forward<Func>(func)));
         }
 
         auto& get_priority_queue() {
            return pri_queue;
         }
 
         const bpo::variables_map& get_options() const;
 
         void set_thread_priority_max();
 
      protected:
         template<typename Impl>
         friend class plugin;
 
         bool initialize_impl(int argc, char** argv, vector<abstract_plugin*> autostart_plugins);
 
         void plugin_initialized(abstract_plugin& plug){ initialized_plugins.push_back(&plug); }
         void plugin_started(abstract_plugin& plug){ running_plugins.push_back(&plug); }
 
      private:
         application(); 
         map<string, std::unique_ptr<abstract_plugin>> plugins; 
         vector<abstract_plugin*>                  initialized_plugins; 
         vector<abstract_plugin*>                  running_plugins; 
 
         std::function<void()>                     sighup_callback;
         map<std::type_index, erased_method_ptr>   methods;
         map<std::type_index, erased_channel_ptr>  channels;
 
         std::shared_ptr<boost::asio::io_service>  io_serv;
         execution_priority_queue                  pri_queue;
 
         void start_sighup_handler( std::shared_ptr<boost::asio::signal_set> sighup_set );
         void set_program_options();
         void write_default_config(const bfs::path& cfg_file);
         void print_default_config(std::ostream& os);
 
         void wait_for_signal(std::shared_ptr<boost::asio::signal_set> ss);
         void setup_signal_handling_on_ios(boost::asio::io_service& ios, bool startup);
 
         std::unique_ptr<class application_impl> my;
 
   };
 
   application& app();
 
 
   template<typename Impl>
   class plugin : public abstract_plugin {
      public:
         plugin():_name(boost::core::demangle(typeid(Impl).name())){}
         virtual ~plugin(){}
 
         virtual state get_state()const override         { return _state; }
         virtual const std::string& name()const override { return _name; }
 
         virtual void register_dependencies() {
            static_cast<Impl*>(this)->plugin_requires([&](auto& plug){});
         }
 
         virtual void initialize(const variables_map& options) override {
            if(_state == registered) {
               _state = initialized;
               static_cast<Impl*>(this)->plugin_requires([&](auto& plug){ plug.initialize(options); });
               static_cast<Impl*>(this)->plugin_initialize(options);
               //ilog( "initializing plugin ${name}", ("name",name()) );
               app().plugin_initialized(*this);
            }
            assert(_state == initialized); 
         }
 
         virtual void handle_sighup() override {
         }
 
         virtual void startup() override {
            if(_state == initialized) {
               _state = started;
               static_cast<Impl*>(this)->plugin_requires([&](auto& plug){ plug.startup(); });
               static_cast<Impl*>(this)->plugin_startup();
               app().plugin_started(*this);
            }
            assert(_state == started); // if initial state was not initialized, final state cannot be started
         }
 
         virtual void shutdown() override {
            if(_state == started) {
               _state = stopped;
               //ilog( "shutting down plugin ${name}", ("name",name()) );
               static_cast<Impl*>(this)->plugin_shutdown();
            }
         }
 
      protected:
         plugin(const string& name) : _name(name){}
 
      private:
         state _state = abstract_plugin::registered;
         std::string _name;
   };
 
   template<typename Data, typename DispatchPolicy>
   void channel<Data,DispatchPolicy>::publish(int priority, const Data& data) {
      if (has_subscribers()) {
         // this will copy data into the lambda
         app().post( priority, [this, data]() {
            _signal(data);
         });
      }
   }
 
}