launcher_def Struct Reference

Collaboration diagram for launcher_def:

Public Member Functions
void	assign_name (eosd_def &node, bool is_bios)
void	set_options (bpo::options_description &cli)
void	initialize (const variables_map &vmap)
void	init_genesis ()
void	load_servers ()
bool	generate ()
void	define_network ()
void	bind_nodes ()
host_def *	find_host (const string &name)
host_def *	find_host_by_name_or_address (const string &name)
host_def *	deploy_config_files (tn_node_def &node)
string	compose_scp_command (const host_def &host, const bfs::path &source, const bfs::path &destination)
void	write_config_file (tn_node_def &node)
void	write_logging_config_file (tn_node_def &node)
void	write_genesis_file (tn_node_def &node)
void	write_setprods_file ()
void	write_bios_boot ()
bool	is_bios_ndx (size_t ndx)
size_t	start_ndx ()
bool	next_ndx (size_t &ndx)
size_t	skip_ndx (size_t from, size_t offset)
void	make_line (bool make_ring=true)
void	make_star ()
void	make_mesh ()
void	make_custom ()
void	write_dot_file ()
void	format_ssh (const string &cmd, const string &host_name, string &ssh_cmd_line)
void	do_command (const host_def &host, const string &name, vector< pair< string, string > > env_pairs, const string &cmd)
bool	do_ssh (const string &cmd, const string &host_name)
void	prep_remote_config_dir (eosd_def &node, host_def *host)
void	launch (eosd_def &node, string &gts)
void	kill (launch_modes mode, string sig_opt)
pair< host_def, eosd_def >	find_node (uint16_t node_num)
vector< pair< host_def, eosd_def > >	get_nodes (const string &node_number_list)
void	bounce (const string &node_numbers)
void	down (const string &node_numbers)
void	roll (const string &host_names)
void	start_all (string &gts, launch_modes mode)
void	ignite ()
string	find_and_remove_arg (string str, string substr)

Static Public Member Functions
static string	get_node_num (uint16_t node_num)

Public Attributes
bool	force_overwrite
size_t	total_nodes
size_t	unstarted_nodes
size_t	prod_nodes
size_t	producers
size_t	shared_producers
size_t	next_node
string	shape
allowed_connection	allowed_connections = PC_NONE
bfs::path	genesis
bfs::path	output
bfs::path	host_map_file
bfs::path	server_ident_file
bfs::path	stage
string	erd
bfs::path	config_dir_base
bfs::path	data_dir_base
bool	skip_transaction_signatures = false
string	eosd_extra_args
std::map< uint, string >	specific_nodeop_args
std::map< uint, string >	specific_nodeop_installation_paths
testnet_def	network
string	gelf_endpoint
vector< string >	aliases
vector< host_def >	bindings
int	per_host = 0
last_run_def	last_run
int	start_delay = 0
bool	gelf_enabled
bool	nogen
bool	boot
bool	add_enable_stale_production = false
string	launch_name
string	launch_time
server_identities	servers
producer_set_def	producer_set
string	start_temp
string	start_script
std::optional< uint32_t >	max_block_cpu_usage
std::optional< uint32_t >	max_transaction_cpu_usage
sysio::chain::genesis_state	genesis_from_file

Detailed Description

Definition at line 385 of file main.cpp.

Member Function Documentation

assign_name()

void launcher_def::assign_name	(	eosd_def &	node,
		bool	is_bios )

Definition at line 699 of file main.cpp.

                                                       {
   string node_cfg_name;
 
   if (is_bios) {
      node.name = "bios";
      node_cfg_name = "node_bios";
   }
   else {
      string dex = next_node < 10 ? "0":"";
      dex += boost::lexical_cast<string,int>(next_node++);
      node.name = network.name + dex;
      node_cfg_name = "node_" + dex;
   }
  node.config_dir_name = (config_dir_base / node_cfg_name).string();
  node.data_dir_name = (data_dir_base / node_cfg_name).string();
}

Here is the caller graph for this function:

bind_nodes()

void launcher_def::bind_nodes

(

)

