From 9452c367e403b2b222992871535a20f242373c23 Mon Sep 17 00:00:00 2001 From: EmelyanenkoK Date: Tue, 26 Mar 2024 14:51:06 +0300 Subject: [PATCH] LS queries to nonfinal blocks (#941) Co-authored-by: SpyCheese --- tl-utils/lite-utils.cpp | 4 +- tl/generate/scheme/lite_api.tl | 9 + tl/generate/scheme/lite_api.tlo | Bin 15368 -> 16988 bytes validator-engine/validator-engine.cpp | 4 + validator-engine/validator-engine.hpp | 4 + validator-session/validator-session-state.h | 22 ++ validator-session/validator-session.cpp | 47 +++++ validator-session/validator-session.h | 4 + validator-session/validator-session.hpp | 3 + validator/impl/CMakeLists.txt | 2 + validator/impl/candidates-buffer.cpp | 213 +++++++++++++++++++ validator/impl/candidates-buffer.hpp | 64 ++++++ validator/impl/liteserver.cpp | 217 +++++++++++--------- validator/impl/liteserver.hpp | 2 + validator/interfaces/validator-manager.h | 20 +- validator/manager-disk.hpp | 21 +- validator/manager-hardfork.hpp | 21 +- validator/manager.cpp | 196 +++++++++++++++--- validator/manager.hpp | 24 ++- validator/validator-group.cpp | 58 +++++- validator/validator-group.hpp | 15 ++ validator/validator-options.hpp | 7 + validator/validator.h | 2 + 23 files changed, 809 insertions(+), 150 deletions(-) create mode 100644 validator/impl/candidates-buffer.cpp create mode 100644 validator/impl/candidates-buffer.hpp diff --git a/tl-utils/lite-utils.cpp b/tl-utils/lite-utils.cpp index 427852cb..99e22f83 100644 --- a/tl-utils/lite-utils.cpp +++ b/tl-utils/lite-utils.cpp @@ -155,7 +155,9 @@ std::string lite_query_name_by_id(int id) { {lite_api::liteServer_getConfigParams::ID, "getConfigParams"}, {lite_api::liteServer_getValidatorStats::ID, "getValidatorStats"}, {lite_api::liteServer_getLibraries::ID, "getLibraries"}, - {lite_api::liteServer_getShardBlockProof::ID, "getShardBlockProof"}}; + {lite_api::liteServer_getShardBlockProof::ID, "getShardBlockProof"}, + {lite_api::liteServer_nonfinal_getCandidate::ID, "nonfinal.getCandidate"}, + {lite_api::liteServer_nonfinal_getValidatorGroups::ID, "nonfinal.getValidatorGroups"}}; auto it = names.find(id); if (it == names.end()) { return "unknown"; diff --git a/tl/generate/scheme/lite_api.tl b/tl/generate/scheme/lite_api.tl index e1e28b9f..f0439a29 100644 --- a/tl/generate/scheme/lite_api.tl +++ b/tl/generate/scheme/lite_api.tl @@ -60,6 +60,12 @@ liteServer.lookupBlockResult id:tonNode.blockIdExt mode:# mc_block_id:tonNode.bl liteServer.debug.verbosity value:int = liteServer.debug.Verbosity; +liteServer.nonfinal.candidateId block_id:tonNode.blockIdExt creator:int256 collated_data_hash:int256 = liteServer.nonfinal.CandidateId; +liteServer.nonfinal.candidate id:liteServer.nonfinal.candidateId data:bytes collated_data:bytes = liteServer.nonfinal.Candidate; +liteServer.nonfinal.candidateInfo id:liteServer.nonfinal.candidateId available:Bool approved_weight:long signed_weight:long total_weight:long = liteServer.nonfinal.CandidateInfo; +liteServer.nonfinal.validatorGroupInfo next_block_id:tonNode.blockId cc_seqno:int prev:(vector tonNode.blockIdExt) candidates:(vector liteServer.nonfinal.candidateInfo) = liteServer.nonfinal.ValidatorGroupInfo; +liteServer.nonfinal.validatorGroups groups:(vector liteServer.nonfinal.validatorGroupInfo) = liteServer.nonfinal.ValidatorGroups; + ---functions--- liteServer.getMasterchainInfo = liteServer.MasterchainInfo; @@ -89,6 +95,9 @@ liteServer.getLibraries library_list:(vector int256) = liteServer.LibraryResult; liteServer.getLibrariesWithProof id:tonNode.blockIdExt mode:# library_list:(vector int256) = liteServer.LibraryResultWithProof; liteServer.getShardBlockProof id:tonNode.blockIdExt = liteServer.ShardBlockProof; +liteServer.nonfinal.getValidatorGroups mode:# wc:mode.0?int shard:mode.1?long = liteServer.nonfinal.ValidatorGroups; +liteServer.nonfinal.getCandidate id:liteServer.nonfinal.candidateId = liteServer.nonfinal.Candidate; + liteServer.queryPrefix = Object; liteServer.query data:bytes = Object; liteServer.waitMasterchainSeqno seqno:int timeout_ms:int = Object; // query prefix diff --git a/tl/generate/scheme/lite_api.tlo b/tl/generate/scheme/lite_api.tlo index 06c082586eff2976ffc6b0b7cb44300126bffab9..d2f67846100190fd875c542232c993e0b610847e 100644 GIT binary patch delta 1061 zcmeCExYNSO`)Ibl6$2DlY~;1(RO)d%+#s8iS&|x@T2z)=q?ebUmzJ5An4{;Mn3s~7 zl30>Dah;UPyLy&TdAzDTQzl-J(74L@##a%)y1cY}1_q#7o#kEEeyU+p8m8XABMSLL{3aE1)r2G10bnw!Uje3*e6 zrJvo`f~L5QiA-61qDUnr)H*SlrT(=RS_5D zEzV5OLx=%G1}MtUQ<7hjm;+PDFuC1OHX39PviopGZW(6eg4BY7hXv|1-n`U`l6Y7c zF-+FCkmTe@PL3~5EzHZG9LOy`c>x~_D@#F9YT4vKefh~>_yst*VE&#wQCU6( h; for (auto &x : conf.validator_->hardforks_) { @@ -3820,6 +3821,9 @@ int main(int argc, char *argv[]) { p.add_option('\0', "disable-rocksdb-stats", "disable gathering rocksdb statistics (enabled by default)", [&]() { acts.push_back([&x]() { td::actor::send_closure(x, &ValidatorEngine::set_disable_rocksdb_stats, true); }); }); + p.add_option('\0', "nonfinal-ls", "enable special LS queries to non-finalized blocks", [&]() { + acts.push_back([&x]() { td::actor::send_closure(x, &ValidatorEngine::set_nonfinal_ls_queries_enabled); }); + }); auto S = p.run(argc, argv); if (S.is_error()) { LOG(ERROR) << "failed to parse options: " << S.move_as_error(); diff --git a/validator-engine/validator-engine.hpp b/validator-engine/validator-engine.hpp index b39b6438..84a5e67f 100644 --- a/validator-engine/validator-engine.hpp +++ b/validator-engine/validator-engine.hpp @@ -207,6 +207,7 @@ class ValidatorEngine : public td::actor::Actor { size_t max_open_archive_files_ = 0; double archive_preload_period_ = 0.0; bool disable_rocksdb_stats_ = false; + bool nonfinal_ls_queries_enabled_ = false; bool read_config_ = false; bool started_keyring_ = false; bool started_ = false; @@ -276,6 +277,9 @@ class ValidatorEngine : public td::actor::Actor { void set_disable_rocksdb_stats(bool value) { disable_rocksdb_stats_ = value; } + void set_nonfinal_ls_queries_enabled() { + nonfinal_ls_queries_enabled_ = true; + } void start_up() override; ValidatorEngine() { } diff --git a/validator-session/validator-session-state.h b/validator-session/validator-session-state.h index f827b3fc..35910535 100644 --- a/validator-session/validator-session-state.h +++ b/validator-session/validator-session-state.h @@ -376,6 +376,15 @@ class ValidatorSessionRoundState : public ValidatorSessionDescription::RootObjec void dump(ValidatorSessionDescription& desc, td::StringBuilder& sb, td::uint32 att) const; void dump_cur_attempt(ValidatorSessionDescription& desc, td::StringBuilder& sb) const; + void for_each_sent_block(std::function foo) const { + if (!sent_blocks_) { + return; + } + for (td::uint32 i = 0; i < sent_blocks_->size(); ++i) { + foo(sent_blocks_->at(i)); + } + } + private: const SentBlock* precommitted_block_; const td::uint32 seqno_; @@ -516,6 +525,19 @@ class ValidatorSessionState : public ValidatorSessionDescription::RootObject { cur_round_->dump_cur_attempt(desc, sb); } + void for_each_cur_round_sent_block(std::function foo) const { + cur_round_->for_each_sent_block(std::move(foo)); + } + + const SentBlock* get_cur_round_precommitted_block() const { + bool found; + return cur_round_->get_precommitted_block(found); + } + + const CntVector* get_cur_round_signatures() const { + return cur_round_->get_signatures(); + } + static const ValidatorSessionState* make_one(ValidatorSessionDescription& desc, const ValidatorSessionState* state, td::uint32 src_idx, td::uint32 att, bool& made); static const ValidatorSessionState* make_all(ValidatorSessionDescription& desc, const ValidatorSessionState* state, diff --git a/validator-session/validator-session.cpp b/validator-session/validator-session.cpp index 88de0fa5..38e2ea23 100644 --- a/validator-session/validator-session.cpp +++ b/validator-session/validator-session.cpp @@ -929,6 +929,53 @@ void ValidatorSessionImpl::get_current_stats(td::Promise promise.set_result(std::move(stats)); } +void ValidatorSessionImpl::get_validator_group_info_for_litequery( + td::uint32 cur_round, + td::Promise>> promise) { + if (cur_round != cur_round_ || real_state_->cur_round_seqno() != cur_round) { + promise.set_value({}); + return; + } + std::vector> result; + real_state_->for_each_cur_round_sent_block([&](const SessionBlockCandidate *block) { + if (block->get_block() == nullptr) { + return; + } + auto candidate = create_tl_object(); + + candidate->id_ = create_tl_object(); + candidate->id_->block_id_ = create_tl_object(); + candidate->id_->block_id_->root_hash_ = + block->get_block()->get_root_hash(); // other fields will be filled in validator-group.cpp + candidate->id_->block_id_->file_hash_ = block->get_block()->get_file_hash(); + candidate->id_->creator_ = + description().get_source_public_key(block->get_block()->get_src_idx()).ed25519_value().raw(); + candidate->id_->collated_data_hash_ = block->get_block()->get_collated_data_file_hash(); + + candidate->total_weight_ = description().get_total_weight(); + candidate->approved_weight_ = 0; + candidate->signed_weight_ = 0; + for (td::uint32 i = 0; i < description().get_total_nodes(); ++i) { + if (real_state_->check_block_is_approved_by(description(), i, block->get_id())) { + candidate->approved_weight_ += description().get_node_weight(i); + } + } + auto precommited = real_state_->get_cur_round_precommitted_block(); + if (SentBlock::get_block_id(precommited) == SentBlock::get_block_id(block->get_block())) { + auto signatures = real_state_->get_cur_round_signatures(); + if (signatures) { + for (td::uint32 i = 0; i < description().get_total_nodes(); ++i) { + if (signatures->at(i)) { + candidate->signed_weight_ += description().get_node_weight(i); + } + } + } + } + result.push_back(std::move(candidate)); + }); + promise.set_result(std::move(result)); +} + void ValidatorSessionImpl::start_up() { CHECK(!rldp_.empty()); cur_round_ = 0; diff --git a/validator-session/validator-session.h b/validator-session/validator-session.h index 3f3b7ab9..6300eaa4 100644 --- a/validator-session/validator-session.h +++ b/validator-session/validator-session.h @@ -28,6 +28,7 @@ #include "catchain/catchain-types.h" #include "validator-session-types.h" +#include "auto/tl/lite_api.h" namespace ton { @@ -92,6 +93,9 @@ class ValidatorSession : public td::actor::Actor { virtual void start() = 0; virtual void destroy() = 0; virtual void get_current_stats(td::Promise promise) = 0; + virtual void get_validator_group_info_for_litequery( + td::uint32 cur_round, + td::Promise>> promise) = 0; static td::actor::ActorOwn create( catchain::CatChainSessionId session_id, ValidatorSessionOptions opts, PublicKeyHash local_id, diff --git a/validator-session/validator-session.hpp b/validator-session/validator-session.hpp index 2dcbb46c..e61e9010 100644 --- a/validator-session/validator-session.hpp +++ b/validator-session/validator-session.hpp @@ -175,6 +175,9 @@ class ValidatorSessionImpl : public ValidatorSession { void start() override; void destroy() override; void get_current_stats(td::Promise promise) override; + void get_validator_group_info_for_litequery( + td::uint32 cur_round, + td::Promise>> promise) override; void process_blocks(std::vector blocks); void finished_processing(); diff --git a/validator/impl/CMakeLists.txt b/validator/impl/CMakeLists.txt index 7cd273f2..42dded31 100644 --- a/validator/impl/CMakeLists.txt +++ b/validator/impl/CMakeLists.txt @@ -7,6 +7,7 @@ endif() set(TON_VALIDATOR_SOURCE accept-block.cpp block.cpp + candidates-buffer.cpp check-proof.cpp collator.cpp config.cpp @@ -24,6 +25,7 @@ set(TON_VALIDATOR_SOURCE accept-block.hpp block.hpp + candidates-buffer.hpp check-proof.hpp collate-query-impl.h collator-impl.h diff --git a/validator/impl/candidates-buffer.cpp b/validator/impl/candidates-buffer.cpp new file mode 100644 index 00000000..e24913b6 --- /dev/null +++ b/validator/impl/candidates-buffer.cpp @@ -0,0 +1,213 @@ +/* + 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 . +*/ +#include "candidates-buffer.hpp" +#include "fabric.h" + +namespace ton::validator { + +void CandidatesBuffer::start_up() { + alarm_timestamp() = td::Timestamp::in(60.0); +} + +void CandidatesBuffer::alarm() { + alarm_timestamp() = td::Timestamp::in(60.0); + for (auto it = candidates_.begin(); it != candidates_.end();) { + Candidate &entry = it->second; + if (entry.ttl_.is_in_past()) { + for (auto &p : entry.data_waiters_) { + p.set_error(td::Status::Error(ErrorCode::timeout, "timeout")); + } + for (auto &p : entry.state_waiters_) { + p.set_error(td::Status::Error(ErrorCode::timeout, "timeout")); + } + it = candidates_.erase(it); + } else { + ++it; + } + } +} + +void CandidatesBuffer::add_new_candidate(BlockIdExt id, PublicKey source, FileHash collated_data_file_hash) { + auto it = candidates_.emplace(id, Candidate{}); + Candidate &entry = it.first->second; + entry.ttl_ = td::Timestamp::in(120.0); + if (!it.second) { // not inserted + return; + } + LOG(DEBUG) << "New block candidate " << id.to_str(); + entry.source_ = source; + entry.collated_data_file_hash_ = collated_data_file_hash; +} + +void CandidatesBuffer::get_block_data(BlockIdExt id, td::Promise> promise) { + auto it = candidates_.find(id); + if (it == candidates_.end()) { + promise.set_error(td::Status::Error(ErrorCode::notready, "unknown block candidate")); + return; + } + Candidate &entry = it->second; + if (entry.data_.not_null()) { + promise.set_result(entry.data_); + return; + } + entry.data_waiters_.push_back(std::move(promise)); + if (entry.data_requested_) { + return; + } + entry.data_requested_ = true; + td::actor::send_closure(manager_, &ValidatorManager::get_block_candidate_from_db, entry.source_, id, + entry.collated_data_file_hash_, [SelfId = actor_id(this), id](td::Result R) { + td::actor::send_closure(SelfId, &CandidatesBuffer::got_block_candidate, id, std::move(R)); + }); +} + +void CandidatesBuffer::got_block_candidate(BlockIdExt id, td::Result R) { + if (R.is_error()) { + finish_get_block_data(id, R.move_as_error()); + return; + } + BlockCandidate cand = R.move_as_ok(); + CHECK(cand.id == id); + finish_get_block_data(id, create_block(id, std::move(cand.data))); +} + +void CandidatesBuffer::get_block_state(BlockIdExt id, td::Promise> promise) { + auto it = candidates_.find(id); + if (it == candidates_.end()) { + promise.set_error(td::Status::Error(ErrorCode::notready, "unknown block candidate")); + return; + } + Candidate &entry = it->second; + if (entry.state_.not_null()) { + promise.set_result(entry.state_); + return; + } + entry.state_waiters_.push_back(std::move(promise)); + if (entry.state_requested_) { + return; + } + entry.state_requested_ = true; + get_block_data(id, [SelfId = actor_id(this), id](td::Result> R) { + if (R.is_error()) { + td::actor::send_closure(SelfId, &CandidatesBuffer::finish_get_block_state, id, R.move_as_error()); + return; + } + td::actor::send_closure(SelfId, &CandidatesBuffer::get_block_state_cont, id, R.move_as_ok()); + }); +} + +void CandidatesBuffer::get_block_state_cont(BlockIdExt id, td::Ref data) { + CHECK(id == data->block_id()); + std::vector prev; + BlockIdExt mc_blkid; + bool after_split; + auto S = block::unpack_block_prev_blk_ext(data->root_cell(), id, prev, mc_blkid, after_split); + if (S.is_error()) { + finish_get_block_state(id, std::move(S)); + return; + } + get_block_state_cont2(std::move(data), std::move(prev), {}); +} + +void CandidatesBuffer::get_block_state_cont2(td::Ref block, std::vector prev, + std::vector> prev_states) { + if (prev_states.size() < prev.size()) { + BlockIdExt prev_id = prev[prev_states.size()]; + td::actor::send_closure(manager_, &ValidatorManager::get_shard_state_from_db_short, prev_id, + [SelfId = actor_id(this), block = std::move(block), prev = std::move(prev), + prev_states = std::move(prev_states)](td::Result> R) mutable { + if (R.is_error()) { + td::actor::send_closure(SelfId, &CandidatesBuffer::finish_get_block_state, + block->block_id(), R.move_as_error()); + return; + } + prev_states.push_back(R.move_as_ok()); + td::actor::send_closure(SelfId, &CandidatesBuffer::get_block_state_cont2, + std::move(block), std::move(prev), std::move(prev_states)); + }); + return; + } + + BlockIdExt id = block->block_id(); + td::Ref state; + CHECK(prev_states.size() == 1 || prev_states.size() == 2); + if (prev_states.size() == 2) { // after merge + auto R = prev_states[0]->merge_with(*prev_states[1]); + if (R.is_error()) { + finish_get_block_state(id, R.move_as_error()); + return; + } + state = R.move_as_ok(); + } else if (id.shard_full() != prev[0].shard_full()) { // after split + auto R = prev_states[0]->split(); + if (R.is_error()) { + finish_get_block_state(id, R.move_as_error()); + return; + } + auto s = R.move_as_ok(); + state = is_left_child(id.shard_full()) ? std::move(s.first) : std::move(s.second); + } else { // no split/merge + state = std::move(prev_states[0]); + } + + auto S = state.write().apply_block(id, std::move(block)); + if (S.is_error()) { + finish_get_block_state(id, std::move(S)); + return; + } + finish_get_block_state(id, std::move(state)); +} + +void CandidatesBuffer::finish_get_block_data(BlockIdExt id, td::Result> res) { + auto it = candidates_.find(id); + if (it == candidates_.end()) { + return; + } + Candidate &entry = it->second; + for (auto &p : entry.data_waiters_) { + p.set_result(res.clone()); + } + entry.data_waiters_.clear(); + entry.data_requested_ = false; + if (res.is_ok()) { + entry.data_ = res.move_as_ok(); + LOG(DEBUG) << "Loaded block data for " << id.to_str(); + } else { + LOG(DEBUG) << "Failed to load block data for " << id.to_str() << ": " << res.move_as_error(); + } +} + +void CandidatesBuffer::finish_get_block_state(BlockIdExt id, td::Result> res) { + auto it = candidates_.find(id); + if (it == candidates_.end()) { + return; + } + Candidate &entry = it->second; + for (auto &p : entry.state_waiters_) { + p.set_result(res.clone()); + } + entry.state_waiters_.clear(); + entry.state_requested_ = false; + if (res.is_ok()) { + entry.state_ = res.move_as_ok(); + LOG(DEBUG) << "Loaded block state for " << id.to_str(); + } else { + LOG(DEBUG) << "Failed to load block state for " << id.to_str() << ": " << res.move_as_error(); + } +} + +} // namespace ton::validator diff --git a/validator/impl/candidates-buffer.hpp b/validator/impl/candidates-buffer.hpp new file mode 100644 index 00000000..5db1e516 --- /dev/null +++ b/validator/impl/candidates-buffer.hpp @@ -0,0 +1,64 @@ +/* + 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 . +*/ +#pragma once +#include "ton/ton-types.h" +#include "td/actor/actor.h" +#include "interfaces/validator-manager.h" + +namespace ton::validator { + +class CandidatesBuffer : public td::actor::Actor { + public: + explicit CandidatesBuffer(td::actor::ActorId manager) : manager_(std::move(manager)) { + } + + void start_up() override; + void alarm() override; + + void add_new_candidate(BlockIdExt id, PublicKey source, FileHash collated_data_file_hash); + void get_block_data(BlockIdExt id, td::Promise> promise); + void get_block_state(BlockIdExt id, td::Promise> promise); + + private: + td::actor::ActorId manager_; + + struct Candidate { + PublicKey source_; + FileHash collated_data_file_hash_; + td::Timestamp ttl_; + + td::Ref data_; + std::vector>> data_waiters_; + bool data_requested_{false}; + + td::Ref state_; + std::vector>> state_waiters_; + bool state_requested_{false}; + }; + std::map candidates_; + + void got_block_candidate(BlockIdExt id, td::Result R); + + void get_block_state_cont(BlockIdExt id, td::Ref data); + void get_block_state_cont2(td::Ref block, std::vector prev, + std::vector> prev_states); + + void finish_get_block_data(BlockIdExt id, td::Result> res); + void finish_get_block_state(BlockIdExt id, td::Result> res); +}; + +} // namespace ton::validator diff --git a/validator/impl/liteserver.cpp b/validator/impl/liteserver.cpp index 5d40b8c2..b7d97321 100644 --- a/validator/impl/liteserver.cpp +++ b/validator/impl/liteserver.cpp @@ -275,6 +275,13 @@ void LiteQuery::perform() { [&](lite_api::liteServer_getShardBlockProof& q) { this->perform_getShardBlockProof(create_block_id(q.id_)); }, + [&](lite_api::liteServer_nonfinal_getCandidate& q) { + this->perform_nonfinal_getCandidate(q.id_->creator_, create_block_id(q.id_->block_id_), + q.id_->collated_data_hash_); + }, + [&](lite_api::liteServer_nonfinal_getValidatorGroups& q) { + this->perform_nonfinal_getValidatorGroups(q.mode_, ShardIdFull{q.wc_, (ShardId)q.shard_}); + }, [&](auto& obj) { this->abort_query(td::Status::Error(ErrorCode::protoviolation, "unknown query")); })); } @@ -343,21 +350,15 @@ void LiteQuery::perform_getBlock(BlockIdExt blkid) { fatal_error("invalid BlockIdExt"); return; } - get_block_handle_checked(blkid, [manager = manager_, Self = actor_id(this), blkid](td::Result R) { - if (R.is_error()) { - td::actor::send_closure(Self, &LiteQuery::abort_query, R.move_as_error()); - return; - } - td::actor::send_closure_later(manager, &ValidatorManager::get_block_data_from_db, R.move_as_ok(), - [=](td::Result> res) { - if (res.is_error()) { - td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error()); - } else { - td::actor::send_closure_later(Self, &LiteQuery::continue_getBlock, blkid, - res.move_as_ok()); - } - }); - }); + td::actor::send_closure(manager_, &ValidatorManager::get_block_data_for_litequery, blkid, + [Self = actor_id(this), blkid](td::Result> res) { + if (res.is_error()) { + td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error()); + } else { + td::actor::send_closure_later(Self, &LiteQuery::continue_getBlock, blkid, + res.move_as_ok()); + } + }); } void LiteQuery::continue_getBlock(BlockIdExt blkid, Ref block) { @@ -375,21 +376,15 @@ void LiteQuery::perform_getBlockHeader(BlockIdExt blkid, int mode) { fatal_error("invalid BlockIdExt"); return; } - get_block_handle_checked(blkid, [=, manager = manager_, Self = actor_id(this)](td::Result R) { - if (R.is_error()) { - td::actor::send_closure(Self, &LiteQuery::abort_query, R.move_as_error()); - return; - } - td::actor::send_closure_later(manager, &ValidatorManager::get_block_data_from_db, R.move_as_ok(), - [=](td::Result> res) { - if (res.is_error()) { - td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error()); - } else { - td::actor::send_closure_later(Self, &LiteQuery::continue_getBlockHeader, blkid, - mode, res.move_as_ok()); - } - }); - }); + td::actor::send_closure(manager_, &ValidatorManager::get_block_data_for_litequery, blkid, + [Self = actor_id(this), blkid, mode](td::Result> res) { + if (res.is_error()) { + td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error()); + } else { + td::actor::send_closure_later(Self, &LiteQuery::continue_getBlockHeader, blkid, mode, + res.move_as_ok()); + } + }); } static bool visit(Ref cell); @@ -495,33 +490,27 @@ void LiteQuery::perform_getState(BlockIdExt blkid) { fatal_error("cannot request total state: possibly too large"); return; } - get_block_handle_checked(blkid, [=, manager = manager_, Self = actor_id(this)](td::Result R) { - if (R.is_error()) { - td::actor::send_closure(Self, &LiteQuery::abort_query, R.move_as_error()); - return; - } - if (blkid.id.seqno) { - td::actor::send_closure_later(manager, &ValidatorManager::get_shard_state_from_db, R.move_as_ok(), - [=](td::Result> res) { - if (res.is_error()) { - td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error()); - } else { - td::actor::send_closure_later(Self, &LiteQuery::continue_getState, blkid, - res.move_as_ok()); - } - }); - } else { - td::actor::send_closure_later(manager, &ValidatorManager::get_zero_state, blkid, - [=](td::Result res) { - if (res.is_error()) { - td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error()); - } else { - td::actor::send_closure_later(Self, &LiteQuery::continue_getZeroState, blkid, - res.move_as_ok()); - } - }); - } - }); + if (blkid.id.seqno) { + td::actor::send_closure(manager_, &ValidatorManager::get_block_state_for_litequery, blkid, + [Self = actor_id(this), blkid](td::Result> res) { + if (res.is_error()) { + td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error()); + } else { + td::actor::send_closure_later(Self, &LiteQuery::continue_getState, blkid, + res.move_as_ok()); + } + }); + } else { + td::actor::send_closure_later(manager_, &ValidatorManager::get_zero_state, blkid, + [Self = actor_id(this), blkid](td::Result res) { + if (res.is_error()) { + td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error()); + } else { + td::actor::send_closure_later(Self, &LiteQuery::continue_getZeroState, blkid, + res.move_as_ok()); + } + }); + } } void LiteQuery::continue_getState(BlockIdExt blkid, Ref state) { @@ -583,7 +572,7 @@ bool LiteQuery::request_mc_block_data(BlockIdExt blkid) { base_blk_id_ = blkid; ++pending_; td::actor::send_closure_later( - manager_, &ValidatorManager::get_block_data_from_db_short, blkid, + manager_, &ValidatorManager::get_block_data_for_litequery, blkid, [Self = actor_id(this), blkid](td::Result> res) { if (res.is_error()) { td::actor::send_closure(Self, &LiteQuery::abort_query, @@ -641,7 +630,7 @@ bool LiteQuery::request_mc_block_state(BlockIdExt blkid) { base_blk_id_ = blkid; ++pending_; td::actor::send_closure_later( - manager_, &ValidatorManager::get_shard_state_from_db_short, blkid, + manager_, &ValidatorManager::get_block_state_for_litequery, blkid, [Self = actor_id(this), blkid](td::Result> res) { if (res.is_error()) { td::actor::send_closure(Self, &LiteQuery::abort_query, @@ -671,22 +660,16 @@ bool LiteQuery::request_block_state(BlockIdExt blkid) { } blk_id_ = blkid; ++pending_; - get_block_handle_checked(blkid, [=, manager = manager_, Self = actor_id(this)](td::Result R) { - if (R.is_error()) { - td::actor::send_closure(Self, &LiteQuery::abort_query, R.move_as_error()); - return; - } - td::actor::send_closure_later( - manager, &ValidatorManager::get_shard_state_from_db, R.move_as_ok(), - [=](td::Result> res) { - if (res.is_error()) { - td::actor::send_closure(Self, &LiteQuery::abort_query, - res.move_as_error_prefix("cannot load state for "s + blkid.to_str() + " : ")); - } else { - td::actor::send_closure_later(Self, &LiteQuery::got_block_state, blkid, res.move_as_ok()); - } - }); - }); + td::actor::send_closure(manager_, &ValidatorManager::get_block_state_for_litequery, blkid, + [Self = actor_id(this), blkid](td::Result> res) { + if (res.is_error()) { + td::actor::send_closure( + Self, &LiteQuery::abort_query, + res.move_as_error_prefix("cannot load state for "s + blkid.to_str() + " : ")); + } else { + td::actor::send_closure_later(Self, &LiteQuery::got_block_state, blkid, res.move_as_ok()); + } + }); return true; } @@ -699,22 +682,16 @@ bool LiteQuery::request_block_data(BlockIdExt blkid) { } blk_id_ = blkid; ++pending_; - get_block_handle_checked(blkid, [=, manager = manager_, Self = actor_id(this)](td::Result R) { - if (R.is_error()) { - td::actor::send_closure(Self, &LiteQuery::abort_query, R.move_as_error()); - return; - } - td::actor::send_closure_later( - manager, &ValidatorManager::get_block_data_from_db, R.move_as_ok(), - [=](td::Result> res) { - if (res.is_error()) { - td::actor::send_closure(Self, &LiteQuery::abort_query, - res.move_as_error_prefix("cannot load block "s + blkid.to_str() + " : ")); - } else { - td::actor::send_closure_later(Self, &LiteQuery::got_block_data, blkid, res.move_as_ok()); - } - }); - }); + td::actor::send_closure(manager_, &ValidatorManager::get_block_data_for_litequery, blkid, + [Self = actor_id(this), blkid](td::Result> res) { + if (res.is_error()) { + td::actor::send_closure( + Self, &LiteQuery::abort_query, + res.move_as_error_prefix("cannot load block "s + blkid.to_str() + " : ")); + } else { + td::actor::send_closure_later(Self, &LiteQuery::got_block_data, blkid, res.move_as_ok()); + } + }); return true; } @@ -1712,7 +1689,7 @@ void LiteQuery::continue_getTransactions(unsigned remaining, bool exact) { LOG(DEBUG) << "sending get_block_by_lt_from_db() query to manager for " << acc_workchain_ << ":" << acc_addr_.to_hex() << " " << trans_lt_; td::actor::send_closure_later( - manager_, &ValidatorManager::get_block_by_lt_from_db_for_litequery, ton::extract_addr_prefix(acc_workchain_, acc_addr_), + manager_, &ValidatorManager::get_block_by_lt_for_litequery, ton::extract_addr_prefix(acc_workchain_, acc_addr_), trans_lt_, [Self = actor_id(this), remaining, manager = manager_](td::Result res) { if (res.is_error()) { td::actor::send_closure(Self, &LiteQuery::abort_getTransactions, res.move_as_error(), ton::BlockIdExt{}); @@ -2088,11 +2065,13 @@ void LiteQuery::perform_lookupBlockWithProof(BlockId blkid, BlockIdExt mc_blkid, }); if (mode & 2) { - td::actor::send_closure_later(manager_, &ValidatorManager::get_block_by_lt_from_db_for_litequery, pfx, lt, std::move(P)); + td::actor::send_closure_later(manager_, &ValidatorManager::get_block_by_lt_for_litequery, pfx, lt, std::move(P)); } else if (mode & 4) { - td::actor::send_closure_later(manager_, &ValidatorManager::get_block_by_unix_time_from_db_for_litequery, pfx, utime, std::move(P)); + td::actor::send_closure_later(manager_, &ValidatorManager::get_block_by_unix_time_for_litequery, pfx, utime, + std::move(P)); } else { - td::actor::send_closure_later(manager_, &ValidatorManager::get_block_by_seqno_from_db_for_litequery, pfx, blkid.seqno, std::move(P)); + td::actor::send_closure_later(manager_, &ValidatorManager::get_block_by_seqno_for_litequery, pfx, blkid.seqno, + std::move(P)); } } @@ -2368,13 +2347,13 @@ void LiteQuery::perform_lookupBlock(BlockId blkid, int mode, LogicalTime lt, Uni ton::AccountIdPrefixFull pfx{blkid.workchain, blkid.shard}; if (mode & 2) { - td::actor::send_closure_later(manager_, &ValidatorManager::get_block_by_lt_from_db_for_litequery, pfx, lt, + td::actor::send_closure_later(manager_, &ValidatorManager::get_block_by_lt_for_litequery, pfx, lt, std::move(P)); } else if (mode & 4) { - td::actor::send_closure_later(manager_, &ValidatorManager::get_block_by_unix_time_from_db_for_litequery, pfx, utime, + td::actor::send_closure_later(manager_, &ValidatorManager::get_block_by_unix_time_for_litequery, pfx, utime, std::move(P)); } else { - td::actor::send_closure_later(manager_, &ValidatorManager::get_block_by_seqno_from_db_for_litequery, pfx, + td::actor::send_closure_later(manager_, &ValidatorManager::get_block_by_seqno_for_litequery, pfx, blkid.seqno, std::move(P)); } } @@ -3133,7 +3112,7 @@ void LiteQuery::perform_getShardBlockProof(BlockIdExt blkid) { } AccountIdPrefixFull pfx{masterchainId, shardIdAll}; td::actor::send_closure_later( - manager, &ValidatorManager::get_block_by_seqno_from_db_for_litequery, pfx, handle->masterchain_ref_block(), + manager, &ValidatorManager::get_block_by_seqno_for_litequery, pfx, handle->masterchain_ref_block(), [Self, manager](td::Result R) { if (R.is_error()) { td::actor::send_closure(Self, &LiteQuery::abort_query, R.move_as_error()); @@ -3237,5 +3216,45 @@ void LiteQuery::continue_getShardBlockProof(Ref cur_block, }); } +void LiteQuery::perform_nonfinal_getCandidate(td::Bits256 source, BlockIdExt blkid, td::Bits256 collated_data_hash) { + LOG(INFO) << "started a nonfinal.getCandidate liteserver query"; + td::actor::send_closure_later( + manager_, &ValidatorManager::get_block_candidate_for_litequery, PublicKey{pubkeys::Ed25519{source}}, blkid, collated_data_hash, + [Self = actor_id(this)](td::Result R) { + if (R.is_error()) { + td::actor::send_closure(Self, &LiteQuery::abort_query, R.move_as_error()); + } else { + BlockCandidate cand = R.move_as_ok(); + td::actor::send_closure_later( + Self, &LiteQuery::finish_query, + create_serialize_tl_object( + create_tl_object( + create_tl_lite_block_id(cand.id), cand.pubkey.as_bits256(), cand.collated_file_hash), + std::move(cand.data), std::move(cand.collated_data)), + false); + } + }); +} + +void LiteQuery::perform_nonfinal_getValidatorGroups(int mode, ShardIdFull shard) { + bool with_shard = mode & 1; + LOG(INFO) << "started a nonfinal.getValidatorGroups" << (with_shard ? shard.to_str() : "(all)") + << " liteserver query"; + td::optional maybe_shard; + if (with_shard) { + maybe_shard = shard; + } + td::actor::send_closure( + manager_, &ValidatorManager::get_validator_groups_info_for_litequery, maybe_shard, + [Self = actor_id(this)](td::Result> R) { + if (R.is_error()) { + td::actor::send_closure(Self, &LiteQuery::abort_query, R.move_as_error()); + } else { + td::actor::send_closure_later(Self, &LiteQuery::finish_query, serialize_tl_object(R.move_as_ok(), true), + false); + } + }); +} + } // namespace validator } // namespace ton diff --git a/validator/impl/liteserver.hpp b/validator/impl/liteserver.hpp index 931dd6f6..20c2abfe 100644 --- a/validator/impl/liteserver.hpp +++ b/validator/impl/liteserver.hpp @@ -168,6 +168,8 @@ class LiteQuery : public td::actor::Actor { void perform_getShardBlockProof(BlockIdExt blkid); void continue_getShardBlockProof(Ref cur_block, std::vector> result); + void perform_nonfinal_getCandidate(td::Bits256 source, BlockIdExt blkid, td::Bits256 collated_data_hash); + void perform_nonfinal_getValidatorGroups(int mode, ShardIdFull shard); void load_prevKeyBlock(ton::BlockIdExt blkid, td::Promise>>); void continue_loadPrevKeyBlock(ton::BlockIdExt blkid, td::Result, BlockIdExt>> res, diff --git a/validator/interfaces/validator-manager.h b/validator/interfaces/validator-manager.h index f0e1bb18..a3e83a9d 100644 --- a/validator/interfaces/validator-manager.h +++ b/validator/interfaces/validator-manager.h @@ -29,6 +29,7 @@ #include "liteserver.h" #include "crypto/vm/db/DynamicBagOfCellsDb.h" #include "validator-session/validator-session-types.h" +#include "auto/tl/lite_api.h" namespace ton { @@ -171,12 +172,19 @@ class ValidatorManager : public ValidatorManagerInterface { virtual void log_validator_session_stats(BlockIdExt block_id, validatorsession::ValidatorSessionStats stats) = 0; virtual void get_block_handle_for_litequery(BlockIdExt block_id, td::Promise promise) = 0; - virtual void get_block_by_lt_from_db_for_litequery(AccountIdPrefixFull account, LogicalTime lt, - td::Promise promise) = 0; - virtual void get_block_by_unix_time_from_db_for_litequery(AccountIdPrefixFull account, UnixTime ts, - td::Promise promise) = 0; - virtual void get_block_by_seqno_from_db_for_litequery(AccountIdPrefixFull account, BlockSeqno seqno, - td::Promise promise) = 0; + virtual void get_block_data_for_litequery(BlockIdExt block_id, td::Promise> promise) = 0; + virtual void get_block_state_for_litequery(BlockIdExt block_id, td::Promise> promise) = 0; + virtual void get_block_by_lt_for_litequery(AccountIdPrefixFull account, LogicalTime lt, + td::Promise promise) = 0; + virtual void get_block_by_unix_time_for_litequery(AccountIdPrefixFull account, UnixTime ts, + td::Promise promise) = 0; + virtual void get_block_by_seqno_for_litequery(AccountIdPrefixFull account, BlockSeqno seqno, + td::Promise promise) = 0; + virtual void get_block_candidate_for_litequery(PublicKey source, BlockIdExt block_id, FileHash collated_data_hash, + td::Promise promise) = 0; + virtual void get_validator_groups_info_for_litequery( + td::optional shard, + td::Promise> promise) = 0; virtual void add_lite_query_stats(int lite_query_id) { } diff --git a/validator/manager-disk.hpp b/validator/manager-disk.hpp index 4812d60a..05816c71 100644 --- a/validator/manager-disk.hpp +++ b/validator/manager-disk.hpp @@ -387,18 +387,33 @@ class ValidatorManagerImpl : public ValidatorManager { void get_block_handle_for_litequery(BlockIdExt block_id, td::Promise promise) override { get_block_handle(block_id, false, promise.wrap([](BlockHandle &&handle) -> ConstBlockHandle { return handle; })); } - void get_block_by_lt_from_db_for_litequery(AccountIdPrefixFull account, LogicalTime lt, + void get_block_data_for_litequery(BlockIdExt block_id, td::Promise> promise) override { + get_block_data_from_db_short(block_id, std::move(promise)); + } + void get_block_state_for_litequery(BlockIdExt block_id, td::Promise> promise) override { + get_shard_state_from_db_short(block_id, std::move(promise)); + } + void get_block_by_lt_for_litequery(AccountIdPrefixFull account, LogicalTime lt, td::Promise promise) override { get_block_by_lt_from_db(account, lt, std::move(promise)); } - void get_block_by_unix_time_from_db_for_litequery(AccountIdPrefixFull account, UnixTime ts, + void get_block_by_unix_time_for_litequery(AccountIdPrefixFull account, UnixTime ts, td::Promise promise) override { get_block_by_unix_time_from_db(account, ts, std::move(promise)); } - void get_block_by_seqno_from_db_for_litequery(AccountIdPrefixFull account, BlockSeqno seqno, + void get_block_by_seqno_for_litequery(AccountIdPrefixFull account, BlockSeqno seqno, td::Promise promise) override { get_block_by_seqno_from_db(account, seqno, std::move(promise)); } + void get_block_candidate_for_litequery(PublicKey source, BlockIdExt block_id, FileHash collated_data_hash, + td::Promise promise) override { + promise.set_result(td::Status::Error("not implemented")); + } + void get_validator_groups_info_for_litequery( + td::optional shard, + td::Promise> promise) override { + promise.set_result(td::Status::Error("not implemented")); + } private: PublicKeyHash local_id_; diff --git a/validator/manager-hardfork.hpp b/validator/manager-hardfork.hpp index c34ae5c7..77e604ae 100644 --- a/validator/manager-hardfork.hpp +++ b/validator/manager-hardfork.hpp @@ -448,18 +448,33 @@ class ValidatorManagerImpl : public ValidatorManager { void get_block_handle_for_litequery(BlockIdExt block_id, td::Promise promise) override { get_block_handle(block_id, false, promise.wrap([](BlockHandle &&handle) -> ConstBlockHandle { return handle; })); } - void get_block_by_lt_from_db_for_litequery(AccountIdPrefixFull account, LogicalTime lt, + void get_block_data_for_litequery(BlockIdExt block_id, td::Promise> promise) override { + get_block_data_from_db_short(block_id, std::move(promise)); + } + void get_block_state_for_litequery(BlockIdExt block_id, td::Promise> promise) override { + get_shard_state_from_db_short(block_id, std::move(promise)); + } + void get_block_by_lt_for_litequery(AccountIdPrefixFull account, LogicalTime lt, td::Promise promise) override { get_block_by_lt_from_db(account, lt, std::move(promise)); } - void get_block_by_unix_time_from_db_for_litequery(AccountIdPrefixFull account, UnixTime ts, + void get_block_by_unix_time_for_litequery(AccountIdPrefixFull account, UnixTime ts, td::Promise promise) override { get_block_by_unix_time_from_db(account, ts, std::move(promise)); } - void get_block_by_seqno_from_db_for_litequery(AccountIdPrefixFull account, BlockSeqno seqno, + void get_block_by_seqno_for_litequery(AccountIdPrefixFull account, BlockSeqno seqno, td::Promise promise) override { get_block_by_seqno_from_db(account, seqno, std::move(promise)); } + void get_block_candidate_for_litequery(PublicKey source, BlockIdExt block_id, FileHash collated_data_hash, + td::Promise promise) override { + promise.set_result(td::Status::Error("not implemented")); + } + void get_validator_groups_info_for_litequery( + td::optional shard, + td::Promise> promise) override { + promise.set_result(td::Status::Error("not implemented")); + } private: td::Ref opts_; diff --git a/validator/manager.cpp b/validator/manager.cpp index 55891ead..c24a98d6 100644 --- a/validator/manager.cpp +++ b/validator/manager.cpp @@ -225,13 +225,13 @@ void ValidatorManagerImpl::sync_complete(td::Promise promise) { VLOG(VALIDATOR_WARNING) << "completed sync. Validating " << validator_groups_.size() << " groups"; for (auto &v : validator_groups_) { - if (!v.second.empty()) { - td::actor::send_closure(v.second, &ValidatorGroup::create_session); + if (!v.second.actor.empty()) { + td::actor::send_closure(v.second.actor, &ValidatorGroup::create_session); } } for (auto &v : next_validator_groups_) { - if (!v.second.empty()) { - td::actor::send_closure(v.second, &ValidatorGroup::create_session); + if (!v.second.actor.empty()) { + td::actor::send_closure(v.second.actor, &ValidatorGroup::create_session); } } } @@ -1168,6 +1168,10 @@ void ValidatorManagerImpl::set_next_block(BlockIdExt block_id, BlockIdExt next, } void ValidatorManagerImpl::set_block_candidate(BlockIdExt id, BlockCandidate candidate, td::Promise promise) { + if (!candidates_buffer_.empty()) { + td::actor::send_closure(candidates_buffer_, &CandidatesBuffer::add_new_candidate, id, + PublicKey{pubkeys::Ed25519{candidate.pubkey.as_bits256()}}, candidate.collated_file_hash); + } td::actor::send_closure(db_, &Db::store_block_candidate, std::move(candidate), std::move(promise)); } @@ -1575,8 +1579,11 @@ void ValidatorManagerImpl::started(ValidatorManagerInitResult R) { td::actor::send_closure(SelfId, &ValidatorManagerImpl::read_gc_list, R.move_as_ok()); } }); - td::actor::send_closure(db_, &Db::get_destroyed_validator_sessions, std::move(P)); + + if (opts_->nonfinal_ls_queries_enabled()) { + candidates_buffer_ = td::actor::create_actor("candidates-buffer", actor_id(this)); + } } void ValidatorManagerImpl::read_gc_list(std::vector list) { @@ -1868,8 +1875,8 @@ void ValidatorManagerImpl::update_shards() { VLOG(VALIDATOR_DEBUG) << "total shards=" << new_shards.size() << " config shards=" << exp_vec.size(); - std::map> new_validator_groups_; - std::map> new_next_validator_groups_; + std::map new_validator_groups_; + std::map new_next_validator_groups_; bool force_recover = false; { @@ -1901,8 +1908,8 @@ void ValidatorManagerImpl::update_shards() { } else { auto it2 = next_validator_groups_.find(legacy_val_group_id); if (it2 != next_validator_groups_.end()) { - if (!it2->second.empty()) { - td::actor::send_closure(it2->second, &ValidatorGroup::start, prev, last_masterchain_block_id_, + if (!it2->second.actor.empty()) { + td::actor::send_closure(it2->second.actor, &ValidatorGroup::start, prev, last_masterchain_block_id_, last_masterchain_state_->get_unix_time()); } new_validator_groups_.emplace(val_group_id, std::move(it2->second)); @@ -1912,7 +1919,7 @@ void ValidatorManagerImpl::update_shards() { td::actor::send_closure(G, &ValidatorGroup::start, prev, last_masterchain_block_id_, last_masterchain_state_->get_unix_time()); } - new_validator_groups_.emplace(val_group_id, std::move(G)); + new_validator_groups_.emplace(val_group_id, ValidatorGroupEntry{std::move(G), shard}); } } } @@ -1957,8 +1964,8 @@ void ValidatorManagerImpl::update_shards() { } else { auto it2 = next_validator_groups_.find(val_group_id); if (it2 != next_validator_groups_.end()) { - if (!it2->second.empty()) { - td::actor::send_closure(it2->second, &ValidatorGroup::start, prev, last_masterchain_block_id_, + if (!it2->second.actor.empty()) { + td::actor::send_closure(it2->second.actor, &ValidatorGroup::start, prev, last_masterchain_block_id_, last_masterchain_state_->get_unix_time()); } new_validator_groups_.emplace(val_group_id, std::move(it2->second)); @@ -1968,7 +1975,7 @@ void ValidatorManagerImpl::update_shards() { td::actor::send_closure(G, &ValidatorGroup::start, prev, last_masterchain_block_id_, last_masterchain_state_->get_unix_time()); } - new_validator_groups_.emplace(val_group_id, std::move(G)); + new_validator_groups_.emplace(val_group_id, ValidatorGroupEntry{std::move(G), shard}); } } } @@ -1988,23 +1995,24 @@ void ValidatorManagerImpl::update_shards() { //CHECK(!it->second.empty()); new_next_validator_groups_.emplace(val_group_id, std::move(it->second)); } else { - new_next_validator_groups_.emplace(val_group_id, - create_validator_group(val_group_id, shard, val_set, opts, started_)); + new_next_validator_groups_.emplace( + val_group_id, + ValidatorGroupEntry{create_validator_group(val_group_id, shard, val_set, opts, started_), shard}); } } } std::vector> gc; for (auto &v : validator_groups_) { - if (!v.second.empty()) { + if (!v.second.actor.empty()) { gc_list_.push_back(v.first); - gc.push_back(v.second.release()); + gc.push_back(v.second.actor.release()); } } for (auto &v : next_validator_groups_) { - if (!v.second.empty()) { + if (!v.second.actor.empty()) { gc_list_.push_back(v.first); - gc.push_back(v.second.release()); + gc.push_back(v.second.actor.release()); } } @@ -2704,19 +2712,72 @@ void ValidatorManagerImpl::log_validator_session_stats(BlockIdExt block_id, } void ValidatorManagerImpl::get_block_handle_for_litequery(BlockIdExt block_id, td::Promise promise) { - get_block_handle( - block_id, false, - [SelfId = actor_id(this), block_id, promise = std::move(promise)](td::Result R) mutable { - if (R.is_ok() && R.ok()->is_applied()) { - promise.set_value(R.move_as_ok()); - } else { - td::actor::send_closure(SelfId, &ValidatorManagerImpl::process_block_handle_for_litequery_error, block_id, - std::move(R), std::move(promise)); - } - }); + get_block_handle(block_id, false, + [SelfId = actor_id(this), block_id, promise = std::move(promise), + allow_not_applied = opts_->nonfinal_ls_queries_enabled()](td::Result R) mutable { + if (R.is_ok() && (allow_not_applied || R.ok()->is_applied())) { + promise.set_value(R.move_as_ok()); + } else { + td::actor::send_closure(SelfId, &ValidatorManagerImpl::process_block_handle_for_litequery_error, + block_id, std::move(R), std::move(promise)); + } + }); } -void ValidatorManagerImpl::get_block_by_lt_from_db_for_litequery(AccountIdPrefixFull account, LogicalTime lt, +void ValidatorManagerImpl::get_block_data_for_litequery(BlockIdExt block_id, td::Promise> promise) { + if (candidates_buffer_.empty()) { + get_block_handle_for_litequery( + block_id, [manager = actor_id(this), promise = std::move(promise)](td::Result R) mutable { + TRY_RESULT_PROMISE(promise, handle, std::move(R)); + td::actor::send_closure_later(manager, &ValidatorManager::get_block_data_from_db, std::move(handle), + std::move(promise)); + }); + } else { + td::actor::send_closure( + candidates_buffer_, &CandidatesBuffer::get_block_data, block_id, + [manager = actor_id(this), promise = std::move(promise), block_id](td::Result> R) mutable { + if (R.is_ok()) { + promise.set_result(R.move_as_ok()); + return; + } + td::actor::send_closure(manager, &ValidatorManagerImpl::get_block_handle_for_litequery, block_id, + [manager, promise = std::move(promise)](td::Result R) mutable { + TRY_RESULT_PROMISE(promise, handle, std::move(R)); + td::actor::send_closure_later(manager, &ValidatorManager::get_block_data_from_db, + std::move(handle), std::move(promise)); + }); + }); + } +} + +void ValidatorManagerImpl::get_block_state_for_litequery(BlockIdExt block_id, + td::Promise> promise) { + if (candidates_buffer_.empty()) { + get_block_handle_for_litequery( + block_id, [manager = actor_id(this), promise = std::move(promise)](td::Result R) mutable { + TRY_RESULT_PROMISE(promise, handle, std::move(R)); + td::actor::send_closure_later(manager, &ValidatorManager::get_shard_state_from_db, std::move(handle), + std::move(promise)); + }); + } else { + td::actor::send_closure( + candidates_buffer_, &CandidatesBuffer::get_block_state, block_id, + [manager = actor_id(this), promise = std::move(promise), block_id](td::Result> R) mutable { + if (R.is_ok()) { + promise.set_result(R.move_as_ok()); + return; + } + td::actor::send_closure(manager, &ValidatorManagerImpl::get_block_handle_for_litequery, + block_id, [manager, promise = std::move(promise)](td::Result R) mutable { + TRY_RESULT_PROMISE(promise, handle, std::move(R)); + td::actor::send_closure_later(manager, &ValidatorManager::get_shard_state_from_db, std::move(handle), + std::move(promise)); + }); + }); + } +} + +void ValidatorManagerImpl::get_block_by_lt_for_litequery(AccountIdPrefixFull account, LogicalTime lt, td::Promise promise) { get_block_by_lt_from_db( account, lt, [=, SelfId = actor_id(this), promise = std::move(promise)](td::Result R) mutable { @@ -2729,7 +2790,7 @@ void ValidatorManagerImpl::get_block_by_lt_from_db_for_litequery(AccountIdPrefix }); } -void ValidatorManagerImpl::get_block_by_unix_time_from_db_for_litequery(AccountIdPrefixFull account, UnixTime ts, +void ValidatorManagerImpl::get_block_by_unix_time_for_litequery(AccountIdPrefixFull account, UnixTime ts, td::Promise promise) { get_block_by_unix_time_from_db( account, ts, [=, SelfId = actor_id(this), promise = std::move(promise)](td::Result R) mutable { @@ -2742,7 +2803,7 @@ void ValidatorManagerImpl::get_block_by_unix_time_from_db_for_litequery(AccountI }); } -void ValidatorManagerImpl::get_block_by_seqno_from_db_for_litequery(AccountIdPrefixFull account, BlockSeqno seqno, +void ValidatorManagerImpl::get_block_by_seqno_for_litequery(AccountIdPrefixFull account, BlockSeqno seqno, td::Promise promise) { get_block_by_seqno_from_db( account, seqno, @@ -2840,6 +2901,77 @@ void ValidatorManagerImpl::process_lookup_block_for_litequery_error(AccountIdPre promise.set_error(std::move(err)); } +void ValidatorManagerImpl::get_block_candidate_for_litequery(PublicKey source, BlockIdExt block_id, + FileHash collated_data_hash, + td::Promise promise) { + if (!opts_->nonfinal_ls_queries_enabled()) { + promise.set_error(td::Status::Error("query is not allowed")); + return; + } + get_block_candidate_from_db(source, block_id, collated_data_hash, std::move(promise)); +} + +void ValidatorManagerImpl::get_validator_groups_info_for_litequery( + td::optional shard, + td::Promise> promise) { + if (!opts_->nonfinal_ls_queries_enabled()) { + promise.set_error(td::Status::Error("query is not allowed")); + return; + } + class Actor : public td::actor::Actor { + public: + explicit Actor(std::vector> groups, + td::Promise> promise) + : groups_(std::move(groups)), promise_(std::move(promise)) { + } + + void start_up() override { + pending_ = groups_.size(); + if (pending_ == 0) { + promise_.set_result(std::move(result_)); + stop(); + return; + } + for (auto &x : groups_) { + td::actor::send_closure( + x, &ValidatorGroup::get_validator_group_info_for_litequery, + [SelfId = actor_id(this)](td::Result> R) { + td::actor::send_closure(SelfId, &Actor::on_result, R.is_ok() ? R.move_as_ok() : nullptr); + }); + } + } + + void on_result(tl_object_ptr r) { + if (r) { + result_->groups_.push_back(std::move(r)); + } + --pending_; + if (pending_ == 0) { + promise_.set_result(std::move(result_)); + stop(); + } + } + + private: + std::vector> groups_; + size_t pending_; + td::Promise> promise_; + tl_object_ptr result_ = + create_tl_object(); + }; + std::vector> groups; + for (auto &x : validator_groups_) { + if (x.second.actor.empty()) { + continue; + } + if (shard && shard.value() != x.second.shard) { + continue; + } + groups.push_back(x.second.actor.get()); + } + td::actor::create_actor("get-validator-groups-info", std::move(groups), std::move(promise)).release(); +} + td::actor::ActorOwn ValidatorManagerFactory::create( td::Ref opts, std::string db_root, td::actor::ActorId keyring, td::actor::ActorId adnl, td::actor::ActorId rldp, diff --git a/validator/manager.hpp b/validator/manager.hpp index 5a1fbc60..fd599563 100644 --- a/validator/manager.hpp +++ b/validator/manager.hpp @@ -29,6 +29,7 @@ #include "rldp/rldp.h" #include "token-manager.h" #include "queue-size-counter.hpp" +#include "impl/candidates-buffer.hpp" #include #include @@ -235,8 +236,12 @@ class ValidatorManagerImpl : public ValidatorManager { td::Ref validator_set, validatorsession::ValidatorSessionOptions opts, bool create_catchain); - std::map> validator_groups_; - std::map> next_validator_groups_; + struct ValidatorGroupEntry { + td::actor::ActorOwn actor; + ShardIdFull shard; + }; + std::map validator_groups_; + std::map next_validator_groups_; std::set check_gc_list_; std::vector gc_list_; @@ -563,17 +568,24 @@ class ValidatorManagerImpl : public ValidatorManager { } void get_block_handle_for_litequery(BlockIdExt block_id, td::Promise promise) override; - void get_block_by_lt_from_db_for_litequery(AccountIdPrefixFull account, LogicalTime lt, + void get_block_data_for_litequery(BlockIdExt block_id, td::Promise> promise) override; + void get_block_state_for_litequery(BlockIdExt block_id, td::Promise> promise) override; + void get_block_by_lt_for_litequery(AccountIdPrefixFull account, LogicalTime lt, td::Promise promise) override; - void get_block_by_unix_time_from_db_for_litequery(AccountIdPrefixFull account, UnixTime ts, + void get_block_by_unix_time_for_litequery(AccountIdPrefixFull account, UnixTime ts, td::Promise promise) override; - void get_block_by_seqno_from_db_for_litequery(AccountIdPrefixFull account, BlockSeqno seqno, + void get_block_by_seqno_for_litequery(AccountIdPrefixFull account, BlockSeqno seqno, td::Promise promise) override; void process_block_handle_for_litequery_error(BlockIdExt block_id, td::Result r_handle, td::Promise promise); void process_lookup_block_for_litequery_error(AccountIdPrefixFull account, int type, td::uint64 value, td::Result r_handle, td::Promise promise); + void get_block_candidate_for_litequery(PublicKey source, BlockIdExt block_id, FileHash collated_data_hash, + td::Promise promise) override; + void get_validator_groups_info_for_litequery( + td::optional shard, + td::Promise> promise) override; void add_lite_query_stats(int lite_query_id) override { ++ls_stats_[lite_query_id]; @@ -648,6 +660,8 @@ class ValidatorManagerImpl : public ValidatorManager { td::Timestamp log_ls_stats_at_; std::map ls_stats_; // lite_api ID -> count, 0 for unknown td::uint32 ls_stats_check_ext_messages_{0}; + + td::actor::ActorOwn candidates_buffer_; }; } // namespace validator diff --git a/validator/validator-group.cpp b/validator/validator-group.cpp index 73ca22a6..05628ef5 100644 --- a/validator/validator-group.cpp +++ b/validator/validator-group.cpp @@ -21,6 +21,7 @@ #include "ton/ton-io.hpp" #include "td/utils/overloaded.h" #include "common/delay.h" +#include "ton/lite-tl.hpp" namespace ton { @@ -61,7 +62,9 @@ void ValidatorGroup::generated_block_candidate(std::shared_ptrresult = R.move_as_ok(); + auto candidate = R.move_as_ok(); + add_available_block_candidate(candidate.pubkey.as_bits256(), candidate.id, candidate.collated_file_hash); + cache->result = std::move(candidate); for (auto &p : cache->promises) { p.set_value(cache->result.value().clone()); } @@ -108,6 +111,8 @@ void ValidatorGroup::validate_block_candidate(td::uint32 round_id, BlockCandidat [&](UnixTime ts) { td::actor::send_closure(SelfId, &ValidatorGroup::update_approve_cache, block_to_cache_key(block), ts); + td::actor::send_closure(SelfId, &ValidatorGroup::add_available_block_candidate, block.pubkey.as_bits256(), + block.id, block.collated_file_hash); promise.set_result(ts); }, [&](CandidateReject reject) { @@ -224,6 +229,16 @@ BlockIdExt ValidatorGroup::create_next_block_id(RootHash root_hash, FileHash fil return BlockIdExt{shard_.workchain, shard_.shard, seqno + 1, root_hash, file_hash}; } +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 BlockId{shard_.workchain, shard_.shard, seqno + 1}; +} + std::unique_ptr ValidatorGroup::make_validator_session_callback() { class Callback : public validatorsession::ValidatorSession::Callback { public: @@ -377,6 +392,47 @@ void ValidatorGroup::destroy() { stop(); } +void ValidatorGroup::get_validator_group_info_for_litequery( + td::Promise> promise) { + if (session_.empty()) { + promise.set_error(td::Status::Error(ErrorCode::notready, "not started")); + return; + } + td::actor::send_closure( + session_, &validatorsession::ValidatorSession::get_validator_group_info_for_litequery, last_known_round_id_, + [SelfId = actor_id(this), promise = std::move(promise), round = last_known_round_id_]( + td::Result>> R) mutable { + TRY_RESULT_PROMISE(promise, result, std::move(R)); + td::actor::send_closure(SelfId, &ValidatorGroup::get_validator_group_info_for_litequery_cont, round, + std::move(result), std::move(promise)); + }); +} + +void ValidatorGroup::get_validator_group_info_for_litequery_cont( + td::uint32 expected_round, std::vector> candidates, + td::Promise> promise) { + if (expected_round != last_known_round_id_) { + candidates.clear(); + } + + BlockId next_block_id = create_next_block_id_simple(); + for (auto &candidate : candidates) { + BlockIdExt id{next_block_id, candidate->id_->block_id_->root_hash_, candidate->id_->block_id_->file_hash_}; + candidate->id_->block_id_ = create_tl_lite_block_id(id); + candidate->available_ = + available_block_candidates_.count({candidate->id_->creator_, id, candidate->id_->collated_data_hash_}); + } + + auto result = create_tl_object(); + result->next_block_id_ = create_tl_lite_block_id_simple(next_block_id); + for (const BlockIdExt& prev : prev_block_ids_) { + result->prev_.push_back(create_tl_lite_block_id(prev)); + } + result->cc_seqno_ = validator_set_->get_catchain_seqno(); + result->candidates_ = std::move(candidates); + promise.set_result(std::move(result)); +} + } // namespace validator } // namespace ton diff --git a/validator/validator-group.hpp b/validator/validator-group.hpp index 26818d43..2dbff8de 100644 --- a/validator/validator-group.hpp +++ b/validator/validator-group.hpp @@ -47,6 +47,7 @@ class ValidatorGroup : public td::actor::Actor { void get_approved_candidate(PublicKey source, RootHash root_hash, FileHash file_hash, FileHash collated_data_file_hash, td::Promise promise); BlockIdExt create_next_block_id(RootHash root_hash, FileHash file_hash) const; + BlockId create_next_block_id_simple() const; void start(std::vector prev, BlockIdExt min_masterchain_block_id, UnixTime min_ts); void create_session(); @@ -58,6 +59,9 @@ class ValidatorGroup : public td::actor::Actor { } } + void get_validator_group_info_for_litequery( + td::Promise> promise); + ValidatorGroup(ShardIdFull shard, PublicKeyHash local_id, ValidatorSessionId session_id, td::Ref validator_set, validatorsession::ValidatorSessionOptions config, td::actor::ActorId keyring, td::actor::ActorId adnl, @@ -135,6 +139,17 @@ class ValidatorGroup : public td::actor::Actor { static CacheKey block_to_cache_key(const BlockCandidate& block) { return std::make_tuple(block.pubkey.as_bits256(), block.id, sha256_bits256(block.data), block.collated_file_hash); } + + void get_validator_group_info_for_litequery_cont( + td::uint32 expected_round, + std::vector> candidates, + td::Promise> promise); + + std::set> available_block_candidates_; // source, id, collated hash + + void add_available_block_candidate(td::Bits256 source, BlockIdExt id, FileHash collated_data_hash) { + available_block_candidates_.emplace(source, id, collated_data_hash); + } }; } // namespace validator diff --git a/validator/validator-options.hpp b/validator/validator-options.hpp index fca8d62f..1b7c5b09 100644 --- a/validator/validator-options.hpp +++ b/validator/validator-options.hpp @@ -126,6 +126,9 @@ struct ValidatorManagerOptionsImpl : public ValidatorManagerOptions { bool get_disable_rocksdb_stats() const override { return disable_rocksdb_stats_; } + bool nonfinal_ls_queries_enabled() const override { + return nonfinal_ls_queries_enabled_; + } void set_zero_block_id(BlockIdExt block_id) override { zero_block_id_ = block_id; @@ -191,6 +194,9 @@ struct ValidatorManagerOptionsImpl : public ValidatorManagerOptions { void set_disable_rocksdb_stats(bool value) override { disable_rocksdb_stats_ = value; } + void set_nonfinal_ls_queries_enabled(bool value) override { + nonfinal_ls_queries_enabled_ = value; + } ValidatorManagerOptionsImpl *make_copy() const override { return new ValidatorManagerOptionsImpl(*this); @@ -237,6 +243,7 @@ struct ValidatorManagerOptionsImpl : public ValidatorManagerOptions { size_t max_open_archive_files_ = 0; double archive_preload_period_ = 0.0; bool disable_rocksdb_stats_; + bool nonfinal_ls_queries_enabled_ = false; }; } // namespace validator diff --git a/validator/validator.h b/validator/validator.h index 2857d333..9ad20b4b 100644 --- a/validator/validator.h +++ b/validator/validator.h @@ -85,6 +85,7 @@ struct ValidatorManagerOptions : public td::CntObject { virtual size_t get_max_open_archive_files() const = 0; virtual double get_archive_preload_period() const = 0; virtual bool get_disable_rocksdb_stats() const = 0; + virtual bool nonfinal_ls_queries_enabled() const = 0; virtual void set_zero_block_id(BlockIdExt block_id) = 0; virtual void set_init_block_id(BlockIdExt block_id) = 0; @@ -108,6 +109,7 @@ struct ValidatorManagerOptions : public td::CntObject { virtual void set_max_open_archive_files(size_t value) = 0; virtual void set_archive_preload_period(double value) = 0; virtual void set_disable_rocksdb_stats(bool value) = 0; + virtual void set_nonfinal_ls_queries_enabled(bool value) = 0; static td::Ref create( BlockIdExt zero_block_id, BlockIdExt init_block_id,