Inside Bitcoin

1001
1002    if (cmd.isEmpty()) {
1003        return;
1004    }
1005
1006    std::string strFilteredCmd;
1007    try {
1008        std::string dummy;
1009        if (!RPCParseCommandLine(nullptr, dummy, cmd.toStdString(), false, &strFilteredCmd)) {
1010            // Failed to parse command, so we cannot even filter it for the history
1011            throw std::runtime_error("Invalid command line");
1012        }
1013    } catch (const std::exception& e) {
1014        QMessageBox::critical(this, "Error", QString("Error: ") + QString::fromStdString(e.what()));
1015        return;
1016    }
1017
1018    // A special case allows to request shutdown even a long-running command is executed.
1019    if (cmd == QLatin1String("stop")) {
1020        std::string dummy;
1021        RPCExecuteCommandLine(m_node, dummy, cmd.toStdString());
1022        return;
1023    }
1024
1025    if (m_is_executing) {
1026        return;
1027    }
1028
1029    ui->lineEdit->clear();
1030
1031    QString in_use_wallet_name;
1032#ifdef ENABLE_WALLET
1033    WalletModel* wallet_model = ui->WalletSelector->currentData().value<WalletModel*>();
1034    in_use_wallet_name = wallet_model ? wallet_model->getWalletName() : QString();
1035    if (m_last_wallet_model != wallet_model) {
1036        if (wallet_model) {
1037            message(CMD_REQUEST, tr("Executing command using \"%1\" wallet").arg(wallet_model->getWalletName()));
1038        } else {
1039            message(CMD_REQUEST, tr("Executing command without any wallet"));
1040        }
1041        m_last_wallet_model = wallet_model;
1042    }
1043#endif // ENABLE_WALLET
1044
1045    message(CMD_REQUEST, QString::fromStdString(strFilteredCmd));
1046    //: A console message indicating an entered command is currently being executed.
1047    message(CMD_REPLY, tr("Executing…"));
1048    m_is_executing = true;
1049
1050    QMetaObject::invokeMethod(m_executor, [this, cmd, in_use_wallet_name] {
1051        m_executor->request(cmd, in_use_wallet_name);
1052    });
1053
1054    cmd = QString::fromStdString(strFilteredCmd);
1055
1056    // Remove command, if already in history
1057    history.removeOne(cmd);
1058    // Append command to history
1059    history.append(cmd);
1060    // Enforce maximum history size
1061    while (history.size() > CONSOLE_HISTORY) {
1062        history.removeFirst();
1063    }
1064    // Set pointer to end of history
1065    historyPtr = history.size();
1066
1067    // Scroll console view to end
1068    scrollToEnd();
1069}
1070
1071void RPCConsole::browseHistory(int offset)
1072{
1073    // store current text when start browsing through the history
1074    if (historyPtr == history.size()) {
1075        cmdBeforeBrowsing = ui->lineEdit->text();
1076    }
1077
1078    historyPtr += offset;
1079    if(historyPtr < 0)
1080        historyPtr = 0;
1081    if(historyPtr > history.size())
1082        historyPtr = history.size();
1083    QString cmd;
1084    if(historyPtr < history.size())
1085        cmd = history.at(historyPtr);
1086    else if (!cmdBeforeBrowsing.isNull()) {
1087        cmd = cmdBeforeBrowsing;
1088    }
1089    ui->lineEdit->setText(cmd);
1090}
1091
1092void RPCConsole::startExecutor()
1093{
1094    m_executor = new RPCExecutor(m_node);
1095    m_executor->moveToThread(&thread);
1096
1097    // Replies from executor object must go to this object
1098    connect(m_executor, &RPCExecutor::reply, this, [this](int category, const QString& command) {
1099        // Remove "Executing…" message.
1100        ui->messagesWidget->undo();
1101        message(category, command);
1102        scrollToEnd();
1103        m_is_executing = false;
1104    });
1105
1106    // Make sure executor object is deleted in its own thread
1107    connect(&thread, &QThread::finished, m_executor, &RPCExecutor::deleteLater);
1108
1109    // Default implementation of QThread::run() simply spins up an event loop in the thread,
1110    // which is what we want.
1111    thread.start();
1112    QTimer::singleShot(0, m_executor, []() {
1113        util::ThreadRename("qt-rpcconsole");
1114    });
1115}
1116
1117void RPCConsole::on_tabWidget_currentChanged(int index)
1118{
1119    if (ui->tabWidget->widget(index) == ui->tab_console) {
1120        ui->lineEdit->setFocus();
1121    }
1122}
1123
1124void RPCConsole::on_openDebugLogfileButton_clicked()
1125{
1126    GUIUtil::openDebugLogfile();
1127}
1128
1129void RPCConsole::scrollToEnd()
1130{
1131    QScrollBar *scrollbar = ui->messagesWidget->verticalScrollBar();
1132    scrollbar->setValue(scrollbar->maximum());
1133}
1134
1135void RPCConsole::on_sldGraphRange_valueChanged(int value)
1136{
1137    const int multiplier = 5; // each position on the slider represents 5 min
1138    int mins = value * multiplier;
1139    setTrafficGraphRange(mins);
1140}
1141
1142void RPCConsole::setTrafficGraphRange(int mins)
1143{
1144    ui->trafficGraph->setGraphRange(std::chrono::minutes{mins});
1145    ui->lblGraphRange->setText(GUIUtil::formatDurationStr(std::chrono::minutes{mins}));
1146}
1147
1148void RPCConsole::updateTrafficStats(quint64 totalBytesIn, quint64 totalBytesOut)
1149{
1150    ui->lblBytesIn->setText(GUIUtil::formatBytes(totalBytesIn));
1151    ui->lblBytesOut->setText(GUIUtil::formatBytes(totalBytesOut));
1152}
1153
1154void RPCConsole::updateDetailWidget()
1155{
1156    const QList<QModelIndex> selected_peers = GUIUtil::getEntryData(ui->peerWidget, PeerTableModel::NetNodeId);
1157    if (!clientModel || !clientModel->getPeerTableModel() || selected_peers.size() != 1) {
1158        ui->peersTabRightPanel->hide();
1159        ui->peerHeading->setText(tr("Select a peer to view detailed information."));
1160        return;
1161    }
1162    const auto stats = selected_peers.first().data(PeerTableModel::StatsRole).value<CNodeCombinedStats*>();
1163    // update the detail ui with latest node information
1164    QString peerAddrDetails(QString::fromStdString(stats->nodeStats.m_addr_name) + " ");
1165    peerAddrDetails += tr("(peer: %1)").arg(QString::number(stats->nodeStats.nodeid));
1166    if (!stats->nodeStats.addrLocal.empty())
1167        peerAddrDetails += "<br />" + tr("via %1").arg(QString::fromStdString(stats->nodeStats.addrLocal));
1168    ui->peerHeading->setText(peerAddrDetails);
1169    QString bip152_hb_settings;
1170    if (stats->nodeStats.m_bip152_highbandwidth_to) bip152_hb_settings = ts.to;
1171    if (stats->nodeStats.m_bip152_highbandwidth_from) bip152_hb_settings += (bip152_hb_settings.isEmpty() ? ts.from : QLatin1Char('/') + ts.from);
1172    if (bip152_hb_settings.isEmpty()) bip152_hb_settings = ts.no;
1173    ui->peerHighBandwidth->setText(bip152_hb_settings);
1174    const auto now{NodeClock::now()};
1175    const auto time_now{GetTime<std::chrono::seconds>()};
1176    ui->peerConnTime->setText(GUIUtil::formatDurationStr(now - stats->nodeStats.m_connected));
1177    ui->peerLastBlock->setText(TimeDurationField(time_now, stats->nodeStats.m_last_block_time));
1178    ui->peerLastTx->setText(TimeDurationField(time_now, stats->nodeStats.m_last_tx_time));
1179    ui->peerLastSend->setText(TimeDurationField(now, stats->nodeStats.m_last_send));
1180    ui->peerLastRecv->setText(TimeDurationField(now, stats->nodeStats.m_last_recv));
1181    ui->peerBytesSent->setText(GUIUtil::formatBytes(stats->nodeStats.nSendBytes));
1182    ui->peerBytesRecv->setText(GUIUtil::formatBytes(stats->nodeStats.nRecvBytes));
1183    ui->peerPingTime->setText(GUIUtil::formatPingTime(stats->nodeStats.m_last_ping_time));
1184    ui->peerMinPing->setText(GUIUtil::formatPingTime(stats->nodeStats.m_min_ping_time));
1185    ui->peerVersion->setText(stats->nodeStats.nVersion ? QString::number(stats->nodeStats.nVersion) : ts.na);
1186    ui->peerSubversion->setText(!stats->nodeStats.cleanSubVer.empty() ? QString::fromStdString(stats->nodeStats.cleanSubVer) : ts.na);
1187    ui->peerConnectionType->setText(GUIUtil::ConnectionTypeToQString(stats->nodeStats.m_conn_type, /*prepend_direction=*/true));
1188    ui->peerTransportType->setText(QString::fromStdString(TransportTypeAsString(stats->nodeStats.m_transport_type)));
1189    if (stats->nodeStats.m_transport_type == TransportProtocolType::V2) {
1190        ui->peerSessionIdLabel->setVisible(true);
1191        ui->peerSessionId->setVisible(true);
1192        ui->peerSessionId->setText(QString::fromStdString(stats->nodeStats.m_session_id));
1193    } else {
1194        ui->peerSessionIdLabel->setVisible(false);
1195        ui->peerSessionId->setVisible(false);
1196    }
1197    ui->peerNetwork->setText(GUIUtil::NetworkToQString(stats->nodeStats.m_network));
1198    if (stats->nodeStats.m_permission_flags == NetPermissionFlags::None) {
1199        ui->peerPermissions->setText(ts.na);
1200    } else {
1201        QStringList permissions;
1202        for (const auto& permission : NetPermissions::ToStrings(stats->nodeStats.m_permission_flags)) {
1203            permissions.append(QString::fromStdString(permission));
1204        }
1205        ui->peerPermissions->setText(permissions.join(" & "));
1206    }
1207    ui->peerMappedAS->setText(stats->nodeStats.m_mapped_as != 0 ? QString::number(stats->nodeStats.m_mapped_as) : ts.na);
1208
1209    // This check fails for example if the lock was busy and
1210    // nodeStateStats couldn't be fetched.
1211    if (stats->fNodeStateStatsAvailable) {
1212        ui->timeoffset->setText(GUIUtil::formatTimeOffset(Ticks<std::chrono::seconds>(stats->nodeStateStats.time_offset)));
1213        ui->peerServices->setText(GUIUtil::formatServicesStr(stats->nodeStateStats.their_services));
1214        // Sync height is init to -1
1215        if (stats->nodeStateStats.nSyncHeight > -1) {
1216            ui->peerSyncHeight->setText(QString("%1").arg(stats->nodeStateStats.nSyncHeight));
1217        } else {
1218            ui->peerSyncHeight->setText(ts.unknown);
1219        }
1220        // Common height is init to -1
1221        if (stats->nodeStateStats.nCommonHeight > -1) {
1222            ui->peerCommonHeight->setText(QString("%1").arg(stats->nodeStateStats.nCommonHeight));
1223        } else {
1224            ui->peerCommonHeight->setText(ts.unknown);
1225        }
1226        ui->peerPingWait->setText(GUIUtil::formatPingTime(stats->nodeStateStats.m_ping_wait));
1227        ui->peerAddrRelayEnabled->setText(stats->nodeStateStats.m_addr_relay_enabled ? ts.yes : ts.no);
1228        ui->peerAddrProcessed->setText(QString::number(stats->nodeStateStats.m_addr_processed));
1229        ui->peerAddrRateLimited->setText(QString::number(stats->nodeStateStats.m_addr_rate_limited));
1230        ui->peerRelayTxes->setText(stats->nodeStateStats.m_relay_txs ? ts.yes : ts.no);
1231    }
1232
1233    ui->hidePeersDetailButton->setIcon(platformStyle->SingleColorIcon(QStringLiteral(":/icons/remove")));
1234    ui->peersTabRightPanel->show();
1235}
1236
1237void RPCConsole::resizeEvent(QResizeEvent *event)
1238{
1239    QWidget::resizeEvent(event);
1240}
1241
1242void RPCConsole::showEvent(QShowEvent *event)
1243{
1244    QWidget::showEvent(event);
1245
1246    if (!clientModel || !clientModel->getPeerTableModel())
1247        return;
1248
1249    // start PeerTableModel auto refresh
1250    clientModel->getPeerTableModel()->startAutoRefresh();