oxen-io
/
oxen-core
mirror of https://github.com/oxen-io/oxen-core.git
2
1
Fork 0
Code Issues Projects Releases Wiki Activity
oxen-core/src/daemon/daemon.cpp

408 lines
16 KiB
C++
Raw Permalink Blame History

// Copyright (c) 2018-2020, The Loki Project
// Copyright (c) 2014-2019, 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.
//
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
#include <fmt/color.h>
#include <oxenmq/oxenmq.h>
#include <boost/asio/ip/address.hpp>
#include <memory>
#include <stdexcept>
#include <utility>
#include "cryptonote_config.h"
#include "cryptonote_core/cryptonote_core.h"
#include "epee/misc_log_ex.h"
#if defined(PER_BLOCK_CHECKPOINT)
#include "blocks/blocks.h"
#endif
#include <functional>
#include "command_line_args.h"
#include "command_server.h"
#include "common/password.h"
#include "common/signal_handler.h"
#include "cryptonote_core/uptime_proof.h"
#include "cryptonote_protocol/quorumnet.h"
#include "daemon.h"
#include "net/parse.h"
#include "rpc/common/rpc_args.h"
#include "rpc/http_server.h"
#include "rpc/omq_server.h"
#include "version.h"
#ifdef ENABLE_SYSTEMD
extern "C" {
#include <systemd/sd-daemon.h>
}
#endif
using namespace std::literals;
namespace daemonize {
namespace log = oxen::log;
static auto logcat = log::Cat("daemon");
std::pair<std::string, uint16_t> parse_ip_port(
std::string_view ip_port, const std::string& argname) {
std::pair<std::string, uint16_t> result;
auto& [ip, port] = result;
if (auto colon = ip_port.rfind(":");
colon != std::string::npos && tools::parse_int(ip_port.substr(colon + 1), port))
ip_port.remove_suffix(ip_port.size() - colon);
else
throw std::runtime_error{
"Invalid IP/port value specified to " + argname + ": " + std::string(ip_port)};
if (!ip_port.empty() && ip_port.front() == '[' && ip_port.back() == ']') {
ip_port.remove_prefix(1);
ip_port.remove_suffix(1);
}
std::string ip_str{ip_port};
boost::system::error_code ec;
auto addr =
#if BOOST_VERSION >= 106600
boost::asio::ip::make_address
#else
boost::asio::ip::address::from_string
#endif
(ip_str, ec);
if (ec)
throw std::runtime_error{"Invalid IP address specified: " + ip_str};
ip = addr.to_string();
return result;
}
daemon::daemon(boost::program_options::variables_map vm_) :
vm{std::move(vm_)},
core{std::make_unique<cryptonote::core>()},
protocol{std::make_unique<protocol_handler>(
*core, command_line::get_arg(vm, cryptonote::arg_offline))},
p2p{std::make_unique<node_server>(*protocol)},
rpc{std::make_unique<cryptonote::rpc::core_rpc_server>(*core, *p2p)} {
log::info(logcat, fg(fmt::terminal_color::blue), "Initializing daemon objects...");
log::info(logcat, "- cryptonote protocol");
if (!protocol->init(vm))
throw std::runtime_error("Failed to initialize cryptonote protocol.");
log::info(logcat, "- p2p");
if (!p2p->init(vm))
throw std::runtime_error("Failed to initialize p2p server.");
// Handle circular dependencies
protocol->set_p2p_endpoint(p2p.get());
core->set_cryptonote_protocol(protocol.get());
auto rpc_config = cryptonote::rpc_args::process(vm);
bool new_rpc_options = !is_arg_defaulted(vm, cryptonote::rpc::http_server::arg_rpc_admin) ||
!is_arg_defaulted(vm, cryptonote::rpc::http_server::arg_rpc_public);
// TODO: Remove these options, perhaps starting in oxen 9.0
bool deprecated_rpc_options =
!is_arg_defaulted(vm, cryptonote::rpc::http_server::arg_rpc_bind_port) ||
!is_arg_defaulted(vm, cryptonote::rpc::http_server::arg_rpc_restricted_bind_port) ||
!is_arg_defaulted(vm, cryptonote::rpc::http_server::arg_restricted_rpc) ||
!is_arg_defaulted(vm, cryptonote::rpc::http_server::arg_public_node) ||
rpc_config.bind_ip.has_value() || rpc_config.bind_ipv6_address.has_value() ||
rpc_config.use_ipv6;
constexpr std::string_view deprecated_option_names =
"--rpc-bind-ip/--rpc-bind-port/--rpc-restricted-bind-port/--restricted-rpc/--public-node/--rpc-use-ipv6"sv;
if (new_rpc_options && deprecated_rpc_options)
throw std::runtime_error{
"Failed to initialize rpc settings: --rpc-public/--rpc-admin cannot be combined "
"with deprecated " +
std::string{deprecated_option_names} + " options"};
// bind ip, listen addr, required
std::vector<std::tuple<std::string, uint16_t, bool>> rpc_listen_admin, rpc_listen_public;
if (deprecated_rpc_options) {
log::info(
logcat,
fg(fmt::terminal_color::red),
"{} options are deprecated and will be removed from a future oxend version; use "
"--rpc-public/--rpc-admin instead",
deprecated_option_names);
// These old options from Monero are really janky: --restricted-rpc turns the main port
// restricted, but then we also have --rpc-restricted-bind-port but both are stuck with
// --rpc-bind-ip, and then half of the options get parsed here but the IP option used to get
// parsed in the http_server code.
auto restricted =
command_line::get_arg(vm, cryptonote::rpc::http_server::arg_restricted_rpc);
auto main_rpc_port =
command_line::get_arg(vm, cryptonote::rpc::http_server::arg_rpc_bind_port);
auto restricted_rpc_port = command_line::get_arg(
vm, cryptonote::rpc::http_server::arg_rpc_restricted_bind_port);
if (main_rpc_port == 0) {
if (restricted && restricted_rpc_port != 0)
std::swap(main_rpc_port, restricted_rpc_port);
else if (command_line::get_arg(vm, cryptonote::arg_testnet_on))
main_rpc_port = cryptonote::config::testnet::RPC_DEFAULT_PORT;
else if (command_line::get_arg(vm, cryptonote::arg_devnet_on))
main_rpc_port = cryptonote::config::devnet::RPC_DEFAULT_PORT;
else
main_rpc_port = cryptonote::config::RPC_DEFAULT_PORT;
}
if (main_rpc_port && main_rpc_port == restricted_rpc_port)
restricted = true;
std::vector<uint16_t> public_ports;
if (restricted)
public_ports.push_back(main_rpc_port);
if (restricted_rpc_port && restricted_rpc_port != main_rpc_port)
public_ports.push_back(restricted_rpc_port);
for (uint16_t port : public_ports) {
rpc_listen_public.emplace_back(
rpc_config.bind_ip.value_or("127.0.0.1"),
main_rpc_port,
rpc_config.require_ipv4);
if (rpc_config.bind_ipv6_address || rpc_config.use_ipv6)
rpc_listen_public.emplace_back(
rpc_config.bind_ipv6_address.value_or("::1"), main_rpc_port, true);
}
if (!restricted && main_rpc_port) {
rpc_listen_admin.emplace_back(
rpc_config.bind_ip.value_or("127.0.0.1"),
main_rpc_port,
rpc_config.require_ipv4);
if (rpc_config.bind_ipv6_address || rpc_config.use_ipv6)
rpc_listen_public.emplace_back(
rpc_config.bind_ipv6_address.value_or("::1"), main_rpc_port, true);
}
} else { // no deprecated options
for (auto& bind : command_line::get_arg(vm, cryptonote::rpc::http_server::arg_rpc_admin)) {
if (bind == "none")
continue;
auto [ip, port] = parse_ip_port(bind, "--rpc-admin");
bool ipv4 = ip.find(':') == std::string::npos;
// If using the default admin setting then don't require the bind to IPv6 localhost, or
// the IPv4 localhost bind if --rpc-ignore-ipv4 is given.
bool required = !command_line::is_arg_defaulted(
vm, cryptonote::rpc::http_server::arg_rpc_admin) ||
(ipv4 && rpc_config.require_ipv4);
rpc_listen_admin.emplace_back(std::move(ip), port, required);
}
for (auto& bind : command_line::get_arg(vm, cryptonote::rpc::http_server::arg_rpc_public)) {
// Much simpler, since this is default empty: everything specified is required.
auto [ip, port] = parse_ip_port(bind, "--rpc-public");
rpc_listen_public.emplace_back(std::move(ip), port, true);
}
}
if (!rpc_listen_admin.empty()) {
log::info(logcat, "- admin HTTP RPC server");
http_rpc_admin.emplace(
*rpc, rpc_config, false /*not restricted*/, std::move(rpc_listen_admin));
}
if (!rpc_listen_public.empty()) {
log::info(logcat, "- public HTTP RPC server");
http_rpc_public.emplace(
*rpc, rpc_config, true /*restricted*/, std::move(rpc_listen_public));
}
log::info(logcat, fg(fmt::terminal_color::blue), "Done daemon object initialization");
}
daemon::~daemon() {
log::info(logcat, fg(fmt::terminal_color::blue), "Deinitializing daemon objects...");
if (http_rpc_public) {
log::info(logcat, "- public HTTP RPC server");
http_rpc_public.reset();
}
if (http_rpc_admin) {
log::info(logcat, "- admin HTTP RPC server");
http_rpc_admin.reset();
}
log::info(logcat, "- p2p");
try {
p2p->deinit();
} catch (const std::exception& e) {
log::error(logcat, "Failed to deinitialize p2p: {}", e.what());
}
log::info(logcat, "- core");
try {
core->deinit();
core->set_cryptonote_protocol(nullptr);
} catch (const std::exception& e) {
log::error(logcat, "Failed to deinitialize core: {}", e.what());
}
log::info(logcat, "- cryptonote protocol");
try {
protocol->deinit();
protocol->set_p2p_endpoint(nullptr);
} catch (const std::exception& e) {
log::error(logcat, "Failed to stop cryptonote protocol: {}", e.what());
}
log::info(logcat, fg(fmt::terminal_color::blue), "Deinitialization complete");
}
void daemon::init_options(
boost::program_options::options_description& option_spec,
boost::program_options::options_description& hidden) {
static bool called = false;
if (called)
throw std::logic_error("daemon::init_options must only be called once");
else
called = true;
cryptonote::core::init_options(option_spec);
node_server::init_options(option_spec, hidden);
cryptonote::rpc::core_rpc_server::init_options(option_spec, hidden);
cryptonote::rpc::http_server::init_options(option_spec, hidden);
cryptonote::rpc::init_omq_options(option_spec);
quorumnet::init_core_callbacks();
}
bool daemon::run(bool interactive) {
if (!core)
throw std::runtime_error{"Can't run stopped daemon"};
std::atomic<bool> stop_sig(false), shutdown(false);
std::thread stop_thread{[&stop_sig, &shutdown, this] {
while (!stop_sig)
std::this_thread::sleep_for(100ms);
if (shutdown)
stop();
}};
OXEN_DEFER {
stop_sig = true;
stop_thread.join();
};
tools::signal_handler::install([&stop_sig, &shutdown](int) {
stop_sig = true;
shutdown = true;
});
try {
log::info(logcat, fg(fmt::terminal_color::blue), "Starting up oxend services...");
cryptonote::GetCheckpointsCallback get_checkpoints;
#if defined(PER_BLOCK_CHECKPOINT)
get_checkpoints = blocks::GetCheckpointsData;
#endif
log::info(logcat, "Starting core");
if (!core->init(vm, nullptr, get_checkpoints))
throw std::runtime_error("Failed to start core");
log::info(logcat, "Starting OxenMQ");
omq_rpc = std::make_unique<cryptonote::rpc::omq_rpc>(*core, *rpc, vm);
core->start_oxenmq();
if (http_rpc_admin) {
log::info(logcat, "Starting admin HTTP RPC server");
http_rpc_admin->start();
}
if (http_rpc_public) {
log::info(logcat, "Starting public HTTP RPC server");
http_rpc_public->start();
}
std::optional<daemonize::command_server> rpc_commands;
if (interactive) {
log::info(logcat, "Starting command-line processor");
auto& omq = core->get_omq();
std::promise<void> p;
auto conn = omq.connect_inproc(
[&p](oxenmq::ConnectionID) { p.set_value(); },
[&p](oxenmq::ConnectionID, std::string_view err) {
try {
throw std::runtime_error{
"Internal oxend RPC connection failed: " + std::string{err}};
} catch (...) {
p.set_exception(std::current_exception());
}
});
p.get_future().get();
rpc_commands.emplace(omq, std::move(conn));
rpc_commands->start_handling([this] { stop(); });
}
log::info(logcat, fg(fmt::terminal_color::green), "Starting up main network");
#ifdef ENABLE_SYSTEMD
sd_notify(0, ("READY=1\nSTATUS=" + core->get_status_string()).c_str());
#endif
p2p->run(); // blocks until p2p goes down
log::info(logcat, fg(fmt::terminal_color::yellow), "Main network stopped");
if (rpc_commands) {
log::info(logcat, "Stopping RPC command processor");
rpc_commands->stop_handling();
rpc_commands.reset();
}
if (http_rpc_public) {
log::info(logcat, "Stopping public HTTP RPC server...");
http_rpc_public->shutdown();
}
if (http_rpc_admin) {
log::info(logcat, "Stopping admin HTTP RPC server...");
http_rpc_admin->shutdown();
}
log::info(logcat, "Node stopped.");
return true;
} catch (std::exception const& ex) {
log::error(logcat, ex.what());
return false;
} catch (...) {
log::error(logcat, "Unknown exception occured!");
return false;
}
}
void daemon::stop() {
if (!core)
throw std::logic_error{"Can't send stop signal to a stopped daemon"};
p2p->send_stop_signal(); // Make p2p stop so that `run()` above continues with tear down
}
} // namespace daemonize
Reference in New Issue View Git Blame Copy Permalink