appbase::application Class Reference

#include <application.hpp>

Public Member Functions
	~application ()
void	set_version (uint64_t version)
	Set version.
uint64_t	version () const
	Get version.
string	version_string () const
	Get version string; generated from git describe if available.
void	set_version_string (std::string v)
	User provided version string for version_string() which overrides git describe value.
string	full_version_string () const
	Get full version string; same as version_string() unless set differently.
void	set_full_version_string (std::string v)
	User provided full version string for full_version_string()
void	set_default_data_dir (const bfs::path &data_dir="data-dir")
	Set default data directory.
bfs::path	data_dir () const
	Get data directory.
void	set_default_config_dir (const bfs::path &config_dir="etc")
	Set default config directory.
bfs::path	config_dir () const
	Get config directory.
bfs::path	get_logging_conf () const
	Get logging configuration path.
bfs::path	full_config_file_path () const
	Get full config.ini path.
void	set_sighup_callback (std::function< void()> callback)
	Set function pointer invoked on receipt of SIGHUP.
template<typename... Plugin>
bool	initialize (int argc, char **argv)
	Looks for the –plugin commandline / config option and calls initialize on those plugins.
void	startup ()
void	shutdown ()
void	exec ()
void	quit ()
bool	is_quiting () const
template<typename T >
void	register_config_type ()
void	register_config_type_comparison (std::type_index, config_comparison_f comp)
abstract_plugin *	find_plugin (const string &name) const
abstract_plugin &	get_plugin (const string &name) const
template<typename Plugin >
auto &	register_plugin ()
template<typename Plugin >
Plugin *	find_plugin () const
template<typename Plugin >
Plugin &	get_plugin () const
template<typename MethodDecl >
auto	get_method () -> std::enable_if_t< is_method_decl< MethodDecl >::value, typename MethodDecl::method_type & >
template<typename ChannelDecl >
auto	get_channel () -> std::enable_if_t< is_channel_decl< ChannelDecl >::value, typename ChannelDecl::channel_type & >
boost::asio::io_service &	get_io_service ()
template<typename Func >
auto	post (int priority, Func &&func)
auto &	get_priority_queue ()
const bpo::variables_map &	get_options () const
void	set_thread_priority_max ()

Static Public Member Functions
static application &	instance ()

Protected Member Functions
bool	initialize_impl (int argc, char **argv, vector< abstract_plugin * > autostart_plugins)
void	plugin_initialized (abstract_plugin &plug)
void	plugin_started (abstract_plugin &plug)

Friends
template<typename Impl >
class	plugin

Detailed Description

Definition at line 16 of file application.hpp.

Constructor & Destructor Documentation

~application()

appbase::application::~application

(

)

Definition at line 96 of file application.cpp.

{ }

Member Function Documentation

config_dir()

bfs::path appbase::application::config_dir

(

)

const

Returns

Config directory, possibly from command line

Definition at line 531 of file application.cpp.

                                      {
   return my->_config_dir;
}

Here is the caller graph for this function:

data_dir()

bfs::path appbase::application::data_dir

(

)

const

Returns

Data directory, possibly from command line

Definition at line 527 of file application.cpp.

                                    {
   return my->_data_dir;
}

Here is the caller graph for this function:

exec()

void appbase::application::exec

(

)

Wait until quit(), SIGINT or SIGTERM and then shutdown. Should only be executed from one thread.

perform synchronous shutdown

Definition at line 442 of file application.cpp.

                       {
   {
      boost::asio::io_service::work work(*io_serv);
      (void)work;
      bool more = true;
      while( more || io_serv->run_one() ) {
         while( io_serv->poll_one() ) {}
         // execute the highest priority item
         more = pri_queue.execute_highest();
      }
 
      shutdown(); 
   }
   io_serv.reset();
}

Here is the call graph for this function:

Here is the caller graph for this function:

find_plugin() [1/2]

template<typename Plugin >

Plugin * appbase::application::find_plugin ( ) const

inline

Definition at line 148 of file application.hpp.

                                    {
            string name = boost::core::demangle(typeid(Plugin).name());
            return dynamic_cast<Plugin*>(find_plugin(name));
         }

Here is the call graph for this function:

Here is the caller graph for this function:

find_plugin() [2/2]

abstract_plugin * appbase::application::find_plugin

(

const string &

name

)

const

Definition at line 511 of file application.cpp.

{
   auto itr = plugins.find(name);
   if(itr == plugins.end()) {
      return nullptr;
   }
   return itr->second.get();
}

