Add getvalidatorsessions query to validator-engine-console

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