/home/mhx/git/github/libmoost/include/moost/service/skeleton.hpp

Go to the documentation of this file.

/* vim:set ts=3 sw=3 sts=3 et: */
#ifndef FM_LAST_MOOST_SERVICE_SKELETON_H_
#define FM_LAST_MOOST_SERVICE_SKELETON_H_

#include <iostream>
#include <sstream>
#include <string>
#include <stdexcept>

#include <boost/program_options.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/noncopyable.hpp>
#include <boost/filesystem.hpp>

#include "../logging.hpp"
#include "../process/service.hpp"
#include "../process/ownership.hpp"
#include "standard_options.hpp"
#include "../utils/assert.hpp"

namespace moost { namespace service {

class NoProcessOwnershipPolicy
{
public:
   void add_options(boost::program_options::options_description&, option_validator&)
   {
   }

   void validate_options(const boost::program_options::variables_map&) const
   {
   }

   void change_ownership(const boost::program_options::variables_map&)
   {
   }
};

class UidGidProcessOwnershipPolicy
{
private:
   moost::process::ownership own;
   std::string m_uid;
   std::string m_gid;

public:
   void add_options(boost::program_options::options_description& od, option_validator&)
   {
      od.add_options()
         ("uid", boost::program_options::value<std::string>(&m_uid), "run process as this user")
         ("gid", boost::program_options::value<std::string>(&m_gid), "run process as this group")
         ;
   }

   void validate_options(const boost::program_options::variables_map& vm) const
   {
      if (own.is_superuser() && vm.count("uid") == 0)
      {
         throw std::runtime_error("please use --uid option when running as root");
      }

      if (vm.count("uid") == 0 && vm.count("gid") != 0)
      {
         throw std::runtime_error("cannot use --gid without --uid option");
      }
   }

   void change_ownership(const boost::program_options::variables_map& vm)
   {
      if (vm.count("uid"))
      {
         own.drop_privileges(m_uid, m_gid);
      }
   }
};

class NoLoggingPolicy
{
public:
   typedef moost::process::NoConsoleLoggerPolicy DefaultConsoleLoggerPolicy;

   void set_init_verbose(bool)
   {
   }

   void add_options(boost::program_options::options_description&, option_validator&)
   {
   }

   void validate_options(const boost::program_options::variables_map&) const
   {
   }

   bool initialise(const std::string&, const boost::program_options::variables_map&)
   {
      return false;
   }

   template <class T>
   void configure_service(T&) const
   {
   }
};

class MoostLoggingPolicy
{
private:
   std::string m_log_level;
   std::string m_log_config;
   bool m_verbose;

public:
   typedef moost::process::MoostStandardConsoleLoggerPolicy DefaultConsoleLoggerPolicy;

   MoostLoggingPolicy()
      : m_verbose(false)
   {
   }

   void set_init_verbose(bool verbose)
   {
      m_verbose = verbose;
   }

   void add_options(boost::program_options::options_description& od, option_validator& opt_validator)
   {
      standard_options(od, opt_validator)
         ("log-level,l", boost::program_options::value<std::string>(&m_log_level)->default_value("info"), "default shell log level")
         ("logging-config", boost::program_options::value<std::string>(&m_log_config), "logging configuration file", validator::file(m_log_config))
         ;
   }

   void validate_options(const boost::program_options::variables_map&) const
   {
      log4cxx::LevelPtr invalid_level(new log4cxx::Level(-1, LOG4CXX_STR("INVALID"), 7 ));
      log4cxx::LevelPtr level = log4cxx::Level::toLevel(m_log_level, invalid_level);

      if (level == invalid_level)
      {
         throw std::runtime_error("invalid log level");
      }

      if (!m_log_config.empty() && !boost::filesystem::exists(m_log_config))
      {
         throw std::runtime_error("logging configuration file does not exist: " + m_log_config);
      }
   }

