Add methods to sign and import certificates

overlay/overlay-manager.cpp

@@ -21,13 +21,18 @@
 #include "overlay.h"
 
 #include "adnl/utils.hpp"
+#include "td/actor/actor.h"
+#include "td/actor/common.h"
 #include "td/utils/Random.h"
 
 #include "td/db/RocksDb.h"
 
+#include "td/utils/Status.h"
 #include "td/utils/overloaded.h"
 
 #include "keys/encryptor.h"
+#include "td/utils/port/Poll.h"
+#include <vector>
 
 namespace ton {
 
@@ -269,6 +274,52 @@ void OverlayManager::save_to_db(adnl::AdnlNodeIdShort local_id, OverlayIdShort o
   db_.set(key, create_serialize_tl_object<ton_api::overlay_db_nodes>(std::move(obj)));
 }
 
+void OverlayManager::get_stats(td::Promise<tl_object_ptr<ton_api::engine_validator_overlaysStats>> promise) {
+  class Cb : public td::actor::Actor {
+   public:
+    Cb(td::Promise<tl_object_ptr<ton_api::engine_validator_overlaysStats>> promise) : promise_(std::move(promise)) {
+    }
+    void incr_pending() {
+      pending_++;
+    }
+    void decr_pending() {
+      if (!--pending_) {
+        promise_.set_result(create_tl_object<ton_api::engine_validator_overlaysStats>(std::move(res_)));
+        stop();
+      }
+    }
+    void receive_answer(tl_object_ptr<ton_api::engine_validator_overlayStats> res) {
+      if (res) {
+        res_.push_back(std::move(res));
+      }
+      decr_pending();
+    }
+
+   private:
+    std::vector<tl_object_ptr<ton_api::engine_validator_overlayStats>> res_;
+    size_t pending_{1};
+    td::Promise<tl_object_ptr<ton_api::engine_validator_overlaysStats>> promise_;
+  };
+
+  auto act = td::actor::create_actor<Cb>("overlaysstatsmerger", std::move(promise)).release();
+
+  for (auto &a : overlays_) {
+    for (auto &b : a.second) {
+      td::actor::send_closure(act, &Cb::incr_pending);
+      td::actor::send_closure(b.second, &Overlay::get_stats,
+                              [act](td::Result<tl_object_ptr<ton_api::engine_validator_overlayStats>> R) {
+                                if (R.is_ok()) {
+                                  td::actor::send_closure(act, &Cb::receive_answer, R.move_as_ok());
+                                } else {
+                                  td::actor::send_closure(act, &Cb::receive_answer, nullptr);
+                                }
+                              });
+    }
+  }
+
+  td::actor::send_closure(act, &Cb::decr_pending);
+}
+
 Certificate::Certificate(PublicKey issued_by, td::int32 expire_at, td::uint32 max_size, td::uint32 flags,
                          td::BufferSlice signature)
     : issued_by_(issued_by)

overlay/overlay-manager.h

@@ -91,6 +91,7 @@ class OverlayManager : public Overlays {
 
   void register_overlay(adnl::AdnlNodeIdShort local_id, OverlayIdShort overlay_id,
                         td::actor::ActorOwn<Overlay> overlay);
+  void get_stats(td::Promise<tl_object_ptr<ton_api::engine_validator_overlaysStats>> promise) override;
 
   struct PrintId {};
 

overlay/overlay.cpp

@@ -16,6 +16,7 @@
 
     Copyright 2017-2020 Telegram Systems LLP
 */
+#include "auto/tl/ton_api.h"
 #include "td/utils/Random.h"
 
 #include "adnl/utils.hpp"
@@ -25,6 +26,7 @@
 #include "auto/tl/ton_api.hpp"
 
 #include "keys/encryptor.h"
+#include "td/utils/StringBuilder.h"
 
 namespace ton {
 
@@ -554,6 +556,19 @@ void OverlayImpl::broadcast_checked(Overlay::BroadcastHash hash, td::Result<td::
   }
 }
 
+void OverlayImpl::get_stats(td::Promise<tl_object_ptr<ton_api::engine_validator_overlayStats>> promise) {
+  auto res = create_tl_object<ton_api::engine_validator_overlayStats>();
+  res->adnl_id_ = local_id_.bits256_value();
+  res->overlay_id_ = overlay_id_.bits256_value();
+  res->overlay_id_full_ = id_full_.pubkey().tl();
+  peers_.iterate([&](const adnl::AdnlNodeIdShort &key, const OverlayPeer &peer) { res->nodes_.push_back(key.tl()); });
+
+  res->stats_.push_back(
+      create_tl_object<ton_api::engine_validator_oneStat>("neighbours_cnt", PSTRING() << neighbours_.size()));
+
+  promise.set_value(std::move(res));
+}
+
 }  // namespace overlay
 
 }  // namespace ton

overlay/overlay.h

@@ -63,6 +63,7 @@ class Overlay : public td::actor::Actor {
   virtual void add_certificate(PublicKeyHash key, std::shared_ptr<Certificate>) = 0;
   virtual void set_privacy_rules(OverlayPrivacyRules rules) = 0;
   virtual void receive_nodes_from_db(tl_object_ptr<ton_api::overlay_nodes> nodes) = 0;
+  virtual void get_stats(td::Promise<tl_object_ptr<ton_api::engine_validator_overlayStats>> promise) = 0;
   //virtual void receive_broadcast(td::BufferSlice data) = 0;
   //virtual void subscribe(std::unique_ptr<Overlays::Callback> callback) = 0;
 };
@@ -70,4 +71,3 @@ class Overlay : public td::actor::Actor {
 }  // namespace overlay
 
 }  // namespace ton
-

overlay/overlay.hpp

@@ -190,6 +190,8 @@ class OverlayImpl : public Overlay {
   std::shared_ptr<Certificate> get_certificate(PublicKeyHash local_id);
   td::Result<Encryptor *> get_encryptor(PublicKey source);
 
+  void get_stats(td::Promise<tl_object_ptr<ton_api::engine_validator_overlayStats>> promise) override;
+
  private:
   template <class T>
   void process_query(adnl::AdnlNodeIdShort src, T &query, td::Promise<td::BufferSlice> promise) {

overlay/overlays.h

@@ -231,6 +231,7 @@ class Overlays : public td::actor::Actor {
 
   virtual void get_overlay_random_peers(adnl::AdnlNodeIdShort local_id, OverlayIdShort overlay, td::uint32 max_peers,
                                         td::Promise<std::vector<adnl::AdnlNodeIdShort>> promise) = 0;
+  virtual void get_stats(td::Promise<tl_object_ptr<ton_api::engine_validator_overlaysStats>> promise) = 0;
 };
 
 }  // namespace overlay