mirror of
https://git.wownero.com/wownero/wownero.git
synced 2024-08-15 01:03:23 +00:00
175 lines
4.6 KiB
C++
175 lines
4.6 KiB
C++
// Copyright (c) 2014-2016, 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 <memory>
|
|
#include <stdexcept>
|
|
#include "misc_log_ex.h"
|
|
#include "daemon/daemon.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 "version.h"
|
|
#include "../../contrib/epee/include/syncobj.h"
|
|
|
|
using namespace epee;
|
|
|
|
#include <functional>
|
|
|
|
namespace daemonize {
|
|
|
|
struct t_internals {
|
|
private:
|
|
t_protocol protocol;
|
|
public:
|
|
t_core core;
|
|
t_p2p p2p;
|
|
t_rpc rpc;
|
|
|
|
t_internals(
|
|
boost::program_options::variables_map const & vm
|
|
)
|
|
: core{vm}
|
|
, protocol{vm, core}
|
|
, p2p{vm, protocol}
|
|
, rpc{vm, core, p2p}
|
|
{
|
|
// Handle circular dependencies
|
|
protocol.set_p2p_endpoint(p2p.get());
|
|
core.set_protocol(protocol.get());
|
|
}
|
|
};
|
|
|
|
void t_daemon::init_options(boost::program_options::options_description & option_spec)
|
|
{
|
|
t_core::init_options(option_spec);
|
|
t_p2p::init_options(option_spec);
|
|
t_rpc::init_options(option_spec);
|
|
}
|
|
|
|
t_daemon::t_daemon(
|
|
boost::program_options::variables_map const & vm
|
|
)
|
|
: mp_internals{new t_internals{vm}}
|
|
{}
|
|
|
|
t_daemon::~t_daemon() = default;
|
|
|
|
// MSVC is brain-dead and can't default this...
|
|
t_daemon::t_daemon(t_daemon && other)
|
|
{
|
|
if (this != &other)
|
|
{
|
|
mp_internals = std::move(other.mp_internals);
|
|
other.mp_internals.reset(nullptr);
|
|
}
|
|
}
|
|
|
|
// or this
|
|
t_daemon & t_daemon::operator=(t_daemon && other)
|
|
{
|
|
if (this != &other)
|
|
{
|
|
mp_internals = std::move(other.mp_internals);
|
|
other.mp_internals.reset(nullptr);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
bool t_daemon::run(bool interactive)
|
|
{
|
|
if (nullptr == mp_internals)
|
|
{
|
|
throw std::runtime_error{"Can't run stopped daemon"};
|
|
}
|
|
tools::signal_handler::install(std::bind(&daemonize::t_daemon::stop_p2p, this));
|
|
|
|
try
|
|
{
|
|
if (!mp_internals->core.run())
|
|
return false;
|
|
mp_internals->rpc.run();
|
|
|
|
daemonize::t_command_server* rpc_commands;
|
|
|
|
if (interactive)
|
|
{
|
|
rpc_commands = new daemonize::t_command_server(0, 0, false, mp_internals->rpc.get_server());
|
|
rpc_commands->start_handling(std::bind(&daemonize::t_daemon::stop_p2p, this));
|
|
}
|
|
|
|
mp_internals->p2p.run(); // blocks until p2p goes down
|
|
|
|
if (interactive)
|
|
{
|
|
rpc_commands->stop_handling();
|
|
}
|
|
|
|
mp_internals->rpc.stop();
|
|
LOG_PRINT("Node stopped.", LOG_LEVEL_0);
|
|
return true;
|
|
}
|
|
catch (std::exception const & ex)
|
|
{
|
|
LOG_ERROR("Uncaught exception! " << ex.what());
|
|
return false;
|
|
}
|
|
catch (...)
|
|
{
|
|
LOG_ERROR("Uncaught exception!");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void t_daemon::stop()
|
|
{
|
|
if (nullptr == mp_internals)
|
|
{
|
|
throw std::runtime_error{"Can't stop stopped daemon"};
|
|
}
|
|
mp_internals->p2p.stop();
|
|
mp_internals->rpc.stop();
|
|
mp_internals.reset(nullptr); // Ensure resources are cleaned up before we return
|
|
}
|
|
|
|
void t_daemon::stop_p2p()
|
|
{
|
|
if (nullptr == mp_internals)
|
|
{
|
|
throw std::runtime_error{"Can't send stop signal to a stopped daemon"};
|
|
}
|
|
mp_internals->p2p.get().send_stop_signal();
|
|
}
|
|
|
|
} // namespace daemonize
|