wownero/src/daemon/command_server.cpp

411 lines
14 KiB
C++
Raw Normal View History

// Copyright (c) 2014-2020, The Monero Project
2016-10-10 20:41:24 +00:00
//
// All rights reserved.
2016-10-10 20:41:24 +00:00
//
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
2016-10-10 20:41:24 +00:00
//
// 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer.
2016-10-10 20:41:24 +00:00
//
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution.
2016-10-10 20:41:24 +00:00
//
// 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific
// prior written permission.
2016-10-10 20:41:24 +00:00
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <boost/algorithm/string.hpp>
#include "cryptonote_config.h"
#include "version.h"
#include "string_tools.h"
#include "daemon/command_server.h"
Change logging to easylogging++ This replaces the epee and data_loggers logging systems with a single one, and also adds filename:line and explicit severity levels. Categories may be defined, and logging severity set by category (or set of categories). epee style 0-4 log level maps to a sensible severity configuration. Log files now also rotate when reaching 100 MB. To select which logs to output, use the MONERO_LOGS environment variable, with a comma separated list of categories (globs are supported), with their requested severity level after a colon. If a log matches more than one such setting, the last one in the configuration string applies. A few examples: This one is (mostly) silent, only outputting fatal errors: MONERO_LOGS=*:FATAL This one is very verbose: MONERO_LOGS=*:TRACE This one is totally silent (logwise): MONERO_LOGS="" This one outputs all errors and warnings, except for the "verify" category, which prints just fatal errors (the verify category is used for logs about incoming transactions and blocks, and it is expected that some/many will fail to verify, hence we don't want the spam): MONERO_LOGS=*:WARNING,verify:FATAL Log levels are, in decreasing order of priority: FATAL, ERROR, WARNING, INFO, DEBUG, TRACE Subcategories may be added using prefixes and globs. This example will output net.p2p logs at the TRACE level, but all other net* logs only at INFO: MONERO_LOGS=*:ERROR,net*:INFO,net.p2p:TRACE Logs which are intended for the user (which Monero was using a lot through epee, but really isn't a nice way to go things) should use the "global" category. There are a few helper macros for using this category, eg: MGINFO("this shows up by default") or MGINFO_RED("this is red"), to try to keep a similar look and feel for now. Existing epee log macros still exist, and map to the new log levels, but since they're used as a "user facing" UI element as much as a logging system, they often don't map well to log severities (ie, a log level 0 log may be an error, or may be something we want the user to see, such as an important info). In those cases, I tried to use the new macros. In other cases, I left the existing macros in. When modifying logs, it is probably best to switch to the new macros with explicit levels. The --log-level options and set_log commands now also accept category settings, in addition to the epee style log levels.
2017-01-01 16:34:23 +00:00
#undef MONERO_DEFAULT_LOG_CATEGORY
#define MONERO_DEFAULT_LOG_CATEGORY "daemon"
namespace daemonize {
namespace p = std::placeholders;
t_command_server::t_command_server(
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
)
: m_parser(ip, port, login, ssl_options, is_rpc, rpc_server)
, m_command_lookup()
, m_is_rpc(is_rpc)
{
m_command_lookup.set_handler(
"help"
, std::bind(&t_command_server::help, this, p::_1)
2017-11-22 12:53:18 +00:00
, "help [<command>]"
, "Show the help section or the documentation about a <command>."
);
m_command_lookup.set_handler(
"print_height"
, std::bind(&t_command_parser_executor::print_height, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "Print the local blockchain height."
);
m_command_lookup.set_handler(
"print_pl"
, std::bind(&t_command_parser_executor::print_peer_list, &m_parser, p::_1)
, "print_pl [white] [gray] [pruned] [publicrpc] [<limit>]"
2017-11-22 12:53:18 +00:00
, "Print the current peer list."
);
2017-02-23 17:20:17 +00:00
m_command_lookup.set_handler(
"print_pl_stats"
, std::bind(&t_command_parser_executor::print_peer_list_stats, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "Print the peer list statistics."
2017-02-23 17:20:17 +00:00
);
m_command_lookup.set_handler(
"print_cn"
, std::bind(&t_command_parser_executor::print_connections, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "Print the current connections."
);
m_command_lookup.set_handler(
"print_net_stats"
, std::bind(&t_command_parser_executor::print_net_stats, &m_parser, p::_1)
, "Print network statistics."
);
m_command_lookup.set_handler(
"print_bc"
, std::bind(&t_command_parser_executor::print_blockchain_info, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "print_bc <begin_height> [<end_height>]"
, "Print the blockchain info in a given blocks range."
);
m_command_lookup.set_handler(
"print_block"
, std::bind(&t_command_parser_executor::print_block, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "print_block <block_hash> | <block_height>"
, "Print a given block."
);
m_command_lookup.set_handler(
"print_tx"
, std::bind(&t_command_parser_executor::print_transaction, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "print_tx <transaction_hash> [+hex] [+json]"
, "Print a given transaction."
);
m_command_lookup.set_handler(
"is_key_image_spent"
, std::bind(&t_command_parser_executor::is_key_image_spent, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "is_key_image_spent <key_image>"
, "Print whether a given key image is in the spent key images set."
);
m_command_lookup.set_handler(
"start_mining"
, std::bind(&t_command_parser_executor::start_mining, &m_parser, p::_1)
, "start_mining <addr> [<threads>|auto] [do_background_mining] [ignore_battery]"
, "Start mining for specified address. Defaults to 1 thread and no background mining. Use \"auto\" to autodetect optimal number of threads."
);
m_command_lookup.set_handler(
"stop_mining"
, std::bind(&t_command_parser_executor::stop_mining, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "Stop mining."
);
2019-02-22 20:17:45 +00:00
m_command_lookup.set_handler(
"mining_status"
, std::bind(&t_command_parser_executor::mining_status, &m_parser, p::_1)
, "Show current mining status."
);
m_command_lookup.set_handler(
"print_pool"
, std::bind(&t_command_parser_executor::print_transaction_pool_long, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "Print the transaction pool using a long format."
);
m_command_lookup.set_handler(
"print_pool_sh"
, std::bind(&t_command_parser_executor::print_transaction_pool_short, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "Print transaction pool using a short format."
);
m_command_lookup.set_handler(
"print_pool_stats"
, std::bind(&t_command_parser_executor::print_transaction_pool_stats, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "Print the transaction pool's statistics."
);
m_command_lookup.set_handler(
"show_hr"
, std::bind(&t_command_parser_executor::show_hash_rate, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "Start showing the current hash rate."
);
m_command_lookup.set_handler(
"hide_hr"
, std::bind(&t_command_parser_executor::hide_hash_rate, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "Stop showing the hash rate."
);
m_command_lookup.set_handler(
"save"
, std::bind(&t_command_parser_executor::save_blockchain, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "Save the blockchain."
);
m_command_lookup.set_handler(
"set_log"
, std::bind(&t_command_parser_executor::set_log_level, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "set_log <level>|<{+,-,}categories>"
, "Change the current log level/categories where <level> is a number 0-4."
);
m_command_lookup.set_handler(
"diff"
, std::bind(&t_command_parser_executor::show_difficulty, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "Show the current difficulty."
);
m_command_lookup.set_handler(
"status"
, std::bind(&t_command_parser_executor::show_status, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "Show the current status."
);
m_command_lookup.set_handler(
"stop_daemon"
, std::bind(&t_command_parser_executor::stop_daemon, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "Stop the daemon."
);
m_command_lookup.set_handler(
"exit"
, std::bind(&t_command_parser_executor::stop_daemon, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "Stop the daemon."
);
m_command_lookup.set_handler(
"print_status"
, std::bind(&t_command_parser_executor::print_status, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "Print the current daemon status."
);
m_command_lookup.set_handler(
"limit"
, std::bind(&t_command_parser_executor::set_limit, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "limit [<kB/s>]"
, "Get or set the download and upload limit."
);
m_command_lookup.set_handler(
"limit_up"
, std::bind(&t_command_parser_executor::set_limit_up, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "limit_up [<kB/s>]"
, "Get or set the upload limit."
);
m_command_lookup.set_handler(
"limit_down"
, std::bind(&t_command_parser_executor::set_limit_down, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "limit_down [<kB/s>]"
, "Get or set the download limit."
);
m_command_lookup.set_handler(
"out_peers"
, std::bind(&t_command_parser_executor::out_peers, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "out_peers <max_number>"
, "Set the <max_number> of out peers."
);
m_command_lookup.set_handler(
"in_peers"
, std::bind(&t_command_parser_executor::in_peers, &m_parser, p::_1)
, "in_peers <max_number>"
, "Set the <max_number> of in peers."
);
m_command_lookup.set_handler(
"hard_fork_info"
, std::bind(&t_command_parser_executor::hard_fork_info, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "Print the hard fork voting information."
);
m_command_lookup.set_handler(
"bans"
, std::bind(&t_command_parser_executor::show_bans, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "Show the currently banned IPs."
);
m_command_lookup.set_handler(
"ban"
, std::bind(&t_command_parser_executor::ban, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "ban <IP> [<seconds>]"
, "Ban a given <IP> for a given amount of <seconds>."
);
m_command_lookup.set_handler(
"unban"
, std::bind(&t_command_parser_executor::unban, &m_parser, p::_1)
2019-03-29 10:47:53 +00:00
, "unban <address>"
2017-11-22 12:53:18 +00:00
, "Unban a given <IP>."
);
2019-03-29 10:47:53 +00:00
m_command_lookup.set_handler(
"banned"
, std::bind(&t_command_parser_executor::banned, &m_parser, p::_1)
, "banned <address>"
, "Check whether an <address> is banned."
);
m_command_lookup.set_handler(
"flush_txpool"
, std::bind(&t_command_parser_executor::flush_txpool, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "flush_txpool [<txid>]"
, "Flush a transaction from the tx pool by its <txid>, or the whole tx pool."
);
m_command_lookup.set_handler(
"output_histogram"
, std::bind(&t_command_parser_executor::output_histogram, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "output_histogram [@<amount>] <min_count> [<max_count>]"
, "Print the output histogram of outputs."
);
2016-10-10 19:45:51 +00:00
m_command_lookup.set_handler(
"print_coinbase_tx_sum"
, std::bind(&t_command_parser_executor::print_coinbase_tx_sum, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "print_coinbase_tx_sum <start_height> [<block_count>]"
, "Print the sum of coinbase transactions."
2016-10-10 19:45:51 +00:00
);
m_command_lookup.set_handler(
"alt_chain_info"
, std::bind(&t_command_parser_executor::alt_chain_info, &m_parser, p::_1)
, "alt_chain_info [blockhash]"
2017-11-22 12:53:18 +00:00
, "Print the information about alternative chains."
);
m_command_lookup.set_handler(
"bc_dyn_stats"
, std::bind(&t_command_parser_executor::print_blockchain_dynamic_stats, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "bc_dyn_stats <last_block_count>"
, "Print the information about current blockchain dynamic state."
);
m_command_lookup.set_handler(
"update"
, std::bind(&t_command_parser_executor::update, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "update (check|download)"
, "Check if an update is available, optionally downloads it if there is. Updating is not yet implemented."
);
2017-04-02 11:17:35 +00:00
m_command_lookup.set_handler(
"relay_tx"
, std::bind(&t_command_parser_executor::relay_tx, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "relay_tx <txid>"
, "Relay a given transaction by its <txid>."
2017-04-02 11:17:35 +00:00
);
m_command_lookup.set_handler(
"sync_info"
, std::bind(&t_command_parser_executor::sync_info, &m_parser, p::_1)
2017-11-22 12:53:18 +00:00
, "Print information about the blockchain sync state."
);
m_command_lookup.set_handler(
"pop_blocks"
, std::bind(&t_command_parser_executor::pop_blocks, &m_parser, p::_1)
, "pop_blocks <nblocks>"
, "Remove blocks from end of blockchain"
);
daemon, wallet: new pay for RPC use system Daemons intended for public use can be set up to require payment in the form of hashes in exchange for RPC service. This enables public daemons to receive payment for their work over a large number of calls. This system behaves similarly to a pool, so payment takes the form of valid blocks every so often, yielding a large one off payment, rather than constant micropayments. This system can also be used by third parties as a "paywall" layer, where users of a service can pay for use by mining Monero to the service provider's address. An example of this for web site access is Primo, a Monero mining based website "paywall": https://github.com/selene-kovri/primo This has some advantages: - incentive to run a node providing RPC services, thereby promoting the availability of third party nodes for those who can't run their own - incentive to run your own node instead of using a third party's, thereby promoting decentralization - decentralized: payment is done between a client and server, with no third party needed - private: since the system is "pay as you go", you don't need to identify yourself to claim a long lived balance - no payment occurs on the blockchain, so there is no extra transactional load - one may mine with a beefy server, and use those credits from a phone, by reusing the client ID (at the cost of some privacy) - no barrier to entry: anyone may run a RPC node, and your expected revenue depends on how much work you do - Sybil resistant: if you run 1000 idle RPC nodes, you don't magically get more revenue - no large credit balance maintained on servers, so they have no incentive to exit scam - you can use any/many node(s), since there's little cost in switching servers - market based prices: competition between servers to lower costs - incentive for a distributed third party node system: if some public nodes are overused/slow, traffic can move to others - increases network security - helps counteract mining pools' share of the network hash rate - zero incentive for a payer to "double spend" since a reorg does not give any money back to the miner And some disadvantages: - low power clients will have difficulty mining (but one can optionally mine in advance and/or with a faster machine) - payment is "random", so a server might go a long time without a block before getting one - a public node's overall expected payment may be small Public nodes are expected to compete to find a suitable level for cost of service. The daemon can be set up this way to require payment for RPC services: monerod --rpc-payment-address 4xxxxxx \ --rpc-payment-credits 250 --rpc-payment-difficulty 1000 These values are an example only. The --rpc-payment-difficulty switch selects how hard each "share" should be, similar to a mining pool. The higher the difficulty, the fewer shares a client will find. The --rpc-payment-credits switch selects how many credits are awarded for each share a client finds. Considering both options, clients will be awarded credits/difficulty credits for every hash they calculate. For example, in the command line above, 0.25 credits per hash. A client mining at 100 H/s will therefore get an average of 25 credits per second. For reference, in the current implementation, a credit is enough to sync 20 blocks, so a 100 H/s client that's just starting to use Monero and uses this daemon will be able to sync 500 blocks per second. The wallet can be set to automatically mine if connected to a daemon which requires payment for RPC usage. It will try to keep a balance of 50000 credits, stopping mining when it's at this level, and starting again as credits are spent. With the example above, a new client will mine this much credits in about half an hour, and this target is enough to sync 500000 blocks (currently about a third of the monero blockchain). There are three new settings in the wallet: - credits-target: this is the amount of credits a wallet will try to reach before stopping mining. The default of 0 means 50000 credits. - auto-mine-for-rpc-payment-threshold: this controls the minimum credit rate which the wallet considers worth mining for. If the daemon credits less than this ratio, the wallet will consider mining to be not worth it. In the example above, the rate is 0.25 - persistent-rpc-client-id: if set, this allows the wallet to reuse a client id across runs. This means a public node can tell a wallet that's connecting is the same as one that connected previously, but allows a wallet to keep their credit balance from one run to the other. Since the wallet only mines to keep a small credit balance, this is not normally worth doing. However, someone may want to mine on a fast server, and use that credit balance on a low power device such as a phone. If left unset, a new client ID is generated at each wallet start, for privacy reasons. To mine and use a credit balance on two different devices, you can use the --rpc-client-secret-key switch. A wallet's client secret key can be found using the new rpc_payments command in the wallet. Note: anyone knowing your RPC client secret key is able to use your credit balance. The wallet has a few new commands too: - start_mining_for_rpc: start mining to acquire more credits, regardless of the auto mining settings - stop_mining_for_rpc: stop mining to acquire more credits - rpc_payments: display information about current credits with the currently selected daemon The node has an extra command: - rpc_payments: display information about clients and their balances The node will forget about any balance for clients which have been inactive for 6 months. Balances carry over on node restart.
2018-02-11 15:15:56 +00:00
m_command_lookup.set_handler(
"rpc_payments"
, std::bind(&t_command_parser_executor::rpc_payments, &m_parser, p::_1)
, "Print information about RPC payments."
);
2018-04-13 17:12:17 +00:00
m_command_lookup.set_handler(
"version"
, std::bind(&t_command_parser_executor::version, &m_parser, p::_1)
, "Print version information."
);
m_command_lookup.set_handler(
"prune_blockchain"
, std::bind(&t_command_parser_executor::prune_blockchain, &m_parser, p::_1)
, "Prune the blockchain."
);
m_command_lookup.set_handler(
"check_blockchain_pruning"
, std::bind(&t_command_parser_executor::check_blockchain_pruning, &m_parser, p::_1)
, "Check the blockchain pruning."
);
m_command_lookup.set_handler(
"set_bootstrap_daemon"
, std::bind(&t_command_parser_executor::set_bootstrap_daemon, &m_parser, p::_1)
, "set_bootstrap_daemon (auto | none | host[:port] [username] [password])"
, "URL of a 'bootstrap' remote daemon that the connected wallets can use while this daemon is still not fully synced.\n"
"Use 'auto' to enable automatic public nodes discovering and bootstrap daemon switching"
);
m_command_lookup.set_handler(
"flush_cache"
, std::bind(&t_command_parser_executor::flush_cache, &m_parser, p::_1)
, "flush_cache [bad-txs] [bad-blocks]"
, "Flush the specified cache(s)."
);
}
bool t_command_server::process_command_str(const std::string& cmd)
{
return m_command_lookup.process_command_str(cmd);
}
bool t_command_server::process_command_vec(const std::vector<std::string>& cmd)
{
bool result = m_command_lookup.process_command_vec(cmd);
if (!result)
{
help(std::vector<std::string>());
}
return result;
}
bool t_command_server::start_handling(std::function<void(void)> exit_handler)
{
if (m_is_rpc) return false;
m_command_lookup.start_handling("", get_commands_str(), exit_handler);
return true;
}
void t_command_server::stop_handling()
{
if (m_is_rpc) return;
m_command_lookup.stop_handling();
}
bool t_command_server::help(const std::vector<std::string>& args)
{
2017-11-22 12:53:18 +00:00
if(args.empty())
{
std::cout << get_commands_str() << std::endl;
}
else
{
std::cout << get_command_usage(args) << std::endl;
}
return true;
}
std::string t_command_server::get_commands_str()
{
std::stringstream ss;
2015-12-31 21:12:13 +00:00
ss << "Monero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")" << std::endl;
ss << "Commands: " << std::endl;
std::string usage = m_command_lookup.get_usage();
boost::replace_all(usage, "\n", "\n ");
usage.insert(0, " ");
ss << usage << std::endl;
return ss.str();
}
2017-11-22 12:53:18 +00:00
std::string t_command_server::get_command_usage(const std::vector<std::string> &args)
{
std::pair<std::string, std::string> documentation = m_command_lookup.get_documentation(args);
std::stringstream ss;
if(documentation.first.empty())
{
ss << "Unknown command: " << args.front() << std::endl;
}
else
{
std::string usage = documentation.second.empty() ? args.front() : documentation.first;
std::string description = documentation.second.empty() ? documentation.first : documentation.second;
usage.insert(0, " ");
ss << "Command usage: " << std::endl << usage << std::endl << std::endl;
boost::replace_all(description, "\n", "\n ");
description.insert(0, " ");
ss << "Command description: " << std::endl << description << std::endl;
}
return ss.str();
}
} // namespace daemonize