Definition at line 861 of file main.cpp.

                          {
   if (prod_nodes < 2) {
      cerr << "Unable to allocate producers due to insufficient prod_nodes = " << prod_nodes << "\n";
      exit (10);
   }
   size_t non_bios = prod_nodes - 1;
   int per_node = producers / non_bios;
   int extra = producers % non_bios;
   unsigned int i = 0;
   unsigned int producer_number = 0;
   const auto to_not_start_node = total_nodes - unstarted_nodes - 1;
   for (auto &h : bindings) {
      for (auto &inst : h.instances) {
         bool is_bios = inst.name == "bios";
         tn_node_def node;
         node.name = inst.name;
         node.instance = &inst;
         auto kp = is_bios ?
            private_key_type(string("5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3")) :
            private_key_type::generate();
         auto pubkey = kp.get_public_key();
         node.keys.emplace_back (move(kp));
         if (is_bios) {
            string prodname = "sysio";
            node.producers.push_back(prodname);
            producer_set.schedule.push_back({prodname,pubkey});
         }
        else {
           if (i < non_bios) {
              int count = per_node;
              if (extra ) {
                 ++count;
                 --extra;
              }
              while (count--) {
                 const auto prodname = producer_names::producer_name(producer_number);
                 node.producers.push_back(prodname);
                 producer_set.schedule.push_back({prodname,pubkey});
                 ++producer_number;
              }
              for (unsigned j = 0; j < shared_producers; ++j) {
                 const auto prodname = producer_names::producer_name(j, true);
                 node.producers.push_back(prodname);
                 producer_set.schedule.push_back({prodname,pubkey});                 
              }
           }
           node.dont_start = i >= to_not_start_node;
        }
        node.gelf_endpoint = gelf_endpoint;
        network.nodes[node.name] = move(node);
        inst.node = &network.nodes[inst.name];
        if (!is_bios) i++;
      }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bounce()

void launcher_def::bounce

(

const string &

node_numbers

)

Definition at line 1815 of file main.cpp.

                                                {
   auto node_list = get_nodes(node_numbers);
   for (auto node_pair: node_list) {
      const host_def& host = node_pair.first;
      const eosd_def& node = node_pair.second;
      const string node_num = node.get_node_num();
      cout << "Bouncing " << node.name << endl;
      string cmd = "./scripts/sysio-tn_bounce.sh " + eosd_extra_args;
      if (node_num != "bios" && !specific_nodeop_args.empty()) {
         const auto node_num_i = boost::lexical_cast<uint16_t,string>(node_num);
         if (specific_nodeop_args.count(node_num_i)) {
            cmd += " " + specific_nodeop_args[node_num_i];
         }
      }
 
      do_command(host, node.name, { { "SYSIO_HOME", host.sysio_home }, { "SYSIO_NODE", node_num } }, cmd);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

compose_scp_command()

string launcher_def::compose_scp_command	(	const host_def &	host,
		const bfs::path &	source,
		const bfs::path &	destination )

Definition at line 1045 of file main.cpp.

                                                                                                          {
  string scp_cmd_line = network.ssh_helper.scp_cmd + " ";
  const string &args = host.ssh_args.length() ? host.ssh_args : network.ssh_helper.ssh_args;
  if (args.length()) {
    scp_cmd_line += args + " ";
  }
  scp_cmd_line += source.string() + " ";
 
  const string &uid = host.ssh_identity.length() ? host.ssh_identity : network.ssh_helper.ssh_identity;
  if (uid.length()) {
    scp_cmd_line += uid + "@";
  }
 
  scp_cmd_line += host.host_name + ":" + destination.string();
 
  return scp_cmd_line;
}

Here is the caller graph for this function:

define_network()

void launcher_def::define_network

(

)

Definition at line 789 of file main.cpp.

                              {
 
  if (per_host == 0) {
    host_def local_host;
    local_host.sysio_home = erd;
    local_host.genesis = genesis.string();
    for (size_t i = 0; i < (total_nodes); i++) {
      eosd_def eosd;
      assign_name(eosd, i == 0);
      aliases.push_back(eosd.name);
      eosd.set_host (&local_host, i == 0);
      local_host.instances.emplace_back(move(eosd));
    }
    bindings.emplace_back(move(local_host));
  }
  else {
    int ph_count = 0;
    host_def *lhost = nullptr;
    size_t host_ndx = 0;
    size_t num_prod_addr = servers.producer.size();
    size_t num_nonprod_addr = servers.nonprod.size();
    for (size_t i = total_nodes; i > 0; i--) {
       bool do_bios = false;
      if (ph_count == 0) {
        if (lhost) {
          bindings.emplace_back(move(*lhost));
          delete lhost;
        }
        lhost = new host_def;
        lhost->genesis = genesis.string();
        if (host_ndx < num_prod_addr ) {
           do_bios = servers.producer[host_ndx].has_bios;
          lhost->host_name = servers.producer[host_ndx].ipaddr;
          lhost->public_name = servers.producer[host_ndx].name;
          ph_count = servers.producer[host_ndx].instances;
        }
        else if (host_ndx - num_prod_addr < num_nonprod_addr) {
          size_t ondx = host_ndx - num_prod_addr;
           do_bios = servers.nonprod[ondx].has_bios;
          lhost->host_name = servers.nonprod[ondx].ipaddr;
          lhost->public_name = servers.nonprod[ondx].name;
          ph_count = servers.nonprod[ondx].instances;
        }
        else {
          string ext = host_ndx < 10 ? "0" : "";
          ext += boost::lexical_cast<string,int>(host_ndx);
          lhost->host_name = "pseudo_" + ext;
          lhost->public_name = lhost->host_name;
          ph_count = 1;
        }
        lhost->sysio_home =
          (local_id.contains (lhost->host_name) || servers.default_sysio_home.empty()) ?
          erd : servers.default_sysio_home;
        host_ndx++;
      } // ph_count == 0
 
      eosd_def eosd;
      assign_name(eosd, do_bios);
 
      aliases.push_back(eosd.name);
      eosd.set_host (lhost, do_bios);
      do_bios = false;
      lhost->instances.emplace_back(move(eosd));
      --ph_count;
    } // for i
    bindings.emplace_back( move(*lhost) );
    delete lhost;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

deploy_config_files()

host_def * launcher_def::deploy_config_files

(

tn_node_def &

node

)

Definition at line 952 of file main.cpp.

                                                    {
  boost::system::error_code ec;
  eosd_def &instance = *node.instance;
  host_def *host = find_host (instance.host);
 
  bfs::path source = stage / instance.config_dir_name / "config.ini";
  bfs::path logging_source = stage / instance.config_dir_name / "logging.json";
  bfs::path genesis_source = stage / instance.config_dir_name / "genesis.json";
 
  if (host->is_local()) {
    bfs::path cfgdir = bfs::path(host->sysio_home) / instance.config_dir_name;
    bfs::path dd = bfs::path(host->sysio_home) / instance.data_dir_name;
 
    if (!bfs::exists (cfgdir)) {
       if (!bfs::create_directories (cfgdir, ec) && ec.value()) {
          cerr << "could not create new directory: " << instance.config_dir_name
               << " errno " << ec.value() << " " << strerror(ec.value()) << endl;
          exit (-1);
       }
    }
    else if (bfs::exists (cfgdir / "config.ini") && !force_overwrite) {
       cerr << cfgdir / "config.ini" << " exists. Use -f|--force to overwrite configuration\n";
       exit (-1);
    }
 
    if (!bfs::exists (dd)) {
       if (!bfs::create_directories (dd, ec) && ec.value()) {
          cerr << "could not create new directory: " << instance.config_dir_name
               << " errno " << ec.value() << " " << strerror(ec.value()) << endl;
          exit (-1);
       }
    }
    else if (force_overwrite) {
       int64_t count =  bfs::remove_all (dd / block_dir, ec);
       if (ec.value() != 0) {
          cerr << "count = " << count << " could not remove old directory: " << dd
               << " " << strerror(ec.value()) << endl;
          exit (-1);
        }
        count = bfs::remove_all (dd / shared_mem_dir, ec);
        if (ec.value() != 0) {
          cerr << "count = " << count << " could not remove old directory: " << dd
               << " " << strerror(ec.value()) << endl;
          exit (-1);
        }
    }
    else if (bfs::exists (dd/ block_dir) || bfs::exists (dd / shared_mem_dir)) {
       cerr << "either " << block_dir << " or " << shared_mem_dir << " exist in \n";
       cerr << dd << ". Use -f|--force to erase blockchain data" << endl;
        exit (-1);
    }
 
    bfs::copy_file (genesis_source, cfgdir / "genesis.json", bfs::copy_option::overwrite_if_exists);
    bfs::copy_file (logging_source, cfgdir / "logging.json", bfs::copy_option::overwrite_if_exists);
    bfs::copy_file (source, cfgdir / "config.ini", bfs::copy_option::overwrite_if_exists);
  }
  else {
    prep_remote_config_dir (instance, host);
 
    bfs::path rfile = bfs::path (host->sysio_home) / instance.config_dir_name / "config.ini";
    auto scp_cmd_line = compose_scp_command(*host, source, rfile);
 
    cerr << "cmdline = " << scp_cmd_line << endl;
    int res = boost::process::system (scp_cmd_line);
    if (res != 0) {
      cerr << "unable to scp config file to host " << host->host_name << endl;
      exit(-1);
    }
 
    rfile = bfs::path (host->sysio_home) / instance.config_dir_name / "logging.json";
 
    scp_cmd_line = compose_scp_command(*host, logging_source, rfile);
 
    res = boost::process::system (scp_cmd_line);
    if (res != 0) {
      cerr << "unable to scp logging config file to host " << host->host_name << endl;
      exit(-1);
    }
 
    rfile = bfs::path (host->sysio_home) / instance.config_dir_name / "genesis.json";
 
    scp_cmd_line = compose_scp_command(*host, genesis_source, rfile);
 
    res = boost::process::system (scp_cmd_line);
    if (res != 0) {
       cerr << "unable to scp genesis.json file to host " << host->host_name << endl;
       exit(-1);
    }
  }
  return host;
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_command()

void launcher_def::do_command	(	const host_def &	host,
		const string &	name,
		vector< pair< string, string > >	env_pairs,
		const string &	cmd )

Definition at line 1791 of file main.cpp.

                                                                                    {
   if (!host.is_local()) {
      string rcmd = "cd " + host.sysio_home + "; ";
      for (auto& env_pair : env_pairs) {
         rcmd += "export " + env_pair.first + "=" + env_pair.second + "; ";
      }
      rcmd += cmd;
      if (!do_ssh(rcmd, host.host_name)) {
         cerr << "Remote command failed for " << name << endl;
         exit (-1);
      }
   }
   else {
      bp::environment e;
      for (auto& env_pair : env_pairs) {
         e.emplace(env_pair.first, env_pair.second);
      }
      bp::child c(cmd, e);
      c.wait();
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_ssh()

bool launcher_def::do_ssh	(	const string &	cmd,
		const string &	host_name )

Definition at line 1488 of file main.cpp.

                                                                {
  string ssh_cmd_line;
  format_ssh (cmd, host_name, ssh_cmd_line);
  int res = boost::process::system (ssh_cmd_line);
  return (res == 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

down()

void launcher_def::down

(

const string &

node_numbers

)

Definition at line 1835 of file main.cpp.

                                              {
   auto node_list = get_nodes(node_numbers);
   for (auto node_pair: node_list) {
      const host_def& host = node_pair.first;
      const eosd_def& node = node_pair.second;
      const string node_num = node.get_node_num();
      cout << "Taking down " << node.name << endl;
      string cmd = "./scripts/sysio-tn_down.sh ";
      do_command(host, node.name,
                 { { "SYSIO_HOME", host.sysio_home }, { "SYSIO_NODE", node_num }, { "SYSIO_TN_RESTART_CONFIG_DIR", node.config_dir_name } },
                 cmd);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

find_and_remove_arg()

string launcher_def::find_and_remove_arg	(	string	str,
		string	substr )

Definition at line 1546 of file main.cpp.

                                                         {
   if (args.empty() || arg.empty())
      return args;
 
   string left, middle, right;
   size_t found = args.find(arg);
   if (found != std::string::npos){
      left = args.substr(0, found);
      middle = args.substr(found + 2); //skip --
      found = middle.find("--");
      if (found != std::string::npos){
         right = middle.substr(found);
      }
      return left + right;
   } else {
      return args;
   }
}

Here is the caller graph for this function:

find_host()

host_def * launcher_def::find_host

(

const string &

name

)

Definition at line 918 of file main.cpp.

{
  host_def *host = nullptr;
  for (auto &h : bindings) {
    if (h.host_name == name) {
      host = &h;
      break;
    }
  }
  if (host == 0) {
    cerr << "could not find host for " << name << endl;
    exit(-1);
  }
  return host;
}

Here is the call graph for this function:

Here is the caller graph for this function:

find_host_by_name_or_address()

host_def * launcher_def::find_host_by_name_or_address

(

const string &

name

)

Definition at line 935 of file main.cpp.

{
  host_def *host = nullptr;
  for (auto &h : bindings) {
    if ((h.host_name == host_id) || (h.public_name == host_id)) {
      host = &h;
      break;
    }
  }
  if (host == 0) {
    cerr << "could not find host for " << host_id << endl;
    exit(-1);
  }
  return host;
}

Here is the call graph for this function:

Here is the caller graph for this function:

find_node()

pair< host_def, eosd_def > launcher_def::find_node

(

uint16_t

node_num

)

Definition at line 1745 of file main.cpp.

                                         {
   const string node_name = network.name + get_node_num(node_num);
   for (const auto& host: bindings) {
      for (const auto& node: host.instances) {
         if (node_name == node.name) {
            return make_pair(host, node);
         }
      }
   }
   cerr << "Unable to find node " << node_num << endl;
   exit (-1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

format_ssh()

void launcher_def::format_ssh	(	const string &	cmd,
		const string &	host_name,
		string &	ssh_cmd_line )

Definition at line 1472 of file main.cpp.

                                                 {
 
  ssh_cmd_line = network.ssh_helper.ssh_cmd + " ";
  if (network.ssh_helper.ssh_args.length()) {
    ssh_cmd_line += network.ssh_helper.ssh_args + " ";
  }
  if (network.ssh_helper.ssh_identity.length()) {
    ssh_cmd_line += network.ssh_helper.ssh_identity + "@";
  }
  ssh_cmd_line += host_name + " \"" + cmd + "\"";
  cerr << "cmdline = " << ssh_cmd_line << endl;
}

Here is the caller graph for this function:

generate()

bool launcher_def::generate

(

)

Definition at line 717 of file main.cpp.

                        {
 
  if (boost::iequals (shape,"ring")) {
    make_line ();
  }
  else if (boost::iequals (shape,"line")) {
    make_line(false);
  }
  else if (boost::iequals (shape, "star")) {
    make_star ();
  }
  else if (boost::iequals (shape, "mesh")) {
    make_mesh ();
  }
  else {
    make_custom ();
  }
 
  if( !nogen ) {
     write_setprods_file();
     write_bios_boot();
     init_genesis();
     for (auto &node : network.nodes) {
        write_config_file(node.second);
        write_logging_config_file(node.second);
        write_genesis_file(node.second);
     }
  }
  write_dot_file ();
 
  if (!output.empty()) {
    bfs::path savefile = output;
    {
      bfs::ofstream sf (savefile);
      sf << fc::json::to_pretty_string (network) << endl;
      sf.close();
    }
    if (host_map_file.empty()) {
      savefile = bfs::path (output.stem().string() + "_hosts.json");
    }
    else {
      savefile = bfs::path (host_map_file);
    }
 
    {
      bfs::ofstream sf (savefile);
 
      sf << fc::json::to_pretty_string (bindings) << endl;
      sf.close();
    }
     return false;
  }
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_node_num()

string launcher_def::get_node_num ( uint16_t node_num )

static

Definition at line 1738 of file main.cpp.

                                            {
   string node_num_str = node_num < 10 ? "0":"";
   node_num_str += boost::lexical_cast<string,uint16_t>(node_num);
   return node_num_str;
}

Here is the caller graph for this function:

get_nodes()

vector< pair< host_def, eosd_def > > launcher_def::get_nodes

(

const string &

node_number_list

)

Definition at line 1759 of file main.cpp.

                                                      {
   vector<pair<host_def, eosd_def>> node_list;
   if (fc::to_lower(node_number_list) == "all") {
      for (auto host: bindings) {
         for (auto node: host.instances) {
            cout << "host=" << host.host_name << ", node=" << node.name << endl;
            node_list.push_back(make_pair(host, node));
         }
      }
   }
   else {
      vector<string> nodes;
      boost::split(nodes, node_number_list, boost::is_any_of(","));
      for (string node_number: nodes) {
         uint16_t node = -1;
         try {
            node = boost::lexical_cast<uint16_t,string>(node_number);
         }
         catch(boost::bad_lexical_cast &) {
            // This exception will be handled below
         }
         if (node < 0 || node > 99) {
            cerr << "Bad node number found in node number list: " << node_number << endl;
            exit(-1);
         }
         node_list.push_back(find_node(node));
      }
   }
   return node_list;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ignite()

void launcher_def::ignite

(

)

Definition at line 1862 of file main.cpp.

                     {
   if (boot) {
      cerr << "Invoking the blockchain boot script, " << start_script << "\n";
      string script("bash " + start_script);
      bp::child c(script);
      try {
         cerr << "waiting for script completion\n";
         c.wait();
      } catch (bfs::filesystem_error &ex) {
         cerr << "wait threw error " << ex.what() << "\n";
      }
      catch (...) {
         // when script dies wait throws an exception but that is ok
      }
   } else {
      cerr << "**********************************************************************\n"
           << "run 'bash " << start_script << "' to kick off delegated block production\n"
           << "**********************************************************************\n";
   }
 
 }

Here is the caller graph for this function:

init_genesis()

void launcher_def::init_genesis

(

)

Definition at line 1222 of file main.cpp.

                            {
   const bfs::path genesis_path = genesis.is_complete() ? genesis : bfs::current_path() / genesis;
   if (!bfs::exists(genesis_path)) {
      cout << "generating default genesis file " << genesis_path << endl;
      sysio::chain::genesis_state default_genesis;
      fc::json::save_to_file( default_genesis, genesis_path, true );
   }
   string bioskey = network.nodes["bios"].keys[0].get_public_key().to_string();
 
   fc::json::from_file(genesis_path).as<sysio::chain::genesis_state>(genesis_from_file);
   genesis_from_file.initial_key = public_key_type(bioskey);
   if (max_block_cpu_usage)
      genesis_from_file.initial_configuration.max_block_cpu_usage = *max_block_cpu_usage;
   if (max_transaction_cpu_usage)
      genesis_from_file.initial_configuration.max_transaction_cpu_usage = *max_transaction_cpu_usage;
}

Here is the call graph for this function:

Here is the caller graph for this function:

initialize()

void launcher_def::initialize

(

const variables_map &

vmap

)

Definition at line 540 of file main.cpp.

                                                   {
  if (vmap.count("mode")) {
    const vector<string> modes = vmap["mode"].as<vector<string>>();
    for(const string&m : modes)
    {
      if (boost::iequals(m, "any"))
        allowed_connections |= PC_ANY;
      else if (boost::iequals(m, "producers"))
        allowed_connections |= PC_PRODUCERS;
      else if (boost::iequals(m, "specified"))
        allowed_connections |= PC_SPECIFIED;
      else if (boost::iequals(m, "none"))
        allowed_connections = PC_NONE;
      else {
        cerr << "unrecognized connection mode: " << m << endl;
        exit (-1);
      }
    }
  }
 
  if (vmap.count("max-block-cpu-usage")) {
     max_block_cpu_usage = vmap["max-block-cpu-usage"].as<uint32_t>();
  }
 
  if (vmap.count("max-transaction-cpu-usage")) {
     max_transaction_cpu_usage = vmap["max-transaction-cpu-usage"].as<uint32_t>();
  }
 
  genesis = vmap["genesis"].as<string>();
  if (vmap.count("host-map")) {
     host_map_file = vmap["host-map"].as<string>();
  }
  if (vmap.count("servers")) {
     server_ident_file = vmap["servers"].as<string>();
  }
 
  retrieve_paired_array_parameters(vmap, "specific-num", "specific-" + string(node_executable_name), specific_nodeop_args);
  retrieve_paired_array_parameters(vmap, "spcfc-inst-num", "spcfc-inst-" + string(node_executable_name), specific_nodeop_installation_paths);
 
  using namespace std::chrono;
  system_clock::time_point now = system_clock::now();
  std::time_t now_c = system_clock::to_time_t(now);
  ostringstream dstrm;
  dstrm << std::put_time(std::localtime(&now_c), "%Y_%m_%d_%H_%M_%S");
  launch_time = dstrm.str();
 
  if ( ! (shape.empty() ||
          boost::iequals( shape, "ring" ) ||
          boost::iequals( shape, "line" ) ||
          boost::iequals( shape, "star" ) ||
          boost::iequals( shape, "mesh" )) &&
       host_map_file.empty()) {
    bfs::path src = shape;
    host_map_file = src.stem().string() + "_hosts.json";
  }
 
  if( !host_map_file.empty() ) {
    try {
      fc::json::from_file(host_map_file).as<vector<host_def>>(bindings);
      for (auto &binding : bindings) {
        for (auto &eosd : binding.instances) {
          eosd.host = binding.host_name;
          eosd.p2p_endpoint = binding.public_name + ":" + boost::lexical_cast<string,uint16_t>(eosd.p2p_port);
 
          aliases.push_back (eosd.name);
        }
      }
    } catch (...) { // this is an optional feature, so an exception is OK
    }
  }
 
  config_dir_base = "etc/sysio";
  data_dir_base = "var/lib";
  next_node = 0;
  ++prod_nodes; // add one for the bios node
  ++total_nodes;
 
  load_servers ();
 
  if (prod_nodes > (producers + 1))
    prod_nodes = producers;
  if (prod_nodes > total_nodes)
    total_nodes = prod_nodes + unstarted_nodes;
  else if (total_nodes < prod_nodes + unstarted_nodes) {
    cerr << "ERROR: if provided, \"--nodes\" must be equal or greater than the number of nodes indicated by \"--pnodes\" and \"--unstarted-nodes\"." << endl;
    exit (-1);
  }
 
  if (vmap.count("specific-num")) {
    const auto specific_nums = vmap["specific-num"].as<vector<uint>>();
    const auto specific_args = vmap["specific-" + string(node_executable_name)].as<vector<string>>();
    if (specific_nums.size() != specific_args.size()) {
      cerr << "ERROR: every specific-num argument must be paired with a specific-" << node_executable_name << " argument" << endl;
      exit (-1);
    }
    // don't include bios
    const auto allowed_nums = total_nodes - 1;
    for(uint i = 0; i < specific_nums.size(); ++i)
    {
      const auto& num = specific_nums[i];
      if (num >= allowed_nums) {
        cerr << "\"--specific-num\" provided value= " << num << " is higher than \"--nodes\" provided value=" << total_nodes << endl;
        exit (-1);
      }
      specific_nodeop_args[num] = specific_args[i];
    }
  }
 
  char* erd_env_var = getenv ("SYSIO_HOME");
  if (erd_env_var == nullptr || std::string(erd_env_var).empty()) {
     erd_env_var = getenv ("PWD");
  }
 
  if (erd_env_var != nullptr) {
     erd = erd_env_var;
  } else {
     erd.clear();
  }
 
  stage = bfs::path(erd);
  if (!bfs::exists(stage)) {
    cerr << "\"" << erd << "\" is not a valid path. Please ensure environment variable SYSIO_HOME is set to the build path." << endl;
    exit (-1);
  }
  stage /= bfs::path("staging");
  bfs::create_directories (stage);
  if (bindings.empty()) {
    define_network ();
  }
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_bios_ndx()

bool launcher_def::is_bios_ndx

(

size_t

ndx

)

Definition at line 1318 of file main.cpp.

                                          {
   return aliases[ndx] == "bios";
}

Here is the caller graph for this function:

kill()

void launcher_def::kill	(	launch_modes	mode,
		string	sig_opt )

Definition at line 1684 of file main.cpp.

                                                     {
  switch (mode) {
  case LM_NONE:
    return;
  case LM_VERIFY:
    // no-op
    return;
  case LM_NAMED: {
    cerr << "feature not yet implemented " << endl;
    #if 0
      auto node = network.nodes.find(launch_name);
      kill_instance (node.second.instance, sig_opt);
      #endif
    break;
  }
  case LM_ALL:
  case LM_LOCAL:
  case LM_REMOTE : {
    bfs::path source = "last_run.json";
    try {
       fc::json::from_file( source ).as<last_run_def>( last_run );
       for( auto& info : last_run.running_nodes ) {
          if( mode == LM_ALL || (info.remote && mode == LM_REMOTE) ||
              (!info.remote && mode == LM_LOCAL) ) {
             try {
                if( info.pid_file.length() ) {
                   string pid;
                   fc::json::from_file( info.pid_file ).as<string>( pid );
                   string kill_cmd = "kill " + sig_opt + " " + pid;
                   boost::process::system( kill_cmd );
                } else {
                   boost::process::system( info.kill_cmd );
                }
             } catch( fc::exception& fce ) {
                cerr << "unable to kill fc::exception=" << fce.to_detail_string() << endl;
             } catch( std::exception& stde ) {
                cerr << "unable to kill std::exception=" << stde.what() << endl;
             } catch( ... ) {
                cerr << "Unable to kill" << endl;
             }
          }
       }
    } catch( fc::exception& fce ) {
       cerr << "unable to open " << source << " fc::exception=" << fce.to_detail_string() << endl;
    } catch( std::exception& stde ) {
       cerr << "unable to open " << source << " std::exception=" << stde.what() << endl;
    } catch( ... ) {
       cerr << "Unable to open " << source << endl;
    }
  }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

launch()

void launcher_def::launch	(	eosd_def &	node,
		string &	gts )

Definition at line 1566 of file main.cpp.

                                                     {
  bfs::path dd = instance.data_dir_name;
  bfs::path reout = dd / "stdout.txt";
  bfs::path reerr_sl = dd / "stderr.txt";
  bfs::path reerr_base = bfs::path("stderr." + launch_time + ".txt");
  bfs::path reerr = dd / reerr_base;
  bfs::path pidf  = dd / bfs::path(string(node_executable_name) + ".pid");
  host_def* host;
  try {
     host = deploy_config_files (*instance.node);
  } catch (const bfs::filesystem_error &ex) {
     cerr << "deploy_config_files threw " << ex.what() << endl;
     exit (-1);
  }
 
  node_rt_info info;
  info.remote = !host->is_local();
 
  string install_path;
  if (instance.name != "bios" && !specific_nodeop_installation_paths.empty()) {
     const auto node_num = boost::lexical_cast<uint16_t,string>(instance.get_node_num());
     if (specific_nodeop_installation_paths.count(node_num)) {
        install_path = specific_nodeop_installation_paths[node_num] + "/";
     }
  }
  string eosdcmd = install_path + "programs/nodeop/" + string(node_executable_name) + " ";
  if (skip_transaction_signatures) {
    eosdcmd += "--skip-transaction-signatures ";
  }
  if (!eosd_extra_args.empty()) {
    eosdcmd += eosd_extra_args + " ";
  }
  if (instance.name != "bios" && !specific_nodeop_args.empty()) {
     const auto node_num = boost::lexical_cast<uint16_t,string>(instance.get_node_num());
     if (specific_nodeop_args.count(node_num)) {
        eosdcmd += specific_nodeop_args[node_num] + " ";
     }
  }
 
  if( add_enable_stale_production ) {
    eosdcmd += "--enable-stale-production true ";
    add_enable_stale_production = false;
  }
 
  eosdcmd += " --config-dir " + instance.config_dir_name + " --data-dir " + instance.data_dir_name;
  eosdcmd += " --genesis-json " + instance.config_dir_name + "/genesis.json";
  if (gts.length()) {
    eosdcmd += " --genesis-timestamp " + gts;
  }
 
  if (eosdcmd.find("sysio::history_api_plugin") != string::npos && eosdcmd.find("sysio::trace_api_plugin") != string::npos){
    // remove trace_api_plugin from old version nodes in multiversion test
    eosdcmd = find_and_remove_arg(eosdcmd, "--plugin sysio::trace_api_plugin");
    eosdcmd = find_and_remove_arg(eosdcmd, "--trace-no-abis");
    eosdcmd = find_and_remove_arg(eosdcmd, "--trace-rpc-abi");
  }
 
  if (!host->is_local()) {
    if (instance.node->dont_start) {
      cerr << "Unable to use \"unstarted-nodes\" with a remote hose" << endl;
      exit (-1);
    }
    string cmdl ("cd ");
    cmdl += host->sysio_home + "; nohup " + eosdcmd + " > "
      + reout.string() + " 2> " + reerr.string() + "& echo $! > " + pidf.string()
      + "; rm -f " + reerr_sl.string()
      + "; ln -s " + reerr_base.string() + " " + reerr_sl.string();
    if (!do_ssh (cmdl, host->host_name)){
      cerr << "Unable to invoke " << cmdl
           << " on host " << host->host_name << endl;
      exit (-1);
    }
 
    string cmd = "cd " + host->sysio_home + "; kill -15 $(cat " + pidf.string() + ")";
    format_ssh (cmd, host->host_name, info.kill_cmd);
  }
  else if (!instance.node->dont_start) {
    cerr << "spawning child, " << eosdcmd << endl;
 
    bp::child c(eosdcmd, bp::std_out > reout, bp::std_err > reerr );
    bfs::remove(reerr_sl);
    bfs::create_symlink (reerr_base, reerr_sl);
 
    bfs::ofstream pidout (pidf);
    pidout << c.id() << flush;
    pidout.close();
 
    info.pid_file = pidf.string();
    info.kill_cmd = "";
 
    if(!c.running()) {
      cerr << "child not running after spawn " << eosdcmd << endl;
      for (int i = 0; i > 0; i++) {
        if (c.running () ) break;
      }
    }
    c.detach();
  }
  else {
    cerr << "not spawning child, " << eosdcmd << endl;
 
    const bfs::path dd = instance.data_dir_name;
    const bfs::path start_file  = dd / "start.cmd";
    bfs::ofstream sf (start_file);
 
    sf << eosdcmd << endl;
    sf.close();
  }
  last_run.running_nodes.emplace_back (move(info));
}

Here is the call graph for this function:

Here is the caller graph for this function:

load_servers()

void launcher_def::load_servers

(

)

Definition at line 673 of file main.cpp.

                            {
  if (!server_ident_file.empty()) {
    try {
      fc::json::from_file(server_ident_file).as<server_identities>(servers);
      prod_nodes = 0;
      for (auto &s : servers.producer) {
         prod_nodes += s.instances;
      }
 
      total_nodes = prod_nodes;
      for (auto &s : servers.nonprod) {
         total_nodes += s.instances;
      }
 
      per_host = 1;
      network.ssh_helper = servers.ssh;
    }
    catch (...) {
      cerr << "unable to load server identity file " << server_ident_file << endl;
      exit (-1);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

make_custom()

void launcher_def::make_custom

(

)

Definition at line 1456 of file main.cpp.

                           {
  bfs::path source = shape;
  fc::json::from_file(source).as<testnet_def>(network);
  for (auto &h : bindings) {
    for (auto &inst : h.instances) {
      tn_node_def *node = &network.nodes[inst.name];
      for (auto &p : node->producers) {
         producer_set.schedule.push_back({p,node->keys[0].get_public_key()});
      }
      node->instance = &inst;
      inst.node = node;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

make_line()

void launcher_def::make_line

(

bool

make_ring = true

)

Definition at line 1350 of file main.cpp.

                                       {
  bind_nodes();
  size_t non_bios = total_nodes - 1;
  if (non_bios > 2) {
     // since we have at least 3 indexes, every next_ndx(i) call is guaranteed to not be the end of the loop
     bool end_of_loop = false;
     for (size_t i = start_ndx(); !end_of_loop; next_ndx(i)) {
        size_t front = i;
        end_of_loop = next_ndx (front);
        // if this is the end of the loop and this is not a ring, then don't connect the end to the beginning to make a ring
        if (end_of_loop && !make_ring) {
           break;
        }
        network.nodes.find(aliases[i])->second.peers.push_back (aliases[front]);
     }
  }
  else if (non_bios == 2) {
     size_t n0 = start_ndx();
     size_t n1 = n0;
     next_ndx(n1);
     network.nodes.find(aliases[n0])->second.peers.push_back (aliases[n1]);
     if (make_ring) {
        network.nodes.find(aliases[n1])->second.peers.push_back (aliases[n0]);
     }
     // since there are only 2 nodes, this really just affects startup and that only index 0 will initiate the connection if !make_ring
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

make_mesh()

void launcher_def::make_mesh

(

)

Definition at line 1431 of file main.cpp.

                         {
  size_t non_bios = total_nodes - 1;
  bind_nodes();
  // use to prevent duplicates since all connections are bidirectional
  std::map <string, std::set<string>> peers_to_from;
  bool loop = false;
  for (size_t i = start_ndx();!loop; loop = next_ndx(i)) {
    const auto& iter = network.nodes.find(aliases[i]);
    auto &current = iter->second;
    const auto& current_name = iter->first;
 
    for (size_t j = 1; j < non_bios; j++) {
       size_t ndx = skip_ndx(i,j);
      const auto& peer = aliases[ndx];
      // if already established, don't add to list
      if (peers_to_from[peer].count(current_name) < 2) {
        current.peers.push_back (peer);
        // keep track of bidirectional relationships to prevent duplicates
        peers_to_from[current_name].insert(peer);
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

make_star()

void launcher_def::make_star

(

)

Definition at line 1379 of file main.cpp.

                         {
  size_t non_bios = total_nodes - 1;
  if (non_bios < 4) {
    make_line ();
    return;
  }
  bind_nodes();
 
  size_t links = 3;
  if (non_bios > 12) {
    links = static_cast<size_t>(sqrt(non_bios)) + 2;
  }
  size_t gap = non_bios > 6 ? 3 : (non_bios - links)/2 +1;
  while (non_bios % gap == 0) {
    ++gap;
  }
  // use to prevent duplicates since all connections are bidirectional
  std::map <string, std::set<string>> peers_to_from;
  bool loop = false;
  for (size_t i = start_ndx(); !loop; loop = next_ndx(i)) {
     const auto& iter = network.nodes.find(aliases[i]);
    auto &current = iter->second;
    const auto& current_name = iter->first;
    size_t ndx = i;
    for (size_t l = 1; l <= links; l++) {
       ndx = skip_ndx(ndx, l * gap);
       auto &peer = aliases[ndx];
      for (bool found = true; found; ) {
        found = false;
        for (auto &p : current.peers) {
          if (p == peer) {
             next_ndx(ndx);
             if (ndx == i) {
                next_ndx(ndx);
             }
            peer = aliases[ndx];
            found = true;
            break;
          }
        }
      }
      // if already established, don't add to list
      if (peers_to_from[peer].count(current_name) < 2) {
        current.peers.push_back(peer); // current_name -> peer
        // keep track of bidirectional relationships to prevent duplicates
        peers_to_from[current_name].insert(peer);
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

next_ndx()

bool launcher_def::next_ndx

(

size_t &

ndx

)

Definition at line 1326 of file main.cpp.

                                       {
   ++ndx;
   bool loop = ndx == total_nodes;
   if (loop)
      ndx = start_ndx();
   else
      if (is_bios_ndx(ndx)) {
         loop = next_ndx(ndx);
      }
   return loop;
}

Here is the call graph for this function:

Here is the caller graph for this function:

prep_remote_config_dir()

void launcher_def::prep_remote_config_dir	(	eosd_def &	node,
		host_def *	host )

Definition at line 1496 of file main.cpp.

                                                                    {
  bfs::path abs_config_dir = bfs::path(host->sysio_home) / node.config_dir_name;
  bfs::path abs_data_dir = bfs::path(host->sysio_home) / node.data_dir_name;
 
  string acd = abs_config_dir.string();
  string add = abs_data_dir.string();
  string cmd = "cd " + host->sysio_home;
 
  cmd = "cd " + host->sysio_home;
  if (!do_ssh(cmd, host->host_name)) {
    cerr << "Unable to switch to path " << host->sysio_home
         << " on host " <<  host->host_name << endl;
    exit (-1);
  }
 
  cmd = "cd " + acd;
  if (!do_ssh(cmd,host->host_name)) {
     cmd = "mkdir -p " + acd;
     if (!do_ssh (cmd, host->host_name)) {
        cerr << "Unable to invoke " << cmd << " on host " << host->host_name << endl;
        exit (01);
     }
  }
  cmd = "cd " + add;
  if (do_ssh(cmd,host->host_name)) {
    if(force_overwrite) {
      cmd = "rm -rf " + add + "/" + block_dir + " ;"
          + "rm -rf " + add + "/" + shared_mem_dir;
      if (!do_ssh (cmd, host->host_name)) {
        cerr << "Unable to remove old data directories on host "
             << host->host_name << endl;
        exit (-1);
      }
    }
    else {
      cerr << add << " already exists on host " << host->host_name << ".  Use -f/--force to overwrite configuration and erase blockchain" << endl;
      exit (-1);
    }
  }
  else {
    cmd = "mkdir -p " + add;
    if (!do_ssh (cmd, host->host_name)) {
      cerr << "Unable to invoke " << cmd << " on host "
           << host->host_name << endl;
      exit (-1);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

roll()

void launcher_def::roll

(

const string &

host_names

)

Definition at line 1850 of file main.cpp.

                                            {
   vector<string> hosts;
   boost::split(hosts, host_names, boost::is_any_of(","));
   for (string host_name: hosts) {
      cout << "Rolling " << host_name << endl;
      auto host = find_host_by_name_or_address(host_name);
      string cmd = "./scripts/sysio-tn_roll.sh ";
      do_command(*host, host_name, { { "SYSIO_HOME", host->sysio_home } }, cmd);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_options()

void launcher_def::set_options

(

bpo::options_description &

cli

)

Definition at line 477 of file main.cpp.

                                                      {
  cfg.add_options()
    ("force,f", bpo::bool_switch(&force_overwrite)->default_value(false), "Force overwrite of existing configuration files and erase blockchain")
    ("nodes,n",bpo::value<size_t>(&total_nodes)->default_value(1),"total number of nodes to configure and launch")
    ("unstarted-nodes",bpo::value<size_t>(&unstarted_nodes)->default_value(0),"total number of nodes to configure, but not launch")
    ("pnodes,p",bpo::value<size_t>(&prod_nodes)->default_value(1),"number of nodes that contain one or more producers")
    ("producers",bpo::value<size_t>(&producers)->default_value(21),"total number of non-bios and non-shared producer instances in this network")
    ("shared-producers",bpo::value<size_t>(&shared_producers)->default_value(0),"total number of shared producers on each non-bios nodes")
    ("mode,m",bpo::value<vector<string>>()->multitoken()->default_value({"any"}, "any"),"connection mode, combination of \"any\", \"producers\", \"specified\", \"none\"")
    ("shape,s",bpo::value<string>(&shape)->default_value("star"),"network topology, use \"star\", \"mesh\", \"ring\", \"line\" or give a filename for custom")
    ("genesis,g",bpo::value<string>()->default_value("./genesis.json"),"set the path to genesis.json")
    ("skip-signature", bpo::bool_switch(&skip_transaction_signatures)->default_value(false), (string(node_executable_name) + " does not require transaction signatures.").c_str())
    (node_executable_name, bpo::value<string>(&eosd_extra_args), ("forward " + string(node_executable_name) + " command line argument(s) to each instance of " + string(node_executable_name) + ", enclose arg(s) in quotes").c_str())
    ("specific-num", bpo::value<vector<uint>>()->composing(), ("forward " + string(node_executable_name) + " command line argument(s) (using \"--specific-" + string(node_executable_name) + "\" flag) to this specific instance of " + string(node_executable_name) + ". This parameter can be entered multiple times and requires a paired \"--specific-" + string(node_executable_name) +"\" flag each time it is used").c_str())
    (("specific-" + string(node_executable_name)).c_str(), bpo::value<vector<string>>()->composing(), ("forward " + string(node_executable_name) + " command line argument(s) to its paired specific instance of " + string(node_executable_name) + "(using \"--specific-num\"), enclose arg(s) in quotes").c_str())
    ("spcfc-inst-num", bpo::value<vector<uint>>()->composing(), ("Specify a specific version installation path (using \"--spcfc-inst-"+ string(node_executable_name) + "\" flag) for launching this specific instance of " + string(node_executable_name) + ". This parameter can be entered multiple times and requires a paired \"--spcfc-inst-" + string(node_executable_name) + "\" flag each time it is used").c_str())
    (("spcfc-inst-" + string(node_executable_name)).c_str(), bpo::value<vector<string>>()->composing(), ("Provide a specific version installation path to its paired specific instance of " + string(node_executable_name) + "(using \"--spcfc-inst-num\")").c_str())
    ("delay,d",bpo::value<int>(&start_delay)->default_value(0),"seconds delay before starting each node after the first")
    ("boot",bpo::bool_switch(&boot)->default_value(false),"After deploying the nodes and generating a boot script, invoke it.")
    ("nogen",bpo::bool_switch(&nogen)->default_value(false),"launch nodes without writing new config files")
    ("host-map",bpo::value<string>(),"a file containing mapping specific nodes to hosts. Used to enhance the custom shape argument")
    ("servers",bpo::value<string>(),"a file containing ip addresses and names of individual servers to deploy as producers or non-producers ")
    ("per-host",bpo::value<int>(&per_host)->default_value(0),("specifies how many " + string(node_executable_name) + " instances will run on a single host. Use 0 to indicate all on one.").c_str())
    ("network-name",bpo::value<string>(&network.name)->default_value("testnet_"),"network name prefix used in GELF logging source")
    ("enable-gelf-logging",bpo::value<bool>(&gelf_enabled)->default_value(false),"enable gelf logging appender in logging configuration file")
    ("gelf-endpoint",bpo::value<string>(&gelf_endpoint)->default_value("10.160.11.21:12201"),"hostname:port or ip:port of GELF endpoint")
    ("template",bpo::value<string>(&start_temp)->default_value("testnet.template"),"the startup script template")
    ("script",bpo::value<string>(&start_script)->default_value("bios_boot.sh"),"the generated startup script name")
    ("max-block-cpu-usage",bpo::value<uint32_t>(),"Provide the \"max-block-cpu-usage\" value to use in the genesis.json file")
    ("max-transaction-cpu-usage",bpo::value<uint32_t>(),"Provide the \"max-transaction-cpu-usage\" value to use in the genesis.json file")
        ;
}

Here is the caller graph for this function:

skip_ndx()

size_t launcher_def::skip_ndx	(	size_t	from,
		size_t	offset )

Definition at line 1338 of file main.cpp.

                                                         {
   size_t ndx = (from + offset) % total_nodes;
   if (total_nodes > 2) {
      size_t attempts = total_nodes - 1;
      while (--attempts && (is_bios_ndx(ndx) || ndx == from)) {
         next_ndx(ndx);
      }
   }
   return ndx;
}

Here is the call graph for this function:

Here is the caller graph for this function:

start_all()

void launcher_def::start_all	(	string &	gts,
		launch_modes	mode )

Definition at line 1885 of file main.cpp.

                                                       {
  switch (mode) {
  case LM_NONE:
    return;
  case LM_VERIFY:
    //validate configuration, report findings, exit
    return;
  case LM_NAMED : {
    try {
      add_enable_stale_production = false;
      auto node = network.nodes.find(launch_name);
      launch(*node->second.instance, gts);
    } catch (fc::exception& fce) {
       cerr << "unable to launch " << launch_name << " fc::exception=" << fce.to_detail_string() << endl;
    } catch (std::exception& stde) {
       cerr << "unable to launch " << launch_name << " std::exception=" << stde.what() << endl;
    } catch (...) {
      cerr << "Unable to launch " << launch_name << endl;
      exit (-1);
    }
    break;
  }
  case LM_ALL:
  case LM_REMOTE:
  case LM_LOCAL: {
 
    for (auto &h : bindings ) {
      if (mode == LM_ALL ||
          (h.is_local() ? mode == LM_LOCAL : mode == LM_REMOTE)) {
        for (auto &inst : h.instances) {
          try {
             cerr << "launching " << inst.name << endl;
             launch (inst, gts);
          } catch (fc::exception& fce) {
             cerr << "unable to launch " << inst.name << " fc::exception=" << fce.to_detail_string() << endl;
          } catch (std::exception& stde) {
             cerr << "unable to launch " << inst.name << " std::exception=" << stde.what() << endl;
          } catch (...) {
            cerr << "unable to launch " << inst.name << endl;
          }
          sleep (start_delay);
        }
      }
    }
    break;
  }
  }
  bfs::path savefile = "last_run.json";
  bfs::ofstream sf (savefile);
 
  sf << fc::json::to_pretty_string (last_run) << endl;
  sf.close();
}

Here is the call graph for this function:

Here is the caller graph for this function:

start_ndx()

size_t launcher_def::start_ndx

(

)

Definition at line 1322 of file main.cpp.

                               {
   return is_bios_ndx(0) ? 1 : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

write_bios_boot()

void launcher_def::write_bios_boot

(

)

Definition at line 1272 of file main.cpp.

                               {
   bfs::ifstream src(bfs::path(config_dir_base) / "launcher" / start_temp);
   if(!src.good()) {
      cerr << "unable to open " << config_dir_base << "launcher/" << start_temp << " " << strerror(errno) << "\n";
    exit (9);
  }
 
   bfs::ofstream brb (bfs::current_path() / start_script);
   if(!brb.good()) {
      cerr << "unable to open " << bfs::current_path() << "/" << start_script << " " << strerror(errno) << "\n";
    exit (9);
  }
 
   auto &bios_node = network.nodes["bios"];
   uint16_t biosport = bios_node.instance->http_port;
   string bhost = bios_node.instance->host;
   string line;
   string prefix = "###INSERT ";
   size_t len = prefix.length();
   while (getline(src,line)) {
      if (line.substr(0,len) == prefix) {
         string key = line.substr(len);
         if (key == "envars") {
            brb << "bioshost=" << bhost << "\nbiosport=" << biosport << "\n";
         }
         else if (key == "prodkeys" ) {
            for (auto &node : network.nodes) {
               brb << "wcmd import -n ignition --private-key " << node.second.keys[0].to_string() << "\n";
            }
         }
         else if (key == "cacmd") {
            for (auto &p : producer_set.schedule) {
               if (p.producer_name == "sysio") {
                  continue;
               }
               brb << "cacmd " << p.producer_name
                   << " " << p.block_signing_key.to_string() << " " << p.block_signing_key.to_string() << "\n";
            }
         }
      }
      brb << line << "\n";
   }
   src.close();
   brb.close();
}

Here is the caller graph for this function:

write_config_file()

void launcher_def::write_config_file

(

tn_node_def &

node

)

Definition at line 1064 of file main.cpp.

                                                  {
   bool is_bios = (node.name == "bios");
   bfs::path filename;
   eosd_def &instance = *node.instance;
   host_def *host = find_host (instance.host);
 
   bfs::path dd = stage / instance.config_dir_name;
   if (!bfs::exists(dd)) {
      try {
         bfs::create_directories (dd);
      } catch (const bfs::filesystem_error &ex) {
         cerr << "write_config_files threw " << ex.what() << endl;
         exit (-1);
      }
   }
 
   filename = dd / "config.ini";
 
   bfs::ofstream cfg(filename);
   if (!cfg.good()) {
      cerr << "unable to open " << filename << " " << strerror(errno) << "\n";
      exit (-1);
   }
 
   cfg << "blocks-dir = " << block_dir << "\n";
   cfg << "http-server-address = " << host->host_name << ":" << instance.http_port << "\n";
   cfg << "http-validate-host = false\n";
   cfg << "p2p-listen-endpoint = " << host->listen_addr << ":" << instance.p2p_port << "\n";
   cfg << "p2p-server-address = " << host->public_name << ":" << instance.p2p_port << "\n";
 
 
   if (is_bios) {
    cfg << "enable-stale-production = true\n";
  }
  if (allowed_connections & PC_ANY) {
    cfg << "allowed-connection = any\n";
  }
  else if (allowed_connections == PC_NONE) {
    cfg << "allowed-connection = none\n";
  }
  else
  {
    if (allowed_connections & PC_PRODUCERS) {
      cfg << "allowed-connection = producers\n";
    }
    if (allowed_connections & PC_SPECIFIED) {
      cfg << "allowed-connection = specified\n";
      cfg << "peer-key = \"" << node.keys.begin()->get_public_key().to_string() << "\"\n";
      cfg << "peer-private-key = [\"" << node.keys.begin()->get_public_key().to_string()
          << "\",\"" << node.keys.begin()->to_string() << "\"]\n";
    }
  }
 
  if(!is_bios) {
     auto &bios_node = network.nodes["bios"];
     cfg << "p2p-peer-address = " << bios_node.instance->p2p_endpoint<< "\n";
  }
  for (const auto &p : node.peers) {
     cfg << "p2p-peer-address = " << network.nodes.find(p)->second.instance->p2p_endpoint << "\n";
  }
  if (node.producers.size()) {
    for (const auto &kp : node.keys ) {
       cfg << "private-key = [\"" << kp.get_public_key().to_string()
           << "\",\"" << kp.to_string() << "\"]\n";
    }
    for (auto &p : node.producers) {
      cfg << "producer-name = " << p << "\n";
    }
    cfg << "plugin = sysio::producer_plugin\n";
  }
  cfg << "plugin = sysio::net_plugin\n";
  cfg << "plugin = sysio::chain_api_plugin\n";
  cfg.close();
}

Here is the call graph for this function:

Here is the caller graph for this function:

write_dot_file()

void launcher_def::write_dot_file

(

)

Definition at line 774 of file main.cpp.

                              {
  bfs::ofstream df ("testnet.dot");
  df << "digraph G\n{\nlayout=\"circo\";\n";
  for (auto &node : network.nodes) {
    for (const auto &p : node.second.peers) {
      string pname=network.nodes.find(p)->second.instance->dot_label();
      df << "\"" << node.second.instance->dot_label ()
         << "\"->\"" << pname
         << "\" [dir=\"forward\"];" << std::endl;
    }
  }
  df << "}\n";
}

Here is the caller graph for this function:

write_genesis_file()

void launcher_def::write_genesis_file

(

tn_node_def &

node

)

Definition at line 1240 of file main.cpp.

                                                  {
  bfs::path filename;
  eosd_def &instance = *node.instance;
 
  bfs::path dd = stage / instance.config_dir_name;
  if (!bfs::exists(dd)) {
    bfs::create_directories(dd);
  }
 
  filename = dd / "genesis.json";
  fc::json::save_to_file( genesis_from_file, dd / "genesis.json", true );
}

Here is the call graph for this function:

Here is the caller graph for this function:

write_logging_config_file()

void launcher_def::write_logging_config_file

(

tn_node_def &

node

)

Definition at line 1140 of file main.cpp.

                                                         {
  bfs::path filename;
  eosd_def &instance = *node.instance;
 
  bfs::path dd = stage / instance.config_dir_name;
  if (!bfs::exists(dd)) {
    bfs::create_directories(dd);
  }
 
  filename = dd / "logging.json";
 
  bfs::ofstream cfg(filename);
  if (!cfg.good()) {
    cerr << "unable to open " << filename << " " << strerror(errno) << "\n";
    exit (9);
  }
 
  auto log_config = fc::logging_config::default_config();
  if(gelf_enabled) {
     log_config.appenders.push_back(
           fc::appender_config( "net", "gelf",
                           fc::mutable_variant_object()
                                 ( "endpoint", node.gelf_endpoint )
                                 ( "host", instance.name )
           ) );
     log_config.loggers.front().appenders.push_back( "net" );
  }
 
  fc::logger_config p2p( "net_plugin_impl" );
  p2p.level = fc::log_level::debug;
  p2p.appenders.push_back( "stderr" );
  if( gelf_enabled ) p2p.appenders.push_back( "net" );
  log_config.loggers.emplace_back( p2p );
 
  fc::logger_config http( "http_plugin" );
  http.level = fc::log_level::debug;
  http.appenders.push_back( "stderr" );
  if( gelf_enabled ) http.appenders.push_back( "net" );
  log_config.loggers.emplace_back( http );
 
  fc::logger_config pp( "producer_plugin" );
  pp.level = fc::log_level::debug;
  pp.appenders.push_back( "stderr" );
  if( gelf_enabled ) pp.appenders.push_back( "net" );
  log_config.loggers.emplace_back( pp );
 
  fc::logger_config tt( "transaction_success_tracing" );
  tt.level = fc::log_level::debug;
  tt.appenders.push_back( "stderr" );
  if( gelf_enabled ) tt.appenders.push_back( "net" );
  log_config.loggers.emplace_back( tt );
 
  fc::logger_config tft( "transaction_failure_tracing" );
  tft.level = fc::log_level::debug;
  tft.appenders.push_back( "stderr" );
  if( gelf_enabled ) tft.appenders.push_back( "net" );
  log_config.loggers.emplace_back( tft );
 
  fc::logger_config tts( "transaction_trace_success" );
  tts.level = fc::log_level::debug;
  tts.appenders.push_back( "stderr" );
  if( gelf_enabled ) tts.appenders.push_back( "net" );
  log_config.loggers.emplace_back( tts );
 
   fc::logger_config ttf( "transaction_trace_failure" );
   ttf.level = fc::log_level::debug;
   ttf.appenders.push_back( "stderr" );
   if( gelf_enabled ) ttf.appenders.push_back( "net" );
   log_config.loggers.emplace_back( ttf );
 
  fc::logger_config ta( "trace_api" );
  ta.level = fc::log_level::debug;
  ta.appenders.push_back( "stderr" );
  if( gelf_enabled ) ta.appenders.push_back( "net" );
  log_config.loggers.emplace_back( ta );
 
  auto str = fc::json::to_pretty_string( log_config, fc::time_point::maximum(), fc::json::output_formatting::stringify_large_ints_and_doubles );
  cfg.write( str.c_str(), str.size() );
  cfg.close();
}

Here is the call graph for this function:

Here is the caller graph for this function:

write_setprods_file()

void launcher_def::write_setprods_file

(

)

Definition at line 1254 of file main.cpp.

                                  {
   bfs::path filename = bfs::current_path() / "setprods.json";
   bfs::ofstream psfile (filename);
   if(!psfile.good()) {
      cerr << "unable to open " << filename << " " << strerror(errno) << "\n";
    exit (9);
  }
   producer_set_def no_bios;
   for (auto &p : producer_set.schedule) {
      if (p.producer_name != "sysio")
         no_bios.schedule.push_back(p);
   }
  auto str = fc::json::to_pretty_string( no_bios, fc::time_point::maximum(), fc::json::output_formatting::stringify_large_ints_and_doubles );
  psfile.write( str.c_str(), str.size() );
  psfile.close();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

add_enable_stale_production

bool launcher_def::add_enable_stale_production = false

Definition at line 418 of file main.cpp.

aliases

vector<string> launcher_def::aliases

Definition at line 410 of file main.cpp.

allowed_connections

allowed_connection launcher_def::allowed_connections = PC_NONE

Definition at line 394 of file main.cpp.

bindings

vector<host_def> launcher_def::bindings

Definition at line 411 of file main.cpp.

boot

bool launcher_def::boot

Definition at line 417 of file main.cpp.

config_dir_base

bfs::path launcher_def::config_dir_base

Definition at line 402 of file main.cpp.

data_dir_base

bfs::path launcher_def::data_dir_base

Definition at line 403 of file main.cpp.

eosd_extra_args

string launcher_def::eosd_extra_args

Definition at line 405 of file main.cpp.

erd

string launcher_def::erd

Definition at line 401 of file main.cpp.

force_overwrite

bool launcher_def::force_overwrite

Definition at line 386 of file main.cpp.

gelf_enabled

bool launcher_def::gelf_enabled

Definition at line 415 of file main.cpp.

gelf_endpoint

string launcher_def::gelf_endpoint

Definition at line 409 of file main.cpp.

genesis

bfs::path launcher_def::genesis

Definition at line 395 of file main.cpp.

genesis_from_file

sysio::chain::genesis_state launcher_def::genesis_from_file

Definition at line 427 of file main.cpp.

host_map_file

bfs::path launcher_def::host_map_file

Definition at line 397 of file main.cpp.

last_run

last_run_def launcher_def::last_run

Definition at line 413 of file main.cpp.

launch_name

string launcher_def::launch_name

Definition at line 419 of file main.cpp.

launch_time

string launcher_def::launch_time

Definition at line 420 of file main.cpp.

max_block_cpu_usage

std::optional<uint32_t> launcher_def::max_block_cpu_usage

Definition at line 425 of file main.cpp.

max_transaction_cpu_usage

std::optional<uint32_t> launcher_def::max_transaction_cpu_usage

Definition at line 426 of file main.cpp.

network

testnet_def launcher_def::network

Definition at line 408 of file main.cpp.

next_node

size_t launcher_def::next_node

Definition at line 392 of file main.cpp.

nogen

bool launcher_def::nogen

Definition at line 416 of file main.cpp.

output

bfs::path launcher_def::output

Definition at line 396 of file main.cpp.

per_host

int launcher_def::per_host = 0

Definition at line 412 of file main.cpp.

prod_nodes

size_t launcher_def::prod_nodes

Definition at line 389 of file main.cpp.

producer_set

producer_set_def launcher_def::producer_set

Definition at line 422 of file main.cpp.

producers

size_t launcher_def::producers

Definition at line 390 of file main.cpp.

server_ident_file

bfs::path launcher_def::server_ident_file

Definition at line 398 of file main.cpp.

servers

server_identities launcher_def::servers

Definition at line 421 of file main.cpp.

shape

string launcher_def::shape

Definition at line 393 of file main.cpp.

shared_producers

size_t launcher_def::shared_producers

Definition at line 391 of file main.cpp.

skip_transaction_signatures

bool launcher_def::skip_transaction_signatures = false

Definition at line 404 of file main.cpp.

specific_nodeop_args

std::map<uint,string> launcher_def::specific_nodeop_args

Definition at line 406 of file main.cpp.

specific_nodeop_installation_paths

std::map<uint,string> launcher_def::specific_nodeop_installation_paths

Definition at line 407 of file main.cpp.

stage

bfs::path launcher_def::stage

Definition at line 399 of file main.cpp.

start_delay

int launcher_def::start_delay = 0

Definition at line 414 of file main.cpp.

start_script

string launcher_def::start_script

Definition at line 424 of file main.cpp.

start_temp

string launcher_def::start_temp

Definition at line 423 of file main.cpp.

total_nodes

size_t launcher_def::total_nodes

Definition at line 387 of file main.cpp.

unstarted_nodes

size_t launcher_def::unstarted_nodes

Definition at line 388 of file main.cpp.

---

The documentation for this struct was generated from the following file:

• programs/sysio-launcher/main.cpp