src/qt/clientmodel.cpp

   1 // Copyright (c) 2011-2016 The Bitcoin Core developers
   2 // Distributed under the MIT software license, see the accompanying
   3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   4
   5 #include "clientmodel.h"
   6
   7 #include "bantablemodel.h"
   8 #include "guiconstants.h"
   9 #include "guiutil.h"
  10 #include "peertablemodel.h"
  11
  12 #include "chain.h"
  13 #include "chainparams.h"
  14 #include "checkpoints.h"
  15 #include "clientversion.h"
  16 #include "validation.h"
  17 #include "net.h"
  18 #include "txmempool.h"
  19 #include "ui_interface.h"
  20 #include "util.h"
  21 #include "warnings.h"
  22
  23 #include <stdint.h>
  24
  25 #include <QDebug>
  26 #include <QTimer>
  27
  28 class CBlockIndex;
  29
  30 static int64_t nLastHeaderTipUpdateNotification = 0;
  31 static int64_t nLastBlockTipUpdateNotification = 0;
  32
  33 ClientModel::ClientModel(OptionsModel *_optionsModel, QObject *parent) :
  34     QObject(parent),
  35     optionsModel(_optionsModel),
  36     peerTableModel(0),
  37     banTableModel(0),
  38     pollTimer(0)
  39 {
  40     cachedBestHeaderHeight = -1;
  41     cachedBestHeaderTime = -1;
  42     peerTableModel = new PeerTableModel(this);
  43     banTableModel = new BanTableModel(this);
  44     pollTimer = new QTimer(this);
  45     connect(pollTimer, SIGNAL(timeout()), this, SLOT(updateTimer()));
  46     pollTimer->start(MODEL_UPDATE_DELAY);
  47
  48     subscribeToCoreSignals();
  49 }
  50
  51 ClientModel::~ClientModel()
  52 {
  53     unsubscribeFromCoreSignals();
  54 }
  55
  56 int ClientModel::getNumConnections(unsigned int flags) const
  57 {
  58     CConnman::NumConnections connections = CConnman::CONNECTIONS_NONE;
  59
  60     if(flags == CONNECTIONS_IN)
  61         connections = CConnman::CONNECTIONS_IN;
  62     else if (flags == CONNECTIONS_OUT)
  63         connections = CConnman::CONNECTIONS_OUT;
  64     else if (flags == CONNECTIONS_ALL)
  65         connections = CConnman::CONNECTIONS_ALL;
  66
  67     if(g_connman)
  68          return g_connman->GetNodeCount(connections);
  69     return 0;
  70 }
  71
  72 int ClientModel::getNumBlocks() const
  73 {
  74     LOCK(cs_main);
  75     return chainActive.Height();
  76 }
  77
  78 int ClientModel::getHeaderTipHeight() const
  79 {
  80     if (cachedBestHeaderHeight == -1) {
  81         // make sure we initially populate the cache via a cs_main lock
  82         // otherwise we need to wait for a tip update
  83         LOCK(cs_main);
  84         if (pindexBestHeader) {
  85             cachedBestHeaderHeight = pindexBestHeader->nHeight;
  86             cachedBestHeaderTime = pindexBestHeader->GetBlockTime();
  87         }
  88     }
  89     return cachedBestHeaderHeight;
  90 }
  91
  92 int64_t ClientModel::getHeaderTipTime() const
  93 {
  94     if (cachedBestHeaderTime == -1) {
  95         LOCK(cs_main);
  96         if (pindexBestHeader) {
  97             cachedBestHeaderHeight = pindexBestHeader->nHeight;
  98             cachedBestHeaderTime = pindexBestHeader->GetBlockTime();
  99         }
 100     }
 101     return cachedBestHeaderTime;
 102 }
 103
 104 quint64 ClientModel::getTotalBytesRecv() const
 105 {
 106     if(!g_connman)
 107         return 0;
 108     return g_connman->GetTotalBytesRecv();
 109 }
 110
 111 quint64 ClientModel::getTotalBytesSent() const
 112 {
 113     if(!g_connman)
 114         return 0;
 115     return g_connman->GetTotalBytesSent();
 116 }
 117
 118 QDateTime ClientModel::getLastBlockDate() const
 119 {
 120     LOCK(cs_main);
 121
 122     if (chainActive.Tip())
 123         return QDateTime::fromTime_t(chainActive.Tip()->GetBlockTime());
 124
 125     return QDateTime::fromTime_t(Params().GenesisBlock().GetBlockTime()); // Genesis block's time of current network
 126 }
 127
 128 long ClientModel::getMempoolSize() const
 129 {
 130     return mempool.size();
 131 }
 132
 133 size_t ClientModel::getMempoolDynamicUsage() const
 134 {
 135     return mempool.DynamicMemoryUsage();
 136 }
 137
 138 double ClientModel::getVerificationProgress(const CBlockIndex *tipIn) const
 139 {
 140     CBlockIndex *tip = const_cast<CBlockIndex *>(tipIn);
 141     if (!tip)
 142     {
 143         LOCK(cs_main);
 144         tip = chainActive.Tip();
 145     }
 146     return GuessVerificationProgress(Params().TxData(), tip);
 147 }
 148
 149 void ClientModel::updateTimer()
 150 {
 151     // no locking required at this point
 152     // the following calls will acquire the required lock
 153     Q_EMIT mempoolSizeChanged(getMempoolSize(), getMempoolDynamicUsage());
 154     Q_EMIT bytesChanged(getTotalBytesRecv(), getTotalBytesSent());
 155 }
 156
 157 void ClientModel::updateNumConnections(int numConnections)
 158 {
 159     Q_EMIT numConnectionsChanged(numConnections);
 160 }
 161
 162 void ClientModel::updateNetworkActive(bool networkActive)
 163 {
 164     Q_EMIT networkActiveChanged(networkActive);
 165 }
 166
 167 void ClientModel::updateAlert()
 168 {
 169     Q_EMIT alertsChanged(getStatusBarWarnings());
 170 }
 171
 172 bool ClientModel::inInitialBlockDownload() const
 173 {
 174     return IsInitialBlockDownload();
 175 }
 176
 177 enum BlockSource ClientModel::getBlockSource() const
 178 {
 179     if (fReindex)
 180         return BLOCK_SOURCE_REINDEX;
 181     else if (fImporting)
 182         return BLOCK_SOURCE_DISK;
 183     else if (getNumConnections() > 0)
 184         return BLOCK_SOURCE_NETWORK;
 185
 186     return BLOCK_SOURCE_NONE;
 187 }
 188
 189 void ClientModel::setNetworkActive(bool active)
 190 {
 191     if (g_connman) {
 192          g_connman->SetNetworkActive(active);
 193     }
 194 }
 195
 196 bool ClientModel::getNetworkActive() const
 197 {
 198     if (g_connman) {
 199         return g_connman->GetNetworkActive();
 200     }
 201     return false;
 202 }
 203
 204 QString ClientModel::getStatusBarWarnings() const
 205 {
 206     return QString::fromStdString(GetWarnings("gui"));
 207 }
 208
 209 OptionsModel *ClientModel::getOptionsModel()
 210 {
 211     return optionsModel;
 212 }
 213
 214 PeerTableModel *ClientModel::getPeerTableModel()
 215 {
 216     return peerTableModel;
 217 }
 218
 219 BanTableModel *ClientModel::getBanTableModel()
 220 {
 221     return banTableModel;
 222 }
 223
 224 QString ClientModel::formatFullVersion() const
 225 {
 226     return QString::fromStdString(FormatFullVersion());
 227 }
 228
 229 QString ClientModel::formatSubVersion() const
 230 {
 231     return QString::fromStdString(strSubVersion);
 232 }
 233
 234 bool ClientModel::isReleaseVersion() const
 235 {
 236     return CLIENT_VERSION_IS_RELEASE;
 237 }
 238
 239 QString ClientModel::formatClientStartupTime() const
 240 {
 241     return QDateTime::fromTime_t(GetStartupTime()).toString();
 242 }
 243
 244 QString ClientModel::dataDir() const
 245 {
 246     return GUIUtil::boostPathToQString(GetDataDir());
 247 }
 248
 249 void ClientModel::updateBanlist()
 250 {
 251     banTableModel->refresh();
 252 }
 253
 254 // Handlers for core signals
 255 static void ShowProgress(ClientModel *clientmodel, const std::string &title, int nProgress)
 256 {
 257     // emits signal "showProgress"
 258     QMetaObject::invokeMethod(clientmodel, "showProgress", Qt::QueuedConnection,
 259                               Q_ARG(QString, QString::fromStdString(title)),
 260                               Q_ARG(int, nProgress));
 261 }
 262
 263 static void NotifyNumConnectionsChanged(ClientModel *clientmodel, int newNumConnections)
 264 {
 265     // Too noisy: qDebug() << "NotifyNumConnectionsChanged: " + QString::number(newNumConnections);
 266     QMetaObject::invokeMethod(clientmodel, "updateNumConnections", Qt::QueuedConnection,
 267                               Q_ARG(int, newNumConnections));
 268 }
 269
 270 static void NotifyNetworkActiveChanged(ClientModel *clientmodel, bool networkActive)
 271 {
 272     QMetaObject::invokeMethod(clientmodel, "updateNetworkActive", Qt::QueuedConnection,
 273                               Q_ARG(bool, networkActive));
 274 }
 275
 276 static void NotifyAlertChanged(ClientModel *clientmodel)
 277 {
 278     qDebug() << "NotifyAlertChanged";
 279     QMetaObject::invokeMethod(clientmodel, "updateAlert", Qt::QueuedConnection);
 280 }
 281
 282 static void BannedListChanged(ClientModel *clientmodel)
 283 {
 284     qDebug() << QString("%1: Requesting update for peer banlist").arg(__func__);
 285     QMetaObject::invokeMethod(clientmodel, "updateBanlist", Qt::QueuedConnection);
 286 }
 287
 288 static void BlockTipChanged(ClientModel *clientmodel, bool initialSync, const CBlockIndex *pIndex, bool fHeader)
 289 {
 290     // lock free async UI updates in case we have a new block tip
 291     // during initial sync, only update the UI if the last update
 292     // was > 250ms (MODEL_UPDATE_DELAY) ago
 293     int64_t now = 0;
 294     if (initialSync)
 295         now = GetTimeMillis();
 296
 297     int64_t& nLastUpdateNotification = fHeader ? nLastHeaderTipUpdateNotification : nLastBlockTipUpdateNotification;
 298
 299     if (fHeader) {
 300         // cache best headers time and height to reduce future cs_main locks
 301         clientmodel->cachedBestHeaderHeight = pIndex->nHeight;
 302         clientmodel->cachedBestHeaderTime = pIndex->GetBlockTime();
 303     }
 304     // if we are in-sync, update the UI regardless of last update time
 305     if (!initialSync || now - nLastUpdateNotification > MODEL_UPDATE_DELAY) {
 306         //pass an async signal to the UI thread
 307         QMetaObject::invokeMethod(clientmodel, "numBlocksChanged", Qt::QueuedConnection,
 308                                   Q_ARG(int, pIndex->nHeight),
 309                                   Q_ARG(QDateTime, QDateTime::fromTime_t(pIndex->GetBlockTime())),
 310                                   Q_ARG(double, clientmodel->getVerificationProgress(pIndex)),
 311                                   Q_ARG(bool, fHeader));
 312         nLastUpdateNotification = now;
 313     }
 314 }
 315
 316 void ClientModel::subscribeToCoreSignals()
 317 {
 318     // Connect signals to client
 319     uiInterface.ShowProgress.connect(boost::bind(ShowProgress, this, _1, _2));
 320     uiInterface.NotifyNumConnectionsChanged.connect(boost::bind(NotifyNumConnectionsChanged, this, _1));
 321     uiInterface.NotifyNetworkActiveChanged.connect(boost::bind(NotifyNetworkActiveChanged, this, _1));
 322     uiInterface.NotifyAlertChanged.connect(boost::bind(NotifyAlertChanged, this));
 323     uiInterface.BannedListChanged.connect(boost::bind(BannedListChanged, this));
 324     uiInterface.NotifyBlockTip.connect(boost::bind(BlockTipChanged, this, _1, _2, false));
 325     uiInterface.NotifyHeaderTip.connect(boost::bind(BlockTipChanged, this, _1, _2, true));
 326 }
 327
 328 void ClientModel::unsubscribeFromCoreSignals()
 329 {
 330     // Disconnect signals from client
 331     uiInterface.ShowProgress.disconnect(boost::bind(ShowProgress, this, _1, _2));
 332     uiInterface.NotifyNumConnectionsChanged.disconnect(boost::bind(NotifyNumConnectionsChanged, this, _1));
 333     uiInterface.NotifyNetworkActiveChanged.disconnect(boost::bind(NotifyNetworkActiveChanged, this, _1));
 334     uiInterface.NotifyAlertChanged.disconnect(boost::bind(NotifyAlertChanged, this));
 335     uiInterface.BannedListChanged.disconnect(boost::bind(BannedListChanged, this));
 336     uiInterface.NotifyBlockTip.disconnect(boost::bind(BlockTipChanged, this, _1, _2, false));
 337     uiInterface.NotifyHeaderTip.disconnect(boost::bind(BlockTipChanged, this, _1, _2, true));
 338 }