net: Notify about connection number by type

Author: hebasto

src/interfaces/node.h

@@ -33,6 +33,7 @@ enum class SynchronizationState;
 enum class TransactionError;
 struct CNodeStateStats;
 struct bilingual_str;
+struct PeersNumByType;
 namespace node {
 struct NodeContext;
 } // namespace node
@@ -238,7 +239,7 @@ class Node
     virtual std::unique_ptr<Handler> handleInitWallet(InitWalletFn fn) = 0;
 
     //! Register handler for number of connections changed messages.
-    using NotifyNumConnectionsChangedFn = std::function<void(int new_num_connections)>;
+    using NotifyNumConnectionsChangedFn = std::function<void(PeersNumByType new_num_connections)>;
     virtual std::unique_ptr<Handler> handleNotifyNumConnectionsChanged(NotifyNumConnectionsChangedFn fn) = 0;
 
     //! Register handler for network active messages.

src/net.cpp

@@ -1133,15 +1133,47 @@ void CConnman::DisconnectNodes()
 
 void CConnman::NotifyNumConnectionsChanged()
 {
-    size_t nodes_size;
+    decltype(m_nodes) nodes_copy;
     {
         LOCK(m_nodes_mutex);
-        nodes_size = m_nodes.size();
+        nodes_copy = m_nodes;
     }
-    if(nodes_size != nPrevNodeCount) {
-        nPrevNodeCount = nodes_size;
+
+    int num_outbound_full_relay{0};
+    int num_block_relay{0};
+    int num_manual{0};
+    int num_inbound{0};
+    for (const auto* node : nodes_copy) {
+        switch (node->m_conn_type) {
+        case ConnectionType::OUTBOUND_FULL_RELAY:
+            ++num_outbound_full_relay;
+            break;
+        case ConnectionType::BLOCK_RELAY:
+            ++num_block_relay;
+            break;
+        case ConnectionType::MANUAL:
+            ++num_manual;
+            break;
+        case ConnectionType::INBOUND:
+            ++num_inbound;
+            break;
+        case ConnectionType::FEELER:
+        case ConnectionType::ADDR_FETCH:
+            break;
+        }
+    }
+
+    if (num_outbound_full_relay != m_num_outbound_full_relay ||
+        num_block_relay != m_num_block_relay ||
+        num_manual != m_num_manual ||
+        num_inbound != m_num_inbound) {
+        m_num_outbound_full_relay = num_outbound_full_relay;
+        m_num_block_relay = num_block_relay;
+        m_num_manual = num_manual;
+        m_num_inbound = num_inbound;
         if (m_client_interface) {
-            m_client_interface->NotifyNumConnectionsChanged(nodes_size);
+            m_client_interface->NotifyNumConnectionsChanged(
+                {num_outbound_full_relay, num_block_relay, num_manual, num_inbound, static_cast<int>(nodes_copy.size())});
         }
     }
 }

src/net.h

@@ -46,6 +46,7 @@ class BanMan;
 class CNode;
 class CScheduler;
 struct bilingual_str;
+struct PeersNumByType;
 
 /** Default for -whitelistrelay. */
 static const bool DEFAULT_WHITELISTRELAY = true;
@@ -1010,7 +1011,11 @@ class CConnman
     std::list<CNode*> m_nodes_disconnected;
     mutable RecursiveMutex m_nodes_mutex;
     std::atomic<NodeId> nLastNodeId{0};
-    unsigned int nPrevNodeCount{0};
+    int m_num_outbound_full_relay{0};
+    int m_num_block_relay{0};
+    int m_num_manual{0};
+    int m_num_inbound{0};
+
 
     /**
      * Cache responses to addr requests to minimize privacy leak.

src/node/interface_ui.cpp

@@ -48,7 +48,7 @@ bool CClientUIInterface::ThreadSafeMessageBox(const bilingual_str& message, cons
 bool CClientUIInterface::ThreadSafeQuestion(const bilingual_str& message, const std::string& non_interactive_message, const std::string& caption, unsigned int style) { return g_ui_signals.ThreadSafeQuestion(message, non_interactive_message, caption, style).value_or(false);}
 void CClientUIInterface::InitMessage(const std::string& message) { return g_ui_signals.InitMessage(message); }
 void CClientUIInterface::InitWallet() { return g_ui_signals.InitWallet(); }
-void CClientUIInterface::NotifyNumConnectionsChanged(int newNumConnections) { return g_ui_signals.NotifyNumConnectionsChanged(newNumConnections); }
+void CClientUIInterface::NotifyNumConnectionsChanged(PeersNumByType newNumConnections) { return g_ui_signals.NotifyNumConnectionsChanged(newNumConnections); }
 void CClientUIInterface::NotifyNetworkActiveChanged(bool networkActive) { return g_ui_signals.NotifyNetworkActiveChanged(networkActive); }
 void CClientUIInterface::NotifyAlertChanged() { return g_ui_signals.NotifyAlertChanged(); }
 void CClientUIInterface::ShowProgress(const std::string& title, int nProgress, bool resume_possible) { return g_ui_signals.ShowProgress(title, nProgress, resume_possible); }

src/node/interface_ui.h

@@ -20,6 +20,14 @@ class connection;
 }
 } // namespace boost
 
+struct PeersNumByType {
+    int outbound_full_relay{0};
+    int block_relay{0};
+    int manual{0};
+    int inbound{0};
+    int total{0};
+};
+
 /** Signals for UI communication. */
 class CClientUIInterface
 {
@@ -85,7 +93,7 @@ class CClientUIInterface
     ADD_SIGNALS_DECL_WRAPPER(InitWallet, void, );
 
     /** Number of network connections changed. */
-    ADD_SIGNALS_DECL_WRAPPER(NotifyNumConnectionsChanged, void, int newNumConnections);
+    ADD_SIGNALS_DECL_WRAPPER(NotifyNumConnectionsChanged, void, PeersNumByType newNumConnections);
 
     /** Network activity state changed. */
     ADD_SIGNALS_DECL_WRAPPER(NotifyNetworkActiveChanged, void, bool networkActive);

src/qt/clientmodel.cpp

@@ -15,6 +15,7 @@
 #include <interfaces/node.h>
 #include <net.h>
 #include <netbase.h>
+#include <node/interface_ui.h>
 #include <util/system.h>
 #include <util/threadnames.h>
 #include <util/time.h>
@@ -245,8 +246,8 @@ void ClientModel::subscribeToCoreSignals()
             Q_EMIT showProgress(QString::fromStdString(title), progress);
         });
     m_handler_notify_num_connections_changed = m_node.handleNotifyNumConnectionsChanged(
-        [this](int new_num_connections) {
-            Q_EMIT numConnectionsChanged(new_num_connections);
+        [this](PeersNumByType new_num_connections) {
+            Q_EMIT numConnectionsChanged(new_num_connections.total);
         });
     m_handler_notify_network_active_changed = m_node.handleNotifyNetworkActiveChanged(
         [this](bool network_active) {