Here is the caller graph for this function:

full_config_file_path()

bfs::path appbase::application::full_config_file_path

(

)

const

Returns

Config directory & config file name, possibly from command line. Only valid after initialize() has been called.

Definition at line 535 of file application.cpp.

                                                 {
   return bfs::canonical(my->_config_file_name);
}

Here is the caller graph for this function:

full_version_string()

string appbase::application::full_version_string

(

)

const

Returns

A string worthy of output with -v/–version, or "Unknown" if git not available

Definition at line 114 of file application.cpp.

                                              {
   return my->_full_version_str;
}

Here is the caller graph for this function:

get_channel()

template<typename ChannelDecl >

auto appbase::application::get_channel ( ) -> std::enable_if_t<is_channel_decl<ChannelDecl>::value, typename ChannelDecl::channel_type&>

inline

Fetch a reference to the channel declared by the passed in type. This will construct the channel on first access. This allows loose and deferred binding between plugins

Template Parameters

ChannelDecl

- appbase::channel_decl

Returns

reference to the channel described by the declaration

Definition at line 188 of file application.hpp.

         {
            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));
            }
         }

Here is the caller graph for this function:

get_io_service()

boost::asio::io_service & appbase::application::get_io_service ( )

inline

Do not run io_service in any other threads, as application assumes single-threaded execution in exec().

Returns

io_serivice of application

Definition at line 205 of file application.hpp.

{ return *io_serv; }

Here is the caller graph for this function:

get_logging_conf()

bfs::path appbase::application::get_logging_conf

(

)

const

Returns

Logging configuration location from command line

Definition at line 130 of file application.cpp.

                                            {
  return my->_logging_conf;
}

Here is the caller graph for this function:

get_method()

template<typename MethodDecl >

auto appbase::application::get_method ( ) -> std::enable_if_t<is_method_decl<MethodDecl>::value, typename MethodDecl::method_type&>

inline

Fetch a reference to the method declared by the passed in type. This will construct the method on first access. This allows loose and deferred binding between plugins

Template Parameters

MethodDecl

- appbase::method_decl

Returns

reference to the method described by the declaration

Definition at line 167 of file application.hpp.

         {
            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));
            }
         }

Here is the caller graph for this function:

get_options()

const bpo::variables_map & appbase::application::get_options

(

)

const

Definition at line 543 of file application.cpp.

                                                      {
      return my->_options;
}

Here is the caller graph for this function:

get_plugin() [1/2]

template<typename Plugin >

Plugin & appbase::application::get_plugin ( ) const

inline

Definition at line 154 of file application.hpp.

                                   {
            auto ptr = find_plugin<Plugin>();
            return *ptr;
         }

Here is the call graph for this function:

Here is the caller graph for this function:

get_plugin() [2/2]

abstract_plugin & appbase::application::get_plugin

(

const string &

name

)

const

