RPC call for summary get_status (#1742)

* RPC call for summary get_status

* lint

* update with review notes

* further review points

* uint64_t

llarp/router/abstractrouter.hpp

@@ -324,6 +324,9 @@ namespace llarp
     virtual util::StatusObject
     ExtractStatus() const = 0;
 
+    virtual util::StatusObject
+    ExtractSummaryStatus() const = 0;
+
     /// gossip an rc if required
     virtual void
     GossipRCIfNeeded(const RouterContact rc) = 0;

llarp/router/router.cpp

@@ -96,6 +96,77 @@ namespace llarp
     }
   }
 
+  util::StatusObject
+  Router::ExtractSummaryStatus() const
+  {
+    if (!_running)
+      return util::StatusObject{{"running", false}};
+
+    auto services = _hiddenServiceContext.ExtractStatus();
+    auto link_types = _linkManager.ExtractStatus();
+
+    uint64_t tx_rate = 0;
+    uint64_t rx_rate = 0;
+    uint64_t peers = 0;
+    for (const auto& links : link_types)
+    {
+      for (const auto& link : links)
+      {
+        if (link.empty())
+          continue;
+        for (const auto& peer : link["sessions"]["established"])
+        {
+          tx_rate += peer["tx"].get<uint64_t>();
+          rx_rate += peer["rx"].get<uint64_t>();
+          peers++;
+        }
+      }
+    }
+
+    // Compute all stats on all path builders on the default endpoint
+    // Merge snodeSessions, remoteSessions and default into a single array
+    std::vector<nlohmann::json> builders;
+    auto snode_sessions = services["default"]["snodeSessions"];
+    for (const auto& session : snode_sessions)
+      builders.push_back(session["buildStats"]);
+
+    auto remote_sessions = services["default"]["remoteSessions"];
+    for (const auto& session : remote_sessions)
+      builders.push_back(session["buildStats"]);
+
+    builders.push_back(services["default"]["buildStats"]);
+
+    // Iterate over all items on this array to build the global pathStats
+    uint64_t paths = 0;
+    uint64_t success = 0;
+    uint64_t attempts = 0;
+    for (const auto& builder : builders)
+    {
+      if (builder.is_null())
+        continue;
+      if (builder["length"].is_number())
+        paths += builder["length"].get<uint64_t>();
+      if (builder["success"].is_number())
+        success += builder["success"].get<uint64_t>();
+      if (builder["attempts"].is_number())
+        attempts += builder["attempts"].get<uint64_t>();
+    }
+    double ratio = static_cast<double>(success) / (attempts + 1);
+
+    return util::StatusObject{
+        {"running", true},
+        {"authCodes", services["default"]["authCodes"]},
+        {"exitMap", services["default"]["exitMap"]},
+        {"lokiAddress", services["default"]["identity"]},
+        {"numPathsBuilt", paths},
+        {"numPeersConnected", peers},
+        {"numRoutersKnown", _nodedb->NumLoaded()},
+        {"ratio", ratio},
+        {"txRate", tx_rate},
+        {"rxRate", rx_rate},
+    };
+  }
+
   bool
   Router::HandleRecvLinkMessageBuffer(ILinkSession* session, const llarp_buffer_t& buf)
   {

llarp/router/router.hpp

@@ -103,6 +103,9 @@ namespace llarp
     util::StatusObject
     ExtractStatus() const override;
 
+    util::StatusObject
+    ExtractSummaryStatus() const override;
+
     const std::shared_ptr<NodeDB>&
     nodedb() const override
     {

llarp/rpc/rpc_server.cpp

@@ -133,6 +133,13 @@ namespace llarp::rpc
                 defer.reply(data);
               });
             })
+        .add_request_command(
+            "get_status",
+            [&](oxenmq::Message& msg) {
+              m_Router->loop()->call([defer = msg.send_later(), r = m_Router]() {
+                defer.reply(CreateJSONResponse(r->ExtractSummaryStatus()));
+              });
+            })
         .add_request_command(
             "quic_connect",
             [&](oxenmq::Message& msg) {