mirror of
https://github.com/oxen-io/oxen-core.git
synced 2023-12-14 02:22:56 +01:00
Merge commit '082730b6e569e155988df5c5b376c45fba56b396' into MergeUpstream3
This commit is contained in:
commit
e98e787d88
|
@ -36,6 +36,7 @@ add_library(rpc_args
|
|||
)
|
||||
|
||||
add_library(rpc
|
||||
bootstrap_daemon.cpp
|
||||
core_rpc_server.cpp
|
||||
rpc_handler.cpp
|
||||
)
|
||||
|
|
95
src/rpc/bootstrap_daemon.cpp
Normal file
95
src/rpc/bootstrap_daemon.cpp
Normal file
|
@ -0,0 +1,95 @@
|
|||
#include "bootstrap_daemon.h"
|
||||
|
||||
#include <stdexcept>
|
||||
|
||||
#include "crypto/crypto.h"
|
||||
#include "cryptonote_core/cryptonote_core.h"
|
||||
#include "misc_log_ex.h"
|
||||
|
||||
#undef MONERO_DEFAULT_LOG_CATEGORY
|
||||
#define MONERO_DEFAULT_LOG_CATEGORY "daemon.rpc.bootstrap_daemon"
|
||||
|
||||
namespace cryptonote
|
||||
{
|
||||
|
||||
bootstrap_daemon::bootstrap_daemon(std::function<boost::optional<std::string>()> get_next_public_node) noexcept
|
||||
: m_get_next_public_node(get_next_public_node)
|
||||
{
|
||||
}
|
||||
|
||||
bootstrap_daemon::bootstrap_daemon(const std::string &address, const boost::optional<epee::net_utils::http::login> &credentials)
|
||||
: bootstrap_daemon(nullptr)
|
||||
{
|
||||
if (!set_server(address, credentials))
|
||||
{
|
||||
throw std::runtime_error("invalid bootstrap daemon address or credentials");
|
||||
}
|
||||
}
|
||||
|
||||
std::string bootstrap_daemon::address() const noexcept
|
||||
{
|
||||
const auto& host = m_http_client.get_host();
|
||||
if (host.empty())
|
||||
{
|
||||
return std::string();
|
||||
}
|
||||
return host + ":" + m_http_client.get_port();
|
||||
}
|
||||
|
||||
boost::optional<uint64_t> bootstrap_daemon::get_height()
|
||||
{
|
||||
// query bootstrap daemon's height
|
||||
cryptonote::rpc::GET_HEIGHT::request req{};
|
||||
cryptonote::rpc::GET_HEIGHT::response res{};
|
||||
if (!invoke_http_json("/getheight", req, res))
|
||||
{
|
||||
return boost::none;
|
||||
}
|
||||
|
||||
if (res.status != cryptonote::rpc::STATUS_OK)
|
||||
{
|
||||
return boost::none;
|
||||
}
|
||||
|
||||
return res.height;
|
||||
}
|
||||
|
||||
bool bootstrap_daemon::handle_result(bool success)
|
||||
{
|
||||
if (!success && m_get_next_public_node)
|
||||
{
|
||||
m_http_client.disconnect();
|
||||
}
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
bool bootstrap_daemon::set_server(const std::string &address, const boost::optional<epee::net_utils::http::login> &credentials /* = boost::none */)
|
||||
{
|
||||
if (!m_http_client.set_server(address, credentials))
|
||||
{
|
||||
MERROR("Failed to set bootstrap daemon address " << address);
|
||||
return false;
|
||||
}
|
||||
|
||||
MINFO("Changed bootstrap daemon address to " << address);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool bootstrap_daemon::switch_server_if_needed()
|
||||
{
|
||||
if (!m_get_next_public_node || m_http_client.is_connected())
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
const boost::optional<std::string> address = m_get_next_public_node();
|
||||
if (address) {
|
||||
return set_server(*address);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
}
|
67
src/rpc/bootstrap_daemon.h
Normal file
67
src/rpc/bootstrap_daemon.h
Normal file
|
@ -0,0 +1,67 @@
|
|||
#pragma once
|
||||
|
||||
#include <functional>
|
||||
#include <vector>
|
||||
|
||||
#include <boost/optional/optional.hpp>
|
||||
#include <boost/utility/string_ref.hpp>
|
||||
|
||||
#include "net/http_client.h"
|
||||
#include "storages/http_abstract_invoke.h"
|
||||
|
||||
namespace cryptonote
|
||||
{
|
||||
|
||||
class bootstrap_daemon
|
||||
{
|
||||
public:
|
||||
bootstrap_daemon(std::function<boost::optional<std::string>()> get_next_public_node) noexcept;
|
||||
bootstrap_daemon(const std::string &address, const boost::optional<epee::net_utils::http::login> &credentials);
|
||||
|
||||
std::string address() const noexcept;
|
||||
boost::optional<uint64_t> get_height();
|
||||
bool handle_result(bool success);
|
||||
|
||||
template <class t_request, class t_response>
|
||||
bool invoke_http_json(const boost::string_ref uri, const t_request &out_struct, t_response &result_struct)
|
||||
{
|
||||
if (!switch_server_if_needed())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
return handle_result(epee::net_utils::invoke_http_json(uri, out_struct, result_struct, m_http_client));
|
||||
}
|
||||
|
||||
template <class t_request, class t_response>
|
||||
bool invoke_http_bin(const boost::string_ref uri, const t_request &out_struct, t_response &result_struct)
|
||||
{
|
||||
if (!switch_server_if_needed())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
return handle_result(epee::net_utils::invoke_http_bin(uri, out_struct, result_struct, m_http_client));
|
||||
}
|
||||
|
||||
template <class t_request, class t_response>
|
||||
bool invoke_http_json_rpc(const boost::string_ref command_name, const t_request &out_struct, t_response &result_struct)
|
||||
{
|
||||
if (!switch_server_if_needed())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
return handle_result(epee::net_utils::invoke_http_json_rpc("/json_rpc", std::string(command_name.begin(), command_name.end()), out_struct, result_struct, m_http_client));
|
||||
}
|
||||
|
||||
private:
|
||||
bool set_server(const std::string &address, const boost::optional<epee::net_utils::http::login> &credentials = boost::none);
|
||||
bool switch_server_if_needed();
|
||||
|
||||
private:
|
||||
epee::net_utils::http::http_simple_client m_http_client;
|
||||
std::function<boost::optional<std::string>()> m_get_next_public_node;
|
||||
};
|
||||
|
||||
}
|
|
@ -188,7 +188,8 @@ namespace cryptonote { namespace rpc {
|
|||
|
||||
const command_line::arg_descriptor<std::string> core_rpc_server::arg_bootstrap_daemon_address = {
|
||||
"bootstrap-daemon-address"
|
||||
, "URL of a 'bootstrap' remote daemon that the connected wallets can use while this daemon is still not fully synced"
|
||||
, "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"
|
||||
, ""
|
||||
};
|
||||
|
||||
|
@ -225,27 +226,70 @@ namespace cryptonote { namespace rpc {
|
|||
return set_bootstrap_daemon(address, credentials);
|
||||
}
|
||||
//------------------------------------------------------------------------------------------------------------------------------
|
||||
boost::optional<std::string> core_rpc_server::get_random_public_node()
|
||||
{
|
||||
GET_PUBLIC_NODES::response response{};
|
||||
try
|
||||
{
|
||||
GET_PUBLIC_NODES::request request{};
|
||||
request.gray = true;
|
||||
request.white = true;
|
||||
|
||||
rpc_context context = {};
|
||||
context.admin = true;
|
||||
response = invoke(std::move(request), context);
|
||||
}
|
||||
catch(const std::exception &e)
|
||||
{
|
||||
return boost::none;
|
||||
}
|
||||
|
||||
const auto get_random_node_address = [](const std::vector<public_node>& public_nodes) -> std::string {
|
||||
const auto& random_node = public_nodes[crypto::rand_idx(public_nodes.size())];
|
||||
const auto address = random_node.host + ":" + std::to_string(random_node.rpc_port);
|
||||
return address;
|
||||
};
|
||||
|
||||
if (!response.white.empty())
|
||||
{
|
||||
return get_random_node_address(response.white);
|
||||
}
|
||||
|
||||
MDEBUG("No white public node found, checking gray peers");
|
||||
|
||||
if (!response.gray.empty())
|
||||
{
|
||||
return get_random_node_address(response.gray);
|
||||
}
|
||||
|
||||
MERROR("Failed to find any suitable public node");
|
||||
return boost::none;
|
||||
}
|
||||
//------------------------------------------------------------------------------------------------------------------------------
|
||||
bool core_rpc_server::set_bootstrap_daemon(const std::string &address, const boost::optional<epee::net_utils::http::login> &credentials)
|
||||
{
|
||||
boost::unique_lock<boost::shared_mutex> lock(m_bootstrap_daemon_mutex);
|
||||
|
||||
if (!address.empty())
|
||||
if (address.empty())
|
||||
{
|
||||
if (!m_http_client.set_server(address, credentials, epee::net_utils::ssl_support_t::e_ssl_support_autodetect))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
m_bootstrap_daemon.reset(nullptr);
|
||||
}
|
||||
else if (address == "auto")
|
||||
{
|
||||
m_bootstrap_daemon.reset(new bootstrap_daemon([this]{ return get_random_public_node(); }));
|
||||
}
|
||||
else
|
||||
{
|
||||
m_bootstrap_daemon.reset(new bootstrap_daemon(address, credentials));
|
||||
}
|
||||
|
||||
m_bootstrap_daemon_address = address;
|
||||
m_should_use_bootstrap_daemon = !m_bootstrap_daemon_address.empty();
|
||||
m_should_use_bootstrap_daemon = m_bootstrap_daemon.get() != nullptr;
|
||||
|
||||
return true;
|
||||
}
|
||||
//------------------------------------------------------------------------------------------------------------------------------
|
||||
void core_rpc_server::init(const boost::program_options::variables_map& vm)
|
||||
{
|
||||
m_bootstrap_daemon_address = command_line::get_arg(vm, arg_bootstrap_daemon_address);
|
||||
if (!set_bootstrap_daemon(command_line::get_arg(vm, arg_bootstrap_daemon_address),
|
||||
command_line::get_arg(vm, arg_bootstrap_daemon_login)))
|
||||
{
|
||||
|
@ -297,7 +341,10 @@ namespace cryptonote { namespace rpc {
|
|||
{
|
||||
{
|
||||
boost::shared_lock<boost::shared_mutex> lock(m_bootstrap_daemon_mutex);
|
||||
res.bootstrap_daemon_address = m_bootstrap_daemon_address;
|
||||
if (m_bootstrap_daemon.get() != nullptr)
|
||||
{
|
||||
res.bootstrap_daemon_address = m_bootstrap_daemon->address();
|
||||
}
|
||||
}
|
||||
crypto::hash top_hash;
|
||||
m_core.get_blockchain_top(res.height_without_bootstrap, top_hash);
|
||||
|
@ -369,7 +416,10 @@ namespace cryptonote { namespace rpc {
|
|||
else
|
||||
{
|
||||
boost::shared_lock<boost::shared_mutex> lock(m_bootstrap_daemon_mutex);
|
||||
res.bootstrap_daemon_address = m_bootstrap_daemon_address;
|
||||
if (m_bootstrap_daemon.get() != nullptr)
|
||||
{
|
||||
res.bootstrap_daemon_address = m_bootstrap_daemon->address();
|
||||
}
|
||||
res.was_bootstrap_ever_used = m_was_bootstrap_ever_used;
|
||||
}
|
||||
res.database_size = m_core.get_blockchain_storage().get_db().get_database_size();
|
||||
|
@ -1670,11 +1720,12 @@ namespace cryptonote { namespace rpc {
|
|||
boost::upgrade_lock<boost::shared_mutex> core_rpc_server::should_bootstrap_lock()
|
||||
{
|
||||
// TODO - support bootstrapping via a remote LMQ RPC; requires some argument fiddling
|
||||
|
||||
if (m_bootstrap_daemon_address.empty() || !m_should_use_bootstrap_daemon)
|
||||
return {};
|
||||
|
||||
boost::upgrade_lock<boost::shared_mutex> lock(m_bootstrap_daemon_mutex);
|
||||
if (!m_should_use_bootstrap_daemon || m_bootstrap_daemon.get() == nullptr)
|
||||
{
|
||||
lock.unlock();
|
||||
return lock;
|
||||
}
|
||||
|
||||
auto current_time = std::chrono::system_clock::now();
|
||||
if (current_time - m_bootstrap_height_check_time > 30s) // update every 30s
|
||||
|
@ -1684,20 +1735,27 @@ namespace cryptonote { namespace rpc {
|
|||
m_bootstrap_height_check_time = current_time;
|
||||
}
|
||||
|
||||
uint64_t top_height;
|
||||
crypto::hash top_hash;
|
||||
m_core.get_blockchain_top(top_height, top_hash);
|
||||
++top_height; // turn top block height into blockchain height
|
||||
boost::optional<uint64_t> bootstrap_daemon_height = m_bootstrap_daemon->get_height();
|
||||
if (!bootstrap_daemon_height)
|
||||
{
|
||||
MERROR("Failed to fetch bootstrap daemon height");
|
||||
lock.unlock();
|
||||
return lock;
|
||||
}
|
||||
|
||||
// query bootstrap daemon's height
|
||||
cryptonote::rpc::GET_HEIGHT::request getheight_req{};
|
||||
cryptonote::rpc::GET_HEIGHT::response getheight_res{};
|
||||
m_should_use_bootstrap_daemon = (
|
||||
epee::net_utils::invoke_http_json("/getheight", getheight_req, getheight_res, m_http_client)
|
||||
&& getheight_res.status == STATUS_OK
|
||||
&& top_height + 10 < getheight_res.height);
|
||||
uint64_t target_height = m_core.get_target_blockchain_height();
|
||||
if (bootstrap_daemon_height < target_height)
|
||||
{
|
||||
MINFO("Bootstrap daemon is out of sync");
|
||||
lock.unlock();
|
||||
m_bootstrap_daemon->handle_result(false);
|
||||
return lock;
|
||||
}
|
||||
|
||||
uint64_t top_height = m_core.get_current_blockchain_height();
|
||||
m_should_use_bootstrap_daemon = top_height + 10 < bootstrap_daemon_height;
|
||||
MINFO((m_should_use_bootstrap_daemon ? "Using" : "Not using") << " the bootstrap daemon (our height: " << top_height << ", bootstrap daemon's height: " << *bootstrap_daemon_height << ")");
|
||||
|
||||
MINFO((m_should_use_bootstrap_daemon ? "Using" : "Not using") << " the bootstrap daemon (our height: " << top_height << ", bootstrap daemon's height: " << getheight_res.height << ")");
|
||||
}
|
||||
|
||||
if (!m_should_use_bootstrap_daemon)
|
||||
|
@ -1705,6 +1763,7 @@ namespace cryptonote { namespace rpc {
|
|||
MINFO("The local daemon is fully synced; disabling bootstrap daemon requests");
|
||||
lock.unlock();
|
||||
}
|
||||
|
||||
return lock;
|
||||
}
|
||||
|
||||
|
@ -1727,7 +1786,7 @@ namespace cryptonote { namespace rpc {
|
|||
|
||||
bool success;
|
||||
if (std::is_base_of<BINARY, RPC>::value)
|
||||
success = epee::net_utils::invoke_http_bin(command_name, req, res, m_http_client);
|
||||
success = m_bootstrap_daemon->invoke_http_bin(command_name, req, res);
|
||||
else
|
||||
{
|
||||
// FIXME: this type explosion of having to instantiate nested types is an epee pain point:
|
||||
|
@ -1739,7 +1798,7 @@ namespace cryptonote { namespace rpc {
|
|||
json_req.id = epee::serialization::storage_entry(0);
|
||||
json_req.method = command_name;
|
||||
json_req.params = req;
|
||||
success = epee::net_utils::invoke_http_json("/json_rpc", json_req, json_resp, m_http_client);
|
||||
success = m_bootstrap_daemon->invoke_http_json_rpc(command_name, json_req, json_resp);
|
||||
if (success)
|
||||
res = std::move(json_resp.result);
|
||||
}
|
||||
|
|
|
@ -32,6 +32,13 @@
|
|||
#pragma once
|
||||
|
||||
#include <mapbox/variant.hpp>
|
||||
#include <memory>
|
||||
|
||||
#include <boost/program_options/options_description.hpp>
|
||||
#include <boost/program_options/variables_map.hpp>
|
||||
|
||||
#include "bootstrap_daemon.h"
|
||||
#include "net/http_server_impl_base.h"
|
||||
#include "net/http_client.h"
|
||||
#include "core_rpc_server_commands_defs.h"
|
||||
#include "cryptonote_core/cryptonote_core.h"
|
||||
|
@ -300,6 +307,7 @@ private:
|
|||
|
||||
//utils
|
||||
uint64_t get_block_reward(const block& blk);
|
||||
boost::optional<std::string> get_random_public_node();
|
||||
bool set_bootstrap_daemon(const std::string &address, const std::string &username_password);
|
||||
bool set_bootstrap_daemon(const std::string &address, const boost::optional<epee::net_utils::http::login> &credentials);
|
||||
void fill_block_header_response(const block& blk, bool orphan_status, uint64_t height, const crypto::hash& hash, block_header_response& response, bool fill_pow_hash);
|
||||
|
@ -310,10 +318,9 @@ private:
|
|||
|
||||
core& m_core;
|
||||
nodetool::node_server<cryptonote::t_cryptonote_protocol_handler<cryptonote::core> >& m_p2p;
|
||||
std::string m_bootstrap_daemon_address;
|
||||
epee::net_utils::http::http_simple_client m_http_client;
|
||||
boost::shared_mutex m_bootstrap_daemon_mutex;
|
||||
std::atomic<bool> m_should_use_bootstrap_daemon;
|
||||
std::unique_ptr<bootstrap_daemon> m_bootstrap_daemon;
|
||||
std::chrono::system_clock::time_point m_bootstrap_height_check_time;
|
||||
bool m_was_bootstrap_ever_used;
|
||||
network_type m_nettype;
|
||||
|
|
Loading…
Reference in a new issue