root
1072 lines
37 KiB
C++
1072 lines
37 KiB
C++
// Copyright (c) 2011-2014 The Bitcoin developers
|
|
// Copyright (c) 2014-2015 The Dash developers
|
|
// Copyright (c) 2015-2019 The PIVX developers
|
|
// Distributed under the MIT/X11 software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#include "rpcconsole.h"
|
|
#include "ui_rpcconsole.h"
|
|
|
|
#include "bantablemodel.h"
|
|
#include "clientmodel.h"
|
|
#include "guiutil.h"
|
|
#include "peertablemodel.h"
|
|
|
|
#include "chainparams.h"
|
|
#include "main.h"
|
|
#include "rpc/client.h"
|
|
#include "rpc/server.h"
|
|
#include "util.h"
|
|
#ifdef ENABLE_WALLET
|
|
#include "wallet/wallet.h"
|
|
#endif // ENABLE_WALLET
|
|
|
|
#include <openssl/crypto.h>
|
|
|
|
#include <univalue.h>
|
|
|
|
#ifdef ENABLE_WALLET
|
|
#include <db_cxx.h>
|
|
#endif
|
|
|
|
#include <QDir>
|
|
#include <QKeyEvent>
|
|
#include <QMenu>
|
|
#include <QScrollBar>
|
|
#include <QSignalMapper>
|
|
#include <QThread>
|
|
#include <QTime>
|
|
#include <QTimer>
|
|
#include <QStringList>
|
|
|
|
// TODO: add a scrollback limit, as there is currently none
|
|
// TODO: make it possible to filter out categories (esp debug messages when implemented)
|
|
// TODO: receive errors and debug messages through ClientModel
|
|
|
|
const int CONSOLE_HISTORY = 50;
|
|
const QSize ICON_SIZE(24, 24);
|
|
|
|
const int INITIAL_TRAFFIC_GRAPH_MINS = 30;
|
|
|
|
// Repair parameters
|
|
const QString SALVAGEWALLET("-salvagewallet");
|
|
const QString RESCAN("-rescan");
|
|
const QString ZAPTXES1("-zapwallettxes=1");
|
|
const QString ZAPTXES2("-zapwallettxes=2");
|
|
const QString UPGRADEWALLET("-upgradewallet");
|
|
const QString REINDEX("-reindex");
|
|
const QString RESYNC("-resync");
|
|
|
|
const struct {
|
|
const char* url;
|
|
const char* source;
|
|
} ICON_MAPPING[] = {
|
|
{"cmd-request", ":/icons/tx_input"},
|
|
{"cmd-reply", ":/icons/tx_output"},
|
|
{"cmd-error", ":/icons/tx_output"},
|
|
{"misc", ":/icons/tx_inout"},
|
|
{NULL, NULL}};
|
|
|
|
/* Object for executing console RPC commands in a separate thread.
|
|
*/
|
|
class RPCExecutor : public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
public slots:
|
|
void request(const QString& command);
|
|
|
|
signals:
|
|
void reply(int category, const QString& command);
|
|
};
|
|
|
|
/** Class for handling RPC timers
|
|
* (used for e.g. re-locking the wallet after a timeout)
|
|
*/
|
|
class QtRPCTimerBase: public QObject, public RPCTimerBase
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
QtRPCTimerBase(boost::function<void(void)>& func, int64_t millis):
|
|
func(func)
|
|
{
|
|
timer.setSingleShot(true);
|
|
connect(&timer, SIGNAL(timeout()), this, SLOT(timeout()));
|
|
timer.start(millis);
|
|
}
|
|
~QtRPCTimerBase() {}
|
|
private slots:
|
|
void timeout() { func(); }
|
|
private:
|
|
QTimer timer;
|
|
boost::function<void(void)> func;
|
|
};
|
|
|
|
class QtRPCTimerInterface: public RPCTimerInterface
|
|
{
|
|
public:
|
|
~QtRPCTimerInterface() {}
|
|
const char *Name() { return "Qt"; }
|
|
RPCTimerBase* NewTimer(boost::function<void(void)>& func, int64_t millis)
|
|
{
|
|
return new QtRPCTimerBase(func, millis);
|
|
}
|
|
};
|
|
|
|
#include "rpcconsole.moc"
|
|
|
|
/**
|
|
* Split shell command line into a list of arguments. Aims to emulate \c bash and friends.
|
|
*
|
|
* - Arguments are delimited with whitespace
|
|
* - Extra whitespace at the beginning and end and between arguments will be ignored
|
|
* - Text can be "double" or 'single' quoted
|
|
* - The backslash \c \ is used as escape character
|
|
* - Outside quotes, any character can be escaped
|
|
* - Within double quotes, only escape \c " and backslashes before a \c " or another backslash
|
|
* - Within single quotes, no escaping is possible and no special interpretation takes place
|
|
*
|
|
* @param[out] args Parsed arguments will be appended to this list
|
|
* @param[in] strCommand Command line to split
|
|
*/
|
|
bool parseCommandLine(std::vector<std::string>& args, const std::string& strCommand)
|
|
{
|
|
enum CmdParseState {
|
|
STATE_EATING_SPACES,
|
|
STATE_ARGUMENT,
|
|
STATE_SINGLEQUOTED,
|
|
STATE_DOUBLEQUOTED,
|
|
STATE_ESCAPE_OUTER,
|
|
STATE_ESCAPE_DOUBLEQUOTED
|
|
} state = STATE_EATING_SPACES;
|
|
std::string curarg;
|
|
foreach (char ch, strCommand) {
|
|
switch (state) {
|
|
case STATE_ARGUMENT: // In or after argument
|
|
case STATE_EATING_SPACES: // Handle runs of whitespace
|
|
switch (ch) {
|
|
case '"':
|
|
state = STATE_DOUBLEQUOTED;
|
|
break;
|
|
case '\'':
|
|
state = STATE_SINGLEQUOTED;
|
|
break;
|
|
case '\\':
|
|
state = STATE_ESCAPE_OUTER;
|
|
break;
|
|
case ' ':
|
|
case '\n':
|
|
case '\t':
|
|
if (state == STATE_ARGUMENT) // Space ends argument
|
|
{
|
|
args.push_back(curarg);
|
|
curarg.clear();
|
|
}
|
|
state = STATE_EATING_SPACES;
|
|
break;
|
|
default:
|
|
curarg += ch;
|
|
state = STATE_ARGUMENT;
|
|
}
|
|
break;
|
|
case STATE_SINGLEQUOTED: // Single-quoted string
|
|
switch (ch) {
|
|
case '\'':
|
|
state = STATE_ARGUMENT;
|
|
break;
|
|
default:
|
|
curarg += ch;
|
|
}
|
|
break;
|
|
case STATE_DOUBLEQUOTED: // Double-quoted string
|
|
switch (ch) {
|
|
case '"':
|
|
state = STATE_ARGUMENT;
|
|
break;
|
|
case '\\':
|
|
state = STATE_ESCAPE_DOUBLEQUOTED;
|
|
break;
|
|
default:
|
|
curarg += ch;
|
|
}
|
|
break;
|
|
case STATE_ESCAPE_OUTER: // '\' outside quotes
|
|
curarg += ch;
|
|
state = STATE_ARGUMENT;
|
|
break;
|
|
case STATE_ESCAPE_DOUBLEQUOTED: // '\' in double-quoted text
|
|
if (ch != '"' && ch != '\\') curarg += '\\'; // keep '\' for everything but the quote and '\' itself
|
|
curarg += ch;
|
|
state = STATE_DOUBLEQUOTED;
|
|
break;
|
|
}
|
|
}
|
|
switch (state) // final state
|
|
{
|
|
case STATE_EATING_SPACES:
|
|
return true;
|
|
case STATE_ARGUMENT:
|
|
args.push_back(curarg);
|
|
return true;
|
|
default: // ERROR to end in one of the other states
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void RPCExecutor::request(const QString& command)
|
|
{
|
|
std::vector<std::string> args;
|
|
if (!parseCommandLine(args, command.toStdString())) {
|
|
emit reply(RPCConsole::CMD_ERROR, QString("Parse error: unbalanced ' or \""));
|
|
return;
|
|
}
|
|
if (args.empty())
|
|
return; // Nothing to do
|
|
try {
|
|
std::string strPrint;
|
|
// Convert argument list to JSON objects in method-dependent way,
|
|
// and pass it along with the method name to the dispatcher.
|
|
UniValue result = tableRPC.execute(
|
|
args[0],
|
|
RPCConvertValues(args[0], std::vector<std::string>(args.begin() + 1, args.end())));
|
|
|
|
// Format result reply
|
|
if (result.isNull())
|
|
strPrint = "";
|
|
else if (result.isStr())
|
|
strPrint = result.get_str();
|
|
else
|
|
strPrint = result.write(2);
|
|
|
|
emit reply(RPCConsole::CMD_REPLY, QString::fromStdString(strPrint));
|
|
} catch (UniValue& objError) {
|
|
try // Nice formatting for standard-format error
|
|
{
|
|
int code = find_value(objError, "code").get_int();
|
|
std::string message = find_value(objError, "message").get_str();
|
|
emit reply(RPCConsole::CMD_ERROR, QString::fromStdString(message) + " (code " + QString::number(code) + ")");
|
|
} catch (std::runtime_error&) // raised when converting to invalid type, i.e. missing code or message
|
|
{ // Show raw JSON object
|
|
emit reply(RPCConsole::CMD_ERROR, QString::fromStdString(objError.write()));
|
|
}
|
|
} catch (std::exception& e) {
|
|
emit reply(RPCConsole::CMD_ERROR, QString("Error: ") + QString::fromStdString(e.what()));
|
|
}
|
|
}
|
|
|
|
RPCConsole::RPCConsole(QWidget* parent) : QDialog(parent, Qt::WindowSystemMenuHint | Qt::WindowTitleHint | Qt::WindowCloseButtonHint),
|
|
ui(new Ui::RPCConsole),
|
|
clientModel(0),
|
|
historyPtr(0),
|
|
cachedNodeid(-1),
|
|
peersTableContextMenu(0),
|
|
banTableContextMenu(0)
|
|
{
|
|
ui->setupUi(this);
|
|
GUIUtil::restoreWindowGeometry("nRPCConsoleWindow", this->size(), this);
|
|
|
|
#ifndef Q_OS_MAC
|
|
ui->openDebugLogfileButton->setIcon(QIcon(":/icons/export"));
|
|
#endif
|
|
|
|
// Install event filter for up and down arrow
|
|
ui->lineEdit->installEventFilter(this);
|
|
ui->messagesWidget->installEventFilter(this);
|
|
|
|
connect(ui->clearButton, SIGNAL(clicked()), this, SLOT(clear()));
|
|
connect(ui->btnClearTrafficGraph, SIGNAL(clicked()), ui->trafficGraph, SLOT(clear()));
|
|
|
|
// Wallet Repair Buttons
|
|
connect(ui->btn_salvagewallet, SIGNAL(clicked()), this, SLOT(walletSalvage()));
|
|
connect(ui->btn_rescan, SIGNAL(clicked()), this, SLOT(walletRescan()));
|
|
connect(ui->btn_zapwallettxes1, SIGNAL(clicked()), this, SLOT(walletZaptxes1()));
|
|
connect(ui->btn_zapwallettxes2, SIGNAL(clicked()), this, SLOT(walletZaptxes2()));
|
|
connect(ui->btn_upgradewallet, SIGNAL(clicked()), this, SLOT(walletUpgrade()));
|
|
connect(ui->btn_reindex, SIGNAL(clicked()), this, SLOT(walletReindex()));
|
|
connect(ui->btn_resync, SIGNAL(clicked()), this, SLOT(walletResync()));
|
|
|
|
// set library version labels
|
|
#if OPENSSL_VERSION_NUMBER >= 0x10100000L
|
|
ui->openSSLVersion->setText(OpenSSL_version(OPENSSL_VERSION));
|
|
#else
|
|
ui->openSSLVersion->setText(SSLeay_version(SSLEAY_VERSION));
|
|
#endif
|
|
#ifdef ENABLE_WALLET
|
|
std::string strPathCustom = GetArg("-backuppath", "");
|
|
std::string strzAGRPathCustom = GetArg("-zagrbackuppath", "");
|
|
int nCustomBackupThreshold = GetArg("-custombackupthreshold", DEFAULT_CUSTOMBACKUPTHRESHOLD);
|
|
|
|
if(!strPathCustom.empty()) {
|
|
ui->wallet_custombackuppath->setText(QString::fromStdString(strPathCustom));
|
|
ui->wallet_custombackuppath_label->show();
|
|
ui->wallet_custombackuppath->show();
|
|
}
|
|
|
|
if(!strzAGRPathCustom.empty()) {
|
|
ui->wallet_customzagrbackuppath->setText(QString::fromStdString(strzAGRPathCustom));
|
|
ui->wallet_customzagrbackuppath_label->setVisible(true);
|
|
ui->wallet_customzagrbackuppath->setVisible(true);
|
|
}
|
|
|
|
if((!strPathCustom.empty() || !strzAGRPathCustom.empty()) && nCustomBackupThreshold > 0) {
|
|
ui->wallet_custombackupthreshold->setText(QString::fromStdString(std::to_string(nCustomBackupThreshold)));
|
|
ui->wallet_custombackupthreshold_label->setVisible(true);
|
|
ui->wallet_custombackupthreshold->setVisible(true);
|
|
}
|
|
|
|
ui->berkeleyDBVersion->setText(DbEnv::version(0, 0, 0));
|
|
ui->wallet_path->setText(QString::fromStdString(GetDataDir().string() + QDir::separator().toLatin1() + GetArg("-wallet", "wallet.dat")));
|
|
#else
|
|
|
|
ui->label_berkeleyDBVersion->hide();
|
|
ui->berkeleyDBVersion->hide();
|
|
#endif
|
|
// Register RPC timer interface
|
|
rpcTimerInterface = new QtRPCTimerInterface();
|
|
// avoid accidentally overwriting an existing, non QTThread
|
|
// based timer interface
|
|
RPCSetTimerInterfaceIfUnset(rpcTimerInterface);
|
|
|
|
startExecutor();
|
|
setTrafficGraphRange(INITIAL_TRAFFIC_GRAPH_MINS);
|
|
|
|
ui->peerHeading->setText(tr("Select a peer to view detailed information."));
|
|
|
|
clear();
|
|
}
|
|
|
|
RPCConsole::~RPCConsole()
|
|
{
|
|
GUIUtil::saveWindowGeometry("nRPCConsoleWindow", this);
|
|
emit stopExecutor();
|
|
RPCUnsetTimerInterface(rpcTimerInterface);
|
|
delete rpcTimerInterface;
|
|
delete ui;
|
|
}
|
|
|
|
bool RPCConsole::eventFilter(QObject* obj, QEvent* event)
|
|
{
|
|
if (event->type() == QEvent::KeyPress) // Special key handling
|
|
{
|
|
QKeyEvent* keyevt = static_cast<QKeyEvent*>(event);
|
|
int key = keyevt->key();
|
|
Qt::KeyboardModifiers mod = keyevt->modifiers();
|
|
switch (key) {
|
|
case Qt::Key_Up:
|
|
if (obj == ui->lineEdit) {
|
|
browseHistory(-1);
|
|
return true;
|
|
}
|
|
break;
|
|
case Qt::Key_Down:
|
|
if (obj == ui->lineEdit) {
|
|
browseHistory(1);
|
|
return true;
|
|
}
|
|
break;
|
|
case Qt::Key_PageUp: /* pass paging keys to messages widget */
|
|
case Qt::Key_PageDown:
|
|
if (obj == ui->lineEdit) {
|
|
QApplication::postEvent(ui->messagesWidget, new QKeyEvent(*keyevt));
|
|
return true;
|
|
}
|
|
break;
|
|
case Qt::Key_Return:
|
|
case Qt::Key_Enter:
|
|
// forward these events to lineEdit
|
|
if(obj == autoCompleter->popup()) {
|
|
QApplication::postEvent(ui->lineEdit, new QKeyEvent(*keyevt));
|
|
return true;
|
|
}
|
|
break;
|
|
default:
|
|
// Typing in messages widget brings focus to line edit, and redirects key there
|
|
// Exclude most combinations and keys that emit no text, except paste shortcuts
|
|
if (obj == ui->messagesWidget && ((!mod && !keyevt->text().isEmpty() && key != Qt::Key_Tab) ||
|
|
((mod & Qt::ControlModifier) && key == Qt::Key_V) ||
|
|
((mod & Qt::ShiftModifier) && key == Qt::Key_Insert))) {
|
|
ui->lineEdit->setFocus();
|
|
QApplication::postEvent(ui->lineEdit, new QKeyEvent(*keyevt));
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return QDialog::eventFilter(obj, event);
|
|
}
|
|
|
|
void RPCConsole::setClientModel(ClientModel* model)
|
|
{
|
|
clientModel = model;
|
|
ui->trafficGraph->setClientModel(model);
|
|
if (model && clientModel->getPeerTableModel() && clientModel->getBanTableModel()) {
|
|
// Keep up to date with client
|
|
setNumConnections(model->getNumConnections());
|
|
connect(model, SIGNAL(numConnectionsChanged(int)), this, SLOT(setNumConnections(int)));
|
|
|
|
setNumBlocks(model->getNumBlocks());
|
|
connect(model, SIGNAL(numBlocksChanged(int)), this, SLOT(setNumBlocks(int)));
|
|
|
|
setMasternodeCount(model->getMasternodeCountString());
|
|
connect(model, SIGNAL(strMasternodesChanged(QString)), this, SLOT(setMasternodeCount(QString)));
|
|
|
|
updateTrafficStats(model->getTotalBytesRecv(), model->getTotalBytesSent());
|
|
connect(model, SIGNAL(bytesChanged(quint64, quint64)), this, SLOT(updateTrafficStats(quint64, quint64)));
|
|
|
|
// set up peer table
|
|
ui->peerWidget->setModel(model->getPeerTableModel());
|
|
ui->peerWidget->verticalHeader()->hide();
|
|
ui->peerWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
|
|
ui->peerWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
|
|
ui->peerWidget->setSelectionMode(QAbstractItemView::SingleSelection);
|
|
ui->peerWidget->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
ui->peerWidget->setColumnWidth(PeerTableModel::Address, ADDRESS_COLUMN_WIDTH);
|
|
ui->peerWidget->setColumnWidth(PeerTableModel::Subversion, SUBVERSION_COLUMN_WIDTH);
|
|
ui->peerWidget->setColumnWidth(PeerTableModel::Ping, PING_COLUMN_WIDTH);
|
|
ui->peerWidget->horizontalHeader()->setStretchLastSection(true);
|
|
|
|
// create peer table context menu actions
|
|
QAction* disconnectAction = new QAction(tr("&Disconnect Node"), this);
|
|
QAction* banAction1h = new QAction(tr("Ban Node for") + " " + tr("1 &hour"), this);
|
|
QAction* banAction24h = new QAction(tr("Ban Node for") + " " + tr("1 &day"), this);
|
|
QAction* banAction7d = new QAction(tr("Ban Node for") + " " + tr("1 &week"), this);
|
|
QAction* banAction365d = new QAction(tr("Ban Node for") + " " + tr("1 &year"), this);
|
|
|
|
// create peer table context menu
|
|
peersTableContextMenu = new QMenu();
|
|
peersTableContextMenu->addAction(disconnectAction);
|
|
peersTableContextMenu->addAction(banAction1h);
|
|
peersTableContextMenu->addAction(banAction24h);
|
|
peersTableContextMenu->addAction(banAction7d);
|
|
peersTableContextMenu->addAction(banAction365d);
|
|
|
|
// Add a signal mapping to allow dynamic context menu arguments.
|
|
// We need to use int (instead of int64_t), because signal mapper only supports
|
|
// int or objects, which is okay because max bantime (1 year) is < int_max.
|
|
QSignalMapper* signalMapper = new QSignalMapper(this);
|
|
signalMapper->setMapping(banAction1h, 60*60);
|
|
signalMapper->setMapping(banAction24h, 60*60*24);
|
|
signalMapper->setMapping(banAction7d, 60*60*24*7);
|
|
signalMapper->setMapping(banAction365d, 60*60*24*365);
|
|
connect(banAction1h, SIGNAL(triggered()), signalMapper, SLOT(map()));
|
|
connect(banAction24h, SIGNAL(triggered()), signalMapper, SLOT(map()));
|
|
connect(banAction7d, SIGNAL(triggered()), signalMapper, SLOT(map()));
|
|
connect(banAction365d, SIGNAL(triggered()), signalMapper, SLOT(map()));
|
|
connect(signalMapper, SIGNAL(mapped(int)), this, SLOT(banSelectedNode(int)));
|
|
|
|
// peer table context menu signals
|
|
connect(ui->peerWidget, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(showPeersTableContextMenu(const QPoint&)));
|
|
connect(disconnectAction, SIGNAL(triggered()), this, SLOT(disconnectSelectedNode()));
|
|
|
|
// peer table signal handling - update peer details when selecting new node
|
|
connect(ui->peerWidget->selectionModel(), SIGNAL(selectionChanged(const QItemSelection&, const QItemSelection&)),
|
|
this, SLOT(peerSelected(const QItemSelection &, const QItemSelection &)));
|
|
// peer table signal handling - update peer details when new nodes are added to the model
|
|
connect(model->getPeerTableModel(), SIGNAL(layoutChanged()), this, SLOT(peerLayoutChanged()));
|
|
|
|
// set up ban table
|
|
ui->banlistWidget->setModel(model->getBanTableModel());
|
|
ui->banlistWidget->verticalHeader()->hide();
|
|
ui->banlistWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
|
|
ui->banlistWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
|
|
ui->banlistWidget->setSelectionMode(QAbstractItemView::SingleSelection);
|
|
ui->banlistWidget->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
ui->banlistWidget->setColumnWidth(BanTableModel::Address, BANSUBNET_COLUMN_WIDTH);
|
|
ui->banlistWidget->setColumnWidth(BanTableModel::Bantime, BANTIME_COLUMN_WIDTH);
|
|
ui->banlistWidget->horizontalHeader()->setStretchLastSection(true);
|
|
|
|
// create ban table context menu action
|
|
QAction* unbanAction = new QAction(tr("&Unban Node"), this);
|
|
|
|
// create ban table context menu
|
|
banTableContextMenu = new QMenu();
|
|
banTableContextMenu->addAction(unbanAction);
|
|
|
|
// ban table context menu signals
|
|
connect(ui->banlistWidget, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(showBanTableContextMenu(const QPoint&)));
|
|
connect(unbanAction, SIGNAL(triggered()), this, SLOT(unbanSelectedNode()));
|
|
|
|
// ban table signal handling - clear peer details when clicking a peer in the ban table
|
|
connect(ui->banlistWidget, SIGNAL(clicked(const QModelIndex&)), this, SLOT(clearSelectedNode()));
|
|
// ban table signal handling - ensure ban table is shown or hidden (if empty)
|
|
connect(model->getBanTableModel(), SIGNAL(layoutChanged()), this, SLOT(showOrHideBanTableIfRequired()));
|
|
showOrHideBanTableIfRequired();
|
|
|
|
// Provide initial values
|
|
ui->clientVersion->setText(model->formatFullVersion());
|
|
ui->clientName->setText(model->clientName());
|
|
ui->buildDate->setText(model->formatBuildDate());
|
|
ui->startupTime->setText(model->formatClientStartupTime());
|
|
ui->networkName->setText(QString::fromStdString(Params().NetworkIDString()));
|
|
|
|
//Setup autocomplete and attach it
|
|
QStringList wordList;
|
|
std::vector<std::string> commandList = tableRPC.listCommands();
|
|
for (size_t i = 0; i < commandList.size(); ++i)
|
|
{
|
|
wordList << commandList[i].c_str();
|
|
}
|
|
|
|
autoCompleter = new QCompleter(wordList, this);
|
|
ui->lineEdit->setCompleter(autoCompleter);
|
|
|
|
// clear the lineEdit after activating from QCompleter
|
|
autoCompleter->popup()->installEventFilter(this);
|
|
}
|
|
}
|
|
|
|
static QString categoryClass(int category)
|
|
{
|
|
switch (category) {
|
|
case RPCConsole::CMD_REQUEST:
|
|
return "cmd-request";
|
|
break;
|
|
case RPCConsole::CMD_REPLY:
|
|
return "cmd-reply";
|
|
break;
|
|
case RPCConsole::CMD_ERROR:
|
|
return "cmd-error";
|
|
break;
|
|
default:
|
|
return "misc";
|
|
}
|
|
}
|
|
|
|
/** Restart wallet with "-salvagewallet" */
|
|
void RPCConsole::walletSalvage()
|
|
{
|
|
buildParameterlist(SALVAGEWALLET);
|
|
}
|
|
|
|
/** Restart wallet with "-rescan" */
|
|
void RPCConsole::walletRescan()
|
|
{
|
|
buildParameterlist(RESCAN);
|
|
}
|
|
|
|
/** Restart wallet with "-zapwallettxes=1" */
|
|
void RPCConsole::walletZaptxes1()
|
|
{
|
|
buildParameterlist(ZAPTXES1);
|
|
}
|
|
|
|
/** Restart wallet with "-zapwallettxes=2" */
|
|
void RPCConsole::walletZaptxes2()
|
|
{
|
|
buildParameterlist(ZAPTXES2);
|
|
}
|
|
|
|
/** Restart wallet with "-upgradewallet" */
|
|
void RPCConsole::walletUpgrade()
|
|
{
|
|
buildParameterlist(UPGRADEWALLET);
|
|
}
|
|
|
|
/** Restart wallet with "-reindex" */
|
|
void RPCConsole::walletReindex()
|
|
{
|
|
buildParameterlist(REINDEX);
|
|
}
|
|
|
|
/** Restart wallet with "-resync" */
|
|
void RPCConsole::walletResync()
|
|
{
|
|
QString resyncWarning = tr("This will delete your local blockchain folders and the wallet will synchronize the complete Blockchain from scratch.<br /><br />");
|
|
resyncWarning += tr("This needs quite some time and downloads a lot of data.<br /><br />");
|
|
resyncWarning += tr("Your transactions and funds will be visible again after the download has completed.<br /><br />");
|
|
resyncWarning += tr("Do you want to continue?.<br />");
|
|
QMessageBox::StandardButton retval = QMessageBox::question(this, tr("Confirm resync Blockchain"),
|
|
resyncWarning,
|
|
QMessageBox::Yes | QMessageBox::Cancel,
|
|
QMessageBox::Cancel);
|
|
|
|
if (retval != QMessageBox::Yes) {
|
|
// Resync canceled
|
|
return;
|
|
}
|
|
|
|
// Restart and resync
|
|
buildParameterlist(RESYNC);
|
|
}
|
|
|
|
/** Build command-line parameter list for restart */
|
|
void RPCConsole::buildParameterlist(QString arg)
|
|
{
|
|
// Get command-line arguments and remove the application name
|
|
QStringList args = QApplication::arguments();
|
|
args.removeFirst();
|
|
|
|
// Remove existing repair-options
|
|
args.removeAll(SALVAGEWALLET);
|
|
args.removeAll(RESCAN);
|
|
args.removeAll(ZAPTXES1);
|
|
args.removeAll(ZAPTXES2);
|
|
args.removeAll(UPGRADEWALLET);
|
|
args.removeAll(REINDEX);
|
|
|
|
// Append repair parameter to command line.
|
|
args.append(arg);
|
|
|
|
// Send command-line arguments to BitcoinGUI::handleRestart()
|
|
emit handleRestart(args);
|
|
}
|
|
|
|
void RPCConsole::clear()
|
|
{
|
|
ui->messagesWidget->clear();
|
|
history.clear();
|
|
historyPtr = 0;
|
|
ui->lineEdit->clear();
|
|
ui->lineEdit->setFocus();
|
|
|
|
// Add smoothly scaled icon images.
|
|
// (when using width/height on an img, Qt uses nearest instead of linear interpolation)
|
|
for (int i = 0; ICON_MAPPING[i].url; ++i) {
|
|
ui->messagesWidget->document()->addResource(
|
|
QTextDocument::ImageResource,
|
|
QUrl(ICON_MAPPING[i].url),
|
|
QImage(ICON_MAPPING[i].source).scaled(ICON_SIZE, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
|
|
}
|
|
|
|
// Set default style sheet
|
|
ui->messagesWidget->document()->setDefaultStyleSheet(
|
|
"table { }"
|
|
"td.time { color: #808080; padding-top: 3px; } "
|
|
"td.message { font-family: Courier, Courier New, Lucida Console, monospace; font-size: 12px; } " // Todo: Remove fixed font-size
|
|
"td.cmd-request { color: #006060; } "
|
|
"td.cmd-error { color: red; } "
|
|
".secwarning { color: red; }"
|
|
"b { color: #006060; } ");
|
|
|
|
#ifdef Q_OS_MAC
|
|
QString clsKey = "(⌘)-L";
|
|
#else
|
|
QString clsKey = "Ctrl-L";
|
|
#endif
|
|
|
|
message(CMD_REPLY, (tr("Welcome to the Agrarian RPC console.") + "<br>" +
|
|
tr("Use up and down arrows to navigate history, and %1 to clear screen.").arg("<b>"+clsKey+"</b>") + "<br>" +
|
|
tr("Type <b>help</b> for an overview of available commands.") +
|
|
"<br><span class=\"secwarning\"><br>" +
|
|
tr("WARNING: Scammers have been active, telling users to type commands here, stealing their wallet contents. Do not use this console without fully understanding the ramifications of a command.") +
|
|
"</span>"),
|
|
true);
|
|
}
|
|
|
|
void RPCConsole::reject()
|
|
{
|
|
// Ignore escape keypress if this is not a seperate window
|
|
if (windowType() != Qt::Widget)
|
|
QDialog::reject();
|
|
}
|
|
|
|
void RPCConsole::message(int category, const QString& message, bool html)
|
|
{
|
|
QTime time = QTime::currentTime();
|
|
QString timeString = time.toString();
|
|
QString out;
|
|
out += "<table><tr><td class=\"time\" width=\"65\">" + timeString + "</td>";
|
|
out += "<td class=\"icon\" width=\"32\"><img src=\"" + categoryClass(category) + "\"></td>";
|
|
out += "<td class=\"message " + categoryClass(category) + "\" valign=\"middle\">";
|
|
if (html)
|
|
out += message;
|
|
else
|
|
out += GUIUtil::HtmlEscape(message, true);
|
|
out += "</td></tr></table>";
|
|
ui->messagesWidget->append(out);
|
|
}
|
|
|
|
void RPCConsole::setNumConnections(int count)
|
|
{
|
|
if (!clientModel)
|
|
return;
|
|
|
|
QString connections = QString::number(count) + " (";
|
|
connections += tr("In:") + " " + QString::number(clientModel->getNumConnections(CONNECTIONS_IN)) + " / ";
|
|
connections += tr("Out:") + " " + QString::number(clientModel->getNumConnections(CONNECTIONS_OUT)) + ")";
|
|
|
|
ui->numberOfConnections->setText(connections);
|
|
}
|
|
|
|
void RPCConsole::setNumBlocks(int count)
|
|
{
|
|
ui->numberOfBlocks->setText(QString::number(count));
|
|
if (clientModel)
|
|
ui->lastBlockTime->setText(clientModel->getLastBlockDate().toString());
|
|
}
|
|
|
|
void RPCConsole::setMasternodeCount(const QString& strMasternodes)
|
|
{
|
|
ui->masternodeCount->setText(strMasternodes);
|
|
}
|
|
|
|
void RPCConsole::on_lineEdit_returnPressed()
|
|
{
|
|
QString cmd = ui->lineEdit->text();
|
|
ui->lineEdit->clear();
|
|
|
|
if (!cmd.isEmpty()) {
|
|
message(CMD_REQUEST, cmd);
|
|
emit cmdRequest(cmd);
|
|
// Remove command, if already in history
|
|
history.removeOne(cmd);
|
|
// Append command to history
|
|
history.append(cmd);
|
|
// Enforce maximum history size
|
|
while (history.size() > CONSOLE_HISTORY)
|
|
history.removeFirst();
|
|
// Set pointer to end of history
|
|
historyPtr = history.size();
|
|
// Scroll console view to end
|
|
scrollToEnd();
|
|
}
|
|
}
|
|
|
|
void RPCConsole::browseHistory(int offset)
|
|
{
|
|
historyPtr += offset;
|
|
if (historyPtr < 0)
|
|
historyPtr = 0;
|
|
if (historyPtr > history.size())
|
|
historyPtr = history.size();
|
|
QString cmd;
|
|
if (historyPtr < history.size())
|
|
cmd = history.at(historyPtr);
|
|
ui->lineEdit->setText(cmd);
|
|
}
|
|
|
|
void RPCConsole::startExecutor()
|
|
{
|
|
QThread* thread = new QThread;
|
|
RPCExecutor* executor = new RPCExecutor();
|
|
executor->moveToThread(thread);
|
|
|
|
// Replies from executor object must go to this object
|
|
connect(executor, SIGNAL(reply(int, QString)), this, SLOT(message(int, QString)));
|
|
// Requests from this object must go to executor
|
|
connect(this, SIGNAL(cmdRequest(QString)), executor, SLOT(request(QString)));
|
|
|
|
// On stopExecutor signal
|
|
// - queue executor for deletion (in execution thread)
|
|
// - quit the Qt event loop in the execution thread
|
|
connect(this, SIGNAL(stopExecutor()), executor, SLOT(deleteLater()));
|
|
connect(this, SIGNAL(stopExecutor()), thread, SLOT(quit()));
|
|
// Queue the thread for deletion (in this thread) when it is finished
|
|
connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
|
|
|
|
// Default implementation of QThread::run() simply spins up an event loop in the thread,
|
|
// which is what we want.
|
|
thread->start();
|
|
}
|
|
|
|
void RPCConsole::on_tabWidget_currentChanged(int index)
|
|
{
|
|
if (ui->tabWidget->widget(index) == ui->tab_console) {
|
|
ui->lineEdit->setFocus();
|
|
} else if (ui->tabWidget->widget(index) != ui->tab_peers) {
|
|
clearSelectedNode();
|
|
}
|
|
}
|
|
|
|
void RPCConsole::on_openDebugLogfileButton_clicked()
|
|
{
|
|
GUIUtil::openDebugLogfile();
|
|
}
|
|
|
|
void RPCConsole::scrollToEnd()
|
|
{
|
|
QScrollBar* scrollbar = ui->messagesWidget->verticalScrollBar();
|
|
scrollbar->setValue(scrollbar->maximum());
|
|
}
|
|
|
|
void RPCConsole::on_sldGraphRange_valueChanged(int value)
|
|
{
|
|
const int multiplier = 5; // each position on the slider represents 5 min
|
|
int mins = value * multiplier;
|
|
setTrafficGraphRange(mins);
|
|
}
|
|
|
|
QString RPCConsole::FormatBytes(quint64 bytes)
|
|
{
|
|
if (bytes < 1024)
|
|
return QString(tr("%1 B")).arg(bytes);
|
|
if (bytes < 1024 * 1024)
|
|
return QString(tr("%1 KB")).arg(bytes / 1024);
|
|
if (bytes < 1024 * 1024 * 1024)
|
|
return QString(tr("%1 MB")).arg(bytes / 1024 / 1024);
|
|
|
|
return QString(tr("%1 GB")).arg(bytes / 1024 / 1024 / 1024);
|
|
}
|
|
|
|
void RPCConsole::setTrafficGraphRange(int mins)
|
|
{
|
|
ui->trafficGraph->setGraphRangeMins(mins);
|
|
ui->lblGraphRange->setText(GUIUtil::formatDurationStr(mins * 60));
|
|
}
|
|
|
|
void RPCConsole::updateTrafficStats(quint64 totalBytesIn, quint64 totalBytesOut)
|
|
{
|
|
ui->lblBytesIn->setText(FormatBytes(totalBytesIn));
|
|
ui->lblBytesOut->setText(FormatBytes(totalBytesOut));
|
|
}
|
|
|
|
void RPCConsole::showInfo()
|
|
{
|
|
ui->tabWidget->setCurrentIndex(0);
|
|
show();
|
|
}
|
|
|
|
void RPCConsole::showConsole()
|
|
{
|
|
ui->tabWidget->setCurrentIndex(1);
|
|
show();
|
|
}
|
|
|
|
void RPCConsole::showNetwork()
|
|
{
|
|
ui->tabWidget->setCurrentIndex(2);
|
|
show();
|
|
}
|
|
|
|
void RPCConsole::showPeers()
|
|
{
|
|
ui->tabWidget->setCurrentIndex(3);
|
|
show();
|
|
}
|
|
|
|
void RPCConsole::showRepair()
|
|
{
|
|
ui->tabWidget->setCurrentIndex(4);
|
|
show();
|
|
}
|
|
|
|
void RPCConsole::showConfEditor()
|
|
{
|
|
GUIUtil::openConfigfile();
|
|
}
|
|
|
|
void RPCConsole::showMNConfEditor()
|
|
{
|
|
GUIUtil::openMNConfigfile();
|
|
}
|
|
|
|
void RPCConsole::peerSelected(const QItemSelection& selected, const QItemSelection& deselected)
|
|
{
|
|
Q_UNUSED(deselected);
|
|
|
|
if (!clientModel || !clientModel->getPeerTableModel() || selected.indexes().isEmpty())
|
|
return;
|
|
|
|
const CNodeCombinedStats* stats = clientModel->getPeerTableModel()->getNodeStats(selected.indexes().first().row());
|
|
if (stats)
|
|
updateNodeDetail(stats);
|
|
}
|
|
|
|
void RPCConsole::peerLayoutChanged()
|
|
{
|
|
if (!clientModel || !clientModel->getPeerTableModel())
|
|
return;
|
|
|
|
const CNodeCombinedStats* stats = NULL;
|
|
bool fUnselect = false;
|
|
bool fReselect = false;
|
|
|
|
if (cachedNodeid == -1) // no node selected yet
|
|
return;
|
|
|
|
// find the currently selected row
|
|
int selectedRow = -1;
|
|
QModelIndexList selectedModelIndex = ui->peerWidget->selectionModel()->selectedIndexes();
|
|
if (!selectedModelIndex.isEmpty()) {
|
|
selectedRow = selectedModelIndex.first().row();
|
|
}
|
|
|
|
// check if our detail node has a row in the table (it may not necessarily
|
|
// be at selectedRow since its position can change after a layout change)
|
|
int detailNodeRow = clientModel->getPeerTableModel()->getRowByNodeId(cachedNodeid);
|
|
|
|
if (detailNodeRow < 0) {
|
|
// detail node dissapeared from table (node disconnected)
|
|
fUnselect = true;
|
|
} else {
|
|
if (detailNodeRow != selectedRow) {
|
|
// detail node moved position
|
|
fUnselect = true;
|
|
fReselect = true;
|
|
}
|
|
|
|
// get fresh stats on the detail node.
|
|
stats = clientModel->getPeerTableModel()->getNodeStats(detailNodeRow);
|
|
}
|
|
|
|
if (fUnselect && selectedRow >= 0) {
|
|
clearSelectedNode();
|
|
}
|
|
|
|
if (fReselect) {
|
|
ui->peerWidget->selectRow(detailNodeRow);
|
|
}
|
|
|
|
if (stats)
|
|
updateNodeDetail(stats);
|
|
}
|
|
|
|
void RPCConsole::updateNodeDetail(const CNodeCombinedStats* stats)
|
|
{
|
|
// Update cached nodeid
|
|
cachedNodeid = stats->nodeStats.nodeid;
|
|
|
|
// update the detail ui with latest node information
|
|
QString peerAddrDetails(QString::fromStdString(stats->nodeStats.addrName) + " ");
|
|
peerAddrDetails += tr("(node id: %1)").arg(QString::number(stats->nodeStats.nodeid));
|
|
if (!stats->nodeStats.addrLocal.empty())
|
|
peerAddrDetails += "<br />" + tr("via %1").arg(QString::fromStdString(stats->nodeStats.addrLocal));
|
|
ui->peerHeading->setText(peerAddrDetails);
|
|
ui->peerServices->setText(GUIUtil::formatServicesStr(stats->nodeStats.nServices));
|
|
ui->peerLastSend->setText(stats->nodeStats.nLastSend ? GUIUtil::formatDurationStr(GetTime() - stats->nodeStats.nLastSend) : tr("never"));
|
|
ui->peerLastRecv->setText(stats->nodeStats.nLastRecv ? GUIUtil::formatDurationStr(GetTime() - stats->nodeStats.nLastRecv) : tr("never"));
|
|
ui->peerBytesSent->setText(FormatBytes(stats->nodeStats.nSendBytes));
|
|
ui->peerBytesRecv->setText(FormatBytes(stats->nodeStats.nRecvBytes));
|
|
ui->peerConnTime->setText(GUIUtil::formatDurationStr(GetTime() - stats->nodeStats.nTimeConnected));
|
|
ui->peerPingTime->setText(GUIUtil::formatPingTime(stats->nodeStats.dPingTime));
|
|
ui->peerPingWait->setText(GUIUtil::formatPingTime(stats->nodeStats.dPingWait));
|
|
ui->timeoffset->setText(GUIUtil::formatTimeOffset(stats->nodeStats.nTimeOffset));
|
|
ui->peerVersion->setText(QString("%1").arg(QString::number(stats->nodeStats.nVersion)));
|
|
ui->peerSubversion->setText(QString::fromStdString(stats->nodeStats.cleanSubVer));
|
|
ui->peerDirection->setText(stats->nodeStats.fInbound ? tr("Inbound") : tr("Outbound"));
|
|
ui->peerHeight->setText(QString("%1").arg(QString::number(stats->nodeStats.nStartingHeight)));
|
|
ui->peerWhitelisted->setText(stats->nodeStats.fWhitelisted ? tr("Yes") : tr("No"));
|
|
|
|
// This check fails for example if the lock was busy and
|
|
// nodeStateStats couldn't be fetched.
|
|
if (stats->fNodeStateStatsAvailable) {
|
|
// Ban score is init to 0
|
|
ui->peerBanScore->setText(QString("%1").arg(stats->nodeStateStats.nMisbehavior));
|
|
|
|
// Sync height is init to -1
|
|
if (stats->nodeStateStats.nSyncHeight > -1)
|
|
ui->peerSyncHeight->setText(QString("%1").arg(stats->nodeStateStats.nSyncHeight));
|
|
else
|
|
ui->peerSyncHeight->setText(tr("Unknown"));
|
|
|
|
// Common height is init to -1
|
|
if (stats->nodeStateStats.nCommonHeight > -1)
|
|
ui->peerCommonHeight->setText(QString("%1").arg(stats->nodeStateStats.nCommonHeight));
|
|
else
|
|
ui->peerCommonHeight->setText(tr("Unknown"));
|
|
}
|
|
|
|
ui->detailWidget->show();
|
|
}
|
|
|
|
void RPCConsole::resizeEvent(QResizeEvent* event)
|
|
{
|
|
QWidget::resizeEvent(event);
|
|
}
|
|
|
|
void RPCConsole::showEvent(QShowEvent* event)
|
|
{
|
|
QWidget::showEvent(event);
|
|
|
|
if (!clientModel || !clientModel->getPeerTableModel())
|
|
return;
|
|
|
|
// start PeerTableModel auto refresh
|
|
clientModel->getPeerTableModel()->startAutoRefresh();
|
|
}
|
|
|
|
void RPCConsole::hideEvent(QHideEvent* event)
|
|
{
|
|
QWidget::hideEvent(event);
|
|
|
|
if (!clientModel || !clientModel->getPeerTableModel())
|
|
return;
|
|
|
|
// stop PeerTableModel auto refresh
|
|
clientModel->getPeerTableModel()->stopAutoRefresh();
|
|
}
|
|
|
|
void RPCConsole::showBackups()
|
|
{
|
|
GUIUtil::showBackups();
|
|
}
|
|
|
|
void RPCConsole::showPeersTableContextMenu(const QPoint& point)
|
|
{
|
|
QModelIndex index = ui->peerWidget->indexAt(point);
|
|
if (index.isValid())
|
|
peersTableContextMenu->exec(QCursor::pos());
|
|
}
|
|
|
|
void RPCConsole::showBanTableContextMenu(const QPoint& point)
|
|
{
|
|
QModelIndex index = ui->banlistWidget->indexAt(point);
|
|
if (index.isValid())
|
|
banTableContextMenu->exec(QCursor::pos());
|
|
}
|
|
|
|
void RPCConsole::disconnectSelectedNode()
|
|
{
|
|
// Get currently selected peer address
|
|
QString strNode = GUIUtil::getEntryData(ui->peerWidget, 0, PeerTableModel::Address);
|
|
// Find the node, disconnect it and clear the selected node
|
|
if (CNode *bannedNode = FindNode(strNode.toStdString())) {
|
|
bannedNode->CloseSocketDisconnect();
|
|
clearSelectedNode();
|
|
}
|
|
}
|
|
|
|
void RPCConsole::banSelectedNode(int bantime)
|
|
{
|
|
if (!clientModel)
|
|
return;
|
|
|
|
// Get currently selected peer address
|
|
QString strNode = GUIUtil::getEntryData(ui->peerWidget, 0, PeerTableModel::Address);
|
|
// Find possible nodes, ban it and clear the selected node
|
|
if (FindNode(strNode.toStdString())) {
|
|
std::string nStr = strNode.toStdString();
|
|
std::string addr;
|
|
int port = 0;
|
|
SplitHostPort(nStr, port, addr);
|
|
|
|
CNode::Ban(CNetAddr(addr), BanReasonManuallyAdded, bantime);
|
|
|
|
clearSelectedNode();
|
|
clientModel->getBanTableModel()->refresh();
|
|
}
|
|
}
|
|
|
|
void RPCConsole::unbanSelectedNode()
|
|
{
|
|
if (!clientModel)
|
|
return;
|
|
|
|
// Get currently selected ban address
|
|
QString strNode = GUIUtil::getEntryData(ui->banlistWidget, 0, BanTableModel::Address);
|
|
CSubNet possibleSubnet(strNode.toStdString());
|
|
|
|
if (possibleSubnet.IsValid())
|
|
{
|
|
CNode::Unban(possibleSubnet);
|
|
clientModel->getBanTableModel()->refresh();
|
|
}
|
|
}
|
|
|
|
void RPCConsole::clearSelectedNode()
|
|
{
|
|
ui->peerWidget->selectionModel()->clearSelection();
|
|
cachedNodeid = -1;
|
|
ui->detailWidget->hide();
|
|
ui->peerHeading->setText(tr("Select a peer to view detailed information."));
|
|
}
|
|
|
|
void RPCConsole::showOrHideBanTableIfRequired()
|
|
{
|
|
if (!clientModel)
|
|
return;
|
|
|
|
bool visible = clientModel->getBanTableModel()->shouldShow();
|
|
ui->banlistWidget->setVisible(visible);
|
|
ui->banHeading->setVisible(visible);
|
|
}
|