Adnl optimizations (#1620)

* Remove AdnlStaticNodesManager

* Remove AdnlPeer

---------

Co-authored-by: EmelyanenkoK <[email protected]>

Author: abacabadabacaba

adnl/CMakeLists.txt

@@ -23,8 +23,6 @@ set(ADNL_HEADERS
   adnl-peer.h
   adnl-peer.hpp
   adnl-query.h
-  adnl-static-nodes.h
-  adnl-static-nodes.hpp
   adnl-proxy-types.h
   adnl-proxy-types.hpp
   adnl.h
@@ -46,7 +44,6 @@ set(ADNL_SOURCE
   adnl-peer.cpp
   adnl-query.cpp
   adnl-channel.cpp
-  adnl-static-nodes.cpp
   adnl-proxy-types.cpp
   utils.cpp
   ${ADNL_HEADERS}

adnl/adnl-peer-table.cpp

@@ -84,15 +84,42 @@ void AdnlPeerTableImpl::receive_packet(td::IPAddress addr, AdnlCategoryMask cat_
                    << " (len=" << (data.size() + 32) << ")";
 }
 
+void AdnlPeerTableImpl::update_id(AdnlPeerTableImpl::PeerInfo &peer_info, AdnlNodeIdFull &&peer_id) {
+  if (peer_info.peer_id.empty()) {
+    peer_info.peer_id = std::move(peer_id);
+    for (auto &e: peer_info.peers) {
+      td::actor::send_closure(e.second, &AdnlPeerPair::update_peer_id, peer_info.peer_id);
+    }
+  }
+}
+
+td::actor::ActorOwn<AdnlPeerPair> &AdnlPeerTableImpl::get_peer_pair(
+    AdnlNodeIdShort peer_id, AdnlPeerTableImpl::PeerInfo &peer_info,
+    AdnlNodeIdShort local_id, AdnlPeerTableImpl::LocalIdInfo &local_id_info) {
+  auto it = peer_info.peers.find(local_id);
+  if (it == peer_info.peers.end()) {
+    it = peer_info.peers.emplace(local_id,
+                                 AdnlPeerPair::create(network_manager_, actor_id(this),
+                                                      local_id_info.mode, local_id_info.local_id.get(),
+                                                      dht_node_, local_id, peer_id))
+                        .first;
+    if (!peer_info.peer_id.empty()) {
+      td::actor::send_closure(it->second, &AdnlPeerPair::update_peer_id, peer_info.peer_id);
+    }
+  }
+  return it->second;
+}
+
 void AdnlPeerTableImpl::receive_decrypted_packet(AdnlNodeIdShort dst, AdnlPacket packet, td::uint64 serialized_size) {
   packet.run_basic_checks().ensure();
 
   if (!packet.inited_from_short()) {
     VLOG(ADNL_INFO) << this << ": dropping IN message [?->" << dst << "]: destination not set";
     return;
   }
+  AdnlNodeIdShort src = packet.from_short();
 
-  auto it = peers_.find(packet.from_short());
+  auto it = peers_.find(src);
   if (it == peers_.end()) {
     if (!packet.inited_from()) {
       VLOG(ADNL_NOTICE) << this << ": dropping IN message [" << packet.from_short() << "->" << dst
@@ -105,11 +132,7 @@ void AdnlPeerTableImpl::receive_decrypted_packet(AdnlNodeIdShort dst, AdnlPacket
       return;
     }
 
-    it = peers_
-             .emplace(packet.from_short(),
-                      AdnlPeer::create(network_manager_, actor_id(this), dht_node_, packet.from_short()))
-             .first;
-    CHECK(it != peers_.end());
+    it = peers_.try_emplace(src).first;
   }
 
   auto it2 = local_ids_.find(dst);
@@ -118,8 +141,13 @@ void AdnlPeerTableImpl::receive_decrypted_packet(AdnlNodeIdShort dst, AdnlPacket
                      << "]: unknown dst (but how did we decrypt message?)";
     return;
   }
-  td::actor::send_closure(it->second, &AdnlPeer::receive_packet, dst, it2->second.mode, it2->second.local_id.get(),
-                          std::move(packet), serialized_size);
+
+  if (packet.inited_from()) {
+    update_id(it->second, packet.from());
+  }
+
+  td::actor::send_closure(get_peer_pair(src, it->second, dst, it2->second),
+                          &AdnlPeerPair::receive_packet, std::move(packet), serialized_size);
 }
 
 void AdnlPeerTableImpl::add_peer(AdnlNodeIdShort local_id, AdnlNodeIdFull id, AdnlAddressList addr_list) {
@@ -129,40 +157,36 @@ void AdnlPeerTableImpl::add_peer(AdnlNodeIdShort local_id, AdnlNodeIdFull id, Ad
   auto it2 = local_ids_.find(local_id);
   CHECK(it2 != local_ids_.end());
 
-  auto it = peers_.find(id_short);
-  if (it == peers_.end()) {
-    it = peers_.emplace(id_short, AdnlPeer::create(network_manager_, actor_id(this), dht_node_, id_short)).first;
-    CHECK(it != peers_.end());
-  }
-  td::actor::send_closure(it->second, &AdnlPeer::update_id, std::move(id));
+  auto &peer_info = peers_[id_short];
+  update_id(peer_info, std::move(id));
   if (!addr_list.empty()) {
-    td::actor::send_closure(it->second, &AdnlPeer::update_addr_list, local_id, it2->second.mode,
-                            it2->second.local_id.get(), std::move(addr_list));
+    td::actor::send_closure(get_peer_pair(id_short, peer_info, local_id, it2->second),
+                            &AdnlPeerPair::update_addr_list, std::move(addr_list));
   }
 }
 
 void AdnlPeerTableImpl::add_static_nodes_from_config(AdnlNodesList nodes) {
-  for (auto &it : nodes.nodes()) {
-    add_static_node(it);
+  for (auto &node : nodes.nodes()) {
+    auto id_short = node.compute_short_id();
+    VLOG(ADNL_INFO) << "[staticnodes] adding static node " << id_short;
+    static_nodes_.emplace(id_short, std::move(node));
   }
 }
 
 void AdnlPeerTableImpl::send_message_in(AdnlNodeIdShort src, AdnlNodeIdShort dst, AdnlMessage message,
                                         td::uint32 flags) {
-  auto it = peers_.find(dst);
-
-  if (it == peers_.end()) {
-    it = peers_.emplace(dst, AdnlPeer::create(network_manager_, actor_id(this), dht_node_, dst)).first;
-  }
+  auto &peer_info = peers_[dst];
 
   auto it2 = local_ids_.find(src);
   if (it2 == local_ids_.end()) {
     LOG(ERROR) << this << ": dropping OUT message [" << src << "->" << dst << "]: unknown src";
     return;
   }
 
-  td::actor::send_closure(it->second, &AdnlPeer::send_one_message, src, it2->second.mode, it2->second.local_id.get(),
-                          OutboundAdnlMessage{std::move(message), flags});
+  std::vector<OutboundAdnlMessage> messages;
+  messages.push_back(OutboundAdnlMessage{std::move(message), flags});
+  td::actor::send_closure(get_peer_pair(dst, peer_info, src, it2->second),
+                          &AdnlPeerPair::send_messages, std::move(messages));
 }
 
 void AdnlPeerTableImpl::answer_query(AdnlNodeIdShort src, AdnlNodeIdShort dst, AdnlQueryId query_id,
@@ -182,20 +206,16 @@ void AdnlPeerTableImpl::send_query(AdnlNodeIdShort src, AdnlNodeIdShort dst, std
     VLOG(ADNL_WARNING) << "DUMP: " << td::buffer_to_hex(data.as_slice().truncate(128));
     return;
   }
-  auto it = peers_.find(dst);
-
-  if (it == peers_.end()) {
-    it = peers_.emplace(dst, AdnlPeer::create(network_manager_, actor_id(this), dht_node_, dst)).first;
-  }
+  auto &peer_info = peers_[dst];
 
   auto it2 = local_ids_.find(src);
   if (it2 == local_ids_.end()) {
     LOG(ERROR) << this << ": dropping OUT message [" << src << "->" << dst << "]: unknown src";
     return;
   }
 
-  td::actor::send_closure(it->second, &AdnlPeer::send_query, src, it2->second.mode, it2->second.local_id.get(), name,
-                          std::move(promise), timeout, std::move(data), 0);
+  td::actor::send_closure(get_peer_pair(dst, peer_info, src, it2->second),
+                          &AdnlPeerPair::send_query, name, std::move(promise), timeout, std::move(data), 0);
 }
 
 void AdnlPeerTableImpl::add_id_ex(AdnlNodeIdFull id, AdnlAddressList addr_list, td::uint8 cat, td::uint32 mode) {
@@ -247,8 +267,10 @@ void AdnlPeerTableImpl::unsubscribe(AdnlNodeIdShort dst, std::string prefix) {
 void AdnlPeerTableImpl::register_dht_node(td::actor::ActorId<dht::Dht> dht_node) {
   dht_node_ = dht_node;
 
-  for (auto &peer : peers_) {
-    td::actor::send_closure(peer.second, &AdnlPeer::update_dht_node, dht_node_);
+  for (auto &e : peers_) {
+    for (auto &e2 : e.second.peers) {
+      td::actor::send_closure(e2.second, &AdnlPeerPair::update_dht_node, dht_node_);
+    }
   }
   for (auto &local_id : local_ids_) {
     td::actor::send_closure(local_id.second.local_id, &AdnlLocalId::update_dht_node, dht_node_);
@@ -332,8 +354,6 @@ void AdnlPeerTableImpl::get_addr_list_from_db(AdnlNodeIdShort local_id, AdnlNode
 
 AdnlPeerTableImpl::AdnlPeerTableImpl(std::string db_root, td::actor::ActorId<keyring::Keyring> keyring) {
   keyring_ = keyring;
-  static_nodes_manager_ = AdnlStaticNodesManager::create();
-
   if (!db_root.empty()) {
     db_ = AdnlDb::create(db_root + "/adnl");
   }
@@ -382,7 +402,64 @@ void AdnlPeerTableImpl::get_conn_ip_str(AdnlNodeIdShort l_id, AdnlNodeIdShort p_
     promise.set_value("undefined");
     return;
   }
-  td::actor::send_closure(it->second, &AdnlPeer::get_conn_ip_str, l_id, std::move(promise));
+  auto it2 = it->second.peers.find(l_id);
+  if (it2 == it->second.peers.end()) {
+    promise.set_value("undefined");
+    return;
+  }
+  td::actor::send_closure(it2->second, &AdnlPeerPair::get_conn_ip_str, std::move(promise));
+}
+
+void AdnlPeerTableImpl::get_stats_peer(AdnlNodeIdShort peer_id, AdnlPeerTableImpl::PeerInfo &peer_info, bool all,
+    td::Promise<std::vector<tl_object_ptr<ton_api::adnl_stats_peerPair>>> promise) {
+  class Cb : public td::actor::Actor {
+   public:
+    explicit Cb(td::Promise<std::vector<tl_object_ptr<ton_api::adnl_stats_peerPair>>> promise)
+        : promise_(std::move(promise)) {
+    }
+
+    void got_peer_pair_stats(tl_object_ptr<ton_api::adnl_stats_peerPair> peer_pair) {
+      if (peer_pair) {
+        result_.push_back(std::move(peer_pair));
+      }
+      dec_pending();
+    }
+
+    void inc_pending() {
+      ++pending_;
+    }
+
+    void dec_pending() {
+      CHECK(pending_ > 0);
+      --pending_;
+      if (pending_ == 0) {
+        promise_.set_result(std::move(result_));
+        stop();
+      }
+    }
+
+   private:
+    td::Promise<std::vector<tl_object_ptr<ton_api::adnl_stats_peerPair>>> promise_;
+    size_t pending_ = 1;
+    std::vector<tl_object_ptr<ton_api::adnl_stats_peerPair>> result_;
+  };
+  auto callback = td::actor::create_actor<Cb>("adnlpeerstats", std::move(promise)).release();
+
+  for (auto &[local_id, peer_pair] : peer_info.peers) {
+    td::actor::send_closure(callback, &Cb::inc_pending);
+    td::actor::send_closure(peer_pair, &AdnlPeerPair::get_stats, all,
+                            [local_id = local_id, peer_id = peer_id,
+                             callback](td::Result<tl_object_ptr<ton_api::adnl_stats_peerPair>> R) {
+                              if (R.is_error()) {
+                                VLOG(ADNL_NOTICE) << "failed to get stats for peer pair " << peer_id << "->" << local_id
+                                                  << " : " << R.move_as_error();
+                                td::actor::send_closure(callback, &Cb::dec_pending);
+                              } else {
+                                td::actor::send_closure(callback, &Cb::got_peer_pair_stats, R.move_as_ok());
+                              }
+                            });
+  }
+  td::actor::send_closure(callback, &Cb::dec_pending);
 }
 
 void AdnlPeerTableImpl::get_stats(bool all, td::Promise<tl_object_ptr<ton_api::adnl_stats>> promise) {
@@ -453,8 +530,8 @@ void AdnlPeerTableImpl::get_stats(bool all, td::Promise<tl_object_ptr<ton_api::a
   }
   for (auto &[id, peer] : peers_) {
     td::actor::send_closure(callback, &Cb::inc_pending);
-    td::actor::send_closure(
-        peer, &AdnlPeer::get_stats, all,
+    get_stats_peer(
+        id, peer, all,
         [id = id, callback](td::Result<std::vector<tl_object_ptr<ton_api::adnl_stats_peerPair>>> R) {
           if (R.is_error()) {
             VLOG(ADNL_NOTICE) << "failed to get stats for peer " << id << " : " << R.move_as_error();

adnl/adnl-peer-table.h

@@ -97,9 +97,7 @@ class AdnlPeerTable : public Adnl {
                                 td::actor::ActorId<AdnlChannel> channel) = 0;
   virtual void unregister_channel(AdnlChannelIdShort id) = 0;
 
-  virtual void add_static_node(AdnlNode node) = 0;
-  virtual void del_static_node(AdnlNodeIdShort id) = 0;
-  virtual void get_static_node(AdnlNodeIdShort id, td::Promise<AdnlNode> promise) = 0;
+  virtual td::Result<AdnlNode> get_static_node(AdnlNodeIdShort id) = 0;
 
   virtual void write_new_addr_list_to_db(AdnlNodeIdShort local_id, AdnlNodeIdShort peer_id, AdnlDbItem node,
                                          td::Promise<td::Unit> promise) = 0;

adnl/adnl-peer-table.hpp

@@ -28,7 +28,6 @@
 #include "adnl-local-id.h"
 #include "adnl-query.h"
 #include "utils.hpp"
-#include "adnl-static-nodes.h"
 #include "adnl-ext-server.h"
 #include "adnl-address-list.h"
 
@@ -86,15 +85,12 @@ class AdnlPeerTableImpl : public AdnlPeerTable {
   void get_addr_list_from_db(AdnlNodeIdShort local_id, AdnlNodeIdShort peer_id,
                              td::Promise<AdnlDbItem> promise) override;
 
-  void add_static_node(AdnlNode node) override {
-    CHECK(!static_nodes_manager_.empty());
-    td::actor::send_closure(static_nodes_manager_, &AdnlStaticNodesManager::add_node, std::move(node));
-  }
-  void del_static_node(AdnlNodeIdShort id) override {
-    td::actor::send_closure(static_nodes_manager_, &AdnlStaticNodesManager::del_node, id);
-  }
-  void get_static_node(AdnlNodeIdShort id, td::Promise<AdnlNode> promise) override {
-    td::actor::send_closure(static_nodes_manager_, &AdnlStaticNodesManager::get_node, id, std::move(promise));
+  td::Result<AdnlNode> get_static_node(AdnlNodeIdShort id) override {
+    auto it = static_nodes_.find(id);
+    if (it == static_nodes_.end()) {
+      return td::Status::Error(ErrorCode::notready, "static node not found");
+    }
+    return it->second;
   }
   void deliver(AdnlNodeIdShort src, AdnlNodeIdShort dst, td::BufferSlice data) override;
   void deliver_query(AdnlNodeIdShort src, AdnlNodeIdShort dst, td::BufferSlice data,
@@ -116,20 +112,26 @@ class AdnlPeerTableImpl : public AdnlPeerTable {
   }
 
  private:
+  struct PeerInfo {
+    AdnlNodeIdFull peer_id;
+    std::map<AdnlNodeIdShort, td::actor::ActorOwn<AdnlPeerPair>> peers;
+  };
+
   struct LocalIdInfo {
     td::actor::ActorOwn<AdnlLocalId> local_id;
     td::uint8 cat;
     td::uint32 mode;
   };
+
   td::actor::ActorId<keyring::Keyring> keyring_;
 
   td::actor::ActorId<AdnlNetworkManager> network_manager_;
   td::actor::ActorId<dht::Dht> dht_node_;
-  td::actor::ActorOwn<AdnlStaticNodesManager> static_nodes_manager_;
+  std::map<AdnlNodeIdShort, AdnlNode> static_nodes_;
 
   void deliver_one_message(AdnlNodeIdShort src, AdnlNodeIdShort dst, AdnlMessage message);
 
-  std::map<AdnlNodeIdShort, td::actor::ActorOwn<AdnlPeer>> peers_;
+  std::map<AdnlNodeIdShort, PeerInfo> peers_;
   std::map<AdnlNodeIdShort, LocalIdInfo> local_ids_;
   std::map<AdnlChannelIdShort, std::pair<td::actor::ActorId<AdnlChannel>, td::uint8>> channels_;
 
@@ -140,6 +142,11 @@ class AdnlPeerTableImpl : public AdnlPeerTable {
   AdnlNodeIdShort proxy_addr_;
   //std::map<td::uint64, td::actor::ActorId<AdnlQuery>> out_queries_;
   //td::uint64 last_query_id_ = 1;
+
+  static void update_id(PeerInfo &peer_info, AdnlNodeIdFull &&peer_id);
+  td::actor::ActorOwn<AdnlPeerPair> &get_peer_pair(AdnlNodeIdShort peer_id, PeerInfo &peer_info, AdnlNodeIdShort local_id, LocalIdInfo &local_id_info);
+  static void get_stats_peer(AdnlNodeIdShort peer_id, PeerInfo &peer_info, bool all,
+    td::Promise<std::vector<tl_object_ptr<ton_api::adnl_stats_peerPair>>> promise);
 };
 
 inline td::StringBuilder &operator<<(td::StringBuilder &sb, const AdnlPeerTableImpl::PrintId &id) {