2015-12-31 08:39:56 +02:00
|
|
|
// Copyright (c) 2014-2016, The Monero Project
|
2015-05-31 14:40:18 +03:00
|
|
|
//
|
2015-01-30 00:10:53 +02:00
|
|
|
// All rights reserved.
|
2015-05-31 14:40:18 +03:00
|
|
|
//
|
2015-01-30 00:10:53 +02:00
|
|
|
// Redistribution and use in source and binary forms, with or without modification, are
|
|
|
|
// permitted provided that the following conditions are met:
|
2015-05-31 14:40:18 +03:00
|
|
|
//
|
2015-01-30 00:10:53 +02:00
|
|
|
// 1. Redistributions of source code must retain the above copyright notice, this list of
|
|
|
|
// conditions and the following disclaimer.
|
2015-05-31 14:40:18 +03:00
|
|
|
//
|
2015-01-30 00:10:53 +02: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.
|
2015-05-31 14:40:18 +03:00
|
|
|
//
|
2015-01-30 00:10:53 +02: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.
|
2015-05-31 14:40:18 +03:00
|
|
|
//
|
2015-01-30 00:10:53 +02: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.
|
|
|
|
//
|
|
|
|
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
|
|
|
|
|
|
|
|
#include "string_tools.h"
|
|
|
|
#include "common/scoped_message_writer.h"
|
|
|
|
#include "daemon/rpc_command_executor.h"
|
|
|
|
#include "rpc/core_rpc_server_commands_defs.h"
|
2015-04-01 20:00:45 +03:00
|
|
|
#include "cryptonote_core/cryptonote_core.h"
|
2015-10-25 23:18:03 +02:00
|
|
|
#include "cryptonote_core/hardfork.h"
|
2015-01-30 00:10:53 +02:00
|
|
|
#include <boost/format.hpp>
|
|
|
|
#include <ctime>
|
2015-04-10 17:13:57 +03:00
|
|
|
#include <string>
|
2015-01-30 00:10:53 +02:00
|
|
|
|
|
|
|
namespace daemonize {
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
void print_peer(std::string const & prefix, cryptonote::peer const & peer)
|
|
|
|
{
|
|
|
|
time_t now;
|
|
|
|
time(&now);
|
|
|
|
time_t last_seen = static_cast<time_t>(peer.last_seen);
|
|
|
|
|
|
|
|
std::string id_str;
|
|
|
|
std::string port_str;
|
|
|
|
std::string elapsed = epee::misc_utils::get_time_interval_string(now - last_seen);
|
|
|
|
std::string ip_str = epee::string_tools::get_ip_string_from_int32(peer.ip);
|
|
|
|
epee::string_tools::xtype_to_string(peer.id, id_str);
|
|
|
|
epee::string_tools::xtype_to_string(peer.port, port_str);
|
|
|
|
std::string addr_str = ip_str + ":" + port_str;
|
|
|
|
tools::msg_writer() << boost::format("%-10s %-25s %-25s %s") % prefix % id_str % addr_str % elapsed;
|
|
|
|
}
|
|
|
|
|
|
|
|
void print_block_header(cryptonote::block_header_responce const & header)
|
|
|
|
{
|
|
|
|
tools::success_msg_writer()
|
|
|
|
<< "timestamp: " << boost::lexical_cast<std::string>(header.timestamp) << std::endl
|
|
|
|
<< "previous hash: " << header.prev_hash << std::endl
|
|
|
|
<< "nonce: " << boost::lexical_cast<std::string>(header.nonce) << std::endl
|
|
|
|
<< "is orphan: " << header.orphan_status << std::endl
|
|
|
|
<< "height: " << boost::lexical_cast<std::string>(header.height) << std::endl
|
|
|
|
<< "depth: " << boost::lexical_cast<std::string>(header.depth) << std::endl
|
2016-03-15 07:31:09 +02:00
|
|
|
<< "hash: " << header.hash << std::endl
|
2015-01-30 00:10:53 +02:00
|
|
|
<< "difficulty: " << boost::lexical_cast<std::string>(header.difficulty) << std::endl
|
|
|
|
<< "reward: " << boost::lexical_cast<std::string>(header.reward);
|
|
|
|
}
|
2016-04-05 21:26:37 +03:00
|
|
|
|
|
|
|
std::string get_human_time_ago(time_t t, time_t now)
|
|
|
|
{
|
|
|
|
if (t == now)
|
|
|
|
return "now";
|
|
|
|
time_t dt = t > now ? t - now : now - t;
|
|
|
|
std::string s;
|
|
|
|
if (dt < 90)
|
|
|
|
s = boost::lexical_cast<std::string>(dt) + " seconds";
|
|
|
|
else if (dt < 90 * 60)
|
|
|
|
s = boost::lexical_cast<std::string>(dt/60) + " minutes";
|
|
|
|
else if (dt < 36 * 3600)
|
|
|
|
s = boost::lexical_cast<std::string>(dt/3600) + " hours";
|
|
|
|
else
|
|
|
|
s = boost::lexical_cast<std::string>(dt/(3600*24)) + " days";
|
|
|
|
return s + " " + (t > now ? "in the future" : "ago");
|
|
|
|
}
|
2015-01-30 00:10:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
t_rpc_command_executor::t_rpc_command_executor(
|
|
|
|
uint32_t ip
|
|
|
|
, uint16_t port
|
2016-09-07 23:38:41 +03:00
|
|
|
, const std::string &user_agent
|
2015-03-27 14:01:30 +02:00
|
|
|
, bool is_rpc
|
|
|
|
, cryptonote::core_rpc_server* rpc_server
|
2015-01-30 00:10:53 +02:00
|
|
|
)
|
2015-03-27 14:01:30 +02:00
|
|
|
: m_rpc_client(NULL), m_rpc_server(rpc_server)
|
|
|
|
{
|
|
|
|
if (is_rpc)
|
|
|
|
{
|
|
|
|
m_rpc_client = new tools::t_rpc_client(ip, port);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (rpc_server == NULL)
|
|
|
|
{
|
2016-03-21 12:12:12 +02:00
|
|
|
throw std::runtime_error("If not calling commands via RPC, rpc_server pointer must be non-null");
|
2015-03-27 14:01:30 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
m_is_rpc = is_rpc;
|
|
|
|
}
|
|
|
|
|
|
|
|
t_rpc_command_executor::~t_rpc_command_executor()
|
|
|
|
{
|
|
|
|
if (m_rpc_client != NULL)
|
|
|
|
{
|
|
|
|
delete m_rpc_client;
|
|
|
|
}
|
|
|
|
}
|
2015-01-30 00:10:53 +02:00
|
|
|
|
|
|
|
bool t_rpc_command_executor::print_peer_list() {
|
|
|
|
cryptonote::COMMAND_RPC_GET_PEER_LIST::request req;
|
|
|
|
cryptonote::COMMAND_RPC_GET_PEER_LIST::response res;
|
|
|
|
|
2015-03-27 14:01:30 +02:00
|
|
|
std::string failure_message = "Couldn't retrieve peer list";
|
|
|
|
if (m_is_rpc)
|
|
|
|
{
|
|
|
|
if (!m_rpc_client->rpc_request(req, res, "/get_peer_list", failure_message.c_str()))
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_get_peer_list(req, res) || res.status != CORE_RPC_STATUS_OK)
|
2015-03-27 14:01:30 +02:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << failure_message;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2015-01-30 00:10:53 +02:00
|
|
|
|
|
|
|
for (auto & peer : res.white_list)
|
|
|
|
{
|
|
|
|
print_peer("white", peer);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (auto & peer : res.gray_list)
|
|
|
|
{
|
|
|
|
print_peer("gray", peer);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool t_rpc_command_executor::save_blockchain() {
|
|
|
|
cryptonote::COMMAND_RPC_SAVE_BC::request req;
|
|
|
|
cryptonote::COMMAND_RPC_SAVE_BC::response res;
|
|
|
|
|
2015-03-27 14:01:30 +02:00
|
|
|
std::string fail_message = "Couldn't save blockchain";
|
|
|
|
|
|
|
|
if (m_is_rpc)
|
2015-01-30 00:10:53 +02:00
|
|
|
{
|
2015-03-27 14:01:30 +02:00
|
|
|
if (!m_rpc_client->rpc_request(req, res, "/save_bc", fail_message.c_str()))
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
2015-01-30 00:10:53 +02:00
|
|
|
}
|
2015-03-27 14:01:30 +02:00
|
|
|
else
|
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_save_bc(req, res) || res.status != CORE_RPC_STATUS_OK)
|
2015-03-27 14:01:30 +02:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
2016-01-31 00:14:51 +02:00
|
|
|
return true;
|
2015-03-27 14:01:30 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
tools::success_msg_writer() << "Blockchain saved";
|
2015-01-30 00:10:53 +02:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool t_rpc_command_executor::show_hash_rate() {
|
|
|
|
cryptonote::COMMAND_RPC_SET_LOG_HASH_RATE::request req;
|
|
|
|
cryptonote::COMMAND_RPC_SET_LOG_HASH_RATE::response res;
|
|
|
|
req.visible = true;
|
|
|
|
|
2015-03-27 14:01:30 +02:00
|
|
|
std::string fail_message = "Unsuccessful";
|
|
|
|
|
|
|
|
if (m_is_rpc)
|
2015-01-30 00:10:53 +02:00
|
|
|
{
|
2015-03-27 14:01:30 +02:00
|
|
|
if (!m_rpc_client->rpc_request(req, res, "/set_log_hash_rate", fail_message.c_str()))
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_set_log_hash_rate(req, res) || res.status != CORE_RPC_STATUS_OK)
|
2015-03-27 14:01:30 +02:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
}
|
2015-01-30 00:10:53 +02:00
|
|
|
}
|
|
|
|
|
2015-03-27 14:01:30 +02:00
|
|
|
tools::success_msg_writer() << "Hash rate logging is on";
|
|
|
|
|
2015-01-30 00:10:53 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool t_rpc_command_executor::hide_hash_rate() {
|
|
|
|
cryptonote::COMMAND_RPC_SET_LOG_HASH_RATE::request req;
|
|
|
|
cryptonote::COMMAND_RPC_SET_LOG_HASH_RATE::response res;
|
|
|
|
req.visible = false;
|
|
|
|
|
2015-03-27 14:01:30 +02:00
|
|
|
std::string fail_message = "Unsuccessful";
|
|
|
|
|
|
|
|
if (m_is_rpc)
|
|
|
|
{
|
|
|
|
if (!m_rpc_client->rpc_request(req, res, "/set_log_hash_rate", fail_message.c_str()))
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2015-01-30 00:10:53 +02:00
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_set_log_hash_rate(req, res) || res.status != CORE_RPC_STATUS_OK)
|
2015-03-27 14:01:30 +02:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
|
|
|
}
|
2015-01-30 00:10:53 +02:00
|
|
|
}
|
|
|
|
|
2015-03-27 14:01:30 +02:00
|
|
|
tools::success_msg_writer() << "Hash rate logging is off";
|
|
|
|
|
2015-01-30 00:10:53 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool t_rpc_command_executor::show_difficulty() {
|
|
|
|
cryptonote::COMMAND_RPC_GET_INFO::request req;
|
|
|
|
cryptonote::COMMAND_RPC_GET_INFO::response res;
|
|
|
|
|
2015-03-27 14:01:30 +02:00
|
|
|
std::string fail_message = "Problem fetching info";
|
|
|
|
|
|
|
|
if (m_is_rpc)
|
2015-01-30 00:10:53 +02:00
|
|
|
{
|
2015-03-27 14:01:30 +02:00
|
|
|
if (!m_rpc_client->rpc_request(req, res, "/getinfo", fail_message.c_str()))
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
2015-01-30 00:10:53 +02:00
|
|
|
}
|
2015-03-27 14:01:30 +02:00
|
|
|
else
|
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_get_info(req, res) || res.status != CORE_RPC_STATUS_OK)
|
2015-03-27 14:01:30 +02:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
tools::success_msg_writer() << "BH: " << res.height
|
2015-12-18 21:56:17 +02:00
|
|
|
<< ", TH: " << res.top_block_hash
|
2015-03-27 14:01:30 +02:00
|
|
|
<< ", DIFF: " << res.difficulty
|
2016-09-11 00:16:25 +03:00
|
|
|
<< ", HR: " << res.difficulty / res.target << " H/s";
|
2015-01-30 00:10:53 +02:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-12-07 21:40:12 +02:00
|
|
|
static std::string get_mining_speed(uint64_t hr)
|
|
|
|
{
|
|
|
|
if (hr>1e9) return (boost::format("%.2f GH/s") % (hr/1e9)).str();
|
|
|
|
if (hr>1e6) return (boost::format("%.2f MH/s") % (hr/1e6)).str();
|
|
|
|
if (hr>1e3) return (boost::format("%.2f kH/s") % (hr/1e3)).str();
|
|
|
|
return (boost::format("%.0f H/s") % hr).str();
|
|
|
|
}
|
|
|
|
|
2016-08-12 21:19:25 +03:00
|
|
|
static std::string get_fork_extra_info(uint64_t t, uint64_t now, uint64_t block_time)
|
|
|
|
{
|
|
|
|
uint64_t blocks_per_day = 86400 / block_time;
|
|
|
|
|
|
|
|
if (t == now)
|
|
|
|
return " (forking now)";
|
|
|
|
|
|
|
|
if (t > now)
|
|
|
|
{
|
|
|
|
uint64_t dblocks = t - now;
|
|
|
|
if (dblocks <= 30)
|
|
|
|
return (boost::format(" (next fork in %u blocks)") % (unsigned)dblocks).str();
|
|
|
|
if (dblocks <= blocks_per_day / 2)
|
|
|
|
return (boost::format(" (next fork in %.1f hours)") % (dblocks / (float)(blocks_per_day / 24))).str();
|
|
|
|
if (dblocks <= blocks_per_day * 30)
|
|
|
|
return (boost::format(" (next fork in %.1f days)") % (dblocks / (float)blocks_per_day)).str();
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
2016-09-24 13:38:58 +03:00
|
|
|
static float get_sync_percentage(const cryptonote::COMMAND_RPC_GET_INFO::response &ires)
|
|
|
|
{
|
|
|
|
uint64_t height = ires.height;
|
|
|
|
uint64_t target_height = ires.target_height ? ires.target_height < ires.height ? ires.height : ires.target_height : ires.height;
|
|
|
|
float pc = 100.0f * height / target_height;
|
|
|
|
if (height < target_height && pc > 99.9f)
|
|
|
|
return 99.9f; // to avoid 100% when not fully synced
|
|
|
|
return pc;
|
|
|
|
}
|
|
|
|
|
2015-10-25 23:18:03 +02:00
|
|
|
bool t_rpc_command_executor::show_status() {
|
|
|
|
cryptonote::COMMAND_RPC_GET_INFO::request ireq;
|
|
|
|
cryptonote::COMMAND_RPC_GET_INFO::response ires;
|
|
|
|
cryptonote::COMMAND_RPC_HARD_FORK_INFO::request hfreq;
|
|
|
|
cryptonote::COMMAND_RPC_HARD_FORK_INFO::response hfres;
|
2015-12-07 21:40:12 +02:00
|
|
|
cryptonote::COMMAND_RPC_MINING_STATUS::request mreq;
|
|
|
|
cryptonote::COMMAND_RPC_MINING_STATUS::response mres;
|
2015-10-25 23:18:03 +02:00
|
|
|
epee::json_rpc::error error_resp;
|
|
|
|
|
|
|
|
std::string fail_message = "Problem fetching info";
|
|
|
|
|
2016-01-31 00:14:51 +02:00
|
|
|
hfreq.version = 0;
|
|
|
|
bool mining_busy = false;
|
2015-10-25 23:18:03 +02:00
|
|
|
if (m_is_rpc)
|
|
|
|
{
|
|
|
|
if (!m_rpc_client->rpc_request(ireq, ires, "/getinfo", fail_message.c_str()))
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
2015-10-28 20:08:14 +02:00
|
|
|
if (!m_rpc_client->json_rpc_request(hfreq, hfres, "hard_fork_info", fail_message.c_str()))
|
2015-10-25 23:18:03 +02:00
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
2016-01-11 23:50:41 +02:00
|
|
|
if (!m_rpc_client->rpc_request(mreq, mres, "/mining_status", fail_message.c_str()))
|
2015-12-07 21:40:12 +02:00
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
2015-10-25 23:18:03 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_get_info(ireq, ires) || ires.status != CORE_RPC_STATUS_OK)
|
2015-10-25 23:18:03 +02:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
|
|
|
}
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_hard_fork_info(hfreq, hfres, error_resp) || hfres.status != CORE_RPC_STATUS_OK)
|
2015-10-25 23:18:03 +02:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
|
|
|
}
|
2015-12-07 21:40:12 +02:00
|
|
|
if (!m_rpc_server->on_mining_status(mreq, mres))
|
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
|
|
|
}
|
2016-01-31 00:14:51 +02:00
|
|
|
|
|
|
|
if (mres.status == CORE_RPC_STATUS_BUSY)
|
|
|
|
{
|
|
|
|
mining_busy = true;
|
|
|
|
}
|
|
|
|
else if (mres.status != CORE_RPC_STATUS_OK)
|
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
|
|
|
}
|
2015-10-25 23:18:03 +02:00
|
|
|
}
|
|
|
|
|
2016-08-12 21:19:25 +03:00
|
|
|
tools::success_msg_writer() << boost::format("Height: %llu/%llu (%.1f%%) on %s, %s, net hash %s, v%u%s, %s, %u+%u connections")
|
2015-10-25 23:18:03 +02:00
|
|
|
% (unsigned long long)ires.height
|
2015-11-23 15:16:05 +02:00
|
|
|
% (unsigned long long)(ires.target_height >= ires.height ? ires.target_height : ires.height)
|
2016-09-24 13:38:58 +03:00
|
|
|
% get_sync_percentage(ires)
|
2015-10-28 20:08:14 +02:00
|
|
|
% (ires.testnet ? "testnet" : "mainnet")
|
2016-01-31 00:14:51 +02:00
|
|
|
% (mining_busy ? "syncing" : mres.active ? "mining at " + get_mining_speed(mres.speed) : "not mining")
|
2015-12-07 21:40:12 +02:00
|
|
|
% get_mining_speed(ires.difficulty / ires.target)
|
2015-10-25 23:18:03 +02:00
|
|
|
% (unsigned)hfres.version
|
2016-08-12 21:19:25 +03:00
|
|
|
% get_fork_extra_info(hfres.earliest_height, ires.height, ires.target)
|
2015-10-25 23:18:03 +02:00
|
|
|
% (hfres.state == cryptonote::HardFork::Ready ? "up to date" : hfres.state == cryptonote::HardFork::UpdateNeeded ? "update needed" : "out of date, likely forked")
|
|
|
|
% (unsigned)ires.outgoing_connections_count % (unsigned)ires.incoming_connections_count
|
|
|
|
;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-01-30 00:10:53 +02:00
|
|
|
bool t_rpc_command_executor::print_connections() {
|
|
|
|
cryptonote::COMMAND_RPC_GET_CONNECTIONS::request req;
|
|
|
|
cryptonote::COMMAND_RPC_GET_CONNECTIONS::response res;
|
2015-03-27 14:01:30 +02:00
|
|
|
epee::json_rpc::error error_resp;
|
2015-01-30 00:10:53 +02:00
|
|
|
|
2015-03-27 14:01:30 +02:00
|
|
|
std::string fail_message = "Unsuccessful";
|
|
|
|
|
|
|
|
if (m_is_rpc)
|
2015-01-30 00:10:53 +02:00
|
|
|
{
|
2015-10-26 12:17:03 +02:00
|
|
|
if (!m_rpc_client->json_rpc_request(req, res, "get_connections", fail_message.c_str()))
|
2015-01-30 00:10:53 +02:00
|
|
|
{
|
2015-03-27 14:01:30 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_get_connections(req, res, error_resp) || res.status != CORE_RPC_STATUS_OK)
|
2015-03-27 14:01:30 +02:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
2015-01-30 00:10:53 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-01 20:00:45 +03:00
|
|
|
tools::msg_writer() << std::setw(30) << std::left << "Remote Host"
|
|
|
|
<< std::setw(20) << "Peer id"
|
|
|
|
<< std::setw(30) << "Recv/Sent (inactive,sec)"
|
|
|
|
<< std::setw(25) << "State"
|
|
|
|
<< std::setw(20) << "Livetime(sec)"
|
|
|
|
<< std::setw(12) << "Down (kB/s)"
|
|
|
|
<< std::setw(14) << "Down(now)"
|
|
|
|
<< std::setw(10) << "Up (kB/s)"
|
|
|
|
<< std::setw(13) << "Up(now)"
|
|
|
|
<< std::endl;
|
|
|
|
|
2015-03-27 14:01:30 +02:00
|
|
|
for (auto & info : res.connections)
|
|
|
|
{
|
2015-04-01 20:00:45 +03:00
|
|
|
std::string address = info.incoming ? "INC " : "OUT ";
|
|
|
|
address += info.ip + ":" + info.port;
|
|
|
|
//std::string in_out = info.incoming ? "INC " : "OUT ";
|
|
|
|
tools::msg_writer()
|
|
|
|
//<< std::setw(30) << std::left << in_out
|
|
|
|
<< std::setw(30) << std::left << address
|
|
|
|
<< std::setw(20) << info.peer_id
|
|
|
|
<< std::setw(30) << std::to_string(info.recv_count) + "(" + std::to_string(info.recv_idle_time) + ")/" + std::to_string(info.send_count) + "(" + std::to_string(info.send_idle_time) + ")"
|
|
|
|
<< std::setw(25) << info.state
|
|
|
|
<< std::setw(20) << info.live_time
|
|
|
|
<< std::setw(12) << info.avg_download
|
|
|
|
<< std::setw(14) << info.current_download
|
|
|
|
<< std::setw(10) << info.avg_upload
|
|
|
|
<< std::setw(13) << info.current_upload
|
|
|
|
|
|
|
|
<< std::left << (info.localhost ? "[LOCALHOST]" : "")
|
|
|
|
<< std::left << (info.local_ip ? "[LAN]" : "");
|
|
|
|
//tools::msg_writer() << boost::format("%-25s peer_id: %-25s %s") % address % info.peer_id % in_out;
|
|
|
|
|
2015-03-27 14:01:30 +02:00
|
|
|
}
|
|
|
|
|
2015-01-30 00:10:53 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool t_rpc_command_executor::print_blockchain_info(uint64_t start_block_index, uint64_t end_block_index) {
|
2015-03-27 14:01:30 +02:00
|
|
|
|
|
|
|
// this function appears to not exist in the json rpc api, and so is commented
|
|
|
|
// until such a time as it does.
|
|
|
|
|
|
|
|
/*
|
2015-01-30 00:10:53 +02:00
|
|
|
cryptonote::COMMAND_RPC_GET_BLOCK_HEADERS_RANGE::request req;
|
|
|
|
cryptonote::COMMAND_RPC_GET_BLOCK_HEADERS_RANGE::response res;
|
2015-03-27 14:01:30 +02:00
|
|
|
epee::json_rpc::error error_resp;
|
2015-01-30 00:10:53 +02:00
|
|
|
|
|
|
|
req.start_height = start_block_index;
|
|
|
|
req.end_height = end_block_index;
|
|
|
|
|
2015-03-27 14:01:30 +02:00
|
|
|
std::string fail_message = "Unsuccessful";
|
|
|
|
|
|
|
|
if (m_is_rpc)
|
2015-01-30 00:10:53 +02:00
|
|
|
{
|
2015-03-27 14:01:30 +02:00
|
|
|
if (!m_rpc_client->json_rpc_request(req, res, "getblockheadersrange", fail_message.c_str()))
|
2015-01-30 00:10:53 +02:00
|
|
|
{
|
2015-03-27 14:01:30 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_getblockheadersrange(req, res, error_resp) || res.status != CORE_RPC_STATUS_OK)
|
2015-03-27 14:01:30 +02:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
2015-01-30 00:10:53 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-27 14:01:30 +02:00
|
|
|
for (auto & header : res.headers)
|
|
|
|
{
|
|
|
|
std::cout
|
|
|
|
<< "major version: " << header.major_version << std::endl
|
|
|
|
<< "minor version: " << header.minor_version << std::endl
|
|
|
|
<< "height: " << header.height << ", timestamp: " << header.timestamp << ", difficulty: " << header.difficulty << std::endl
|
|
|
|
<< "block id: " << header.hash << std::endl
|
|
|
|
<< "previous block id: " << header.prev_hash << std::endl
|
|
|
|
<< "difficulty: " << header.difficulty << ", nonce " << header.nonce << std::endl;
|
|
|
|
}
|
|
|
|
|
|
|
|
*/
|
2015-01-30 00:10:53 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool t_rpc_command_executor::set_log_level(int8_t level) {
|
|
|
|
cryptonote::COMMAND_RPC_SET_LOG_LEVEL::request req;
|
|
|
|
cryptonote::COMMAND_RPC_SET_LOG_LEVEL::response res;
|
|
|
|
req.level = level;
|
|
|
|
|
2015-03-27 14:01:30 +02:00
|
|
|
std::string fail_message = "Unsuccessful";
|
|
|
|
|
|
|
|
if (m_is_rpc)
|
|
|
|
{
|
|
|
|
if (!m_rpc_client->rpc_request(req, res, "/set_log_level", fail_message.c_str()))
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2015-01-30 00:10:53 +02:00
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_set_log_level(req, res) || res.status != CORE_RPC_STATUS_OK)
|
2015-03-27 14:01:30 +02:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
|
|
|
}
|
2015-01-30 00:10:53 +02:00
|
|
|
}
|
|
|
|
|
2015-04-10 17:13:57 +03:00
|
|
|
tools::success_msg_writer() << "Log level is now " << std::to_string(level);
|
2015-03-27 14:01:30 +02:00
|
|
|
|
2015-01-30 00:10:53 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool t_rpc_command_executor::print_height() {
|
|
|
|
cryptonote::COMMAND_RPC_GET_HEIGHT::request req;
|
|
|
|
cryptonote::COMMAND_RPC_GET_HEIGHT::response res;
|
|
|
|
|
2015-03-27 14:01:30 +02:00
|
|
|
std::string fail_message = "Unsuccessful";
|
|
|
|
|
|
|
|
if (m_is_rpc)
|
2015-01-30 00:10:53 +02:00
|
|
|
{
|
2015-03-27 14:01:30 +02:00
|
|
|
if (!m_rpc_client->rpc_request(req, res, "/getheight", fail_message.c_str()))
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_get_height(req, res) || res.status != CORE_RPC_STATUS_OK)
|
2015-03-27 14:01:30 +02:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
|
|
|
}
|
2015-01-30 00:10:53 +02:00
|
|
|
}
|
|
|
|
|
2015-03-27 14:01:30 +02:00
|
|
|
tools::success_msg_writer() << boost::lexical_cast<std::string>(res.height);
|
|
|
|
|
2015-01-30 00:10:53 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool t_rpc_command_executor::print_block_by_hash(crypto::hash block_hash) {
|
2015-10-13 23:37:35 +03:00
|
|
|
cryptonote::COMMAND_RPC_GET_BLOCK::request req;
|
|
|
|
cryptonote::COMMAND_RPC_GET_BLOCK::response res;
|
2015-03-27 14:01:30 +02:00
|
|
|
epee::json_rpc::error error_resp;
|
2015-01-30 00:10:53 +02:00
|
|
|
|
|
|
|
req.hash = epee::string_tools::pod_to_hex(block_hash);
|
|
|
|
|
2015-03-27 14:01:30 +02:00
|
|
|
std::string fail_message = "Unsuccessful";
|
|
|
|
|
|
|
|
if (m_is_rpc)
|
|
|
|
{
|
2015-10-13 23:37:35 +03:00
|
|
|
if (!m_rpc_client->json_rpc_request(req, res, "getblock", fail_message.c_str()))
|
2015-03-27 14:01:30 +02:00
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2015-01-30 00:10:53 +02:00
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_get_block(req, res, error_resp) || res.status != CORE_RPC_STATUS_OK)
|
2015-03-27 14:01:30 +02:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
|
|
|
}
|
2015-01-30 00:10:53 +02:00
|
|
|
}
|
|
|
|
|
2015-03-27 14:01:30 +02:00
|
|
|
print_block_header(res.block_header);
|
2015-10-13 23:37:35 +03:00
|
|
|
tools::success_msg_writer() << res.json << ENDL;
|
2015-03-27 14:01:30 +02:00
|
|
|
|
2015-01-30 00:10:53 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool t_rpc_command_executor::print_block_by_height(uint64_t height) {
|
2015-10-13 23:37:35 +03:00
|
|
|
cryptonote::COMMAND_RPC_GET_BLOCK::request req;
|
|
|
|
cryptonote::COMMAND_RPC_GET_BLOCK::response res;
|
2015-03-27 14:01:30 +02:00
|
|
|
epee::json_rpc::error error_resp;
|
2015-01-30 00:10:53 +02:00
|
|
|
|
|
|
|
req.height = height;
|
|
|
|
|
2015-03-27 14:01:30 +02:00
|
|
|
std::string fail_message = "Unsuccessful";
|
|
|
|
|
|
|
|
if (m_is_rpc)
|
|
|
|
{
|
2015-10-13 23:37:35 +03:00
|
|
|
if (!m_rpc_client->json_rpc_request(req, res, "getblock", fail_message.c_str()))
|
2015-03-27 14:01:30 +02:00
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2015-01-30 00:10:53 +02:00
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_get_block(req, res, error_resp) || res.status != CORE_RPC_STATUS_OK)
|
2015-03-27 14:01:30 +02:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
|
|
|
}
|
2015-01-30 00:10:53 +02:00
|
|
|
}
|
|
|
|
|
2015-03-27 14:01:30 +02:00
|
|
|
print_block_header(res.block_header);
|
2015-10-13 23:37:35 +03:00
|
|
|
tools::success_msg_writer() << res.json << ENDL;
|
2015-03-27 14:01:30 +02:00
|
|
|
|
2015-01-30 00:10:53 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool t_rpc_command_executor::print_transaction(crypto::hash transaction_hash) {
|
|
|
|
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::request req;
|
|
|
|
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::response res;
|
|
|
|
|
2015-03-27 14:01:30 +02:00
|
|
|
std::string fail_message = "Problem fetching transaction";
|
|
|
|
|
2016-03-20 01:58:30 +02:00
|
|
|
req.txs_hashes.push_back(epee::string_tools::pod_to_hex(transaction_hash));
|
2015-03-27 14:01:30 +02:00
|
|
|
if (m_is_rpc)
|
2015-01-30 00:10:53 +02:00
|
|
|
{
|
2015-03-27 14:01:30 +02:00
|
|
|
if (!m_rpc_client->rpc_request(req, res, "/gettransactions", fail_message.c_str()))
|
2015-01-30 00:10:53 +02:00
|
|
|
{
|
2015-03-27 14:01:30 +02:00
|
|
|
return true;
|
2015-01-30 00:10:53 +02:00
|
|
|
}
|
2015-03-27 14:01:30 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_get_transactions(req, res) || res.status != CORE_RPC_STATUS_OK)
|
2015-01-30 00:10:53 +02:00
|
|
|
{
|
2015-03-27 14:01:30 +02:00
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
2015-01-30 00:10:53 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-03 14:51:28 +03:00
|
|
|
if (1 == res.txs.size() || 1 == res.txs_as_hex.size())
|
2015-03-27 14:01:30 +02:00
|
|
|
{
|
2016-04-03 14:51:28 +03:00
|
|
|
if (1 == res.txs.size())
|
|
|
|
{
|
|
|
|
// only available for new style answers
|
|
|
|
if (res.txs.front().in_pool)
|
|
|
|
tools::success_msg_writer() << "Found in pool";
|
|
|
|
else
|
|
|
|
tools::success_msg_writer() << "Found in blockchain at height " << res.txs.front().block_height;
|
|
|
|
}
|
|
|
|
|
2015-08-09 18:24:18 +03:00
|
|
|
// first as hex
|
2016-04-03 14:51:28 +03:00
|
|
|
const std::string &as_hex = (1 == res.txs.size()) ? res.txs.front().as_hex : res.txs_as_hex.front();
|
|
|
|
tools::success_msg_writer() << as_hex;
|
2015-08-09 18:24:18 +03:00
|
|
|
|
|
|
|
// then as json
|
|
|
|
crypto::hash tx_hash, tx_prefix_hash;
|
|
|
|
cryptonote::transaction tx;
|
|
|
|
cryptonote::blobdata blob;
|
2016-04-03 14:51:28 +03:00
|
|
|
if (!string_tools::parse_hexstr_to_binbuff(as_hex, blob))
|
2015-08-09 18:24:18 +03:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << "Failed to parse tx";
|
|
|
|
}
|
|
|
|
else if (!cryptonote::parse_and_validate_tx_from_blob(blob, tx, tx_hash, tx_prefix_hash))
|
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << "Failed to parse tx blob";
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
tools::success_msg_writer() << cryptonote::obj_to_json_str(tx) << std::endl;
|
|
|
|
}
|
2015-03-27 14:01:30 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-08-09 18:28:13 +03:00
|
|
|
tools::fail_msg_writer() << "transaction wasn't found: " << transaction_hash << std::endl;
|
2015-03-27 14:01:30 +02:00
|
|
|
}
|
|
|
|
|
2015-01-30 00:10:53 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-08-11 12:49:15 +03:00
|
|
|
bool t_rpc_command_executor::is_key_image_spent(const crypto::key_image &ki) {
|
|
|
|
cryptonote::COMMAND_RPC_IS_KEY_IMAGE_SPENT::request req;
|
|
|
|
cryptonote::COMMAND_RPC_IS_KEY_IMAGE_SPENT::response res;
|
|
|
|
|
2016-01-28 11:24:26 +02:00
|
|
|
std::string fail_message = "Problem checking key image";
|
2015-08-11 12:49:15 +03:00
|
|
|
|
|
|
|
req.key_images.push_back(epee::string_tools::pod_to_hex(ki));
|
|
|
|
if (m_is_rpc)
|
|
|
|
{
|
|
|
|
if (!m_rpc_client->rpc_request(req, res, "/is_key_image_spent", fail_message.c_str()))
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_is_key_image_spent(req, res) || res.status != CORE_RPC_STATUS_OK)
|
2015-08-11 12:49:15 +03:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (1 == res.spent_status.size())
|
|
|
|
{
|
|
|
|
// first as hex
|
|
|
|
tools::success_msg_writer() << ki << ": " << (res.spent_status.front() ? "spent" : "unspent");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << "key image status could not be determined" << std::endl;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-01-30 00:10:53 +02:00
|
|
|
bool t_rpc_command_executor::print_transaction_pool_long() {
|
|
|
|
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL::request req;
|
|
|
|
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL::response res;
|
|
|
|
|
2015-03-27 14:01:30 +02:00
|
|
|
std::string fail_message = "Problem fetching transaction pool";
|
|
|
|
|
|
|
|
if (m_is_rpc)
|
2015-01-30 00:10:53 +02:00
|
|
|
{
|
2015-03-27 14:01:30 +02:00
|
|
|
if (!m_rpc_client->rpc_request(req, res, "/get_transaction_pool", fail_message.c_str()))
|
2015-01-30 00:10:53 +02:00
|
|
|
{
|
2015-03-27 14:01:30 +02:00
|
|
|
return true;
|
2015-01-30 00:10:53 +02:00
|
|
|
}
|
2015-03-27 14:01:30 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_get_transaction_pool(req, res) || res.status != CORE_RPC_STATUS_OK)
|
2015-01-30 00:10:53 +02:00
|
|
|
{
|
2015-03-27 14:01:30 +02:00
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
2015-01-30 00:10:53 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-23 15:13:07 +03:00
|
|
|
if (res.transactions.empty() && res.spent_key_images.empty())
|
2015-03-27 14:01:30 +02:00
|
|
|
{
|
|
|
|
tools::msg_writer() << "Pool is empty" << std::endl;
|
|
|
|
}
|
2015-04-23 15:13:07 +03:00
|
|
|
if (! res.transactions.empty())
|
2015-03-27 14:01:30 +02:00
|
|
|
{
|
2016-04-05 21:26:37 +03:00
|
|
|
const time_t now = time(NULL);
|
2015-04-23 15:13:07 +03:00
|
|
|
tools::msg_writer() << "Transactions: ";
|
|
|
|
for (auto & tx_info : res.transactions)
|
|
|
|
{
|
|
|
|
tools::msg_writer() << "id: " << tx_info.id_hash << std::endl
|
|
|
|
<< tx_info.tx_json << std::endl
|
|
|
|
<< "blob_size: " << tx_info.blob_size << std::endl
|
|
|
|
<< "fee: " << cryptonote::print_money(tx_info.fee) << std::endl
|
2016-04-05 21:26:37 +03:00
|
|
|
<< "receive_time: " << tx_info.receive_time << " (" << get_human_time_ago(tx_info.receive_time, now) << ")" << std::endl
|
2015-04-23 15:13:07 +03:00
|
|
|
<< "kept_by_block: " << (tx_info.kept_by_block ? 'T' : 'F') << std::endl
|
|
|
|
<< "max_used_block_height: " << tx_info.max_used_block_height << std::endl
|
|
|
|
<< "max_used_block_id: " << tx_info.max_used_block_id_hash << std::endl
|
|
|
|
<< "last_failed_height: " << tx_info.last_failed_height << std::endl
|
|
|
|
<< "last_failed_id: " << tx_info.last_failed_id_hash << std::endl;
|
|
|
|
}
|
|
|
|
if (res.spent_key_images.empty())
|
|
|
|
{
|
|
|
|
tools::msg_writer() << "WARNING: Inconsistent pool state - no spent key images";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (! res.spent_key_images.empty())
|
|
|
|
{
|
|
|
|
tools::msg_writer() << ""; // one newline
|
|
|
|
tools::msg_writer() << "Spent key images: ";
|
|
|
|
for (const cryptonote::spent_key_image_info& kinfo : res.spent_key_images)
|
|
|
|
{
|
|
|
|
tools::msg_writer() << "key image: " << kinfo.id_hash;
|
|
|
|
if (kinfo.txs_hashes.size() == 1)
|
|
|
|
{
|
|
|
|
tools::msg_writer() << " tx: " << kinfo.txs_hashes[0];
|
|
|
|
}
|
|
|
|
else if (kinfo.txs_hashes.size() == 0)
|
|
|
|
{
|
|
|
|
tools::msg_writer() << " WARNING: spent key image has no txs associated";
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
tools::msg_writer() << " NOTE: key image for multiple txs: " << kinfo.txs_hashes.size();
|
|
|
|
for (const std::string& tx_id : kinfo.txs_hashes)
|
|
|
|
{
|
|
|
|
tools::msg_writer() << " tx: " << tx_id;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (res.transactions.empty())
|
|
|
|
{
|
|
|
|
tools::msg_writer() << "WARNING: Inconsistent pool state - no transactions";
|
|
|
|
}
|
2015-03-27 14:01:30 +02:00
|
|
|
}
|
|
|
|
|
2015-01-30 00:10:53 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool t_rpc_command_executor::print_transaction_pool_short() {
|
|
|
|
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL::request req;
|
|
|
|
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL::response res;
|
|
|
|
|
2015-03-27 14:01:30 +02:00
|
|
|
std::string fail_message = "Problem fetching transaction pool";
|
|
|
|
|
|
|
|
if (m_is_rpc)
|
2015-01-30 00:10:53 +02:00
|
|
|
{
|
2015-03-27 14:01:30 +02:00
|
|
|
if (!m_rpc_client->rpc_request(req, res, "/get_transaction_pool", fail_message.c_str()))
|
2015-01-30 00:10:53 +02:00
|
|
|
{
|
2015-03-27 14:01:30 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_get_transaction_pool(req, res) || res.status != CORE_RPC_STATUS_OK)
|
2015-03-27 14:01:30 +02:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
2015-01-30 00:10:53 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-27 14:01:30 +02:00
|
|
|
if (res.transactions.empty())
|
|
|
|
{
|
|
|
|
tools::msg_writer() << "Pool is empty" << std::endl;
|
|
|
|
}
|
2016-04-05 21:26:37 +03:00
|
|
|
else
|
|
|
|
{
|
|
|
|
const time_t now = time(NULL);
|
|
|
|
for (auto & tx_info : res.transactions)
|
|
|
|
{
|
|
|
|
tools::msg_writer() << "id: " << tx_info.id_hash << std::endl
|
|
|
|
<< "blob_size: " << tx_info.blob_size << std::endl
|
|
|
|
<< "fee: " << cryptonote::print_money(tx_info.fee) << std::endl
|
|
|
|
<< "receive_time: " << tx_info.receive_time << " (" << get_human_time_ago(tx_info.receive_time, now) << ")" << std::endl
|
|
|
|
<< "kept_by_block: " << (tx_info.kept_by_block ? 'T' : 'F') << std::endl
|
|
|
|
<< "max_used_block_height: " << tx_info.max_used_block_height << std::endl
|
|
|
|
<< "max_used_block_id: " << tx_info.max_used_block_id_hash << std::endl
|
|
|
|
<< "last_failed_height: " << tx_info.last_failed_height << std::endl
|
|
|
|
<< "last_failed_id: " << tx_info.last_failed_id_hash << std::endl;
|
|
|
|
}
|
2015-03-27 14:01:30 +02:00
|
|
|
}
|
|
|
|
|
2015-01-30 00:10:53 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-10-28 20:08:14 +02:00
|
|
|
bool t_rpc_command_executor::start_mining(cryptonote::account_public_address address, uint64_t num_threads, bool testnet) {
|
2015-01-30 00:10:53 +02:00
|
|
|
cryptonote::COMMAND_RPC_START_MINING::request req;
|
|
|
|
cryptonote::COMMAND_RPC_START_MINING::response res;
|
2015-10-28 20:08:14 +02:00
|
|
|
req.miner_address = cryptonote::get_account_address_as_str(testnet, address);
|
2015-01-30 00:10:53 +02:00
|
|
|
req.threads_count = num_threads;
|
|
|
|
|
2015-04-10 11:08:04 +03:00
|
|
|
std::string fail_message = "Mining did not start";
|
|
|
|
|
|
|
|
if (m_is_rpc)
|
|
|
|
{
|
|
|
|
if (m_rpc_client->rpc_request(req, res, "/start_mining", fail_message.c_str()))
|
|
|
|
{
|
|
|
|
tools::success_msg_writer() << "Mining started";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2015-01-30 00:10:53 +02:00
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_start_mining(req, res) || res.status != CORE_RPC_STATUS_OK)
|
2015-04-10 11:08:04 +03:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
|
|
|
}
|
2015-01-30 00:10:53 +02:00
|
|
|
}
|
2015-04-10 11:08:04 +03:00
|
|
|
|
2015-01-30 00:10:53 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool t_rpc_command_executor::stop_mining() {
|
|
|
|
cryptonote::COMMAND_RPC_STOP_MINING::request req;
|
|
|
|
cryptonote::COMMAND_RPC_STOP_MINING::response res;
|
|
|
|
|
2015-03-27 14:01:30 +02:00
|
|
|
std::string fail_message = "Mining did not stop";
|
|
|
|
|
|
|
|
if (m_is_rpc)
|
2015-01-30 00:10:53 +02:00
|
|
|
{
|
2015-03-27 14:01:30 +02:00
|
|
|
if (!m_rpc_client->rpc_request(req, res, "/stop_mining", fail_message.c_str()))
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
2015-01-30 00:10:53 +02:00
|
|
|
}
|
2015-03-27 14:01:30 +02:00
|
|
|
else
|
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_stop_mining(req, res) || res.status != CORE_RPC_STATUS_OK)
|
2015-03-27 14:01:30 +02:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
tools::success_msg_writer() << "Mining stopped";
|
2015-01-30 00:10:53 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool t_rpc_command_executor::stop_daemon()
|
|
|
|
{
|
|
|
|
cryptonote::COMMAND_RPC_STOP_DAEMON::request req;
|
|
|
|
cryptonote::COMMAND_RPC_STOP_DAEMON::response res;
|
|
|
|
|
|
|
|
//# ifdef WIN32
|
|
|
|
// // Stop via service API
|
|
|
|
// // TODO - this is only temporary! Get rid of hard-coded constants!
|
|
|
|
// bool ok = windows::stop_service("BitMonero Daemon");
|
|
|
|
// ok = windows::uninstall_service("BitMonero Daemon");
|
|
|
|
// //bool ok = windows::stop_service(SERVICE_NAME);
|
|
|
|
// //ok = windows::uninstall_service(SERVICE_NAME);
|
|
|
|
// if (ok)
|
|
|
|
// {
|
|
|
|
// return true;
|
|
|
|
// }
|
|
|
|
//# endif
|
|
|
|
|
|
|
|
// Stop via RPC
|
2015-03-27 14:01:30 +02:00
|
|
|
std::string fail_message = "Daemon did not stop";
|
|
|
|
|
|
|
|
if (m_is_rpc)
|
|
|
|
{
|
|
|
|
if(!m_rpc_client->rpc_request(req, res, "/stop_daemon", fail_message.c_str()))
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2015-01-30 00:10:53 +02:00
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_stop_daemon(req, res) || res.status != CORE_RPC_STATUS_OK)
|
2015-03-27 14:01:30 +02:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
|
|
|
}
|
2015-01-30 00:10:53 +02:00
|
|
|
}
|
|
|
|
|
2015-03-27 14:01:30 +02:00
|
|
|
tools::success_msg_writer() << "Stop signal sent";
|
|
|
|
|
2015-01-30 00:10:53 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool t_rpc_command_executor::print_status()
|
|
|
|
{
|
2015-03-27 14:01:30 +02:00
|
|
|
if (!m_is_rpc)
|
|
|
|
{
|
|
|
|
tools::success_msg_writer() << "print_status makes no sense in interactive mode";
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool daemon_is_alive = m_rpc_client->check_connection();
|
2015-01-30 00:10:53 +02:00
|
|
|
|
|
|
|
if(daemon_is_alive) {
|
2016-09-03 23:03:44 +03:00
|
|
|
tools::success_msg_writer() << "monerod is running";
|
2015-01-30 00:10:53 +02:00
|
|
|
}
|
|
|
|
else {
|
2016-09-03 23:03:44 +03:00
|
|
|
tools::fail_msg_writer() << "monerod is NOT running";
|
2015-01-30 00:10:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-05-17 15:13:02 +03:00
|
|
|
bool t_rpc_command_executor::get_limit()
|
|
|
|
{
|
|
|
|
int limit_down = epee::net_utils::connection_basic::get_rate_down_limit( );
|
|
|
|
int limit_up = epee::net_utils::connection_basic::get_rate_up_limit( );
|
|
|
|
std::cout << "limit-down is " << limit_down/1024 << " kB/s" << std::endl;
|
|
|
|
std::cout << "limit-up is " << limit_up/1024 << " kB/s" << std::endl;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-01-30 00:10:53 +02:00
|
|
|
bool t_rpc_command_executor::set_limit(int limit)
|
|
|
|
{
|
|
|
|
epee::net_utils::connection_basic::set_rate_down_limit( limit );
|
|
|
|
epee::net_utils::connection_basic::set_rate_up_limit( limit );
|
|
|
|
std::cout << "Set limit-down to " << limit/1024 << " kB/s" << std::endl;
|
|
|
|
std::cout << "Set limit-up to " << limit/1024 << " kB/s" << std::endl;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-05-17 15:13:02 +03:00
|
|
|
bool t_rpc_command_executor::get_limit_up()
|
|
|
|
{
|
|
|
|
int limit_up = epee::net_utils::connection_basic::get_rate_up_limit( );
|
|
|
|
std::cout << "limit-up is " << limit_up/1024 << " kB/s" << std::endl;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-01-30 00:10:53 +02:00
|
|
|
bool t_rpc_command_executor::set_limit_up(int limit)
|
|
|
|
{
|
|
|
|
epee::net_utils::connection_basic::set_rate_up_limit( limit );
|
|
|
|
std::cout << "Set limit-up to " << limit/1024 << " kB/s" << std::endl;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-05-17 15:13:02 +03:00
|
|
|
bool t_rpc_command_executor::get_limit_down()
|
|
|
|
{
|
|
|
|
int limit_down = epee::net_utils::connection_basic::get_rate_down_limit( );
|
|
|
|
std::cout << "limit-down is " << limit_down/1024 << " kB/s" << std::endl;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-01-30 00:10:53 +02:00
|
|
|
bool t_rpc_command_executor::set_limit_down(int limit)
|
|
|
|
{
|
|
|
|
epee::net_utils::connection_basic::set_rate_down_limit( limit );
|
|
|
|
std::cout << "Set limit-down to " << limit/1024 << " kB/s" << std::endl;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-04-01 20:00:45 +03:00
|
|
|
bool t_rpc_command_executor::fast_exit()
|
|
|
|
{
|
|
|
|
cryptonote::COMMAND_RPC_FAST_EXIT::request req;
|
|
|
|
cryptonote::COMMAND_RPC_FAST_EXIT::response res;
|
|
|
|
|
|
|
|
std::string fail_message = "Daemon did not stop";
|
|
|
|
|
|
|
|
if (m_is_rpc)
|
|
|
|
{
|
|
|
|
if (!m_rpc_client->rpc_request(req, res, "/fast_exit", fail_message.c_str()))
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
else
|
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_fast_exit(req, res) || res.status != CORE_RPC_STATUS_OK)
|
2015-04-01 20:00:45 +03:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
tools::success_msg_writer() << "Daemon stopped";
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool t_rpc_command_executor::out_peers(uint64_t limit)
|
|
|
|
{
|
|
|
|
cryptonote::COMMAND_RPC_OUT_PEERS::request req;
|
|
|
|
cryptonote::COMMAND_RPC_OUT_PEERS::response res;
|
|
|
|
|
|
|
|
epee::json_rpc::error error_resp;
|
|
|
|
|
|
|
|
req.out_peers = limit;
|
|
|
|
|
|
|
|
std::string fail_message = "Unsuccessful";
|
|
|
|
|
|
|
|
if (m_is_rpc)
|
|
|
|
{
|
2015-10-26 12:17:03 +02:00
|
|
|
if (!m_rpc_client->json_rpc_request(req, res, "out_peers", fail_message.c_str()))
|
2015-04-01 20:00:45 +03:00
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_out_peers(req, res) || res.status != CORE_RPC_STATUS_OK)
|
2015-04-01 20:00:45 +03:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-15 00:13:12 +02:00
|
|
|
std::cout << "Max number of out peers set to " << limit << std::endl;
|
2016-01-15 00:10:07 +02:00
|
|
|
|
2015-04-01 20:00:45 +03:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool t_rpc_command_executor::start_save_graph()
|
|
|
|
{
|
|
|
|
cryptonote::COMMAND_RPC_START_SAVE_GRAPH::request req;
|
|
|
|
cryptonote::COMMAND_RPC_START_SAVE_GRAPH::response res;
|
|
|
|
std::string fail_message = "Unsuccessful";
|
|
|
|
|
|
|
|
if (m_is_rpc)
|
|
|
|
{
|
|
|
|
if (!m_rpc_client->rpc_request(req, res, "/start_save_graph", fail_message.c_str()))
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
else
|
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_start_save_graph(req, res) || res.status != CORE_RPC_STATUS_OK)
|
2015-04-01 20:00:45 +03:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool t_rpc_command_executor::stop_save_graph()
|
|
|
|
{
|
|
|
|
cryptonote::COMMAND_RPC_STOP_SAVE_GRAPH::request req;
|
|
|
|
cryptonote::COMMAND_RPC_STOP_SAVE_GRAPH::response res;
|
|
|
|
std::string fail_message = "Unsuccessful";
|
|
|
|
|
|
|
|
if (m_is_rpc)
|
|
|
|
{
|
|
|
|
if (!m_rpc_client->rpc_request(req, res, "/stop_save_graph", fail_message.c_str()))
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
else
|
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_stop_save_graph(req, res) || res.status != CORE_RPC_STATUS_OK)
|
2015-04-01 20:00:45 +03:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-09-19 18:34:29 +03:00
|
|
|
bool t_rpc_command_executor::hard_fork_info(uint8_t version)
|
|
|
|
{
|
|
|
|
cryptonote::COMMAND_RPC_HARD_FORK_INFO::request req;
|
|
|
|
cryptonote::COMMAND_RPC_HARD_FORK_INFO::response res;
|
|
|
|
std::string fail_message = "Unsuccessful";
|
|
|
|
epee::json_rpc::error error_resp;
|
|
|
|
|
|
|
|
req.version = version;
|
|
|
|
|
|
|
|
if (m_is_rpc)
|
|
|
|
{
|
2015-10-26 12:17:03 +02:00
|
|
|
if (!m_rpc_client->json_rpc_request(req, res, "hard_fork_info", fail_message.c_str()))
|
2015-09-19 18:34:29 +03:00
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_hard_fork_info(req, res, error_resp) || res.status != CORE_RPC_STATUS_OK)
|
2015-09-19 18:34:29 +03:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
2015-10-26 12:17:48 +02:00
|
|
|
|
|
|
|
version = version > 0 ? version : res.voting;
|
|
|
|
tools::msg_writer() << "version " << (uint32_t)version << " " << (res.enabled ? "enabled" : "not enabled") <<
|
|
|
|
", " << res.votes << "/" << res.window << " votes, threshold " << res.threshold;
|
|
|
|
tools::msg_writer() << "current version " << (uint32_t)res.version << ", voting for version " << (uint32_t)res.voting;
|
|
|
|
|
2015-09-19 18:34:29 +03:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-11-26 02:04:22 +02:00
|
|
|
bool t_rpc_command_executor::print_bans()
|
|
|
|
{
|
|
|
|
cryptonote::COMMAND_RPC_GETBANS::request req;
|
|
|
|
cryptonote::COMMAND_RPC_GETBANS::response res;
|
|
|
|
std::string fail_message = "Unsuccessful";
|
|
|
|
epee::json_rpc::error error_resp;
|
|
|
|
|
|
|
|
if (m_is_rpc)
|
|
|
|
{
|
|
|
|
if (!m_rpc_client->json_rpc_request(req, res, "get_bans", fail_message.c_str()))
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_get_bans(req, res, error_resp) || res.status != CORE_RPC_STATUS_OK)
|
2015-11-26 02:04:22 +02:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (auto i = res.bans.begin(); i != res.bans.end(); ++i)
|
|
|
|
{
|
2016-07-10 17:11:23 +03:00
|
|
|
tools::msg_writer() << epee::string_tools::get_ip_string_from_int32(i->ip) << " banned for " << i->seconds << " seconds";
|
2015-11-26 02:04:22 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool t_rpc_command_executor::ban(const std::string &ip, time_t seconds)
|
|
|
|
{
|
|
|
|
cryptonote::COMMAND_RPC_SETBANS::request req;
|
|
|
|
cryptonote::COMMAND_RPC_SETBANS::response res;
|
|
|
|
std::string fail_message = "Unsuccessful";
|
|
|
|
epee::json_rpc::error error_resp;
|
|
|
|
|
|
|
|
cryptonote::COMMAND_RPC_SETBANS::ban ban;
|
|
|
|
if (!epee::string_tools::get_ip_int32_from_string(ban.ip, ip))
|
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << "Invalid IP";
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
ban.ban = true;
|
|
|
|
ban.seconds = seconds;
|
|
|
|
req.bans.push_back(ban);
|
|
|
|
|
|
|
|
if (m_is_rpc)
|
|
|
|
{
|
|
|
|
if (!m_rpc_client->json_rpc_request(req, res, "set_bans", fail_message.c_str()))
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_set_bans(req, res, error_resp) || res.status != CORE_RPC_STATUS_OK)
|
2015-11-26 02:04:22 +02:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool t_rpc_command_executor::unban(const std::string &ip)
|
|
|
|
{
|
|
|
|
cryptonote::COMMAND_RPC_SETBANS::request req;
|
|
|
|
cryptonote::COMMAND_RPC_SETBANS::response res;
|
|
|
|
std::string fail_message = "Unsuccessful";
|
|
|
|
epee::json_rpc::error error_resp;
|
|
|
|
|
|
|
|
cryptonote::COMMAND_RPC_SETBANS::ban ban;
|
|
|
|
if (!epee::string_tools::get_ip_int32_from_string(ban.ip, ip))
|
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << "Invalid IP";
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
ban.ban = false;
|
|
|
|
ban.seconds = 0;
|
|
|
|
req.bans.push_back(ban);
|
|
|
|
|
|
|
|
if (m_is_rpc)
|
|
|
|
{
|
|
|
|
if (!m_rpc_client->json_rpc_request(req, res, "set_bans", fail_message.c_str()))
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-01-31 00:14:51 +02:00
|
|
|
if (!m_rpc_server->on_set_bans(req, res, error_resp) || res.status != CORE_RPC_STATUS_OK)
|
2015-11-26 02:04:22 +02:00
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-01-30 15:28:26 +02:00
|
|
|
bool t_rpc_command_executor::flush_txpool(const std::string &txid)
|
|
|
|
{
|
|
|
|
cryptonote::COMMAND_RPC_FLUSH_TRANSACTION_POOL::request req;
|
|
|
|
cryptonote::COMMAND_RPC_FLUSH_TRANSACTION_POOL::response res;
|
|
|
|
std::string fail_message = "Unsuccessful";
|
|
|
|
epee::json_rpc::error error_resp;
|
|
|
|
|
|
|
|
if (!txid.empty())
|
|
|
|
req.txids.push_back(txid);
|
|
|
|
|
|
|
|
if (m_is_rpc)
|
|
|
|
{
|
|
|
|
if (!m_rpc_client->json_rpc_request(req, res, "flush_txpool", fail_message.c_str()))
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (!m_rpc_server->on_flush_txpool(req, res, error_resp))
|
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-03-26 16:30:23 +02:00
|
|
|
bool t_rpc_command_executor::output_histogram(uint64_t min_count, uint64_t max_count)
|
|
|
|
{
|
|
|
|
cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::request req;
|
|
|
|
cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::response res;
|
|
|
|
std::string fail_message = "Unsuccessful";
|
|
|
|
epee::json_rpc::error error_resp;
|
|
|
|
|
|
|
|
req.min_count = min_count;
|
|
|
|
req.max_count = max_count;
|
|
|
|
|
|
|
|
if (m_is_rpc)
|
|
|
|
{
|
|
|
|
if (!m_rpc_client->json_rpc_request(req, res, "get_output_histogram", fail_message.c_str()))
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (!m_rpc_server->on_get_output_histogram(req, res, error_resp))
|
|
|
|
{
|
|
|
|
tools::fail_msg_writer() << fail_message.c_str();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
std::sort(res.histogram.begin(), res.histogram.end(),
|
|
|
|
[](const cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::entry &e1, const cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::entry &e2)->bool { return e1.instances < e2.instances; });
|
|
|
|
for (const auto &e: res.histogram)
|
|
|
|
{
|
|
|
|
tools::msg_writer() << e.instances << " " << cryptonote::print_money(e.amount);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-01-30 15:28:26 +02:00
|
|
|
|
2015-01-30 00:10:53 +02:00
|
|
|
}// namespace daemonize
|