main.cpp File Reference

#include <appbase/application.hpp>
#include <sysio/chain_plugin/chain_plugin.hpp>
#include <sysio/http_plugin/http_plugin.hpp>
#include <sysio/net_plugin/net_plugin.hpp>
#include <sysio/producer_plugin/producer_plugin.hpp>
#include <sysio/resource_monitor_plugin/resource_monitor_plugin.hpp>
#include <sysio/version/version.hpp>
#include <fc/log/logger.hpp>
#include <fc/log/logger_config.hpp>
#include <fc/log/appender.hpp>
#include <fc/exception/exception.hpp>
#include <boost/dll/runtime_symbol_info.hpp>
#include <boost/exception/diagnostic_information.hpp>
#include "config.hpp"

Include dependency graph for main.cpp:

Go to the source code of this file.

Namespaces
namespace	detail

Enumerations
enum	return_codes {   OTHER_FAIL = -2 , INITIALIZE_FAIL = -1 , SUCCESS = 0 , BAD_ALLOC = 1 ,   DATABASE_DIRTY = 2 , FIXED_REVERSIBLE = SUCCESS , EXTRACTED_GENESIS = SUCCESS , NODE_MANAGEMENT_SUCCESS = 5 }

Functions
fc::logging_config &	detail::add_deep_mind_logger (fc::logging_config &config)
void	detail::configure_logging (const bfs::path &config_path)
void	logging_conf_handler ()
void	initialize_logging ()
int	main (int argc, char **argv)

Enumeration Type Documentation

return_codes

enum return_codes

Enumerator
OTHER_FAIL
INITIALIZE_FAIL
SUCCESS
BAD_ALLOC
DATABASE_DIRTY
FIXED_REVERSIBLE
EXTRACTED_GENESIS
NODE_MANAGEMENT_SUCCESS

Definition at line 97 of file main.cpp.

                  {
   OTHER_FAIL        = -2,
   INITIALIZE_FAIL   = -1,
   SUCCESS           = 0,
   BAD_ALLOC         = 1,
   DATABASE_DIRTY    = 2,
   FIXED_REVERSIBLE  = SUCCESS,
   EXTRACTED_GENESIS = SUCCESS,
   NODE_MANAGEMENT_SUCCESS = 5
};

Function Documentation

initialize_logging()

void initialize_logging

(

)

Definition at line 81 of file main.cpp.

{
   auto config_path = app().get_logging_conf();
   if(fc::exists(config_path))
     fc::configure_logging(config_path); // intentionally allowing exceptions to escape
   else {
      auto cfg = fc::logging_config::default_config();
 
      fc::configure_logging( ::detail::add_deep_mind_logger(cfg) );
   }
 
   fc::log_config::initialize_appenders( app().get_io_service() );
 
   app().set_sighup_callback(logging_conf_handler);
}

Here is the call graph for this function:

Here is the caller graph for this function:

logging_conf_handler()

void logging_conf_handler

(

)

Definition at line 69 of file main.cpp.

{
   auto config_path = app().get_logging_conf();
   if( fc::exists( config_path ) ) {
      ilog( "Received HUP.  Reloading logging configuration from ${p}.", ("p", config_path.string()) );
   } else {
      ilog( "Received HUP.  No log config found at ${p}, setting to default.", ("p", config_path.string()) );
   }
   ::detail::configure_logging( config_path );
   fc::log_config::initialize_appenders( app().get_io_service() );
}

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char **	argv )

Definition at line 108 of file main.cpp.

{
   try {
      app().set_version(sysio::nodeop::config::version);
      app().set_version_string(sysio::version::version_client());
      app().set_full_version_string(sysio::version::version_full());
 
      auto root = fc::app_path();
      app().set_default_data_dir(root / "sysio" / nodeop::config::node_executable_name / "data" );
      app().set_default_config_dir(root / "sysio" / nodeop::config::node_executable_name / "config" );
      http_plugin::set_defaults({
         .default_unix_socket_path = "",
         .default_http_port = 8888
      });
      if(!app().initialize<chain_plugin, net_plugin, producer_plugin, resource_monitor_plugin>(argc, argv)) {
         const auto& opts = app().get_options();
         if( opts.count("help") || opts.count("version") || opts.count("full-version") || opts.count("print-default-config") ) {
            return SUCCESS;
         }
         return INITIALIZE_FAIL;
      }
      if (auto resmon_plugin = app().find_plugin<resource_monitor_plugin>()) {
         resmon_plugin->monitor_directory(app().data_dir());
      } else {
         elog("resource_monitor_plugin failed to initialize");
         return INITIALIZE_FAIL;
      }
      initialize_logging();
      ilog( "${name} version ${ver} ${fv}",
            ("name", nodeop::config::node_executable_name)("ver", app().version_string())
            ("fv", app().version_string() == app().full_version_string() ? "" : app().full_version_string()) );
      ilog("${name} using configuration file ${c}", ("name", nodeop::config::node_executable_name)("c", app().full_config_file_path().string()));
      ilog("${name} data directory is ${d}", ("name", nodeop::config::node_executable_name)("d", app().data_dir().string()));
      app().startup();
      app().set_thread_priority_max();
      app().exec();
   } catch( const extract_genesis_state_exception& e ) {
      return EXTRACTED_GENESIS;
   } catch( const fixed_reversible_db_exception& e ) {
      return FIXED_REVERSIBLE;
   } catch( const node_management_success& e ) {
      return NODE_MANAGEMENT_SUCCESS;
   } catch( const fc::exception& e ) {
      if( e.code() == fc::std_exception_code ) {
         if( e.top_message().find( "atabase dirty flag set" ) != std::string::npos ) {
            elog( "database dirty flag set (likely due to unclean shutdown): replay required" );
            return DATABASE_DIRTY;
         }
      }
      elog( "${e}", ("e", e.to_detail_string()));
      return OTHER_FAIL;
   } catch( const boost::interprocess::bad_alloc& e ) {
      elog("bad alloc");
      return BAD_ALLOC;
   } catch( const boost::exception& e ) {
      elog("${e}", ("e",boost::diagnostic_information(e)));
      return OTHER_FAIL;
   } catch( const std::runtime_error& e ) {
      if( std::string(e.what()).find("atabase dirty flag set") != std::string::npos ) {
         elog( "database dirty flag set (likely due to unclean shutdown): replay required" );
         return DATABASE_DIRTY;
      } else {
         elog( "${e}", ("e",e.what()));
      }
      return OTHER_FAIL;
   } catch( const std::exception& e ) {
      elog("${e}", ("e",e.what()));
      return OTHER_FAIL;
   } catch( ... ) {
      elog("unknown exception");
      return OTHER_FAIL;
   }
 
   ilog("${name} successfully exiting", ("name", nodeop::config::node_executable_name));
   return SUCCESS;
}

Here is the call graph for this function: