src/qt/clientmodel.cpp

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