Skip to content
Permalink
Browse files

daemon: automatic public nodes discovering and bootstrap daemon switc…

…hing
  • Loading branch information...
xiphon committed Aug 9, 2019
1 parent 1bb4ae3 commit 0e129639ade282b68151764908875f755036e494
Showing with 229 additions and 36 deletions.
  1. +184 −0 src/rpc/bootstrap_daemon.h
  2. +41 −34 src/rpc/core_rpc_server.cpp
  3. +4 −2 src/rpc/core_rpc_server.h
@@ -0,0 +1,184 @@
#pragma once

#include <iterator>
#include <list>
#include <stdexcept>
#include <vector>

#include <boost/utility/string_ref.hpp>

#include "crypto/crypto.h"
#include "cryptonote_core/cryptonote_core.h"
#include "cryptonote_protocol/cryptonote_protocol_handler.h"
#include "misc_log_ex.h"
#include "net/http_client.h"
#include "p2p/net_node.h"
#include "p2p/p2p_protocol_defs.h"
#include "storages/http_abstract_invoke.h"

#undef MONERO_DEFAULT_LOG_CATEGORY
#define MONERO_DEFAULT_LOG_CATEGORY "daemon.bootstrap_daemon"

namespace cryptonote
{

class bootstrap_daemon
{
public:
bootstrap_daemon(nodetool::node_server<cryptonote::t_cryptonote_protocol_handler<cryptonote::core>> *p2p)
: m_last_result(false)
, m_p2p(p2p)
{
}

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");
}
}

const std::string &address() const noexcept
{
return m_address;
}

bool get_height(uint64_t *height) noexcept
{
cryptonote::COMMAND_RPC_GET_HEIGHT::request getheight_req;
cryptonote::COMMAND_RPC_GET_HEIGHT::response getheight_res;

if (!invoke_http_json("/getheight", getheight_req, getheight_res))
{
return false;
}

if (getheight_res.status != CORE_RPC_STATUS_OK)
{
return false;
}

*height = getheight_res.height;

return true;
}