Definition at line 520 of file application.cpp.

                                                                {
   auto ptr = find_plugin(name);
   if(!ptr)
      BOOST_THROW_EXCEPTION(std::runtime_error("unable to find plugin: " + name));
   return *ptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_priority_queue()

auto & appbase::application::get_priority_queue ( )

inline

Provide access to execution priority queue so it can be used to wrap functions for prioritized execution.

Example: boost::asio::steady_timer timer( app().get_io_service() ); timer.async_wait( app().get_priority_queue().wrap(priority::low, [](){ do_something(); }) );

Definition at line 227 of file application.hpp.

                                    {
            return pri_queue;
         }

initialize()

template<typename... Plugin>

bool appbase::application::initialize ( int argc, char ** argv )

inline

Template Parameters

Plugin

List of plugins to initalize even if not mentioned by configuration. For plugins started by configuration settings or dependency resolution, this template has no effect.

Returns

true if the application and plugins were initialized, false or exception on error

Definition at line 99 of file application.hpp.

                                                                {
            return initialize_impl(argc, argv, {find_plugin<Plugin>()...});
         }

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_impl()

bool appbase::application::initialize_impl ( int argc, char ** argv, vector< abstract_plugin * > autostart_plugins )

protected

Definition at line 250 of file application.cpp.

                                                                                                   {
   set_program_options();
 
   bpo::variables_map& options = my->_options;
   try {
      bpo::parsed_options parsed = bpo::command_line_parser(argc, argv).options(my->_app_options).run();
      bpo::store(parsed, options);
      vector<string> positionals = bpo::collect_unrecognized(parsed.options, bpo::include_positional);
      if(!positionals.empty())
         BOOST_THROW_EXCEPTION(std::runtime_error("Unknown option '" + positionals[0] + "' passed as command line argument"));
   } catch( const boost::program_options::unknown_option& e ) {
      BOOST_THROW_EXCEPTION(std::runtime_error("Unknown option '" + e.get_option_name() + "' passed as command line argument"));
   }
 
   if( options.count( "help" ) ) {
      cout << my->_app_options << std::endl;
      return false;
   }
 
   if( options.count( "version" ) ) {
      cout << version_string() << std::endl;
      return false;
   }
 
   if( options.count( "full-version" ) ) {
      cout << full_version_string() << std::endl;
      return false;
   }
 
   if( options.count( "print-default-config" ) ) {
      print_default_config(cout);
      return false;
   }
 
   if( options.count( "data-dir" ) ) {
      // Workaround for 10+ year old Boost defect
      // See https://svn.boost.org/trac10/ticket/8535
      // Should be .as<bfs::path>() but paths with escaped spaces break bpo e.g.
      // std::exception::what: the argument ('/path/with/white\ space') for option '--data-dir' is invalid
      auto workaround = options["data-dir"].as<std::string>();
      bfs::path data_dir = workaround;
      if( data_dir.is_relative() )
         data_dir = bfs::current_path() / data_dir;
      my->_data_dir = data_dir;
   }
 
   if( options.count( "config-dir" ) ) {
      auto workaround = options["config-dir"].as<std::string>();
      bfs::path config_dir = workaround;
      if( config_dir.is_relative() )
         config_dir = bfs::current_path() / config_dir;
      my->_config_dir = config_dir;
   }
 
   auto workaround = options["logconf"].as<std::string>();
   bfs::path logconf = workaround;
   if( logconf.is_relative() )
      logconf = my->_config_dir / logconf;
   my->_logging_conf = logconf;
 
   workaround = options["config"].as<std::string>();
   my->_config_file_name = workaround;
   if( my->_config_file_name.is_relative() )
      my->_config_file_name = my->_config_dir / my->_config_file_name;
 
   if(!bfs::exists(my->_config_file_name)) {
      if(my->_config_file_name.compare(my->_config_dir / "config.ini") != 0)
      {
         cout << "Config file " << my->_config_file_name << " missing." << std::endl;
         return false;
      }
      write_default_config(my->_config_file_name);
   }
 
   std::vector< bpo::basic_option<char> > opts_from_config;
   try {
      bpo::parsed_options parsed_opts_from_config = bpo::parse_config_file<char>(my->_config_file_name.make_preferred().string().c_str(), my->_cfg_options, false);
      bpo::store(parsed_opts_from_config, options);
      opts_from_config = parsed_opts_from_config.options;
   } catch( const boost::program_options::unknown_option& e ) {
      BOOST_THROW_EXCEPTION(std::runtime_error("Unknown option '" + e.get_option_name() + "' inside the config file " +  full_config_file_path().string()));
   }
 
   std::vector<string> set_but_default_list;
 
   for(const boost::shared_ptr<bpo::option_description>& od_ptr : my->_cfg_options.options()) {
      boost::any default_val, config_val;
      if(!od_ptr->semantic()->apply_default(default_val))
         continue;
 
      if(my->_any_compare_map.find(default_val.type()) == my->_any_compare_map.end()) {
         std::cerr << "APPBASE: Developer -- the type " << default_val.type().name() << " is not registered with appbase," << std::endl;
         std::cerr << "         add a register_config_type<>() in your plugin's ctor" << std::endl;
         return false;
      }
 
      for(const bpo::basic_option<char>& opt : opts_from_config) {
         if(opt.string_key != od_ptr->long_name())
            continue;
 
         od_ptr->semantic()->parse(config_val, opt.value, true);
         if(my->_any_compare_map.at(default_val.type())(default_val, config_val))
            set_but_default_list.push_back(opt.string_key);
         break;
      }
   }
   if(set_but_default_list.size()) {
      std::cerr << "APPBASE: Warning: The following configuration items in the config.ini file are redundantly set to" << std::endl;
      std::cerr << "         their default value:" << std::endl;
      std::cerr << "             ";
      size_t chars_on_line = 0;
      for(auto it = set_but_default_list.cbegin(); it != set_but_default_list.end(); ++it) {
         std::cerr << *it;
         if(it + 1 != set_but_default_list.end())
            std::cerr << ", ";
         if((chars_on_line += it->size()) > 65) {
            std::cerr << std::endl << "             ";
            chars_on_line = 0;
         }
      }
      std::cerr << std::endl;
      std::cerr << "         Explicit values will override future changes to application defaults. Consider commenting out or" << std::endl;
      std::cerr << "         removing these items." << std::endl;
   }
 
   if(options.count("plugin") > 0)
   {
      auto plugins = options.at("plugin").as<std::vector<std::string>>();
      for(auto& arg : plugins)
      {
         vector<string> names;
         boost::split(names, arg, boost::is_any_of(" \t,"));
         for(const std::string& name : names)
            get_plugin(name).initialize(options);
      }
   }
   try {
      for (auto plugin : autostart_plugins)
         if (plugin != nullptr && plugin->get_state() == abstract_plugin::registered)
            plugin->initialize(options);
 
      bpo::notify(options);
   } catch (...) {
      std::cerr << "Failed to initialize\n";
      return false;
   }
 
   return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

instance()

application & appbase::application::instance ( )

static

Definition at line 206 of file application.cpp.

                                   {
   static application _app;
   return _app;
}

Here is the caller graph for this function:

is_quiting()

bool appbase::application::is_quiting

(

)

const

If in long running process this flag can be checked to see if processing should be stoppped.

Returns

true if quit() has been called.

Definition at line 420 of file application.cpp.

                                   {
   return my->_is_quiting;
}

Here is the caller graph for this function:

plugin_initialized()

void appbase::application::plugin_initialized ( abstract_plugin & plug )

inlineprotected

these notifications get called from the plugin when their state changes so that the application can call shutdown in the reverse order.

Definition at line 249 of file application.hpp.

{ initialized_plugins.push_back(&plug); }

Here is the caller graph for this function:

plugin_started()

void appbase::application::plugin_started ( abstract_plugin & plug )

inlineprotected

Definition at line 250 of file application.hpp.

{ running_plugins.push_back(&plug); }

Here is the caller graph for this function:

post()

template<typename Func >

auto appbase::application::post ( int priority, Func && func )

inline

Post func to run on io_service with given priority.

Parameters

priority	can be appbase::priority::* constants or any int, larger ints run first
func	function to run on io_service

Returns

result of boost::asio::post

Definition at line 215 of file application.hpp.

                                                {
            return boost::asio::post(*io_serv, pri_queue.wrap(priority, std::forward<Func>(func)));
         }

Here is the call graph for this function:

Here is the caller graph for this function:

quit()

void appbase::application::quit

(

)

Definition at line 415 of file application.cpp.

                       {
   my->_is_quiting = true;
   io_serv->stop();
}

Here is the caller graph for this function:

register_config_type()

template<typename T >

void appbase::application::register_config_type ( )

inline

Register a configuration type with appbase. most "plain" types are already registered in application.cpp. Failure to register a type will cause initialization to fail.

Definition at line 123 of file application.hpp.

                                                           {
            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);
            });
         }

