Add getvalidatorsessions query to validator-engine-console

test/test-validator-session-state.cpp

@@ -103,6 +103,10 @@ class Description : public ton::validatorsession::ValidatorSessionDescription {
   td::uint32 get_max_priority() const override {
     return opts_.round_candidates - 1;
   }
+  td::uint32 get_node_by_priority(td::uint32 round, td::uint32 priority) const override {
+    CHECK(priority <= get_max_priority());
+    return (round + priority) % get_total_nodes();
+  }
   td::uint32 get_unixtime(td::uint64 ts) const override {
     return static_cast<td::uint32>(ts >> 32);
   }

tl/generate/scheme/ton_api.tl

@@ -630,6 +630,8 @@ engine.validator.overlayStatsNode adnl_id:int256 ip_addr:string bdcst_errors:int
 engine.validator.overlayStats overlay_id:int256 overlay_id_full:PublicKey adnl_id:int256 scope:string nodes:(vector engine.validator.overlayStatsNode) stats:(vector engine.validator.oneStat) = engine.validator.OverlayStats;
 engine.validator.overlaysStats overlays:(vector engine.validator.overlayStats) = engine.validator.OverlaysStats;
 
+engine.validator.validatorSessionInfo current_block:tonNode.blockId self:int256 current_round:int next_producers:(vector int256) = engine.validator.ValidatorSessionInfo;
+engine.validator.validatorSessionsInfo sessions:(vector engine.validator.validatorSessionInfo) = engine.validator.ValidatorSessionsInfo;
 
 ---functions---
 
@@ -680,6 +682,8 @@ engine.validator.importCertificate overlay_id:int256 local_id:adnl.id.short sign
 engine.validator.signShardOverlayCertificate workchain:int shard:long signed_key:engine.validator.KeyHash expire_at:int max_size:int = overlay.Certificate;
 engine.validator.importShardOverlayCertificate workchain:int shard:long signed_key:engine.validator.KeyHash cert:overlay.Certificate = engine.validator.Success;
 
+engine.validator.getValidatorSessionsInfo = engine.validator.ValidatorSessionsInfo;
+
 ---types---
 
 storage.pong = storage.Pong;

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

@@ -32,6 +32,9 @@
 #include "terminal/terminal.h"
 #include "td/utils/filesystem.h"
 #include "overlay/overlays.h"
+#include "ton/ton-tl.hpp"
+#include "auto/tl/ton_api_json.h"
+#include "tl/tl_json.h"
 
 #include <cctype>
 #include <fstream>
@@ -1005,3 +1008,23 @@ td::Status ImportShardOverlayCertificateQuery::receive(td::BufferSlice data) {
   td::TerminalIO::out() << "successfully sent certificate to overlay manager\n";
   return td::Status::OK();
 }
+
+td::Status GetValidatorSessionsInfoQuery::run() {
+  TRY_STATUS(tokenizer_.check_endl());
+  return td::Status::OK();
+}
+
+td::Status GetValidatorSessionsInfoQuery::send() {
+  auto b = ton::create_serialize_tl_object<ton::ton_api::engine_validator_getValidatorSessionsInfo>();
+  td::actor::send_closure(console_, &ValidatorEngineConsole::envelope_send_query, std::move(b), create_promise());
+  return td::Status::OK();
+}
+
+td::Status GetValidatorSessionsInfoQuery::receive(td::BufferSlice data) {
+  TRY_RESULT_PREFIX(
+      f, ton::fetch_tl_object<ton::ton_api::engine_validator_validatorSessionsInfo>(data.as_slice(), true),
+      "received incorrect answer: ");
+  std::string s = td::json_encode<std::string>(td::ToJson(*f), true);
+  td::TerminalIO::out() << "---------\n" << s << "--------\n";
+  return td::Status::OK();
+}

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

@@ -1075,3 +1075,23 @@ class ImportShardOverlayCertificateQuery : public Query {
   std::string in_file_;
 };
 
+class GetValidatorSessionsInfoQuery : public Query {
+ public:
+  GetValidatorSessionsInfoQuery(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 "getvalidatorsessions";
+  }
+  static std::string get_help() {
+    return "getvalidatorsessions\tprint info about validator session";
+  }
+  std::string name() const override {
+    return get_name();
+  }
+
+ private:
+};

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

@@ -140,6 +140,7 @@ void ValidatorEngineConsole::run() {
   add_query_runner(std::make_unique<QueryRunnerImpl<GetOverlaysStatsJsonQuery>>());
   add_query_runner(std::make_unique<QueryRunnerImpl<ImportShardOverlayCertificateQuery>>());
   add_query_runner(std::make_unique<QueryRunnerImpl<SignShardOverlayCertificateQuery>>());
+  add_query_runner(std::make_unique<QueryRunnerImpl<GetValidatorSessionsInfoQuery>>());
 }
 
 bool ValidatorEngineConsole::envelope_send_query(td::BufferSlice query, td::Promise<td::BufferSlice> promise) {

validator-engine/validator-engine.cpp

@@ -3280,6 +3280,33 @@ void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_getOverla
                           });
 }
 