   bool initialise(const std::string& program_name, const boost::program_options::variables_map&)
   {
      moost::logging::global & glog = moost::logging::global_singleton::instance();

      glog.attach_ostream(std::cout);

      if (!(m_log_config.empty() ? glog.enable(program_name)
                                 : glog.enable(boost::filesystem::path(m_log_config))))
      {
         // the root (default) logger was not configured from a config file so we'll do our own thing with it

#if defined(NDEBUG) && !defined(SERVICE_SKELETON_NOCFG_LOG_ALL)
         MLOG_SET_DEFAULT_LEVEL_INFO();
#else
         MLOG_SET_DEFAULT_LEVEL_ALL();
#endif
      }

      return true;
   }

   template <class T>
   void configure_service(T& service) const
   {
      service.set_log_level(m_log_level);
      service.set_appender_factory(moost::service::appender_factory_ptr(new moost::service::log4cxx_appender_factory(m_log_level)));
   }
};

template <class ServiceT,
          class ProcessOwnershipPolicy = UidGidProcessOwnershipPolicy,
          class LoggingPolicy = MoostLoggingPolicy,
          class ConsoleLoggerPolicy = typename LoggingPolicy::DefaultConsoleLoggerPolicy>
class skeleton : public boost::noncopyable
{
private:
   bool m_logging_enabled;
   bool m_options_valid;
   std::string m_pidfile;
   unsigned short m_shell_port;
   boost::program_options::variables_map m_opt_varmap;
   ProcessOwnershipPolicy m_ownership;
   LoggingPolicy m_logging;
   std::string m_program_name;

   typedef moost::process::service<ServiceT, ConsoleLoggerPolicy> ProcessServiceType;

   class child_init_func
   {
   public:
      bool operator()()
      {
         m_log_enabled = m_log.initialise(m_program_name, m_varmap);
         m_log.configure_service(m_svc);
         return false;
      }

      child_init_func(ProcessServiceType& svc, LoggingPolicy& log, bool& log_enabled, const std::string& program_name, const boost::program_options::variables_map& varmap)
        : m_svc(svc)
        , m_log(log)
        , m_log_enabled(log_enabled)
        , m_program_name(program_name)
        , m_varmap(varmap)
      {
      }

   private:
      ProcessServiceType& m_svc;
      LoggingPolicy& m_log;
      bool& m_log_enabled;
      const std::string m_program_name;
      const boost::program_options::variables_map& m_varmap;
   };

protected:
   typedef ServiceT ServiceType;

   virtual void add_options(boost::program_options::options_description&)
   {
   }

   virtual void add_options(boost::program_options::options_description&, option_validator&)
   {
   }

   virtual void validate_options() const
   {
   }

   virtual std::string name() const = 0;

   virtual std::string version() const = 0;

   virtual std::string description() const = 0;

   virtual std::string copyright() const = 0;

   virtual boost::shared_ptr<ServiceType> create_service_instance() = 0;

   virtual std::string help_header() const
   {
      std::ostringstream oss;
      oss << "\r\n" << name() << ": " << description() << "\r\n\r\n";
      oss << "Version: " << version() << " :: Build: " << __DATE__ << " (" << __TIME__ << ") :: (c) "
          << copyright() << "\r\n\r\n";
      return oss.str();
   }

   bool logging_enabled() const
   {
      return m_logging_enabled;
   }

   const boost::program_options::variables_map& options() const
   {
      if (!m_options_valid)
      {
         throw std::runtime_error("(BUG) attempt to access options map before initialisation");
      }

      return m_opt_varmap;
   }

   bool running_as_daemon() const
   {
      return options().count("daemon") != 0;
   }