Here is the call graph for this function:

Here is the caller graph for this function:

register_config_type_comparison()

void appbase::application::register_config_type_comparison	(	std::type_index	i,
		config_comparison_f	comp )

Definition at line 212 of file application.cpp.

                                                                                           {
   my->_any_compare_map.emplace(i, comp);
}

Here is the caller graph for this function:

register_plugin()

template<typename Plugin >

auto & appbase::application::register_plugin ( )

inline

Definition at line 136 of file application.hpp.

                                 {
            auto existing = find_plugin<Plugin>();
            if(existing)
               return *existing;
 
            auto plug = new Plugin();
            plugins[plug->name()].reset(plug);
            plug->register_dependencies();
            return *plug;
         }

Here is the call graph for this function:

Here is the caller graph for this function:

set_default_config_dir()

void appbase::application::set_default_config_dir

(

const bfs::path &

config_dir = "etc"

)

Parameters

config_dir

Default configuration directory to use if not specified on the command line.

Definition at line 126 of file application.cpp.

                                                                  {
  my->_config_dir = config_dir;
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_default_data_dir()

void appbase::application::set_default_data_dir

(

const bfs::path &

data_dir = "data-dir"

)

Parameters

data_dir

Default data directory to use if not specified on the command line.

Definition at line 122 of file application.cpp.

                                                              {
  my->_data_dir = data_dir;
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_full_version_string()

void appbase::application::set_full_version_string

(

std::string

v

)

Definition at line 118 of file application.cpp.

                                                       {
   my->_full_version_str = std::move( v );
}

Here is the caller graph for this function:

set_sighup_callback()

void appbase::application::set_sighup_callback

(

std::function< void()>

callback

)

The provided function will be invoked on receipt of SIGHUP followed by invoking handle_sighup() on all initialized plugins. Caller is responsible for preserving an object if necessary.

Parameters

callback

Function pointer that will be invoked when the process receives the HUP (1) signal.

Definition at line 539 of file application.cpp.

                                                                  {
   sighup_callback = callback;
}

Here is the caller graph for this function:

set_thread_priority_max()

void appbase::application::set_thread_priority_max

(

)

Set the current thread schedule priority to maximum. Works for pthreads.

Definition at line 424 of file application.cpp.

                                          {
#if __has_include(<pthread.h>)
   pthread_t this_thread = pthread_self();
   struct sched_param params{};
   int policy = 0;
   int ret = pthread_getschedparam(this_thread, &policy, &params);
   if( ret != 0 ) {
      std::cerr << "ERROR: Unable to get thread priority" << std::endl;
   }
 
   params.sched_priority = sched_get_priority_max(policy);
   ret = pthread_setschedparam(this_thread, policy, &params);
   if( ret != 0 ) {
      std::cerr << "ERROR: Unable to set thread priority" << std::endl;
   }
#endif
}

Here is the caller graph for this function:

set_version()

void appbase::application::set_version

(

uint64_t

version

)

Parameters

version

Version output with -v/–version

Definition at line 98 of file application.cpp.

                                              {
  my->_version = version;
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_version_string()

void appbase::application::set_version_string

(

std::string

v

)

Definition at line 110 of file application.cpp.

                                                  {
   my->_version_str = std::move( v );
}

Here is the caller graph for this function:

shutdown()

void appbase::application::shutdown

(

)

Definition at line 400 of file application.cpp.

                           {
   for(auto ritr = running_plugins.rbegin();
       ritr != running_plugins.rend(); ++ritr) {
      (*ritr)->shutdown();
   }
   for(auto ritr = running_plugins.rbegin();
       ritr != running_plugins.rend(); ++ritr) {
      plugins.erase((*ritr)->name());
   }
   running_plugins.clear();
   initialized_plugins.clear();
   plugins.clear();
   quit();
}

Here is the call graph for this function:

Here is the caller graph for this function:

startup()

void appbase::application::startup

(

)

Definition at line 156 of file application.cpp.

                          {
   //during startup, run a second thread to catch SIGINT/SIGTERM/SIGPIPE/SIGHUP
   boost::asio::io_service startup_thread_ios;
   setup_signal_handling_on_ios(startup_thread_ios, true);
   std::thread startup_thread([&startup_thread_ios]() {
      startup_thread_ios.run();
   });
   auto clean_up_signal_thread = [&startup_thread_ios, &startup_thread]() {
      startup_thread_ios.stop();
      startup_thread.join();
   };
 
   try {
      for( auto plugin : initialized_plugins ) {
         if( is_quiting() ) break;
         plugin->startup();
      }
 
   } catch( ... ) {
      clean_up_signal_thread();
      shutdown();
      throw;
   }
 
   //after startup, shut down the signal handling thread and catch the signals back on main io_service
   clean_up_signal_thread();
   setup_signal_handling_on_ios(get_io_service(), false);
 
#ifdef SIGHUP
   std::shared_ptr<boost::asio::signal_set> sighup_set(new boost::asio::signal_set(get_io_service(), SIGHUP));
   start_sighup_handler( sighup_set );
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

version()

uint64_t appbase::application::version

(

)

const

Returns

Version output with -v/–version

Definition at line 102 of file application.cpp.

                                    {
  return my->_version;
}

Here is the caller graph for this function:

version_string()

string appbase::application::version_string

(

)

const

Returns

A string worthy of output with -v/–version, or "Unknown" if git not available

Definition at line 106 of file application.cpp.

                                         {
   return my->_version_str;
}

Here is the caller graph for this function:

Friends And Related Symbol Documentation

plugin

template<typename Impl >

friend class plugin

friend

Definition at line 241 of file application.hpp.

---

The documentation for this class was generated from the following files:

• libraries/appbase/include/appbase/application.hpp
• libraries/appbase/application.cpp