Bitcoin Core  27.99.0
P2P Digital Currency
clientmodel.cpp
Go to the documentation of this file.
1 // Copyright (c) 2011-2022 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 <config/bitcoin-config.h> // IWYU pragma: keep
6 
7 #include <qt/clientmodel.h>
8 
9 #include <qt/bantablemodel.h>
10 #include <qt/guiconstants.h>
11 #include <qt/guiutil.h>
12 #include <qt/peertablemodel.h>
13 #include <qt/peertablesortproxy.h>
14 
15 #include <clientversion.h>
16 #include <common/args.h>
17 #include <common/system.h>
18 #include <interfaces/handler.h>
19 #include <interfaces/node.h>
20 #include <net.h>
21 #include <netbase.h>
22 #include <util/threadnames.h>
23 #include <util/time.h>
24 #include <validation.h>
25 
26 #include <stdint.h>
27 
28 #include <QDebug>
29 #include <QMetaObject>
30 #include <QThread>
31 #include <QTimer>
32 
33 static SteadyClock::time_point g_last_header_tip_update_notification{};
34 static SteadyClock::time_point g_last_block_tip_update_notification{};
35 
36 ClientModel::ClientModel(interfaces::Node& node, OptionsModel *_optionsModel, QObject *parent) :
37  QObject(parent),
38  m_node(node),
39  optionsModel(_optionsModel),
40  m_thread(new QThread(this))
41 {
44 
47  m_peer_table_sort_proxy->setSourceModel(peerTableModel);
48 
49  banTableModel = new BanTableModel(m_node, this);
50 
51  QTimer* timer = new QTimer;
52  timer->setInterval(MODEL_UPDATE_DELAY);
53  connect(timer, &QTimer::timeout, [this] {
54  // no locking required at this point
55  // the following calls will acquire the required lock
58  });
59  connect(m_thread, &QThread::finished, timer, &QObject::deleteLater);
60  connect(m_thread, &QThread::started, [timer] { timer->start(); });
61  // move timer to thread so that polling doesn't disturb main event loop
62  timer->moveToThread(m_thread);
63  m_thread->start();
64  QTimer::singleShot(0, timer, []() {
65  util::ThreadRename("qt-clientmodl");
66  });
67 
69 }
70 
72 {
74 
75  m_thread->quit();
76  m_thread->wait();
77 }
78 
80 {
81  stop();
82 }
83 
84 int ClientModel::getNumConnections(unsigned int flags) const
85 {
87 
88  if(flags == CONNECTIONS_IN)
89  connections = ConnectionDirection::In;
90  else if (flags == CONNECTIONS_OUT)
91  connections = ConnectionDirection::Out;
92  else if (flags == CONNECTIONS_ALL)
93  connections = ConnectionDirection::Both;
94 
95  return m_node.getNodeCount(connections);
96 }
97 
99 {
100  if (cachedBestHeaderHeight == -1) {
101  // make sure we initially populate the cache via a cs_main lock
102  // otherwise we need to wait for a tip update
103  int height;
104  int64_t blockTime;
105  if (m_node.getHeaderTip(height, blockTime)) {
106  cachedBestHeaderHeight = height;
107  cachedBestHeaderTime = blockTime;
108  }
109  }
110  return cachedBestHeaderHeight;
111 }
112 
114 {
115  if (cachedBestHeaderTime == -1) {
116  int height;
117  int64_t blockTime;
118  if (m_node.getHeaderTip(height, blockTime)) {
119  cachedBestHeaderHeight = height;
120  cachedBestHeaderTime = blockTime;
121  }
122  }
123  return cachedBestHeaderTime;
124 }
125 
127 {
128  if (m_cached_num_blocks == -1) {
130  }
131  return m_cached_num_blocks;
132 }
133 
135 {
136  uint256 tip{WITH_LOCK(m_cached_tip_mutex, return m_cached_tip_blocks)};
137 
138  if (!tip.IsNull()) {
139  return tip;
140  }
141 
142  // Lock order must be: first `cs_main`, then `m_cached_tip_mutex`.
143  // The following will lock `cs_main` (and release it), so we must not
144  // own `m_cached_tip_mutex` here.
145  tip = m_node.getBestBlockHash();
146 
148  // We checked that `m_cached_tip_blocks` is not null above, but then we
149  // released the mutex `m_cached_tip_mutex`, so it could have changed in the
150  // meantime. Thus, check again.
151  if (m_cached_tip_blocks.IsNull()) {
152  m_cached_tip_blocks = tip;
153  }
154  return m_cached_tip_blocks;
155 }
156 
158 {
160  if (getNumConnections() > 0) return BlockSource::NETWORK;
161  return BlockSource::NONE;
162 }
163 
165 {
166  return QString::fromStdString(m_node.getWarnings().translated);
167 }
168 
170 {
171  return optionsModel;
172 }
173 
175 {
176  return peerTableModel;
177 }
178 
180 {
182 }
183 
185 {
186  return banTableModel;
187 }
188 
190 {
191  return QString::fromStdString(FormatFullVersion());
192 }
193 
195 {
196  return QString::fromStdString(strSubVersion);
197 }
198 
200 {
202 }
203 
205 {
206  return QDateTime::fromSecsSinceEpoch(GetStartupTime()).toString();
207 }
208 
209 QString ClientModel::dataDir() const
210 {
212 }
213 
214 QString ClientModel::blocksDir() const
215 {
217 }
218 
219 void ClientModel::TipChanged(SynchronizationState sync_state, interfaces::BlockTip tip, double verification_progress, SyncType synctype)
220 {
221  if (synctype == SyncType::HEADER_SYNC) {
222  // cache best headers time and height to reduce future cs_main locks
225  } else if (synctype == SyncType::BLOCK_SYNC) {
227  WITH_LOCK(m_cached_tip_mutex, m_cached_tip_blocks = tip.block_hash;);
228  }
229 
230  // Throttle GUI notifications about (a) blocks during initial sync, and (b) both blocks and headers during reindex.
231  const bool throttle = (sync_state != SynchronizationState::POST_INIT && synctype == SyncType::BLOCK_SYNC) || sync_state == SynchronizationState::INIT_REINDEX;
232  const auto now{throttle ? SteadyClock::now() : SteadyClock::time_point{}};
234  if (throttle && now < nLastUpdateNotification + MODEL_UPDATE_DELAY) {
235  return;
236  }
237 
238  Q_EMIT numBlocksChanged(tip.block_height, QDateTime::fromSecsSinceEpoch(tip.block_time), verification_progress, synctype, sync_state);
239  nLastUpdateNotification = now;
240 }
241 
243 {
245  [this](const std::string& title, int progress, [[maybe_unused]] bool resume_possible) {
246  Q_EMIT showProgress(QString::fromStdString(title), progress);
247  }));
249  [this](int new_num_connections) {
250  Q_EMIT numConnectionsChanged(new_num_connections);
251  }));
253  [this](bool network_active) {
254  Q_EMIT networkActiveChanged(network_active);
255  }));
257  [this]() {
258  qDebug() << "ClientModel: NotifyAlertChanged";
259  Q_EMIT alertsChanged(getStatusBarWarnings());
260  }));
262  [this]() {
263  qDebug() << "ClienModel: Requesting update for peer banlist";
264  QMetaObject::invokeMethod(banTableModel, [this] { banTableModel->refresh(); });
265  }));
266  m_event_handlers.emplace_back(m_node.handleNotifyBlockTip(
267  [this](SynchronizationState sync_state, interfaces::BlockTip tip, double verification_progress) {
268  TipChanged(sync_state, tip, verification_progress, SyncType::BLOCK_SYNC);
269  }));
270  m_event_handlers.emplace_back(m_node.handleNotifyHeaderTip(
271  [this](SynchronizationState sync_state, interfaces::BlockTip tip, bool presync) {
272  TipChanged(sync_state, tip, /*verification_progress=*/0.0, presync ? SyncType::HEADER_PRESYNC : SyncType::HEADER_SYNC);
273  }));
274 }
275 
277 {
278  m_event_handlers.clear();
279 }
280 
281 bool ClientModel::getProxyInfo(std::string& ip_port) const
282 {
283  Proxy ipv4, ipv6;
284  if (m_node.getProxy((Network) 1, ipv4) && m_node.getProxy((Network) 2, ipv6)) {
285  ip_port = ipv4.proxy.ToStringAddrPort();
286  return true;
287  }
288  return false;
289 }
ArgsManager gArgs
Definition: args.cpp:41
#define CLIENT_VERSION_IS_RELEASE
node::NodeContext m_node
Definition: bitcoin-gui.cpp:37
int flags
Definition: bitcoin-tx.cpp:533
fs::path GetDataDirNet() const
Get data directory path with appended network identifier.
Definition: args.h:232
fs::path GetBlocksDirPath() const
Get blocks directory path.
Definition: args.cpp:280
Qt model providing information about banned peers, similar to the "getpeerinfo" RPC call.
Definition: bantablemodel.h:44
std::string ToStringAddrPort() const
Definition: netaddress.cpp:905
void bytesChanged(quint64 totalBytesIn, quint64 totalBytesOut)
QString blocksDir() const
QString getStatusBarWarnings() const
Return warnings to be displayed in status bar.
std::vector< std::unique_ptr< interfaces::Handler > > m_event_handlers
Definition: clientmodel.h:100
int getHeaderTipHeight() const
Definition: clientmodel.cpp:98
std::atomic< int64_t > cachedBestHeaderTime
Definition: clientmodel.h:92
interfaces::Node & m_node
Definition: clientmodel.h:96
Mutex m_cached_tip_mutex
Definition: clientmodel.h:95
PeerTableModel * getPeerTableModel()
PeerTableSortProxy * peerTableSortProxy()
std::atomic< int > cachedBestHeaderHeight
Definition: clientmodel.h:91
uint256 getBestBlockHash() EXCLUSIVE_LOCKS_REQUIRED(!m_cached_tip_mutex)
BlockSource getBlockSource() const
Returns the block source of the current importing/syncing state.
int getNumBlocks() const
int64_t getHeaderTipTime() const
QString formatClientStartupTime() const
int getNumConnections(unsigned int flags=CONNECTIONS_ALL) const
Return number of connections, default is in- and outbound (total)
Definition: clientmodel.cpp:84
ClientModel(interfaces::Node &node, OptionsModel *optionsModel, QObject *parent=nullptr)
Definition: clientmodel.cpp:36
OptionsModel * optionsModel
Definition: clientmodel.h:101
BanTableModel * banTableModel
Definition: clientmodel.h:104
QThread *const m_thread
A thread to interact with m_node asynchronously.
Definition: clientmodel.h:107
BanTableModel * getBanTableModel()
void unsubscribeFromCoreSignals()
void numBlocksChanged(int count, const QDateTime &blockDate, double nVerificationProgress, SyncType header, SynchronizationState sync_state)
void TipChanged(SynchronizationState sync_state, interfaces::BlockTip tip, double verification_progress, SyncType synctype) EXCLUSIVE_LOCKS_REQUIRED(!m_cached_tip_mutex)
QString dataDir() const
std::atomic< int > m_cached_num_blocks
Definition: clientmodel.h:93
OptionsModel * getOptionsModel()
QString formatFullVersion() const
PeerTableModel * peerTableModel
Definition: clientmodel.h:102
PeerTableSortProxy * m_peer_table_sort_proxy
Definition: clientmodel.h:103
bool getProxyInfo(std::string &ip_port) const
QString formatSubVersion() const
void mempoolSizeChanged(long count, size_t mempoolSizeInBytes)
bool isReleaseVersion() const
void subscribeToCoreSignals()
Interface from Qt to configuration data structure for Bitcoin client.
Definition: optionsmodel.h:43
Qt model providing information about connected peers, similar to the "getpeerinfo" RPC call.
Definition: netbase.h:59
CService proxy
Definition: netbase.h:65
Top-level interface for a bitcoin node (bitcoind process).
Definition: node.h:70
virtual std::unique_ptr< Handler > handleNotifyAlertChanged(NotifyAlertChangedFn fn)=0
virtual std::unique_ptr< Handler > handleNotifyNetworkActiveChanged(NotifyNetworkActiveChangedFn fn)=0
virtual bilingual_str getWarnings()=0
Get warnings.
virtual std::unique_ptr< Handler > handleNotifyNumConnectionsChanged(NotifyNumConnectionsChangedFn fn)=0
virtual std::unique_ptr< Handler > handleShowProgress(ShowProgressFn fn)=0
virtual size_t getMempoolSize()=0
Get mempool size.
virtual bool isLoadingBlocks()=0
Is loading blocks.
virtual size_t getNodeCount(ConnectionDirection flags)=0
Get number of connections.
virtual bool getHeaderTip(int &height, int64_t &block_time)=0
Get header tip height and time.
virtual uint256 getBestBlockHash()=0
Get best block hash.
virtual int64_t getTotalBytesRecv()=0
Get total bytes recv.
virtual std::unique_ptr< Handler > handleBannedListChanged(BannedListChangedFn fn)=0
virtual int64_t getTotalBytesSent()=0
Get total bytes sent.
virtual size_t getMempoolDynamicUsage()=0
Get mempool dynamic usage.
virtual bool getProxy(Network net, Proxy &proxy_info)=0
Get proxy.
virtual int getNumBlocks()=0
Get num blocks.
256-bit opaque blob.
Definition: uint256.h:106
static SteadyClock::time_point g_last_block_tip_update_notification
Definition: clientmodel.cpp:34
static SteadyClock::time_point g_last_header_tip_update_notification
Definition: clientmodel.cpp:33
SyncType
Definition: clientmodel.h:39
@ CONNECTIONS_IN
Definition: clientmodel.h:47
@ CONNECTIONS_OUT
Definition: clientmodel.h:48
@ CONNECTIONS_ALL
Definition: clientmodel.h:49
BlockSource
Definition: clientmodel.h:33
std::string FormatFullVersion()
int64_t GetStartupTime()
Definition: system.cpp:109
static constexpr auto MODEL_UPDATE_DELAY
Definition: guiconstants.h:14
QString PathToQString(const fs::path &path)
Convert OS specific boost path to QString through UTF-8.
Definition: guiutil.cpp:676
Definition: messages.h:20
void ThreadRename(const std::string &)
Rename a thread both in terms of an internal (in-memory) name as well as its system thread name.
Definition: threadnames.cpp:57
std::string strSubVersion
Subversion as sent to the P2P network in version messages.
Definition: net.cpp:117
Network
A network type.
Definition: netaddress.h:32
ConnectionDirection
Definition: netbase.h:33
std::string translated
Definition: translation.h:20
Block tip (could be a header or not, depends on the subscribed signal).
Definition: node.h:276
uint256 block_hash
Definition: node.h:279
int64_t block_time
Definition: node.h:278
#define LOCK(cs)
Definition: sync.h:257
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
Definition: sync.h:301
SynchronizationState
Current sync state passed to tip changed callbacks.
Definition: validation.h:80