daemonize::t_command_parser_executor Class Reference

#include <command_parser_executor.h>

Public Member Functions
	t_command_parser_executor (uint32_t ip, uint16_t port, const boost::optional< tools::login > &login, const epee::net_utils::ssl_options_t &ssl_options, bool is_rpc, cryptonote::core_rpc_server *rpc_server=NULL)
bool	print_peer_list (const std::vector< std::string > &args)
bool	print_peer_list_stats (const std::vector< std::string > &args)
bool	save_blockchain (const std::vector< std::string > &args)
bool	show_hash_rate (const std::vector< std::string > &args)
bool	hide_hash_rate (const std::vector< std::string > &args)
bool	show_difficulty (const std::vector< std::string > &args)
bool	show_status (const std::vector< std::string > &args)
bool	print_connections (const std::vector< std::string > &args)
bool	print_blockchain_info (const std::vector< std::string > &args)
bool	set_log_level (const std::vector< std::string > &args)
bool	set_log_categories (const std::vector< std::string > &args)
bool	print_height (const std::vector< std::string > &args)
bool	print_block (const std::vector< std::string > &args)
bool	print_transaction (const std::vector< std::string > &args)
bool	is_key_image_spent (const std::vector< std::string > &args)
bool	is_public_output_spent (const std::vector< std::string > &args)
bool	print_transaction_pool_long (const std::vector< std::string > &args)
bool	print_transaction_pool_short (const std::vector< std::string > &args)
bool	print_transaction_pool_stats (const std::vector< std::string > &args)
bool	start_mining (const std::vector< std::string > &args)
bool	stop_mining (const std::vector< std::string > &args)
bool	mining_status (const std::vector< std::string > &args)
bool	stop_daemon (const std::vector< std::string > &args)
bool	print_status (const std::vector< std::string > &args)
bool	set_limit (const std::vector< std::string > &args)
bool	set_limit_up (const std::vector< std::string > &args)
bool	set_limit_down (const std::vector< std::string > &args)
bool	out_peers (const std::vector< std::string > &args)
bool	in_peers (const std::vector< std::string > &args)
bool	start_save_graph (const std::vector< std::string > &args)
bool	stop_save_graph (const std::vector< std::string > &args)
bool	hard_fork_info (const std::vector< std::string > &args)
bool	show_bans (const std::vector< std::string > &args)
bool	ban (const std::vector< std::string > &args)
bool	unban (const std::vector< std::string > &args)
bool	flush_txpool (const std::vector< std::string > &args)
bool	output_histogram (const std::vector< std::string > &args)
bool	print_coinbase_tx_sum (const std::vector< std::string > &args)
bool	alt_chain_info (const std::vector< std::string > &args)
bool	print_blockchain_dynamic_stats (const std::vector< std::string > &args)
bool	update (const std::vector< std::string > &args)
bool	relay_tx (const std::vector< std::string > &args)
bool	sync_info (const std::vector< std::string > &args)
bool	pop_blocks (const std::vector< std::string > &args)
bool	version (const std::vector< std::string > &args)
bool	prune_blockchain (const std::vector< std::string > &args)
bool	check_blockchain_pruning (const std::vector< std::string > &args)
bool	print_net_stats (const std::vector< std::string > &args)
bool	set_validator_key (const std::vector< std::string > &args)
bool	generate_ed25519_keypair (const std::vector< std::string > &args)
bool	sign_message (const std::vector< std::string > &args)

Detailed Description

Definition at line 49 of file command_parser_executor.h.

Constructor & Destructor Documentation

t_command_parser_executor()

daemonize::t_command_parser_executor::t_command_parser_executor	(	uint32_t	ip,
		uint16_t	port,
		const boost::optional< tools::login > &	login,
		const epee::net_utils::ssl_options_t &	ssl_options,
		bool	is_rpc,
		cryptonote::core_rpc_server *	rpc_server = NULL )

Definition at line 40 of file command_parser_executor.cpp.

  : m_executor(ip, port, login, ssl_options, is_rpc, rpc_server)
{}

Member Function Documentation

alt_chain_info()

bool daemonize::t_command_parser_executor::alt_chain_info

