main.cpp File Reference

#include <string>
#include <vector>
#include <math.h>
#include <sstream>
#include <regex>
#include <boost/algorithm/string.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/ip/host_name.hpp>
#include <boost/program_options.hpp>
#include <boost/process/child.hpp>
#include <boost/process/env.hpp>
#include <boost/process/system.hpp>
#include <boost/process/io.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/filesystem.hpp>
#include <boost/filesystem/path.hpp>
#include <boost/filesystem/fstream.hpp>
#include <fc/crypto/private_key.hpp>
#include <fc/crypto/public_key.hpp>
#include <fc/io/json.hpp>
#include <fc/network/ip.hpp>
#include <fc/reflect/variant.hpp>
#include <fc/log/logger_config.hpp>
#include <ifaddrs.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <net/if.h>
#include <sysio/chain/genesis_state.hpp>
#include "config.hpp"

Include dependency graph for main.cpp:

Go to the source code of this file.

Classes
struct	local_identity
class	host_def
class	eosd_def
class	tn_node_def
struct	remote_deploy
struct	testnet_def
struct	prodkey_def
struct	producer_set_def
struct	server_name_def
struct	server_identities
struct	node_rt_info
struct	last_run_def
class	producer_names
struct	launcher_def

Enumerations
enum	launch_modes {   LM_NONE , LM_LOCAL , LM_REMOTE , LM_NAMED ,   LM_ALL , LM_VERIFY }
enum	allowed_connection : char { PC_NONE = 0 , PC_PRODUCERS = 1 << 0 , PC_SPECIFIED = 1 << 1 , PC_ANY = 1 << 2 }