+void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_getValidatorSessionsInfo &query,
+                                        td::BufferSlice data, ton::PublicKeyHash src, td::uint32 perm,
+                                        td::Promise<td::BufferSlice> promise) {
+  if (!(perm & ValidatorEnginePermissions::vep_default)) {
+    promise.set_value(create_control_query_error(td::Status::Error(ton::ErrorCode::error, "not authorized")));
+    return;
+  }
+
+  if (validator_manager_.empty()) {
+    promise.set_value(
+        create_control_query_error(td::Status::Error(ton::ErrorCode::notready, "validator manager not started")));
+    return;
+  }
+
+  auto P = td::PromiseCreator::lambda(
+      [promise = std::move(promise)](
+          td::Result<ton::tl_object_ptr<ton::ton_api::engine_validator_validatorSessionsInfo>> R) mutable {
+        if (R.is_error()) {
+          promise.set_value(create_control_query_error(R.move_as_error()));
+        } else {
+          promise.set_value(ton::serialize_tl_object(R.move_as_ok(), true));
+        }
+      });
+  td::actor::send_closure(validator_manager_, &ton::validator::ValidatorManagerInterface::get_validator_sessions_info,
+                          std::move(P));
+}
+
 void ValidatorEngine::process_control_query(td::uint16 port, ton::adnl::AdnlNodeIdShort src,
                                             ton::adnl::AdnlNodeIdShort dst, td::BufferSlice data,
                                             td::Promise<td::BufferSlice> promise) {

validator-engine/validator-engine.hpp

@@ -407,6 +407,8 @@ class ValidatorEngine : public td::actor::Actor {
                          ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise);
   void run_control_query(ton::ton_api::engine_validator_getOverlaysStats &query, td::BufferSlice data,
                          ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise);
+  void run_control_query(ton::ton_api::engine_validator_getValidatorSessionsInfo &query, td::BufferSlice data,
+                         ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise);
   template <class T>
   void run_control_query(T &query, td::BufferSlice data, ton::PublicKeyHash src, td::uint32 perm,
                          td::Promise<td::BufferSlice> promise) {

validator-session/validator-session-description.cpp

@@ -79,6 +79,11 @@ td::uint32 ValidatorSessionDescriptionImpl::get_max_priority() const {
   return opts_.round_candidates - 1;
 }
 
+td::uint32 ValidatorSessionDescriptionImpl::get_node_by_priority(td::uint32 round, td::uint32 priority) const {
+  CHECK(priority <= get_max_priority());
+  return (round + priority) % get_total_nodes();
+}
+
 ValidatorSessionCandidateId ValidatorSessionDescriptionImpl::candidate_id(
     td::uint32 src_idx, ValidatorSessionRootHash root_hash, ValidatorSessionFileHash file_hash,
     ValidatorSessionCollatedDataFileHash collated_data_file_hash) const {

validator-session/validator-session-description.h

@@ -85,6 +85,7 @@ class ValidatorSessionDescription {
   virtual ValidatorWeight get_total_weight() const = 0;
   virtual td::int32 get_node_priority(td::uint32 src_idx, td::uint32 round) const = 0;
   virtual td::uint32 get_max_priority() const = 0;
+  virtual td::uint32 get_node_by_priority(td::uint32 round, td::uint32 priority) const = 0;
   virtual td::uint32 get_unixtime(td::uint64 t) const = 0;
   virtual td::uint32 get_attempt_seqno(td::uint64 t) const = 0;
   virtual td::uint32 get_self_idx() const = 0;

validator-session/validator-session-description.hpp

@@ -101,6 +101,7 @@ class ValidatorSessionDescriptionImpl : public ValidatorSessionDescription {
   }
   td::int32 get_node_priority(td::uint32 src_idx, td::uint32 round) const override;
   td::uint32 get_max_priority() const override;
+  td::uint32 get_node_by_priority(td::uint32 round, td::uint32 priority) const override;
   td::uint32 get_unixtime(td::uint64 ts) const override {
     return static_cast<td::uint32>(ts >> 32);
   }

validator-session/validator-session.cpp

@@ -19,6 +19,7 @@
 #include "validator-session.hpp"
 #include "td/utils/Random.h"
 #include "td/utils/crypto.h"
+#include "ton/ton-tl.hpp"
 
 namespace ton {
 
@@ -937,6 +938,18 @@ void ValidatorSessionImpl::stats_set_candidate_status(td::uint32 round, PublicKe
   it->block_status = status;
 }
 
+void ValidatorSessionImpl::get_session_info(
+    td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionInfo>> promise) {
+  std::vector<td::Bits256> next_producers;
+  for (td::uint32 round = cur_round_; round < cur_round_ + 20; ++round) {
+    td::uint32 node = description().get_node_by_priority(round, 0);
+    next_producers.push_back(description().get_source_id(node).bits256_value());
+  }
+  promise.set_result(create_tl_object<ton_api::engine_validator_validatorSessionInfo>(
+      create_tl_block_id_simple(BlockId{}), description().get_source_id(local_idx()).bits256_value(),
+      cur_round_, std::move(next_producers)));
+}
+
 td::actor::ActorOwn<ValidatorSession> ValidatorSession::create(
     catchain::CatChainSessionId session_id, ValidatorSessionOptions opts, PublicKeyHash local_id,
     std::vector<ValidatorSessionNode> nodes, std::unique_ptr<Callback> callback,

validator-session/validator-session.h

@@ -92,6 +92,8 @@ class ValidatorSession : public td::actor::Actor {
   virtual void start() = 0;
   virtual void destroy() = 0;
 
+  virtual void get_session_info(td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionInfo>> promise) = 0;
+
   static td::actor::ActorOwn<ValidatorSession> create(
       catchain::CatChainSessionId session_id, ValidatorSessionOptions opts, PublicKeyHash local_id,
       std::vector<ValidatorSessionNode> nodes, std::unique_ptr<Callback> callback,

validator-session/validator-session.hpp

@@ -159,6 +159,8 @@ class ValidatorSessionImpl : public ValidatorSession {
   void stats_add_round();
   void stats_set_candidate_status(td::uint32 round, PublicKeyHash src, int status);
 
+  void get_session_info(td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionInfo>> promise) override;
+
  public:
   ValidatorSessionImpl(catchain::CatChainSessionId session_id, ValidatorSessionOptions opts, PublicKeyHash local_id,
                        std::vector<ValidatorSessionNode> nodes, std::unique_ptr<Callback> callback,

validator/manager-disk.hpp

@@ -367,6 +367,10 @@ class ValidatorManagerImpl : public ValidatorManager {
   void log_validator_session_stats(BlockIdExt block_id, validatorsession::ValidatorSessionStats stats) override {
     UNREACHABLE();
   }
+  void get_validator_sessions_info(
+      td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionsInfo>> promise) override {
+    UNREACHABLE();
+  }
 
  private:
   PublicKeyHash local_id_;

validator/manager-hardfork.hpp

@@ -426,6 +426,10 @@ class ValidatorManagerImpl : public ValidatorManager {
   void log_validator_session_stats(BlockIdExt block_id, validatorsession::ValidatorSessionStats stats) override {
     UNREACHABLE();
   }
+  void get_validator_sessions_info(
+      td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionsInfo>> promise) override {
+    UNREACHABLE();
+  }
 
  private:
   td::Ref<ValidatorManagerOptions> opts_;

validator/manager.cpp

@@ -2539,7 +2539,7 @@ void ValidatorManagerImpl::log_validator_session_stats(BlockIdExt block_id,
       stats.creator.bits256_value(), stats.total_validators, stats.total_weight, stats.signatures,
       stats.signatures_weight, stats.approve_signatures, stats.approve_signatures_weight, stats.first_round,
       std::move(rounds));
-  std::string s = td::json_encode<std::string>(td::ToJson(*obj.get()), false);
+  std::string s = td::json_encode<std::string>(td::ToJson(*obj), false);
   s.erase(std::remove_if(s.begin(), s.end(), [](char c) { return c == '\n' || c == '\r'; }), s.end());
 
   std::ofstream file;
@@ -2550,6 +2550,39 @@ void ValidatorManagerImpl::log_validator_session_stats(BlockIdExt block_id,
   LOG(INFO) << "Writing validator session stats for " << block_id.id;
 }
 
+void ValidatorManagerImpl::get_validator_sessions_info(
+    td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionsInfo>> promise) {
+  std::vector<td::actor::ActorId<ValidatorGroup>> groups;
+  for (const auto& g : validator_groups_) {
+    groups.push_back(g.second.get());
+  }
+  struct IntermediateData {
+    std::vector<td::actor::ActorId<ValidatorGroup>> groups;
+    std::vector<tl_object_ptr<ton_api::engine_validator_validatorSessionInfo>> result;
+    td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionsInfo>> promise;
+
+    static void step(IntermediateData data) {
+      if (data.groups.empty()) {
+        data.promise.set_result(
+            create_tl_object<ton_api::engine_validator_validatorSessionsInfo>(std::move(data.result)));
+        return;
+      }
+      auto group = std::move(data.groups.back());
+      data.groups.pop_back();
+      auto P = td::PromiseCreator::lambda(
+          [data =
+               std::move(data)](td::Result<tl_object_ptr<ton_api::engine_validator_validatorSessionInfo>> R) mutable {
+            if (R.is_ok()) {
+              data.result.push_back(R.move_as_ok());
+            }
+            step(std::move(data));
+          });
+      td::actor::send_closure(group, &ValidatorGroup::get_session_info, std::move(P));
+    }
+  };
+  IntermediateData::step({std::move(groups), {}, std::move(promise)});
+}
+
 td::actor::ActorOwn<ValidatorManagerInterface> ValidatorManagerFactory::create(
     td::Ref<ValidatorManagerOptions> opts, std::string db_root, td::actor::ActorId<keyring::Keyring> keyring,
     td::actor::ActorId<adnl::Adnl> adnl, td::actor::ActorId<rldp::Rldp> rldp,

validator/manager.hpp

@@ -531,8 +531,10 @@ class ValidatorManagerImpl : public ValidatorManager {
   void wait_shard_client_state(BlockSeqno seqno, td::Timestamp timeout, td::Promise<td::Unit> promise) override;
 
   void log_validator_session_stats(BlockIdExt block_id, validatorsession::ValidatorSessionStats stats) override;
+  void get_validator_sessions_info(
+      td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionsInfo>> promise) override;
 
- private:
+    private:
   td::Timestamp resend_shard_blocks_at_;
   td::Timestamp check_waiters_at_;
   td::Timestamp check_shard_clients_;

validator/validator-group.cpp

@@ -21,6 +21,7 @@
 #include "ton/ton-io.hpp"
 #include "td/utils/overloaded.h"
 #include "common/delay.h"
+#include "ton/ton-tl.hpp"
 
 namespace ton {
 
@@ -159,14 +160,18 @@ void ValidatorGroup::get_approved_candidate(PublicKey source, RootHash root_hash
                           std::move(promise));
 }
 
-BlockIdExt ValidatorGroup::create_next_block_id(RootHash root_hash, FileHash file_hash) const {
+BlockId ValidatorGroup::create_next_block_id_simple() const {
   BlockSeqno seqno = 0;
   for (auto &p : prev_block_ids_) {
     if (seqno < p.id.seqno) {
       seqno = p.id.seqno;
     }
   }
-  return BlockIdExt{shard_.workchain, shard_.shard, seqno + 1, root_hash, file_hash};
+  return BlockId{shard_.workchain, shard_.shard, seqno + 1};
+}
+
+BlockIdExt ValidatorGroup::create_next_block_id(RootHash root_hash, FileHash file_hash) const {
+  return BlockIdExt{create_next_block_id_simple(), root_hash, file_hash};
 }
 
 std::unique_ptr<validatorsession::ValidatorSession::Callback> ValidatorGroup::make_validator_session_callback() {
@@ -307,6 +312,25 @@ void ValidatorGroup::destroy() {
   stop();
 }
 
+void ValidatorGroup::get_session_info(
+    td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionInfo>> promise) {
+  if (session_.empty() || !started_) {
+    promise.set_error(td::Status::Error(ErrorCode::notready, "session not started"));
+  }
+  auto P = td::PromiseCreator::lambda(
+      [promise = std::move(promise), block_id = create_next_block_id_simple()](
+          td::Result<tl_object_ptr<ton_api::engine_validator_validatorSessionInfo>> R) mutable {
+        if (R.is_error()) {
+          promise.set_error(R.move_as_error());
+          return;
+        }
+        auto info = R.move_as_ok();
+        info->current_block_ = create_tl_block_id_simple(block_id);
+        promise.set_result(std::move(info));
+      });
+  td::actor::send_closure(session_, &validatorsession::ValidatorSession::get_session_info, std::move(P));
+}
+
 }  // namespace validator
 
 }  // namespace ton

validator/validator-group.hpp

@@ -44,6 +44,7 @@ class ValidatorGroup : public td::actor::Actor {
                                 td::Promise<td::Unit> promise);
   void get_approved_candidate(PublicKey source, RootHash root_hash, FileHash file_hash,
                               FileHash collated_data_file_hash, td::Promise<BlockCandidate> promise);
+  BlockId create_next_block_id_simple() const;
   BlockIdExt create_next_block_id(RootHash root_hash, FileHash file_hash) const;
 
   void start(std::vector<BlockIdExt> prev, BlockIdExt min_masterchain_block_id, UnixTime min_ts);
@@ -56,6 +57,8 @@ class ValidatorGroup : public td::actor::Actor {
     }
   }
 
+  void get_session_info(td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionInfo>> promise);
+
   ValidatorGroup(ShardIdFull shard, PublicKeyHash local_id, ValidatorSessionId session_id,
                  td::Ref<ValidatorSet> validator_set, validatorsession::ValidatorSessionOptions config,
                  td::actor::ActorId<keyring::Keyring> keyring, td::actor::ActorId<adnl::Adnl> adnl,

validator/validator.h

@@ -214,6 +214,8 @@ class ValidatorManagerInterface : public td::actor::Actor {
 
   virtual void run_ext_query(td::BufferSlice data, td::Promise<td::BufferSlice> promise) = 0;
   virtual void prepare_stats(td::Promise<std::vector<std::pair<std::string, std::string>>> promise) = 0;
+  virtual void get_validator_sessions_info(
+      td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionsInfo>> promise) = 0;
 };
 
 }  // namespace validator