(

const std::vector< std::string > &

args

)

Definition at line 721 of file command_parser_executor.cpp.

{
  if(args.size() > 1)
  {
    std::cout << "usage: alt_chain_info [block_hash]" << std::endl;
    return false;
  }
 
  return m_executor.alt_chain_info(args.size() == 1 ? args[0] : "");
}

Here is the caller graph for this function:

ban()

bool daemonize::t_command_parser_executor::ban

(

const std::vector< std::string > &

args

)

Definition at line 613 of file command_parser_executor.cpp.

{
  if (args.size() != 1 && args.size() != 2) return false;
  std::string ip = args[0];
  time_t seconds = P2P_IP_BLOCKTIME;
  if (args.size() > 1)
  {
    try
    {
      if(args[1] == "-1"){
          seconds = std::numeric_limits<time_t>::max();
      }
      else{
          seconds = std::stoi(args[1]);
      }
    }
    catch (const std::exception &e)
    {
      return false;
    }
    if (seconds == 0)
    {
      return false;
    }
  }
  return m_executor.ban(ip, seconds);
}

Here is the caller graph for this function:

check_blockchain_pruning()

bool daemonize::t_command_parser_executor::check_blockchain_pruning

(

const std::vector< std::string > &

args

)

Definition at line 832 of file command_parser_executor.cpp.

{
  return m_executor.check_blockchain_pruning();
}

Here is the caller graph for this function:

flush_txpool()

bool daemonize::t_command_parser_executor::flush_txpool

(

const std::vector< std::string > &

args

)

Definition at line 648 of file command_parser_executor.cpp.

{
  if (args.size() > 1) return false;
 
  std::string txid;
  if (args.size() == 1)
  {
    crypto::hash hash;
    if (!parse_hash256(args[0], hash))
    {
      std::cout << "failed to parse tx id" << std::endl;
      return true;
    }
    txid = args[0];
  }
  return m_executor.flush_txpool(txid);
}

Here is the call graph for this function:

Here is the caller graph for this function:

generate_ed25519_keypair()

bool daemonize::t_command_parser_executor::generate_ed25519_keypair

(

const std::vector< std::string > &

args

)

Definition at line 852 of file command_parser_executor.cpp.

{
  if(args.size() != 0) return false;
 
  return m_executor.generate_ed25519_keypair();
}

Here is the caller graph for this function:

hard_fork_info()

bool daemonize::t_command_parser_executor::hard_fork_info

(

const std::vector< std::string > &

args

)

Definition at line 585 of file command_parser_executor.cpp.

{
  int version;
  if (args.size() == 0) {
    version = 0;
  }
  else if (args.size() == 1) {
    try {
      version = std::stoi(args[0]);
    }
    catch(const std::exception& ex) {
        return false;
    }
    if (version <= 0 || version > 255)
      return false;
  }
  else {
    return false;
  }
  return m_executor.hard_fork_info(version);
}

Here is the call graph for this function:

Here is the caller graph for this function:

hide_hash_rate()

bool daemonize::t_command_parser_executor::hide_hash_rate

(

const std::vector< std::string > &

args

)

Definition at line 104 of file command_parser_executor.cpp.

{
  if (!args.empty()) return false;
 
  return m_executor.hide_hash_rate();
}

Here is the caller graph for this function:

in_peers()

bool daemonize::t_command_parser_executor::in_peers

(

const std::vector< std::string > &

args

)

Definition at line 556 of file command_parser_executor.cpp.

{
    if (args.empty()) return false;
 
    unsigned int limit;
    try {
        limit = std::stoi(args[0]);
    }
 
    catch(const std::exception& ex) {
        _erro("stoi exception");
        return false;
    }
 
    return m_executor.in_peers(limit);
}

Here is the caller graph for this function:

is_key_image_spent()

bool daemonize::t_command_parser_executor::is_key_image_spent

(

const std::vector< std::string > &

args

)

Definition at line 269 of file command_parser_executor.cpp.

