mirror of
https://git.wownero.com/wownero/wownero.git
synced 2024-08-15 01:03:23 +00:00
155 lines
6 KiB
C++
155 lines
6 KiB
C++
// Copyright (c) 2014-2022, 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.
|
|
|
|
#pragma once
|
|
|
|
#include "misc_log_ex.h"
|
|
#include "daemon/daemon.h"
|
|
#include "rpc/daemon_handler.h"
|
|
#include "rpc/zmq_server.h"
|
|
#include "common/password.h"
|
|
#include "common/util.h"
|
|
#include "daemon/core.h"
|
|
#include "daemon/p2p.h"
|
|
#include "daemon/protocol.h"
|
|
#include "daemon/rpc.h"
|
|
#include "daemon/command_server.h"
|
|
#include "daemon/command_server.h"
|
|
#include "daemon/command_line_args.h"
|
|
#include "version.h"
|
|
#include "tools.h"
|
|
|
|
|
|
class mock_rpc_daemon : public cryptonote::core_rpc_server {
|
|
public:
|
|
mock_rpc_daemon(
|
|
cryptonote::core& cr
|
|
, nodetool::node_server<cryptonote::t_cryptonote_protocol_handler<cryptonote::core> >& p2p
|
|
): cryptonote::core_rpc_server(cr, p2p) {}
|
|
|
|
static void init_options(boost::program_options::options_description& desc){ cryptonote::core_rpc_server::init_options(desc); }
|
|
cryptonote::network_type nettype() const { return m_network_type; }
|
|
void nettype(cryptonote::network_type nettype) { m_network_type = nettype; }
|
|
|
|
CHAIN_HTTP_TO_MAP2(cryptonote::core_rpc_server::connection_context); //forward http requests to uri map
|
|
BEGIN_URI_MAP2()
|
|
MAP_URI_AUTO_JON2("/send_raw_transaction", on_send_raw_tx_2, cryptonote::COMMAND_RPC_SEND_RAW_TX)
|
|
MAP_URI_AUTO_JON2("/sendrawtransaction", on_send_raw_tx_2, cryptonote::COMMAND_RPC_SEND_RAW_TX)
|
|
else { // Default to parent for non-overriden callbacks
|
|
return cryptonote::core_rpc_server::handle_http_request_map(query_info, response_info, m_conn_context);
|
|
}
|
|
END_URI_MAP2()
|
|
|
|
bool 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);
|
|
|
|
protected:
|
|
cryptonote::network_type m_network_type;
|
|
};
|
|
|
|
class mock_daemon {
|
|
public:
|
|
typedef cryptonote::t_cryptonote_protocol_handler<cryptonote::core> t_protocol_raw;
|
|
typedef nodetool::node_server<t_protocol_raw> t_node_server;
|
|
|
|
static constexpr const std::chrono::seconds rpc_timeout = std::chrono::seconds(120);
|
|
|
|
cryptonote::core * m_core;
|
|
t_protocol_raw m_protocol;
|
|
mock_rpc_daemon m_rpc_server;
|
|
t_node_server m_server;
|
|
cryptonote::network_type m_network_type;
|
|
epee::net_utils::http::http_simple_client m_http_client;
|
|
|
|
bool m_start_p2p;
|
|
bool m_start_zmq;
|
|
boost::program_options::variables_map m_vm;
|
|
|
|
std::string m_p2p_bind_port;
|
|
std::string m_rpc_bind_port;
|
|
std::string m_zmq_bind_port;
|
|
|
|
std::atomic<bool> m_stopped;
|
|
std::atomic<bool> m_terminated;
|
|
std::atomic<bool> m_deinitalized;
|
|
boost::thread m_run_thread;
|
|
|
|
mock_daemon(
|
|
cryptonote::core * core,
|
|
boost::program_options::variables_map const & vm
|
|
)
|
|
: m_core(core)
|
|
, m_vm(vm)
|
|
, m_start_p2p(false)
|
|
, m_start_zmq(false)
|
|
, m_terminated(false)
|
|
, m_deinitalized(false)
|
|
, m_stopped(false)
|
|
, m_protocol{*core, nullptr, command_line::get_arg(vm, cryptonote::arg_offline)}
|
|
, m_server{m_protocol}
|
|
, m_rpc_server{*core, m_server}
|
|
{
|
|
// Handle circular dependencies
|
|
m_protocol.set_p2p_endpoint(&m_server);
|
|
m_core->set_cryptonote_protocol(&m_protocol);
|
|
load_params(vm);
|
|
}
|
|
|
|
virtual ~mock_daemon();
|
|
|
|
static void init_options(boost::program_options::options_description & option_spec);
|
|
static void default_options(boost::program_options::variables_map & vm);
|
|
static void set_ports(boost::program_options::variables_map & vm, unsigned initial_port);
|
|
|
|
mock_daemon * set_start_p2p(bool fl) { m_start_p2p = fl; return this; }
|
|
mock_daemon * set_start_zmq(bool fl) { m_start_zmq = fl; return this; }
|
|
|
|
void init();
|
|
void deinit();
|
|
void run();
|
|
bool run_main();
|
|
void stop();
|
|
void stop_p2p();
|
|
void stop_rpc();
|
|
void init_and_run();
|
|
void stop_and_deinit();
|
|
void try_init_and_run(boost::optional<unsigned> initial_port=boost::none);
|
|
|
|
void mine_blocks(size_t num_blocks, const std::string &miner_address);
|
|
void start_mining(const std::string &miner_address, uint64_t threads_count=1, bool do_background_mining=false, bool ignore_battery=true);
|
|
void stop_mining();
|
|
uint64_t get_height();
|
|
|
|
void load_params(boost::program_options::variables_map const & vm);
|
|
|
|
std::string zmq_addr() const { return std::string("127.0.0.1:") + m_zmq_bind_port; }
|
|
std::string rpc_addr() const { return std::string("127.0.0.1:") + m_rpc_bind_port; }
|
|
std::string p2p_addr() const { return std::string("127.0.0.1:") + m_p2p_bind_port; }
|
|
cryptonote::network_type nettype() const { return m_network_type; }
|
|
cryptonote::core * core() const { return m_core; }
|
|
};
|