initial commit

dht/dht-in.hpp

@@ -0,0 +1,168 @@
+/*
+    This file is part of TON Blockchain Library.
+
+    TON Blockchain Library is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 2 of the License, or
+    (at your option) any later version.
+
+    TON Blockchain Library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with TON Blockchain Library.  If not, see <http://www.gnu.org/licenses/>.
+
+    Copyright 2017-2019 Telegram Systems LLP
+*/
+#pragma once
+
+#include "dht.hpp"
+#include "td/db/KeyValueAsync.h"
+
+#include <map>
+
+namespace ton {
+
+namespace dht {
+
+class DhtRemoteNode;
+class DhtBucket;
+
+class DhtMemberImpl : public DhtMember {
+ private:
+  class DhtKeyValueLru : public td::ListNode {
+   public:
+    DhtKeyValueLru(DhtValue value) : kv_(std::move(value)) {
+    }
+    DhtValue kv_;
+    static inline DhtKeyValueLru *from_list_node(ListNode *node) {
+      return static_cast<DhtKeyValueLru *>(node);
+    }
+  };
+  //std::unique_ptr<adnl::AdnlDecryptor> decryptor_;
+  adnl::AdnlNodeIdShort id_;
+  DhtKeyId key_;
+  td::uint32 k_;
+  td::uint32 a_;
+  td::uint32 max_cache_time_ = 60;
+  td::uint32 max_cache_size_ = 100;
+
+  std::vector<DhtBucket> buckets_;
+
+  std::string db_root_;
+
+  // to be republished once in a while
+  std::map<DhtKeyId, DhtValue> our_values_;
+
+  std::map<DhtKeyId, DhtKeyValueLru> cached_values_;
+  td::ListNode cached_values_lru_;
+
+  std::map<DhtKeyId, DhtValue> values_;
+
+  td::Timestamp fill_att_ = td::Timestamp::in(0);
+  td::Timestamp republish_att_ = td::Timestamp::in(0);
+
+  DhtKeyId last_republish_key_ = DhtKeyId::zero();
+  DhtKeyId last_check_key_ = DhtKeyId::zero();
+
+  class Callback : public adnl::Adnl::Callback {
+   public:
+    void receive_message(adnl::AdnlNodeIdShort src, adnl::AdnlNodeIdShort dst, td::BufferSlice data) override {
+      CHECK(dst == id_);
+      td::actor::send_closure(self_, &DhtMemberImpl::receive_message, src, std::move(data));
+    }
+    void receive_query(adnl::AdnlNodeIdShort src, adnl::AdnlNodeIdShort dst, td::BufferSlice data,
+                       td::Promise<td::BufferSlice> promise) override {
+      CHECK(dst == id_);
+      td::actor::send_closure(self_, &DhtMemberImpl::receive_query, src, std::move(data), std::move(promise));
+    }
+
+    Callback(td::actor::ActorId<DhtMemberImpl> self, adnl::AdnlNodeIdShort id) : self_(self), id_(id) {
+    }
+
+   private:
+    td::actor::ActorId<DhtMemberImpl> self_;
+    adnl::AdnlNodeIdShort id_;
+  };
+
+  void receive_query(adnl::AdnlNodeIdShort src, td::BufferSlice data, td::Promise<td::BufferSlice> promise);
+
+  void receive_message(adnl::AdnlNodeIdShort src, td::BufferSlice data);
+
+  td::actor::ActorId<keyring::Keyring> keyring_;
+  td::actor::ActorId<adnl::Adnl> adnl_;
+
+  td::uint64 ping_queries_{0};
+  td::uint64 find_node_queries_{0};
+  td::uint64 find_value_queries_{0};
+  td::uint64 store_queries_{0};
+  td::uint64 get_addr_list_queries_{0};
+
+  using DbType = td::KeyValueAsync<td::Bits256, td::BufferSlice>;
+  DbType db_;
+  td::Timestamp next_save_to_db_at_ = td::Timestamp::in(10.0);
+
+  void save_to_db();
+
+  DhtNodesList get_nearest_nodes(DhtKeyId id, td::uint32 k);
+  void check();
+
+  template <class T>
+  void process_query(adnl::AdnlNodeIdShort src, T &query, td::Promise<td::BufferSlice> promise) {
+    promise.set_error(td::Status::Error(ErrorCode::protoviolation, "bad DHT query"));
+  }
+
+  void process_query(adnl::AdnlNodeIdShort src, ton_api::dht_ping &query, td::Promise<td::BufferSlice> promise);
+  void process_query(adnl::AdnlNodeIdShort src, ton_api::dht_findNode &query, td::Promise<td::BufferSlice> promise);
+  void process_query(adnl::AdnlNodeIdShort src, ton_api::dht_findValue &query, td::Promise<td::BufferSlice> promise);
+  void process_query(adnl::AdnlNodeIdShort src, ton_api::dht_store &query, td::Promise<td::BufferSlice> promise);
+  void process_query(adnl::AdnlNodeIdShort src, ton_api::dht_getSignedAddressList &query,
+                     td::Promise<td::BufferSlice> promise);
+
+ public:
+  DhtMemberImpl(adnl::AdnlNodeIdShort id, std::string db_root, td::actor::ActorId<keyring::Keyring> keyring,
+                td::actor::ActorId<adnl::Adnl> adnl, td::uint32 k, td::uint32 a = 3)
+      : id_(id), key_{id_}, k_(k), a_(a), db_root_(db_root), keyring_(keyring), adnl_(adnl) {
+    for (size_t i = 0; i < 256; i++) {
+      buckets_.emplace_back(k_);
+    }
+  }
+
+  void add_full_node(DhtKeyId id, DhtNode node) override;
+
+  adnl::AdnlNodeIdShort get_id() const override {
+    return id_;
+  }
+
+  void receive_ping(DhtKeyId id, DhtNode result) override;
+
+  void set_value(DhtValue key_value, td::Promise<td::Unit> result) override;
+  td::uint32 distance(DhtKeyId key_id, td::uint32 max_value);
+
+  td::Status store_in(DhtValue value) override;
+  void send_store(DhtValue value, td::Promise<td::Unit> promise);
+
+  void get_value_in(DhtKeyId key, td::Promise<DhtValue> result) override;
+  void get_value(DhtKey key, td::Promise<DhtValue> result) override {
+    get_value_in(key.compute_key_id(), std::move(result));
+  }
+
+  void alarm() override {
+    alarm_timestamp() = td::Timestamp::in(1.0);
+    check();
+  }
+  void start_up() override;
+  void tear_down() override;
+  void dump(td::StringBuilder &sb) const override;
+  PrintId print_id() const override {
+    return PrintId{id_};
+  }
+
+  void get_self_node(td::Promise<DhtNode> promise) override;
+};
+
+}  // namespace dht
+
+}  // namespace ton