{
  if (args.empty())
  {
    std::cout << "expected: is_key_image_spent <key_image>" << std::endl;
    return true;
  }
 
  const std::string& str = args.front();
  crypto::key_image ki;
  crypto::hash hash;
  if (parse_hash256(str, hash))
  {
    memcpy(&ki, &hash, sizeof(ki));
    m_executor.is_key_image_spent(ki);
  }
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_public_output_spent()

bool daemonize::t_command_parser_executor::is_public_output_spent

(

const std::vector< std::string > &

args

)

Definition at line 289 of file command_parser_executor.cpp.

                                                                                       {
    // Check if the number of arguments is exactly 3
    if (args.size() != 3) {
        std::cout << "expected: is_public_output_spent <tx hash> <relative output index> <amount without decimal period, eg 0.01 should be 1>" << std::endl;
        return true;
    }
 
    const std::string &tx_hash_str = args[0];
    const std::string &relative_output_index_str = args[1];
    const std::string &amount_str = args[2];
 
    // Parse the transaction hash
    crypto::hash tx_hash;
    if (!parse_hash256(tx_hash_str, tx_hash)) {
        std::cout << "Invalid transaction hash: " << tx_hash_str << std::endl;
        return true;
    }
 
    // Parse the relative output index
    uint64_t relative_output_index;
    if (!epee::string_tools::get_xtype_from_string(relative_output_index, relative_output_index_str)) {
        std::cout << "Invalid relative output index: " << relative_output_index_str << std::endl;
        return true;
    }
 
    // Parse the amount
    uint64_t amount;
    if (!epee::string_tools::get_xtype_from_string(amount, amount_str)) {
        std::cout << "Invalid amount: " << amount_str << std::endl;
        return true;
    }
 
    cryptonote::txin_to_key_public txin;
    txin.tx_hash = tx_hash;
    txin.relative_offset = relative_output_index;
    txin.amount = amount;
 
    // Assuming m_executor.is_public_output_spent needs these parsed values
    m_executor.is_public_output_spent(txin);
 
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mining_status()

bool daemonize::t_command_parser_executor::mining_status

(

const std::vector< std::string > &

args

)

Definition at line 466 of file command_parser_executor.cpp.

{
  return m_executor.mining_status();
}

Here is the caller graph for this function:

out_peers()

bool daemonize::t_command_parser_executor::out_peers

(

const std::vector< std::string > &

args

)

Definition at line 539 of file command_parser_executor.cpp.

{
    if (args.empty()) return false;
    
    unsigned int limit;
    try {
        limit = std::stoi(args[0]);
    }
      
    catch(const std::exception& ex) {
        _erro("stoi exception");
        return false;
    }
    
    return m_executor.out_peers(limit);
}

Here is the caller graph for this function:

output_histogram()

bool daemonize::t_command_parser_executor::output_histogram

(

const std::vector< std::string > &

args

)

Definition at line 666 of file command_parser_executor.cpp.

{
  std::vector<uint64_t> amounts;
  uint64_t min_count = 3;
  uint64_t max_count = 0;
  size_t n_raw = 0;
 
  for (size_t n = 0; n < args.size(); ++n)
  {
    if (args[n][0] == '@')
    {
      amounts.push_back(boost::lexical_cast<uint64_t>(args[n].c_str() + 1));
    }
    else if (n_raw == 0)
    {
      min_count = boost::lexical_cast<uint64_t>(args[n]);
      n_raw++;
    }
    else if (n_raw == 1)
    {
      max_count = boost::lexical_cast<uint64_t>(args[n]);
      n_raw++;
    }
    else
    {
      std::cout << "Invalid syntax: more than two non-amount parameters" << std::endl;
      return true;
    }
  }
  return m_executor.output_histogram(amounts, min_count, max_count);
}

Here is the caller graph for this function:

pop_blocks()

bool daemonize::t_command_parser_executor::pop_blocks

(

const std::vector< std::string > &

args

)

Definition at line 783 of file command_parser_executor.cpp.

{
  if (args.size() != 1)
  {
    std::cout << "Exactly one parameter is needed" << std::endl;
    return false;
  }
 
  try
  {
    uint64_t nblocks = boost::lexical_cast<uint64_t>(args[0]);
    if (nblocks < 1)
    {
      std::cout << "number of blocks must be greater than 0" << std::endl;
      return false;
    }
    return m_executor.pop_blocks(nblocks);
  }
  catch (const boost::bad_lexical_cast&)
  {
    std::cout << "number of blocks must be a number greater than 0" << std::endl;
  }
  return false;
}

Here is the caller graph for this function:

print_block()

bool daemonize::t_command_parser_executor::print_block

(

const std::vector< std::string > &

args

)

Definition at line 198 of file command_parser_executor.cpp.

{
  bool include_hex = false;
 
  // Assumes that optional flags come after mandatory argument <transaction_hash>
  for (unsigned int i = 1; i < args.size(); ++i) {
    if (args[i] == "+hex")
      include_hex = true;
    else
    {
      std::cout << "unexpected argument: " << args[i] << std::endl;
      return true;
    }
  }
  if (args.empty())
  {
    std::cout << "expected: print_block (<block_hash> | <block_height>) [+hex]" << std::endl;
    return false;
  }
 
  const std::string& arg = args.front();
  try
  {
    uint64_t height = boost::lexical_cast<uint64_t>(arg);
    return m_executor.print_block_by_height(height, include_hex);
  }
  catch (const boost::bad_lexical_cast&)
  {
    crypto::hash block_hash;
    if (parse_hash256(arg, block_hash))
    {
      return m_executor.print_block_by_hash(block_hash, include_hex);
    }
  }
 
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_blockchain_dynamic_stats()

bool daemonize::t_command_parser_executor::print_blockchain_dynamic_stats

(

const std::vector< std::string > &

args

)

Definition at line 732 of file command_parser_executor.cpp.

{
  if(args.size() != 1)
  {
    std::cout << "Exactly one parameter is needed" << std::endl;
    return false;
  }
 
  uint64_t nblocks = 0;
  if(!epee::string_tools::get_xtype_from_string(nblocks, args[0]) || nblocks == 0)
  {
    std::cout << "wrong number of blocks" << std::endl;
    return false;
  }
 
  return m_executor.print_blockchain_dynamic_stats(nblocks);
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_blockchain_info()

bool daemonize::t_command_parser_executor::print_blockchain_info

(

const std::vector< std::string > &

args

)

Definition at line 139 of file command_parser_executor.cpp.

{
  if(!args.size())
  {
    std::cout << "need block index parameter" << std::endl;
    return false;
  }
  uint64_t start_index = 0;
  uint64_t end_index = 0;
  if(!epee::string_tools::get_xtype_from_string(start_index, args[0]))
  {
    std::cout << "wrong starter block index parameter" << std::endl;
    return false;
  }
  if(args.size() >1 && !epee::string_tools::get_xtype_from_string(end_index, args[1]))
  {
    std::cout << "wrong end block index parameter" << std::endl;
    return false;
  }
 
  return m_executor.print_blockchain_info(start_index, end_index);
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_coinbase_tx_sum()

bool daemonize::t_command_parser_executor::print_coinbase_tx_sum

(

const std::vector< std::string > &

args

)

Definition at line 698 of file command_parser_executor.cpp.

{
  if(!args.size())
  {
    std::cout << "need block height parameter" << std::endl;
    return false;
  }
  uint64_t height = 0;
  uint64_t count = 0;
  if(!epee::string_tools::get_xtype_from_string(height, args[0]))
  {
    std::cout << "wrong starter block height parameter" << std::endl;
    return false;
  }
  if(args.size() >1 && !epee::string_tools::get_xtype_from_string(count, args[1]))
  {
    std::cout << "wrong count parameter" << std::endl;
    return false;
  }
 
  return m_executor.print_coinbase_tx_sum(height, count);
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_connections()

bool daemonize::t_command_parser_executor::print_connections

(

const std::vector< std::string > &

args

)

Definition at line 125 of file command_parser_executor.cpp.

{
  if (!args.empty()) return false;
 
  return m_executor.print_connections();
}

Here is the caller graph for this function:

print_height()

bool daemonize::t_command_parser_executor::print_height

(

const std::vector< std::string > &

args

)

Definition at line 191 of file command_parser_executor.cpp.

{
  if (!args.empty()) return false;
 
  return m_executor.print_height();
}

Here is the caller graph for this function:

print_net_stats()

bool daemonize::t_command_parser_executor::print_net_stats

(

const std::vector< std::string > &

args

)

Definition at line 132 of file command_parser_executor.cpp.

{
  if (!args.empty()) return false;
 
  return m_executor.print_net_stats();
}

Here is the caller graph for this function:

print_peer_list()

bool daemonize::t_command_parser_executor::print_peer_list

(

const std::vector< std::string > &

args

)

Definition at line 51 of file command_parser_executor.cpp.

{
  if (args.size() > 3)
  {
    std::cout << "use: print_pl [white] [gray] [<limit>]" << std::endl;
    return true;
  }
 
  bool white = false;
  bool gray = false;
  size_t limit = 0;
  for (size_t i = 0; i < args.size(); ++i)
  {
    if (args[i] == "white")
    {
      white = true;
    }
    else if (args[i] == "gray")
    {
      gray = true;
    }
    else if (!epee::string_tools::get_xtype_from_string(limit, args[i]))
    {
      std::cout << "unexpected argument: " << args[i] << std::endl;
      return true;
    }
  }
 
  const bool print_both = !white && !gray;
  return m_executor.print_peer_list(white | print_both, gray | print_both, limit);
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_peer_list_stats()

bool daemonize::t_command_parser_executor::print_peer_list_stats

(

const std::vector< std::string > &

args

)

Definition at line 83 of file command_parser_executor.cpp.

{
  if (!args.empty()) return false;
 
  return m_executor.print_peer_list_stats();
}

Here is the caller graph for this function:

print_status()

bool daemonize::t_command_parser_executor::print_status

(

const std::vector< std::string > &

args

)

Definition at line 478 of file command_parser_executor.cpp.

{
  if (!args.empty()) return false;
 
  return m_executor.print_status();
}

Here is the caller graph for this function:

print_transaction()

bool daemonize::t_command_parser_executor::print_transaction

(

const std::vector< std::string > &

args

)

Definition at line 236 of file command_parser_executor.cpp.

{
  bool include_hex = false;
  bool include_json = false;
 
  // Assumes that optional flags come after mandatory argument <transaction_hash>
  for (unsigned int i = 1; i < args.size(); ++i) {
    if (args[i] == "+hex")
      include_hex = true;
    else if (args[i] == "+json")
      include_json = true;
    else
    {
      std::cout << "unexpected argument: " << args[i] << std::endl;
      return true;
    }
  }
  if (args.empty())
  {
    std::cout << "expected: print_tx <transaction_hash> [+hex] [+json]" << std::endl;
    return true;
  }
 
  const std::string& str_hash = args.front();
  crypto::hash tx_hash;
  if (parse_hash256(str_hash, tx_hash))
  {
    m_executor.print_transaction(tx_hash, include_hex, include_json);
  }
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_transaction_pool_long()

bool daemonize::t_command_parser_executor::print_transaction_pool_long

(

const std::vector< std::string > &

args

)

Definition at line 332 of file command_parser_executor.cpp.

{
  if (!args.empty()) return false;
 
  return m_executor.print_transaction_pool_long();
}

Here is the caller graph for this function:

print_transaction_pool_short()

bool daemonize::t_command_parser_executor::print_transaction_pool_short

(

const std::vector< std::string > &

args

)

Definition at line 339 of file command_parser_executor.cpp.

{
  if (!args.empty()) return false;
 
  return m_executor.print_transaction_pool_short();
}

Here is the caller graph for this function:

print_transaction_pool_stats()

bool daemonize::t_command_parser_executor::print_transaction_pool_stats

(

const std::vector< std::string > &

args

)

Definition at line 346 of file command_parser_executor.cpp.

{
  if (!args.empty()) return false;
 
  return m_executor.print_transaction_pool_stats();
}

Here is the caller graph for this function:

prune_blockchain()

bool daemonize::t_command_parser_executor::prune_blockchain

(

const std::vector< std::string > &

args

)

Definition at line 814 of file command_parser_executor.cpp.

{
  if (args.size() > 1) return false;
 
  if (args.empty() || args[0] != "confirm")
  {
    std::cout << "Warning: pruning from within electroneumd will not shrink the database file size." << std::endl;
    std::cout << "Instead, parts of the file will be marked as free, so the file will not grow" << std::endl;
    std::cout << "until that newly free space is used up. If you want a smaller file size now," << std::endl;
    std::cout << "exit electroneumd and run electroneum-blockchain-prune (you will temporarily need more" << std::endl;
    std::cout << "disk space for the database conversion though). If you are OK with the database" << std::endl;
    std::cout << "file keeping the same size, re-run this command with the \"confirm\" parameter." << std::endl;
    return true;
  }
 
  return m_executor.prune_blockchain();
}

Here is the caller graph for this function:

relay_tx()

bool daemonize::t_command_parser_executor::relay_tx

(

const std::vector< std::string > &

args

)

Definition at line 761 of file command_parser_executor.cpp.

{
  if (args.size() != 1) return false;
 
  std::string txid;
  crypto::hash hash;
  if (!parse_hash256(args[0], hash))
  {
    std::cout << "failed to parse tx id" << std::endl;
    return true;
  }
  txid = args[0];
  return m_executor.relay_tx(txid);
}

Here is the call graph for this function:

Here is the caller graph for this function:

save_blockchain()

bool daemonize::t_command_parser_executor::save_blockchain

(

const std::vector< std::string > &

args

)

Definition at line 90 of file command_parser_executor.cpp.

{
  if (!args.empty()) return false;
 
  return m_executor.save_blockchain();
}

Here is the caller graph for this function:

set_limit()

bool daemonize::t_command_parser_executor::set_limit

(

const std::vector< std::string > &

args

)

Definition at line 485 of file command_parser_executor.cpp.

{
  if(args.size()>1) return false;
  if(args.size()==0) {
    return m_executor.get_limit();
  }
  int64_t limit;
  try {
      limit = std::stoll(args[0]);
  }
  catch(const std::exception& ex) {
      std::cout << "failed to parse argument" << std::endl;
      return false;
  }
 
  return m_executor.set_limit(limit, limit);
}

Here is the caller graph for this function:

set_limit_down()

bool daemonize::t_command_parser_executor::set_limit_down

(

const std::vector< std::string > &

args

)

Definition at line 521 of file command_parser_executor.cpp.

{
  if(args.size()>1) return false;
  if(args.size()==0) {
    return m_executor.get_limit_down();
  }
  int64_t limit;
  try {
      limit = std::stoll(args[0]);
  }
  catch(const std::exception& ex) {
      std::cout << "failed to parse argument" << std::endl;
      return false;
  }
 
  return m_executor.set_limit(limit, 0);
}

Here is the caller graph for this function:

set_limit_up()

bool daemonize::t_command_parser_executor::set_limit_up

(

const std::vector< std::string > &

args

)

Definition at line 503 of file command_parser_executor.cpp.

{
  if(args.size()>1) return false;
  if(args.size()==0) {
    return m_executor.get_limit_up();
  }
  int64_t limit;
  try {
      limit = std::stoll(args[0]);
  }
  catch(const std::exception& ex) {
      std::cout << "failed to parse argument" << std::endl;
      return false;
  }
 
  return m_executor.set_limit(0, limit);
}

Here is the caller graph for this function:

set_log_categories()

bool daemonize::t_command_parser_executor::set_log_categories

(

const std::vector< std::string > &

args

)

set_log_level()

bool daemonize::t_command_parser_executor::set_log_level

(

const std::vector< std::string > &

args

)

Definition at line 162 of file command_parser_executor.cpp.

{
  if(args.size() > 1)
  {
    std::cout << "use: set_log [<log_level_number_0-4> | <categories>]" << std::endl;
    return true;
  }
 
  if (args.empty())
  {
    return m_executor.set_log_categories("+");
  }
 
  uint16_t l = 0;
  if(epee::string_tools::get_xtype_from_string(l, args[0]))
  {
    if(4 < l)
    {
      std::cout << "wrong number range, use: set_log <log_level_number_0-4>" << std::endl;
      return true;
    }
    return m_executor.set_log_level(l);
  }
  else
  {
    return m_executor.set_log_categories(args.front());
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_validator_key()

bool daemonize::t_command_parser_executor::set_validator_key

(

const std::vector< std::string > &

args

)

Definition at line 837 of file command_parser_executor.cpp.

{
  if(args.size() != 1) return false;
 
  std::string key(args[0]);
 
  bool is_validator_key_valid = std::count_if(key.begin(), key.end(), [](int c) {return !std::isxdigit(c);}) == 0;
  if(!is_validator_key_valid || key.size() != 64) {
    std::cout << "Failed to parse validator key (wrong format)." << std::endl;
    return true;
  }
 
  return m_executor.set_validator_key(key);
}

Here is the caller graph for this function:

show_bans()

bool daemonize::t_command_parser_executor::show_bans

(

const std::vector< std::string > &

args

)

Definition at line 607 of file command_parser_executor.cpp.

{
  if (!args.empty()) return false;
  return m_executor.print_bans();
}

Here is the caller graph for this function:

show_difficulty()

bool daemonize::t_command_parser_executor::show_difficulty

(

const std::vector< std::string > &

args

)

Definition at line 111 of file command_parser_executor.cpp.

{
  if (!args.empty()) return false;
 
  return m_executor.show_difficulty();
}

Here is the caller graph for this function:

show_hash_rate()

bool daemonize::t_command_parser_executor::show_hash_rate

(

const std::vector< std::string > &

args

)

Definition at line 97 of file command_parser_executor.cpp.

{
  if (!args.empty()) return false;
 
  return m_executor.show_hash_rate();
}

Here is the caller graph for this function:

show_status()

bool daemonize::t_command_parser_executor::show_status

(

const std::vector< std::string > &

args

)

Definition at line 118 of file command_parser_executor.cpp.

{
  if (!args.empty()) return false;
 
  return m_executor.show_status();
}

Here is the caller graph for this function:

sign_message()

bool daemonize::t_command_parser_executor::sign_message

(

const std::vector< std::string > &

args

)

Definition at line 859 of file command_parser_executor.cpp.

{
  if(args.size() != 2) return false;
 
  std::string key(args[0]);
  return m_executor.sign_message(key, args[1]);
}

Here is the caller graph for this function:

start_mining()

bool daemonize::t_command_parser_executor::start_mining

(

const std::vector< std::string > &

args

)

Definition at line 353 of file command_parser_executor.cpp.

{
  if(!args.size())
  {
    std::cout << "Please specify a wallet address to mine for: start_mining <addr> [<threads>|auto]" << std::endl;
    return true;
  }
 
  cryptonote::address_parse_info info;
  cryptonote::network_type nettype = cryptonote::MAINNET;
  if(!cryptonote::get_account_address_from_str(info, cryptonote::MAINNET, args.front()))
  {
    if(!cryptonote::get_account_address_from_str(info, cryptonote::TESTNET, args.front()))
    {
      if(!cryptonote::get_account_address_from_str(info, cryptonote::STAGENET, args.front()))
      {
        bool dnssec_valid;
        std::string address_str = tools::dns_utils::get_account_address_as_str_from_url(args.front(), dnssec_valid,
            [](const std::string &url, const std::vector<std::string> &addresses, bool dnssec_valid){return addresses[0];});
        if(!cryptonote::get_account_address_from_str(info, cryptonote::MAINNET, address_str))
        {
          if(!cryptonote::get_account_address_from_str(info, cryptonote::TESTNET, address_str))
          {
            if(!cryptonote::get_account_address_from_str(info, cryptonote::STAGENET, address_str))
            {
              std::cout << "target account address has wrong format" << std::endl;
              return true;
            }
            else
            {
              nettype = cryptonote::STAGENET;
            }
          }
          else
          {
            nettype = cryptonote::TESTNET;
          }
        }
      }
      else
      {
        nettype = cryptonote::STAGENET;
      }
    }
    else
    {
      nettype = cryptonote::TESTNET;
    }
  }
  if (info.is_subaddress)
  {
    tools::fail_msg_writer() << "subaddress for mining reward is not yet supported!" << std::endl;
    return true;
  }
  if(nettype != cryptonote::MAINNET)
    std::cout << "Mining to a " << (nettype == cryptonote::TESTNET ? "testnet" : "stagenet") << " address, make sure this is intentional!" << std::endl;
  uint64_t threads_count = 1;
  bool do_background_mining = false;  
  bool ignore_battery = false;  
  if(args.size() > 4)
  {
    return false;
  }
  
  if(args.size() == 4)
  {
    if(args[3] == "true" || command_line::is_yes(args[3]) || args[3] == "1")
    {
      ignore_battery = true;
    }
    else if(args[3] != "false" && !command_line::is_no(args[3]) && args[3] != "0")
    {
      return false;
    }
  }  
  
  if(args.size() >= 3)
  {
    if(args[2] == "true" || command_line::is_yes(args[2]) || args[2] == "1")
    {
      do_background_mining = true;
    }
    else if(args[2] != "false" && !command_line::is_no(args[2]) && args[2] != "0")
    {
      return false;
    }
  }
  
  if(args.size() >= 2)
  {
    if (args[1] == "auto" || args[1] == "autodetect")
    {
      threads_count = 0;
    }
    else
    {
      bool ok = epee::string_tools::get_xtype_from_string(threads_count, args[1]);
      threads_count = (ok && 0 < threads_count) ? threads_count : 1;
    }
  }
 
  m_executor.start_mining(info.address, threads_count, nettype, do_background_mining, ignore_battery);
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

start_save_graph()

bool daemonize::t_command_parser_executor::start_save_graph

(

const std::vector< std::string > &

args

)

Definition at line 573 of file command_parser_executor.cpp.

{
    if (!args.empty()) return false;
    return m_executor.start_save_graph();
}

Here is the caller graph for this function:

stop_daemon()

bool daemonize::t_command_parser_executor::stop_daemon

(

const std::vector< std::string > &

args

)

Definition at line 471 of file command_parser_executor.cpp.

{
  if (!args.empty()) return false;
 
  return m_executor.stop_daemon();
}

Here is the caller graph for this function:

stop_mining()

bool daemonize::t_command_parser_executor::stop_mining

(

const std::vector< std::string > &

args

)

Definition at line 459 of file command_parser_executor.cpp.

{
  if (!args.empty()) return false;
 
  return m_executor.stop_mining();
}

Here is the caller graph for this function:

stop_save_graph()

bool daemonize::t_command_parser_executor::stop_save_graph

(

const std::vector< std::string > &

args

)

Definition at line 579 of file command_parser_executor.cpp.

{
    if (!args.empty()) return false;
    return m_executor.stop_save_graph();
}

Here is the caller graph for this function:

sync_info()

bool daemonize::t_command_parser_executor::sync_info

(

const std::vector< std::string > &

args

)

Definition at line 776 of file command_parser_executor.cpp.

{
  if (args.size() != 0) return false;
 
  return m_executor.sync_info();
}

Here is the caller graph for this function:

unban()

bool daemonize::t_command_parser_executor::unban

(

const std::vector< std::string > &

args

)

Definition at line 641 of file command_parser_executor.cpp.

{
  if (args.size() != 1) return false;
  std::string ip = args[0];
  return m_executor.unban(ip);
}

Here is the caller graph for this function:

update()

bool daemonize::t_command_parser_executor::update

(

const std::vector< std::string > &

args

)

Definition at line 750 of file command_parser_executor.cpp.

{
  if(args.size() != 1)
  {
    std::cout << "Exactly one parameter is needed: check, download, or update" << std::endl;
    return false;
  }
 
  return m_executor.update(args.front());
}

Here is the caller graph for this function:

version()

bool daemonize::t_command_parser_executor::version

(

const std::vector< std::string > &

args

)

Definition at line 808 of file command_parser_executor.cpp.

{
  std::cout << "Electroneum '" << ELECTRONEUM_RELEASE_NAME << "' (v" << ELECTRONEUM_VERSION_FULL << ")" << std::endl;
  return true;
}

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/daemon/command_parser_executor.h
• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/daemon/command_parser_executor.cpp