#include <state_history_plugin.hpp>

Inheritance diagram for sysio::state_history_plugin:

[legend]

Collaboration diagram for sysio::state_history_plugin:

[legend]

Public Member Functions
	state_history_plugin ()

virtual	~state_history_plugin ()

virtual void	set_program_options (options_description &cli, options_description &cfg) override

void	plugin_initialize (const variables_map &options)

void	plugin_startup ()

void	plugin_shutdown ()

Public Member Functions inherited from appbase::plugin< state_history_plugin >
	plugin ()

virtual	~plugin ()

virtual state	get_state () const override

virtual const std::string &	name () const override

virtual void	register_dependencies ()

virtual void	initialize (const variables_map &options) override

virtual void	handle_sighup () override

virtual void	startup () override

virtual void	shutdown () override

Public Member Functions inherited from appbase::abstract_plugin
virtual	~abstract_plugin ()

Additional Inherited Members
Public Types inherited from appbase::abstract_plugin
enum	state { registered , initialized , started , stopped }

Protected Member Functions inherited from appbase::plugin< state_history_plugin >
	plugin (const string &name)

Detailed Description

Definition at line 17 of file state_history_plugin.hpp.

Constructor & Destructor Documentation

◆ state_history_plugin()

sysio::state_history_plugin::state_history_plugin ( )

Definition at line 438 of file state_history_plugin.cpp.

439 : my(std::make_shared<state_history_plugin_impl>()) {}

◆ ~state_history_plugin()

sysio::state_history_plugin::~state_history_plugin ( )

virtual

Definition at line 441 of file state_history_plugin.cpp.

441{}

Member Function Documentation

◆ plugin_initialize()

void sysio::state_history_plugin::plugin_initialize ( const variables_map & options )

Definition at line 459 of file state_history_plugin.cpp.

                                                                         {
   try {
      SYS_ASSERT(options.at("disable-replay-opts").as<bool>(), plugin_exception,
                 "state_history_plugin requires --disable-replay-opts");
 
      my->chain_plug = app().find_plugin<chain_plugin>();
      SYS_ASSERT(my->chain_plug, chain::missing_chain_plugin_exception, "");
      auto& chain = my->chain_plug->chain();
      my->applied_transaction_connection.emplace(
          chain.applied_transaction.connect([&](std::tuple<const transaction_trace_ptr&, const packed_transaction_ptr&> t) {
             my->on_applied_transaction(std::get<0>(t), std::get<1>(t));
          }));
      my->accepted_block_connection.emplace(
          chain.accepted_block.connect([&](const block_state_ptr& p) { my->on_accepted_block(p); }));
      my->block_start_connection.emplace(
          chain.block_start.connect([&](uint32_t block_num) { my->on_block_start(block_num); }));
 
      auto                    dir_option = options.at("state-history-dir").as<bfs::path>();
      boost::filesystem::path state_history_dir;
      if (dir_option.is_relative())
         state_history_dir = app().data_dir() / dir_option;
      else
         state_history_dir = dir_option;
      if (auto resmon_plugin = app().find_plugin<resource_monitor_plugin>())
         resmon_plugin->monitor_directory(state_history_dir);
 
      auto ip_port         = options.at("state-history-endpoint").as<string>();
      auto port            = ip_port.substr(ip_port.find(':') + 1, ip_port.size());
      auto host            = ip_port.substr(0, ip_port.find(':'));
      my->endpoint_address = host;
      my->endpoint_port    = std::stoi(port);
      idump((ip_port)(host)(port));
 
      if (options.at("delete-state-history").as<bool>()) {
         ilog("Deleting state history");
         boost::filesystem::remove_all(state_history_dir);
      }
      boost::filesystem::create_directories(state_history_dir);
 
      if (options.at("trace-history-debug-mode").as<bool>()) {
         my->trace_debug_mode = true;
      }
 
      std::optional<state_history_log_prune_config> ship_log_prune_conf;
      if (options.count("state-history-log-retain-blocks")) {
         ship_log_prune_conf.emplace();
         ship_log_prune_conf->prune_blocks = options.at("state-history-log-retain-blocks").as<uint32_t>();
         //the arbitrary limit of 1000 here is mainly so that there is enough buffer for newly applied forks to be delivered to clients
         // before getting pruned out. ideally pruning would have been smart enough to know not to prune reversible blocks
         SYS_ASSERT(ship_log_prune_conf->prune_blocks >= 1000, plugin_exception, "state-history-log-retain-blocks must be 1000 blocks or greater");
      }
 
      if (options.at("trace-history").as<bool>())
         my->trace_log.emplace("trace_history", (state_history_dir / "trace_history.log").string(),
                               (state_history_dir / "trace_history.index").string(), ship_log_prune_conf);
      if (options.at("chain-state-history").as<bool>())
         my->chain_state_log.emplace("chain_state_history", (state_history_dir / "chain_state_history.log").string(),
                                     (state_history_dir / "chain_state_history.index").string(), ship_log_prune_conf);
   }
   FC_LOG_AND_RETHROW()
} // state_history_plugin::plugin_initialize

Here is the call graph for this function:

◆ plugin_shutdown()

void sysio::state_history_plugin::plugin_shutdown ( )

Definition at line 523 of file state_history_plugin.cpp.

                                           {
   my->applied_transaction_connection.reset();
   my->accepted_block_connection.reset();
   my->block_start_connection.reset();
   while (!my->sessions.empty())
      my->sessions.begin()->second->close();
   my->stopping = true;
}

◆ plugin_startup()

void sysio::state_history_plugin::plugin_startup ( )

Definition at line 521 of file state_history_plugin.cpp.

521{ my->listen(); }

◆ set_program_options()

void sysio::state_history_plugin::set_program_options	(	options_description &	cli,
		options_description &	cfg )

overridevirtual

Implements appbase::abstract_plugin.

Definition at line 443 of file state_history_plugin.cpp.

                                                                                                 {
   auto options = cfg.add_options();
   options("state-history-dir", bpo::value<bfs::path>()->default_value("state-history"),
           "the location of the state-history directory (absolute path or relative to application data dir)");
   cli.add_options()("delete-state-history", bpo::bool_switch()->default_value(false), "clear state history files");
   options("trace-history", bpo::bool_switch()->default_value(false), "enable trace history");
   options("chain-state-history", bpo::bool_switch()->default_value(false), "enable chain state history");
   options("state-history-endpoint", bpo::value<string>()->default_value("127.0.0.1:8080"),
           "the endpoint upon which to listen for incoming connections. Caution: only expose this port to "
           "your internal network.");
   options("trace-history-debug-mode", bpo::bool_switch()->default_value(false), "enable debug mode for trace history");
 
   if(cfile::supports_hole_punching())
      options("state-history-log-retain-blocks", bpo::value<uint32_t>(), "if set, periodically prune the state history files to store only configured number of most recent blocks");
}