bool handle_result(bool success)
{
return m_last_result = 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) noexcept
{
if (!switch_daemon_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) noexcept
{
if (!switch_daemon_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) noexcept
{
if (!switch_daemon_if_needed())
{
return false;
}

epee::json_rpc::request<t_request> json_req = AUTO_VAL_INIT(json_req);
epee::json_rpc::response<t_response, std::string> json_resp = AUTO_VAL_INIT(json_resp);
json_req.jsonrpc = "2.0";
json_req.id = epee::serialization::storage_entry(0);
json_req.method = std::string(command_name.begin(), command_name.end());
json_req.params = out_struct;

if (!handle_result(epee::net_utils::invoke_http_json("/json_rpc", json_req, json_resp, m_http_client)))
{
return false;
}

result_struct = json_resp.result;
return true;
}

private:
bool set_server(const std::string &address, const boost::optional<epee::net_utils::http::login> &credentials) noexcept
{
if (!m_http_client.set_server(address, credentials))
{
MERROR("Failed to set bootstrap daemon address " << address);
return false;
}

m_address = address;
MINFO("Changed bootstrap daemon address to " << m_address);

return true;
}

const nodetool::peerlist_entry *get_random_public_node(const std::vector<nodetool::peerlist_entry> &peers) const noexcept
{
const size_t size = peers.size();
size_t cursor = crypto::rand_idx(size);
for (size_t index = 0; index < size; ++index)
{
const auto *peer = &peers[++cursor % size];
if (peer->rpc_port != 0)
{
return peer;
}
}

return nullptr;
}

bool switch_daemon_if_needed() noexcept
{
if (m_p2p == nullptr || m_last_result)
{
return true;
}

std::vector<nodetool::peerlist_entry> white_list;
std::vector<nodetool::peerlist_entry> gray_list;
m_p2p->get_public_peerlist(gray_list, white_list);

const nodetool::peerlist_entry *public_node = get_random_public_node(white_list);
if (public_node == nullptr)
{
MDEBUG("No white public node found, checking gray peers");

public_node = get_random_public_node(gray_list);
if (public_node == nullptr)
{
MERROR("Failed to switch bootstrap daemon, no white or gray public node found");
return false;
}
}

return set_server(public_node->adr.host_str() + ":" + std::to_string(public_node->rpc_port), boost::none);
}

private:
std::string m_address;
epee::net_utils::http::http_simple_client m_http_client;
bool m_last_result;
nodetool::node_server<cryptonote::t_cryptonote_protocol_handler<cryptonote::core>> *m_p2p;
};

}
@@ -120,16 +120,20 @@ namespace cryptonote
{
boost::unique_lock<boost::shared_mutex> lock(m_bootstrap_daemon_mutex);

if (!address.empty())
m_should_use_bootstrap_daemon = !address.empty();

if (!m_should_use_bootstrap_daemon)
{
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.compare("auto") == 0)
{
m_bootstrap_daemon.reset(new bootstrap_daemon(&m_p2p));
}
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();

return true;
}
@@ -199,7 +203,10 @@ namespace cryptonote
{
{
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);
@@ -248,7 +255,10 @@ namespace cryptonote
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();
@@ -1492,8 +1502,10 @@ namespace cryptonote

boost::upgrade_lock<boost::shared_mutex> upgrade_lock(m_bootstrap_daemon_mutex);

if (m_bootstrap_daemon_address.empty())
if (m_bootstrap_daemon.get() == nullptr)
{
return false;
}

if (!m_should_use_bootstrap_daemon)
{
@@ -1509,42 +1521,36 @@ namespace cryptonote
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
uint64_t bootstrap_daemon_height;
if (!m_bootstrap_daemon->get_height(&bootstrap_daemon_height))
{
return false;
}

// query bootstrap daemon's height
cryptonote::COMMAND_RPC_GET_HEIGHT::request getheight_req;
cryptonote::COMMAND_RPC_GET_HEIGHT::response getheight_res;
bool ok = epee::net_utils::invoke_http_json("/getheight", getheight_req, getheight_res, m_http_client);
ok = ok && getheight_res.status == CORE_RPC_STATUS_OK;
uint64_t target_height = m_core.get_target_blockchain_height();
if (bootstrap_daemon_height < target_height)
{
return m_bootstrap_daemon->handle_result(false);
}

m_should_use_bootstrap_daemon = ok && top_height + 10 < getheight_res.height;
MINFO((m_should_use_bootstrap_daemon ? "Using" : "Not using") << " the bootstrap daemon (our height: " << top_height << ", bootstrap daemon's height: " << (ok ? getheight_res.height : 0) << ")");
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 << ")");
}
if (!m_should_use_bootstrap_daemon)
return false;

if (mode == invoke_http_mode::JON)
{
r = epee::net_utils::invoke_http_json(command_name, req, res, m_http_client);
r = m_bootstrap_daemon->invoke_http_json(command_name, req, res);
}
else if (mode == invoke_http_mode::BIN)
{
r = epee::net_utils::invoke_http_bin(command_name, req, res, m_http_client);
r = m_bootstrap_daemon->invoke_http_bin(command_name, req, res);
}
else if (mode == invoke_http_mode::JON_RPC)
{
epee::json_rpc::request<typename COMMAND_TYPE::request> json_req = AUTO_VAL_INIT(json_req);
epee::json_rpc::response<typename COMMAND_TYPE::response, std::string> json_resp = AUTO_VAL_INIT(json_resp);
json_req.jsonrpc = "2.0";
json_req.id = epee::serialization::storage_entry(0);
json_req.method = command_name;
json_req.params = req;
r = net_utils::invoke_http_json("/json_rpc", json_req, json_resp, m_http_client);
if (r)
res = json_resp.result;
r = m_bootstrap_daemon->invoke_http_json_rpc(command_name, req, res);
}
else
{
@@ -2499,7 +2505,8 @@ namespace cryptonote

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"
, ""
};

@@ -30,9 +30,12 @@

#pragma once

#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"
@@ -248,9 +251,8 @@ namespace cryptonote

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::unique_ptr<bootstrap_daemon> m_bootstrap_daemon;
bool m_should_use_bootstrap_daemon;
std::chrono::system_clock::time_point m_bootstrap_height_check_time;
bool m_was_bootstrap_ever_used;

0 comments on commit 0e12963

Please sign in to comment.
You can’t perform that action at this time.