   void process_cmdline_options(boost::program_options::options_description& cmdline_options, option_validator& opt_validator, int argc, char **argv)
   {
      add_options(cmdline_options);
      add_options(cmdline_options, opt_validator);

      standard_options(cmdline_options, opt_validator)
         .port("shell-port", "remote shell port when daemonised", m_shell_port)
         ("pidfile", boost::program_options::value<std::string>(&m_pidfile), "pidfile location")
         ("noerr,n", "shut up stderr (for thrift)")
         ("help,h", "output help message and exit")
         ("version", "output service version and exit")
         ("daemon", "daemonise (fork to background)")
         ;

      m_ownership.add_options(cmdline_options, opt_validator);
      m_logging.add_options(cmdline_options, opt_validator);

      boost::program_options::store(boost::program_options::parse_command_line(argc, argv, cmdline_options), m_opt_varmap);
      boost::program_options::notify(m_opt_varmap);
      m_options_valid = true;
   }

   int safe_main(int argc, char **argv, bool noargs)
   {
      m_program_name = argv[0];

      // process command line options first

      boost::program_options::options_description cmdline_options;
      option_validator opt_validator;
      process_cmdline_options(cmdline_options, opt_validator, argc, argv);

      if (options().count("help") || (!noargs && argc == 1))
      {
         std::cout << help_header() << cmdline_options << std::endl;
         return 0; // nothing more to do here
      }

      if (options().count("version"))
      {
         std::cout << version() << std::endl;
         return 0; // nothing more to do here
      }

      // some basic command line options consistency checks

      if (running_as_daemon() && m_shell_port == 0)
      {
         throw std::runtime_error("please use --shell-port option when running with --daemon");
      }

      moost::utils::assert_absolute_path(m_pidfile, "pidfile");

      // service specific checks

      validator::constraints_map_t opt_constraints;

      if (running_as_daemon())
      {
         opt_constraints["absolute_filenames"] = "1";
      }

      opt_validator(options(), opt_constraints);
      m_ownership.validate_options(options());
      m_logging.validate_options(options());
      validate_options();

      // configure logging initialisation verbosity

      m_logging.set_init_verbose(!running_as_daemon());

      // change ownership according to policy

      m_ownership.change_ownership(options());

      run();

      return 0;  // apparently, we've managed to finish cleanly
   }

   virtual void run()
   {
      run_service();
   }

   void run_service()
   {
      ProcessServiceType service(create_service_instance());

      child_init_func child_init(service, m_logging, m_logging_enabled, m_program_name, options());

      service.set_child_init_func(boost::ref(child_init));

      if (options().count("noerr"))
      {
         service.set_default_stderr_state(false);
      }

      if (!m_pidfile.empty())
      {
         service.set_pidfile(m_pidfile);
      }

      if (m_shell_port)
      {
         service.set_shell_port(m_shell_port);
      }

      service.run(running_as_daemon());
   }

public:
   skeleton()
      : m_logging_enabled(false)
      , m_options_valid(false)
      , m_shell_port(0)
   {
   }

   virtual ~skeleton()
   {
   }

   virtual int main(int argc, char **argv, bool noargs)
   {
      try
      {
         return safe_main(argc, argv, noargs);
      }
      catch (const std::exception& e)
      {
         if (logging_enabled())
         {
            MLOG_DEFAULT_FATAL(e.what());
         }

         throw; // will be caught by main template below
      }
      catch (...)
      {
         if (logging_enabled())
         {
            MLOG_DEFAULT_FATAL("unknown exception caught");
         }

         throw; // will be caught by main template below
      }

      return 1;
   }
};

template <class SkeletonT>
int main(int argc, char **argv, bool noargs = false)
{
   // This try/catch catches exceptions during construction of the skeleton instance
   // (those should be really rare).

   // Any other exceptions will be caught by the skeleton's main() implementation.

   try
   {
      return SkeletonT().main(argc, argv, noargs);
   }
   catch (const std::exception& e)
   {
      std::cerr << "ERROR: " << e.what() << std::endl;
   }
   catch (...)
   {
      std::cerr << "ERROR: unknown exception caught" << std::endl;
   }

   return 1;
}

} }

#endif