Functions
template<class enum_type , class = typename std::enable_if<std::is_enum<enum_type>::value>::type>
enum_type &	operator|= (enum_type &lhs, const enum_type &rhs)
template<typename T >
void	retrieve_paired_array_parameters (const variables_map &vmap, const std::string &num_selector, const std::string &paired_selector, std::map< uint, T > &selector_map)
void	write_default_config (const bfs::path &cfg_file, const options_description &cfg)
int	main (int argc, char *argv[])
	FC_REFLECT (remote_deploy,(ssh_cmd)(scp_cmd)(ssh_identity)(ssh_args)) FC_REFLECT(prodkey_def
	producer_name (block_signing_key)) FC_REFLECT(producer_set_def
schedule	FC_REFLECT (host_def,(genesis)(ssh_identity)(ssh_args)(sysio_home)(host_name)(public_name)(base_p2p_port)(base_http_port)(def_file_size)(instances)) FC_REFLECT(eosd_def
schedule config_dir_name data_dir_name p2p_port http_port file_size name	host (p2p_endpoint)) FC_REFLECT(tn_node_def
schedule config_dir_name data_dir_name p2p_port http_port file_size name name keys peers	producers (dont_start)) FC_REFLECT(testnet_def
schedule config_dir_name data_dir_name p2p_port http_port file_size name name keys peers name	ssh_helper (nodes)) FC_REFLECT(server_name_def
schedule config_dir_name data_dir_name p2p_port http_port file_size name name keys peers name ipaddr name has_bios	sysio_home (instances)) FC_REFLECT(server_identities
schedule config_dir_name data_dir_name p2p_port http_port file_size name name keys peers name ipaddr name has_bios producer nonprod db	default_sysio_home (ssh)) FC_REFLECT(node_rt_info

Variables
const string	block_dir = "blocks"
const string	shared_mem_dir = "state"
struct local_identity	local_id

Enumeration Type Documentation

allowed_connection

enum allowed_connection : char

Enumerator
PC_NONE
PC_PRODUCERS
PC_SPECIFIED
PC_ANY

Definition at line 333 of file main.cpp.

                        : char {
  PC_NONE = 0,
  PC_PRODUCERS = 1 << 0,
  PC_SPECIFIED = 1 << 1,
  PC_ANY = 1 << 2
};

launch_modes

enum launch_modes

Enumerator
LM_NONE
LM_LOCAL
LM_REMOTE
LM_NAMED
LM_ALL
LM_VERIFY

Definition at line 324 of file main.cpp.

                  {
  LM_NONE,
  LM_LOCAL,
  LM_REMOTE,
  LM_NAMED,
  LM_ALL,
  LM_VERIFY
};

Function Documentation

default_sysio_home()

schedule config_dir_name data_dir_name p2p_port http_port file_size name name keys peers name ipaddr name has_bios producer nonprod db default_sysio_home

(

ssh

)

FC_REFLECT() [1/2]

schedule FC_REFLECT	(	host_def	,
		(genesis)(ssh_identity)(ssh_args)(sysio_home)(host_name)(public_name)(base_p2p_port)(base_http_port)(def_file_size)(instances)	)

FC_REFLECT() [2/2]

FC_REFLECT	(	remote_deploy	,
		(ssh_cmd)(scp_cmd)(ssh_identity)(ssh_args)	)

host()

schedule config_dir_name data_dir_name p2p_port http_port file_size name host

(

p2p_endpoint

)

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 1983 of file main.cpp.

                                  {
 
  variables_map vmap;
  options_description cfg ("Testnet launcher config options");
  options_description cli ("launcher command line options");
  launcher_def top;
  string gts;
  launch_modes mode;
  string kill_arg;
  string bounce_nodes;
  string down_nodes;
  string roll_nodes;
  bfs::path config_dir;
  bfs::path config_file;
 
  local_id.initialize();
  top.set_options(cfg);
 
  cli.add_options()
    ("timestamp,i",bpo::value<string>(&gts),"set the timestamp for the first block. Use \"now\" to indicate the current time")
    ("launch,l",bpo::value<string>(), "select a subset of nodes to launch. Currently may be \"all\", \"none\", or \"local\". If not set, the default is to launch all unless an output file is named, in which case it starts none.")
    ("output,o",bpo::value<bfs::path>(&top.output),"save a copy of the generated topology in this file")
    ("kill,k", bpo::value<string>(&kill_arg),"The launcher retrieves the previously started process ids and issues a kill to each.")
    ("down", bpo::value<string>(&down_nodes),"comma-separated list of node numbers that will be taken down using the sysio-tn_down.sh script")
    ("bounce", bpo::value<string>(&bounce_nodes),"comma-separated list of node numbers that will be restarted using the sysio-tn_bounce.sh script")
    ("roll", bpo::value<string>(&roll_nodes),"comma-separated list of host names where the nodes should be rolled to a new version using the sysio-tn_roll.sh script")
    ("version,v", "print version information")
    ("help,h","print this list")
    ("config-dir", bpo::value<bfs::path>(), "Directory containing configuration files such as config.ini")
    ("config,c", bpo::value<bfs::path>()->default_value( "config.ini" ), "Configuration file name relative to config-dir");
 
  cli.add(cfg);
 
  try {
    bpo::store(bpo::parse_command_line(argc, argv, cli), vmap);
    bpo::notify(vmap);
 
    top.initialize(vmap);
 
    if (vmap.count("help") > 0) {
      cli.print(cerr);
      return 0;
    }
    if (vmap.count("version") > 0) {
      cout << sysio::launcher::config::version_str << endl;
      return 0;
    }
 
    if( vmap.count( "config-dir" ) ) {
      config_dir = vmap["config-dir"].as<bfs::path>();
      if( config_dir.is_relative() )
         config_dir = bfs::current_path() / config_dir;
    }
 
   bfs::path config_file_name = config_dir / "config.ini";
   if( vmap.count( "config" ) ) {
      config_file_name = vmap["config"].as<bfs::path>();
      if( config_file_name.is_relative() )
         config_file_name = config_dir / config_file_name;
   }
 
   if(!bfs::exists(config_file_name)) {
      if(config_file_name.compare(config_dir / "config.ini") != 0)
      {
         cout << "Config file " << config_file_name << " missing." << std::endl;
         return -1;
      }
      write_default_config(config_file_name, cfg);
   }
 
 
   bpo::store(bpo::parse_config_file<char>(config_file_name.make_preferred().string().c_str(),
                                           cfg, true), vmap);
 
 
 
    if (vmap.count("launch")) {
      string l = vmap["launch"].as<string>();
      if (boost::iequals(l,"all"))
        mode = LM_ALL;
      else if (boost::iequals(l,"local"))
        mode = LM_LOCAL;
      else if (boost::iequals(l,"remote"))
        mode = LM_REMOTE;
      else if (boost::iequals(l,"none"))
        mode = LM_NONE;
      else if (boost::iequals(l,"verify"))
        mode = LM_VERIFY;
      else {
        mode = LM_NAMED;
        top.launch_name = l;
      }
    }
    else {
      mode = !kill_arg.empty() || top.output.empty() ? LM_ALL : LM_NONE;
    }
 
    if (!kill_arg.empty()) {
      cout << "killing" << std::endl;
      if (kill_arg[0] != '-') {
        kill_arg = "-" + kill_arg;
      }
      top.kill (mode, kill_arg);
    }
    else if (!bounce_nodes.empty()) {
       top.bounce(bounce_nodes);
    }
    else if (!down_nodes.empty()) {
       top.down(down_nodes);
    }
    else if (!roll_nodes.empty()) {
       top.roll(roll_nodes);
    }
    else {
      top.generate();
      top.start_all(gts, mode);
      top.ignite();
    }
  } catch (bpo::unknown_option &ex) {
    cerr << ex.what() << endl;
    cli.print (cerr);
  }
  return 0;
}

Here is the call graph for this function:

operator|=()

template<class enum_type , class = typename std::enable_if<std::is_enum<enum_type>::value>::type>

enum_type & operator|= ( enum_type & lhs, const enum_type & rhs )

inline

Definition at line 511 of file main.cpp.

{
  using T = std::underlying_type_t <enum_type>;
  return lhs = static_cast<enum_type>(static_cast<T>(lhs) | static_cast<T>(rhs));
}

producer_name()

producer_name

(

block_signing_key

)

Here is the caller graph for this function:

producers()

schedule config_dir_name data_dir_name p2p_port http_port file_size name name keys peers producers

(

dont_start

)

Here is the caller graph for this function:

retrieve_paired_array_parameters()

template<typename T >

void retrieve_paired_array_parameters	(	const variables_map &	vmap,
		const std::string &	num_selector,
		const std::string &	paired_selector,
		std::map< uint, T > &	selector_map )

Definition at line 518 of file main.cpp.

                                                                                                                                                                 {
   if (vmap.count(num_selector)) {
     const auto specific_nums = vmap[num_selector].as<vector<uint>>();
     const auto specific_args = vmap[paired_selector].as<vector<string>>();
     if (specific_nums.size() != specific_args.size()) {
       cerr << "ERROR: every " << num_selector << " argument must be paired with a " << paired_selector << " argument" << endl;
       exit (-1);
     }
     const auto total_nodes = vmap["nodes"].as<size_t>();
     for(uint i = 0; i < specific_nums.size(); ++i)
     {
       const auto& num = specific_nums[i];
       if (num >= total_nodes) {
         cerr << "\"--" << num_selector << "\" provided value= " << num << " is higher than \"--nodes\" provided value=" << total_nodes << endl;
         exit (-1);
       }
       selector_map[num] = specific_args[i];
     }
   }
}

Here is the caller graph for this function:

ssh_helper()

schedule config_dir_name data_dir_name p2p_port http_port file_size name name keys peers name ssh_helper

(

nodes

)

sysio_home()

schedule config_dir_name data_dir_name p2p_port http_port file_size name name keys peers name ipaddr name has_bios sysio_home

(

instances

)

write_default_config()

void write_default_config	(	const bfs::path &	cfg_file,
		const options_description &	cfg )

Definition at line 1941 of file main.cpp.

                                                                                    {
   bfs::path parent = cfg_file.parent_path();
   if (parent.empty()) {
      parent = ".";
   }
   if(!bfs::exists(parent)) {
      try {
         bfs::create_directories(parent);
      } catch (bfs::filesystem_error &ex) {
         cerr << "could not create new directory: " << cfg_file.parent_path()
              << " caught " << ex.what() << endl;
         exit (-1);
      }
   }
 
   std::ofstream out_cfg( bfs::path(cfg_file).make_preferred().string());
   for(const boost::shared_ptr<bpo::option_description>& od : cfg.options())
   {
      if(!od->description().empty()) {
         out_cfg << "# " << od->description() << std::endl;
      }
      boost::any store;
      if(!od->semantic()->apply_default(store))
         out_cfg << "# " << od->long_name() << " = " << std::endl;
      else {
         auto example = od->format_parameter();
         if(example.empty())
            // This is a boolean switch
            out_cfg << od->long_name() << " = " << "false" << std::endl;
         else {
            // The string is formatted "arg (=<interesting part>)"
            example.erase(0, 6);
            example.erase(example.length()-1);
            out_cfg << od->long_name() << " = " << example << std::endl;
         }
      }
      out_cfg << std::endl;
   }
   out_cfg.close();
}

Here is the caller graph for this function:

Variable Documentation

block_dir

const string block_dir = "blocks"

Definition at line 48 of file main.cpp.

local_id

struct local_identity local_id

shared_mem_dir

const string shared_mem_dir = "state"

Definition at line 49 of file main.cpp.