mirror of
https://git.wownero.com/wownero/wownero.git
synced 2024-08-15 01:03:23 +00:00
375 lines
12 KiB
C++
375 lines
12 KiB
C++
// Copyright (c) 2014-2018, The Monero Project
|
|
//
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without modification, are
|
|
// permitted provided that the following conditions are met:
|
|
//
|
|
// 1. Redistributions of source code must retain the above copyright notice, this list of
|
|
// conditions and the following disclaimer.
|
|
//
|
|
// 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.
|
|
//
|
|
// 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.
|
|
//
|
|
// 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 "daemon.h"
|
|
#include <common/command_line.h>
|
|
|
|
using namespace std;
|
|
using namespace daemonize;
|
|
namespace po = boost::program_options;
|
|
|
|
bool mock_rpc_daemon::on_send_raw_tx_2(const cryptonote::COMMAND_RPC_SEND_RAW_TX::request& req, cryptonote::COMMAND_RPC_SEND_RAW_TX::response& res, const cryptonote::core_rpc_server::connection_context *ctx)
|
|
{
|
|
cryptonote::COMMAND_RPC_SEND_RAW_TX::request req2(req);
|
|
req2.do_not_relay = true; // Do not relay in test setup, only one daemon running.
|
|
return cryptonote::core_rpc_server::on_send_raw_tx(req2, res, ctx);
|
|
}
|
|
|
|
void mock_daemon::init_options(boost::program_options::options_description & option_spec)
|
|
{
|
|
cryptonote::core::init_options(option_spec);
|
|
t_node_server::init_options(option_spec);
|
|
cryptonote::core_rpc_server::init_options(option_spec);
|
|
|
|
command_line::add_arg(option_spec, daemon_args::arg_zmq_rpc_bind_ip);
|
|
command_line::add_arg(option_spec, daemon_args::arg_zmq_rpc_bind_port);
|
|
}
|
|
|
|
void mock_daemon::default_options(boost::program_options::variables_map & vm)
|
|
{
|
|
std::vector<std::string> exclusive_nodes{"127.0.0.1:65525"};
|
|
tools::options::set_option(vm, nodetool::arg_p2p_add_exclusive_node, po::variable_value(exclusive_nodes, false));
|
|
|
|
tools::options::set_option(vm, nodetool::arg_p2p_bind_ip, po::variable_value(std::string("127.0.0.1"), false));
|
|
tools::options::set_option(vm, nodetool::arg_no_igd, po::variable_value(true, false));
|
|
tools::options::set_option(vm, cryptonote::arg_offline, po::variable_value(true, false));
|
|
tools::options::set_option(vm, "disable-dns-checkpoints", po::variable_value(true, false));
|
|
|
|
const char *test_mainnet = getenv("TEST_MAINNET");
|
|
if (!test_mainnet || atoi(test_mainnet) == 0)
|
|
{
|
|
tools::options::set_option(vm, cryptonote::arg_testnet_on, po::variable_value(true, false));
|
|
}
|
|
|
|
// By default pick non-standard ports to avoid confusion with possibly locally running daemons (mainnet/testnet)
|
|
const char *test_p2p_port = getenv("TEST_P2P_PORT");
|
|
auto p2p_port = std::string(test_p2p_port && strlen(test_p2p_port) > 0 ? test_p2p_port : "61340");
|
|
tools::options::set_option(vm, nodetool::arg_p2p_bind_port, po::variable_value(p2p_port, false));
|
|
|
|
const char *test_rpc_port = getenv("TEST_RPC_PORT");
|
|
auto rpc_port = std::string(test_rpc_port && strlen(test_rpc_port) > 0 ? test_rpc_port : "61341");
|
|
tools::options::set_option(vm, cryptonote::core_rpc_server::arg_rpc_bind_port, po::variable_value(rpc_port, false));
|
|
|
|
const char *test_zmq_port = getenv("TEST_ZMQ_PORT");
|
|
auto zmq_port = std::string(test_zmq_port && strlen(test_zmq_port) > 0 ? test_zmq_port : "61342");
|
|
tools::options::set_option(vm, daemon_args::arg_zmq_rpc_bind_port, po::variable_value(zmq_port, false));
|
|
|
|
po::notify(vm);
|
|
}
|
|
|
|
void mock_daemon::set_ports(boost::program_options::variables_map & vm, unsigned initial_port)
|
|
{
|
|
CHECK_AND_ASSERT_THROW_MES(initial_port < 65535-2, "Invalid port number");
|
|
tools::options::set_option(vm, nodetool::arg_p2p_bind_port, po::variable_value(std::to_string(initial_port), false));
|
|
tools::options::set_option(vm, cryptonote::core_rpc_server::arg_rpc_bind_port, po::variable_value(std::to_string(initial_port + 1), false));
|
|
tools::options::set_option(vm, daemon_args::arg_zmq_rpc_bind_port, po::variable_value(std::to_string(initial_port + 2), false));
|
|
po::notify(vm);
|
|
}
|
|
|
|
void mock_daemon::load_params(boost::program_options::variables_map const & vm)
|
|
{
|
|
m_p2p_bind_port = command_line::get_arg(vm, nodetool::arg_p2p_bind_port);
|
|
m_rpc_bind_port = command_line::get_arg(vm, cryptonote::core_rpc_server::arg_rpc_bind_port);
|
|
m_zmq_bind_port = command_line::get_arg(vm, daemon_args::arg_zmq_rpc_bind_port);
|
|
m_network_type = command_line::get_arg(vm, cryptonote::arg_testnet_on) ? cryptonote::TESTNET : cryptonote::MAINNET;
|
|
}
|
|
|
|
mock_daemon::~mock_daemon()
|
|
{
|
|
if(m_http_client.is_connected())
|
|
m_http_client.disconnect();
|
|
|
|
if (!m_terminated)
|
|
{
|
|
try
|
|
{
|
|
stop();
|
|
}
|
|
catch (...)
|
|
{
|
|
MERROR("Failed to stop");
|
|
}
|
|
}
|
|
|
|
if (!m_deinitalized)
|
|
{
|
|
deinit();
|
|
}
|
|
}
|
|
|
|
void mock_daemon::init()
|
|
{
|
|
m_deinitalized = false;
|
|
const auto main_rpc_port = command_line::get_arg(m_vm, cryptonote::core_rpc_server::arg_rpc_bind_port);
|
|
m_rpc_server.nettype(m_network_type);
|
|
|
|
CHECK_AND_ASSERT_THROW_MES(m_protocol.init(m_vm), "Failed to initialize cryptonote protocol.");
|
|
CHECK_AND_ASSERT_THROW_MES(m_rpc_server.init(m_vm, false, main_rpc_port), "Failed to initialize RPC server.");
|
|
|
|
if (m_start_p2p)
|
|
CHECK_AND_ASSERT_THROW_MES(m_server.init(m_vm), "Failed to initialize p2p server.");
|
|
|
|
if(m_http_client.is_connected())
|
|
m_http_client.disconnect();
|
|
|
|
CHECK_AND_ASSERT_THROW_MES(m_http_client.set_server(rpc_addr(), boost::none, epee::net_utils::ssl_support_t::e_ssl_support_disabled), "RPC client init fail");
|
|
}
|
|
|
|
void mock_daemon::deinit()
|
|
{
|
|
if(m_http_client.is_connected())
|
|
m_http_client.disconnect();
|
|
|
|
try
|
|
{
|
|
m_rpc_server.deinit();
|
|
}
|
|
catch (...)
|
|
{
|
|
MERROR("Failed to deinitialize RPC server...");
|
|
}
|
|
|
|
if (m_start_p2p)
|
|
{
|
|
try
|
|
{
|
|
m_server.deinit();
|
|
}
|
|
catch (...)
|
|
{
|
|
MERROR("Failed to deinitialize p2p...");
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
m_protocol.deinit();
|
|
m_protocol.set_p2p_endpoint(nullptr);
|
|
}
|
|
catch (...)
|
|
{
|
|
MERROR("Failed to stop cryptonote protocol!");
|
|
}
|
|
|
|
m_deinitalized = true;
|
|
}
|
|
|
|
void mock_daemon::init_and_run()
|
|
{
|
|
init();
|
|
run();
|
|
}
|
|
|
|
void mock_daemon::stop_and_deinit()
|
|
{
|
|
stop();
|
|
deinit();
|
|
}
|
|
|
|
void mock_daemon::try_init_and_run(boost::optional<unsigned> initial_port)
|
|
{
|
|
const unsigned max_attempts = 3;
|
|
for(unsigned attempts=0; attempts < max_attempts; ++attempts)
|
|
{
|
|
if (initial_port)
|
|
{
|
|
set_ports(m_vm, initial_port.get());
|
|
load_params(m_vm);
|
|
MDEBUG("Ports changed, RPC: " << rpc_addr());
|
|
}
|
|
|
|
try
|
|
{
|
|
init_and_run();
|
|
return;
|
|
}
|
|
catch(const std::exception &e)
|
|
{
|
|
MWARNING("Could not init and start, attempt: " << attempts << ", reason: " << e.what());
|
|
if (attempts + 1 >= max_attempts)
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void mock_daemon::run()
|
|
{
|
|
m_run_thread = boost::thread(boost::bind(&mock_daemon::run_main, this));
|
|
}
|
|
|
|
bool mock_daemon::run_main()
|
|
{
|
|
CHECK_AND_ASSERT_THROW_MES(!m_terminated, "Can't run stopped daemon");
|
|
CHECK_AND_ASSERT_THROW_MES(!m_start_zmq || m_start_p2p, "ZMQ requires P2P");
|
|
boost::thread stop_thread = boost::thread([this] {
|
|
while (!this->m_stopped)
|
|
epee::misc_utils::sleep_no_w(100);
|
|
this->stop_p2p();
|
|
});
|
|
|
|
epee::misc_utils::auto_scope_leave_caller scope_exit_handler = epee::misc_utils::create_scope_leave_handler([&](){
|
|
m_stopped = true;
|
|
stop_thread.join();
|
|
});
|
|
|
|
try
|
|
{
|
|
CHECK_AND_ASSERT_THROW_MES(m_rpc_server.run(2, false), "Failed to start RPC");
|
|
cryptonote::rpc::DaemonHandler rpc_daemon_handler(*m_core, m_server);
|
|
cryptonote::rpc::ZmqServer zmq_server(rpc_daemon_handler);
|
|
|
|
if (m_start_zmq)
|
|
{
|
|
if (!zmq_server.addTCPSocket("127.0.0.1", m_zmq_bind_port))
|
|
{
|
|
MERROR("Failed to add TCP Socket (127.0.0.1:" << m_zmq_bind_port << ") to ZMQ RPC Server");
|
|
|
|
stop_rpc();
|
|
return false;
|
|
}
|
|
|
|
MINFO("Starting ZMQ server...");
|
|
zmq_server.run();
|
|
|
|
MINFO("ZMQ server started at 127.0.0.1: " << m_zmq_bind_port);
|
|
}
|
|
|
|
if (m_start_p2p)
|
|
{
|
|
m_server.run(); // blocks until p2p goes down
|
|
}
|
|
else
|
|
{
|
|
while (!this->m_stopped)
|
|
epee::misc_utils::sleep_no_w(100);
|
|
}
|
|
|
|
if (m_start_zmq)
|
|
zmq_server.stop();
|
|
|
|
stop_rpc();
|
|
return true;
|
|
}
|
|
catch (std::exception const & ex)
|
|
{
|
|
MFATAL("Uncaught exception! " << ex.what());
|
|
return false;
|
|
}
|
|
catch (...)
|
|
{
|
|
MFATAL("Uncaught exception!");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void mock_daemon::stop()
|
|
{
|
|
CHECK_AND_ASSERT_THROW_MES(!m_terminated, "Can't stop stopped daemon");
|
|
m_stopped = true;
|
|
m_terminated = true;
|
|
m_run_thread.join();
|
|
}
|
|
|
|
void mock_daemon::stop_rpc()
|
|
{
|
|
m_rpc_server.send_stop_signal();
|
|
m_rpc_server.timed_wait_server_stop(5000);
|
|
}
|
|
|
|
void mock_daemon::stop_p2p()
|
|
{
|
|
if (m_start_p2p)
|
|
m_server.send_stop_signal();
|
|
}
|
|
|
|
void mock_daemon::mine_blocks(size_t num_blocks, const std::string &miner_address)
|
|
{
|
|
bool blocks_mined = false;
|
|
const uint64_t start_height = get_height();
|
|
const auto mining_timeout = std::chrono::seconds(30);
|
|
MDEBUG("Current height before mining: " << start_height);
|
|
|
|
start_mining(miner_address);
|
|
auto mining_started = std::chrono::system_clock::now();
|
|
|
|
while(true) {
|
|
epee::misc_utils::sleep_no_w(100);
|
|
const uint64_t cur_height = get_height();
|
|
|
|
if (cur_height - start_height >= num_blocks)
|
|
{
|
|
MDEBUG("Cur blocks: " << cur_height << " start: " << start_height);
|
|
blocks_mined = true;
|
|
break;
|
|
}
|
|
|
|
auto current_time = std::chrono::system_clock::now();
|
|
if (mining_timeout < current_time - mining_started)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
stop_mining();
|
|
CHECK_AND_ASSERT_THROW_MES(blocks_mined, "Mining failed in the time limit");
|
|
}
|
|
|
|
constexpr const std::chrono::seconds mock_daemon::rpc_timeout;
|
|
|
|
void mock_daemon::start_mining(const std::string &miner_address, uint64_t threads_count, bool do_background_mining, bool ignore_battery)
|
|
{
|
|
cryptonote::COMMAND_RPC_START_MINING::request req;
|
|
req.miner_address = miner_address;
|
|
req.threads_count = threads_count;
|
|
req.do_background_mining = do_background_mining;
|
|
req.ignore_battery = ignore_battery;
|
|
|
|
cryptonote::COMMAND_RPC_START_MINING::response resp;
|
|
bool r = epee::net_utils::invoke_http_json("/start_mining", req, resp, m_http_client, rpc_timeout);
|
|
CHECK_AND_ASSERT_THROW_MES(r, "RPC error - start mining");
|
|
CHECK_AND_ASSERT_THROW_MES(resp.status != CORE_RPC_STATUS_BUSY, "Daemon busy");
|
|
CHECK_AND_ASSERT_THROW_MES(resp.status == CORE_RPC_STATUS_OK, "Daemon response invalid: " << resp.status);
|
|
}
|
|
|
|
void mock_daemon::stop_mining()
|
|
{
|
|
cryptonote::COMMAND_RPC_STOP_MINING::request req;
|
|
cryptonote::COMMAND_RPC_STOP_MINING::response resp;
|
|
bool r = epee::net_utils::invoke_http_json("/stop_mining", req, resp, m_http_client, rpc_timeout);
|
|
CHECK_AND_ASSERT_THROW_MES(r, "RPC error - stop mining");
|
|
CHECK_AND_ASSERT_THROW_MES(resp.status != CORE_RPC_STATUS_BUSY, "Daemon busy");
|
|
CHECK_AND_ASSERT_THROW_MES(resp.status == CORE_RPC_STATUS_OK, "Daemon response invalid: " << resp.status);
|
|
}
|
|
|
|
uint64_t mock_daemon::get_height()
|
|
{
|
|
return m_core->get_blockchain_storage().get_current_blockchain_height();
|
|
}
|