changed validate broadcast logic, added new queries to

validator-engine-console

Author: ton

adnl/CMakeLists.txt

@@ -87,6 +87,11 @@ target_include_directories(adnl-proxy PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_S
 target_link_libraries(adnl-proxy PUBLIC tdactor ton_crypto tl_api tdnet common
   tl-utils)
 
+add_executable(adnl-pong adnl-pong.cpp)
+target_include_directories(adnl-pong PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>)
+target_link_libraries(adnl-pong PUBLIC tdactor ton_crypto tl_api tdnet common
+  tl-utils adnl dht)
+
 add_library(adnltest STATIC ${ADNL_TEST_SOURCE})
 target_include_directories(adnltest PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>)
 target_link_libraries(adnltest PUBLIC adnl )

adnl/adnl-peer-table.cpp

@@ -283,19 +283,29 @@ void AdnlPeerTableImpl::start_up() {
 
 void AdnlPeerTableImpl::write_new_addr_list_to_db(AdnlNodeIdShort local_id, AdnlNodeIdShort peer_id, AdnlDbItem node,
                                                   td::Promise<td::Unit> promise) {
+  if (db_.empty()) {
+    promise.set_value(td::Unit());
+    return;
+  }
   td::actor::send_closure(db_, &AdnlDb::update, local_id, peer_id, std::move(node), std::move(promise));
 }
 
 void AdnlPeerTableImpl::get_addr_list_from_db(AdnlNodeIdShort local_id, AdnlNodeIdShort peer_id,
                                               td::Promise<AdnlDbItem> promise) {
+  if (db_.empty()) {
+    promise.set_error(td::Status::Error(ErrorCode::notready, "db not inited"));
+    return;
+  }
   td::actor::send_closure(db_, &AdnlDb::get, local_id, peer_id, std::move(promise));
 }
 
 AdnlPeerTableImpl::AdnlPeerTableImpl(std::string db_root, td::actor::ActorId<keyring::Keyring> keyring) {
   keyring_ = keyring;
   static_nodes_manager_ = AdnlStaticNodesManager::create();
 
-  db_ = AdnlDb::create(db_root + "/adnl");
+  if (!db_root.empty()) {
+    db_ = AdnlDb::create(db_root + "/adnl");
+  }
 }
 
 void AdnlPeerTableImpl::deliver(AdnlNodeIdShort src, AdnlNodeIdShort dst, td::BufferSlice data) {

adnl/adnl-pong.cpp

@@ -0,0 +1,195 @@
+/* 
+    This file is part of TON Blockchain source code.
+
+    TON Blockchain is free software; you can redistribute it and/or
+    modify it under the terms of the GNU 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 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with TON Blockchain.  If not, see <http://www.gnu.org/licenses/>.
+
+    In addition, as a special exception, the copyright holders give permission 
+    to link the code of portions of this program with the OpenSSL library. 
+    You must obey the GNU General Public License in all respects for all 
+    of the code used other than OpenSSL. If you modify file(s) with this 
+    exception, you may extend this exception to your version of the file(s), 
+    but you are not obligated to do so. If you do not wish to do so, delete this 
+    exception statement from your version. If you delete this exception statement 
+    from all source files in the program, then also delete it here.
+
+    Copyright 2017-2019 Telegram Systems LLP
+*/
+#include "td/actor/actor.h"
+#include "td/utils/buffer.h"
+#include "td/utils/port/IPAddress.h"
+#include "td/net/UdpServer.h"
+#include "td/utils/port/signals.h"
+#include "td/utils/OptionsParser.h"
+#include "td/utils/FileLog.h"
+#include "td/utils/port/path.h"
+#include "td/utils/port/user.h"
+#include "td/utils/filesystem.h"
+#include "common/checksum.h"
+#include "common/errorcode.h"
+#include "tl-utils/tl-utils.hpp"
+#include "auto/tl/ton_api_json.h"
+#include "adnl/adnl.h"
+#include <map>
+
+#if TD_DARWIN || TD_LINUX
+#include <unistd.h>
+#endif
+
+namespace ton {
+
+namespace adnl {
+
+class Callback : public adnl::Adnl::Callback {
+ public:
+  void receive_message(AdnlNodeIdShort src, AdnlNodeIdShort dst, td::BufferSlice data) override {
+  }
+  void receive_query(AdnlNodeIdShort src, AdnlNodeIdShort dst, td::BufferSlice data,
+                     td::Promise<td::BufferSlice> promise) override {
+    TRY_RESULT_PROMISE_PREFIX(promise, f, fetch_tl_object<ton_api::adnl_ping>(std::move(data), true),
+                              "adnl.ping expected");
+    promise.set_value(create_serialize_tl_object<ton_api::adnl_pong>(f->value_));
+  }
+
+  Callback() {
+  }
+
+ private:
+};
+
+}  // namespace adnl
+
+}  // namespace ton
+
+std::atomic<bool> rotate_logs_flags{false};
+void force_rotate_logs(int sig) {
+  rotate_logs_flags.store(true);
+}
+
+int main(int argc, char *argv[]) {
+  SET_VERBOSITY_LEVEL(verbosity_INFO);
+
+  ton::PrivateKey pk;
+  td::IPAddress addr;
+
+  td::set_default_failure_signal_handler().ensure();
+
+  std::unique_ptr<td::LogInterface> logger_;
+  SCOPE_EXIT {
+    td::log_interface = td::default_log_interface;
+  };
+
+  std::string config = "/var/ton-work/etc/adnl-proxy.conf.json";
+
+  td::OptionsParser p;
+  p.set_description("adnl pinger");
+  p.add_option('v', "verbosity", "set verbosity level", [&](td::Slice arg) {
+    int v = VERBOSITY_NAME(FATAL) + (td::to_integer<int>(arg));
+    SET_VERBOSITY_LEVEL(v);
+    return td::Status::OK();
+  });
+  p.add_option('h', "help", "prints_help", [&]() {
+    char b[10240];
+    td::StringBuilder sb(td::MutableSlice{b, 10000});
+    sb << p;
+    std::cout << sb.as_cslice().c_str();
+    std::exit(2);
+    return td::Status::OK();
+  });
+  p.add_option('d', "daemonize", "set SIGHUP", [&]() {
+#if TD_DARWIN || TD_LINUX
+    close(0);
+    setsid();
+#endif
+    td::set_signal_handler(td::SignalType::HangUp, force_rotate_logs).ensure();
+    return td::Status::OK();
+  });
+  p.add_option('l', "logname", "log to file", [&](td::Slice fname) {
+    auto F = std::make_unique<td::FileLog>();
+    TRY_STATUS(F->init(fname.str(), std::numeric_limits<td::uint64>::max(), true));
+    logger_ = std::move(F);
+    td::log_interface = logger_.get();
+    return td::Status::OK();
+  });
+  td::uint32 threads = 7;
+  p.add_option('t', "threads", PSTRING() << "number of threads (default=" << threads << ")", [&](td::Slice fname) {
+    td::int32 v;
+    try {
+      v = std::stoi(fname.str());
+    } catch (...) {
+      return td::Status::Error(ton::ErrorCode::error, "bad value for --threads: not a number");
+    }
+    if (v < 1 || v > 256) {
+      return td::Status::Error(ton::ErrorCode::error, "bad value for --threads: should be in range [1..256]");
+    }
+    threads = v;
+    return td::Status::OK();
+  });
+  p.add_option('u', "user", "change user", [&](td::Slice user) { return td::change_user(user); });
+  p.add_option('k', "key", "private key", [&](td::Slice key) {
+    TRY_RESULT_ASSIGN(pk, ton::PrivateKey::import(key));
+    return td::Status::OK();
+  });
+  p.add_option('a', "addr", "ip:port of instance", [&](td::Slice key) {
+    TRY_STATUS(addr.init_host_port(key.str()));
+    return td::Status::OK();
+  });
+
+  p.run(argc, argv).ensure();
+
+  if (pk.empty()) {
+    LOG(FATAL) << "no --key given";
+  }
+  if (!addr.is_valid()) {
+    LOG(FATAL) << "no --addr given";
+  }
+
+  td::actor::Scheduler scheduler({threads});
+
+  td::actor::ActorOwn<ton::keyring::Keyring> keyring;
+  td::actor::ActorOwn<ton::adnl::Adnl> adnl;
+  td::actor::ActorOwn<ton::adnl::AdnlNetworkManager> network_manager;
+
+  auto pub = pk.compute_public_key();
+
+  scheduler.run_in_context([&]() {
+    keyring = ton::keyring::Keyring::create("");
+    td::actor::send_closure(keyring, &ton::keyring::Keyring::add_key, std::move(pk), true, [](td::Unit) {});
+
+    adnl = ton::adnl::Adnl::create("", keyring.get());
+
+    network_manager = ton::adnl::AdnlNetworkManager::create(static_cast<td::uint16>(addr.get_port()));
+
+    td::actor::send_closure(network_manager, &ton::adnl::AdnlNetworkManager::add_self_addr, addr, 0);
+
+    auto tladdr = ton::create_tl_object<ton::ton_api::adnl_address_udp>(addr.get_ipv4(), addr.get_port());
+    auto addr_vec = std::vector<ton::tl_object_ptr<ton::ton_api::adnl_Address>>();
+    addr_vec.push_back(std::move(tladdr));
+    auto tladdrlist = ton::create_tl_object<ton::ton_api::adnl_addressList>(
+        std::move(addr_vec), ton::adnl::Adnl::adnl_start_time(), ton::adnl::Adnl::adnl_start_time(), 0, 2000000000);
+    auto addrlist = ton::adnl::AdnlAddressList::create(tladdrlist).move_as_ok();
+
+    td::actor::send_closure(adnl, &ton::adnl::Adnl::add_id, ton::adnl::AdnlNodeIdFull{pub}, std::move(addrlist));
+    td::actor::send_closure(adnl, &ton::adnl::Adnl::subscribe, ton::adnl::AdnlNodeIdShort{pub.compute_short_id()},
+                            ton::adnl::Adnl::int_to_bytestring(ton::ton_api::adnl_ping::ID),
+                            std::make_unique<ton::adnl::Callback>());
+  });
+
+  while (scheduler.run(1)) {
+    if (rotate_logs_flags.exchange(false)) {
+      if (td::log_interface) {
+        td::log_interface->rotate();
+      }
+    }
+  }
+}

crypto/block/mc-config.cpp

@@ -67,7 +67,7 @@ td::Result<std::unique_ptr<Config>> Config::extract_from_key_block(Ref<vm::Cell>
         tlb::unpack_cell(extra.custom->prefetch_ref(), mc_extra) && mc_extra.key_block && mc_extra.config.not_null())) {
     return td::Status::Error(-400, "cannot unpack extra header of key block to extract configuration");
   }
-  return block::Config::unpack_config(std::move(mc_extra.config));
+  return block::Config::unpack_config(std::move(mc_extra.config), mode);
 }
 
 td::Result<std::unique_ptr<Config>> Config::extract_from_state(Ref<vm::Cell> mc_state_root, int mode) {
@@ -1482,6 +1482,7 @@ std::vector<ton::ValidatorDescr> Config::compute_validator_set(ton::ShardIdFull
 std::vector<ton::ValidatorDescr> Config::compute_validator_set(ton::ShardIdFull shard, ton::UnixTime time,
                                                                ton::CatchainSeqno cc_seqno) const {
   if (!cur_validators_) {
+    LOG(DEBUG) << "failed to compute validator set: cur_validators_ is empty";
     return {};
   } else {
     return compute_validator_set(shard, *cur_validators_, time, cc_seqno);

tl/generate/scheme/ton_api.tl

@@ -498,6 +498,14 @@ engine.adnlProxy.config ports:(vector engine.adnlProxy.port) = engine.adnlProxy.
 
 ---types---
 
+adnl.pong value:long = adnl.Pong;
+
+---functions---
+
+adnl.ping value:long = adnl.Pong;
+
+---types---
+
 engine.validator.keyHash key_hash:int256 = engine.validator.KeyHash;
 engine.validator.signature signature:bytes = engine.validator.Signature;
 
@@ -513,6 +521,9 @@ engine.validator.jsonConfig data:string = engine.validator.JsonConfig;
 
 engine.validator.electionBid election_date:int perm_key:int256 adnl_addr:int256 to_send_payload:bytes = engine.validator.ElectionBid; 
 
+engine.validator.dhtServerStatus id:int256 status:int = engine.validator.DhtServerStatus;
+engine.validator.dhtServersStatus servers:(vector engine.validator.dhtServerStatus) = engine.validator.DhtServersStatus;
+
 ---functions---
 
 engine.validator.getTime = engine.validator.Time;
@@ -550,4 +561,6 @@ engine.validator.setVerbosity verbosity:int = engine.validator.Success;
 
 engine.validator.createElectionBid election_date:int election_addr:string wallet:string = engine.validator.ElectionBid;
 
+engine.validator.checkDhtServers id:int256 = engine.validator.DhtServersStatus;
+
 engine.validator.controlQuery data:bytes = Object;

tl/generate/scheme/ton_api.tlo

@@ -655,3 +655,23 @@ td::Status CreateElectionBidQuery::receive(td::BufferSlice data) {
   TRY_STATUS(td::write_file(fname_, f->to_send_payload_.as_slice()));
   return td::Status::OK();
 }
+
+td::Status CheckDhtServersQuery::run() {
+  TRY_RESULT_ASSIGN(id_, tokenizer_.get_token<ton::PublicKeyHash>());
+  return td::Status::OK();
+}
+
+td::Status CheckDhtServersQuery::send() {
+  auto b = ton::create_serialize_tl_object<ton::ton_api::engine_validator_checkDhtServers>(id_.tl());
+  td::actor::send_closure(console_, &ValidatorEngineConsole::envelope_send_query, std::move(b), create_promise());
+  return td::Status::OK();
+}
+
+td::Status CheckDhtServersQuery::receive(td::BufferSlice data) {
+  TRY_RESULT_PREFIX(f, ton::fetch_tl_object<ton::ton_api::engine_validator_dhtServersStatus>(data.as_slice(), true),
+                    "received incorrect answer: ");
+  for (auto &s : f->servers_) {
+    td::TerminalIO::out() << "id=" << s->id_ << " status=" << (s->status_ ? "SUCCESS" : "FAIL") << "\n";
+  }
+  return td::Status::OK();
+}

validator-engine-console/validator-engine-console-query.cpp

@@ -821,3 +821,24 @@ class CreateElectionBidQuery : public Query {
   std::string fname_;
 };
 
+class CheckDhtServersQuery : public Query {
+ public:
+  CheckDhtServersQuery(td::actor::ActorId<ValidatorEngineConsole> console, Tokenizer tokenizer)
+      : Query(console, std::move(tokenizer)) {
+  }
+  td::Status run() override;
+  td::Status send() override;
+  td::Status receive(td::BufferSlice data) override;
+  static std::string get_name() {
+    return "checkdht";
+  }
+  static std::string get_help() {
+    return "checkdht <adnlid>\tchecks, which root DHT servers are accessible from this ADNL addr";
+  }
+  std::string name() const override {
+    return get_name();
+  }
+
+ private:
+  ton::PublicKeyHash id_;
+};

validator-engine-console/validator-engine-console-query.h

@@ -130,6 +130,7 @@ void ValidatorEngineConsole::run() {
   add_query_runner(std::make_unique<QueryRunnerImpl<AddNetworkAddressQuery>>());
   add_query_runner(std::make_unique<QueryRunnerImpl<AddNetworkProxyAddressQuery>>());
   add_query_runner(std::make_unique<QueryRunnerImpl<CreateElectionBidQuery>>());
+  add_query_runner(std::make_unique<QueryRunnerImpl<CheckDhtServersQuery>>());
 }
 
 bool ValidatorEngineConsole::envelope_send_query(td::BufferSlice query, td::Promise<td::BufferSlice> promise) {