monero/src/daemon/daemon.cpp

176 lines
4.6 KiB
C++
Raw Normal View History

// Copyright (c) 2014-2015, The Monero Project
//
2014-07-23 09:03:52 -04:00
// All rights reserved.
//
2014-07-23 09:03:52 -04:00
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
//
2014-07-23 09:03:52 -04:00
// 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer.
//
2014-07-23 09:03:52 -04:00
// 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.
//
2014-07-23 09:03:52 -04:00
// 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.
//
2014-07-23 09:03:52 -04:00
// 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.
//
2014-07-23 09:03:52 -04:00
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
2014-03-03 17:07:58 -05:00
#include <memory>
#include <stdexcept>
#include "misc_log_ex.h"
#include "daemon/daemon.h"
2014-03-03 17:07:58 -05:00
#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"
2014-03-03 17:07:58 -05:00
#include "version.h"
#include "../../contrib/epee/include/syncobj.h"
using namespace epee;
#include <functional>
unsigned int epee::g_test_dbg_lock_sleep = 0;
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());
}
};
2014-03-03 17:07:58 -05:00
void t_daemon::init_options(boost::program_options::options_description & option_spec)
2014-03-03 17:07:58 -05:00
{
t_core::init_options(option_spec);
t_p2p::init_options(option_spec);
t_rpc::init_options(option_spec);
2014-03-03 17:07:58 -05:00
}
t_daemon::t_daemon(
boost::program_options::variables_map const & vm
)
: mp_internals{new t_internals{vm}}
{}
2014-09-09 20:18:23 -04:00
t_daemon::~t_daemon() = default;
2014-09-09 20:18:23 -04:00
// MSVC is brain-dead and can't default this...
t_daemon::t_daemon(t_daemon && other)
{
if (this != &other)
2014-09-09 20:18:23 -04:00
{
mp_internals = std::move(other.mp_internals);
other.mp_internals.reset(nullptr);
2014-09-09 20:18:23 -04:00
}
}
2014-03-03 17:07:58 -05:00
// or this
t_daemon & t_daemon::operator=(t_daemon && other)
2014-03-03 17:07:58 -05:00
{
if (this != &other)
2014-09-08 17:30:50 -04:00
{
mp_internals = std::move(other.mp_internals);
other.mp_internals.reset(nullptr);
2014-09-08 17:30:50 -04:00
}
return *this;
}
2014-09-08 17:30:50 -04:00
bool t_daemon::run(bool interactive)
{
if (nullptr == mp_internals)
2014-09-08 17:30:50 -04:00
{
throw std::runtime_error{"Can't run stopped daemon"};
2014-09-08 17:30:50 -04:00
}
tools::signal_handler::install(std::bind(&daemonize::t_daemon::stop_p2p, this));
2014-09-08 17:30:50 -04:00
try
2014-09-08 17:30:50 -04:00
{
mp_internals->core.run();
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());
2015-06-13 19:30:04 -04:00
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;
2014-09-08 17:30:50 -04:00
}
catch (std::exception const & ex)
2014-03-03 17:07:58 -05:00
{
LOG_ERROR("Uncaught exception! " << ex.what());
return false;
2014-03-03 17:07:58 -05:00
}
catch (...)
{
LOG_ERROR("Uncaught exception!");
return false;
}
}
void t_daemon::stop()
{
if (nullptr == mp_internals)
2014-03-20 07:46:11 -04:00
{
throw std::runtime_error{"Can't stop stopped daemon"};
2014-03-20 07:46:11 -04:00
}
mp_internals->p2p.stop();
mp_internals->rpc.stop();
mp_internals.reset(nullptr); // Ensure resources are cleaned up before we return
2014-03-03 17:07:58 -05:00
}
2015-06-13 19:30:04 -04:00
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