external/ton
1
0
Fork 0
mirror of https://github.com/ton-blockchain/ton synced 2025-03-09 15:40:10 +00:00
Code Issues Releases Wiki Activity

LS queries to nonfinal blocks (#941)

Browse source 
Co-authored-by: SpyCheese <mikle98@yandex.ru>
This commit is contained in:
EmelyanenkoK 2024-03-26 14:51:06 +03:00 • committed by GitHub
parent 0feaaf591c
commit 9452c367e4
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
23 changed files with 809 additions and 150 deletions
Download patch file Download diff file Expand all files Collapse all files

196
validator/manager.cpp
View file

@ -225,13 +225,13 @@ void ValidatorManagerImpl::sync_complete(td::Promise<td::Unit> 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<td::Unit> 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<CandidatesBuffer>("candidates-buffer", actor_id(this));
}
}
void ValidatorManagerImpl::read_gc_list(std::vector<ValidatorSessionId> list) {
@ -1868,8 +1875,8 @@ void ValidatorManagerImpl::update_shards() {
VLOG(VALIDATOR_DEBUG) << "total shards=" << new_shards.size() << " config shards=" << exp_vec.size();
std::map<ValidatorSessionId, td::actor::ActorOwn<ValidatorGroup>> new_validator_groups_;
std::map<ValidatorSessionId, td::actor::ActorOwn<ValidatorGroup>> new_next_validator_groups_;
std::map<ValidatorSessionId, ValidatorGroupEntry> new_validator_groups_;
std::map<ValidatorSessionId, ValidatorGroupEntry> 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<td::actor::ActorId<ValidatorGroup>> 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<ConstBlockHandle> promise) {
get_block_handle(
block_id, false,
[SelfId = actor_id(this), block_id, promise = std::move(promise)](td::Result<BlockHandle> 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<BlockHandle> 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<td::Ref<BlockData>> promise) {
if (candidates_buffer_.empty()) {
get_block_handle_for_litequery(
block_id, [manager = actor_id(this), promise = std::move(promise)](td::Result<ConstBlockHandle> 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<td::Ref<BlockData>> 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<ConstBlockHandle> 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<td::Ref<ShardState>> promise) {
if (candidates_buffer_.empty()) {
get_block_handle_for_litequery(
block_id, [manager = actor_id(this), promise = std::move(promise)](td::Result<ConstBlockHandle> 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<td::Ref<ShardState>> 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<ConstBlockHandle> 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<ConstBlockHandle> promise) {
get_block_by_lt_from_db(
account, lt, [=, SelfId = actor_id(this), promise = std::move(promise)](td::Result<ConstBlockHandle> 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<ConstBlockHandle> promise) {
get_block_by_unix_time_from_db(
account, ts, [=, SelfId = actor_id(this), promise = std::move(promise)](td::Result<ConstBlockHandle> 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<ConstBlockHandle> 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<BlockCandidate> 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<ShardIdFull> shard,
td::Promise<tl_object_ptr<lite_api::liteServer_nonfinal_validatorGroups>> 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<td::actor::ActorId<ValidatorGroup>> groups,
td::Promise<tl_object_ptr<lite_api::liteServer_nonfinal_validatorGroups>> 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<tl_object_ptr<lite_api::liteServer_nonfinal_validatorGroupInfo>> R) {
td::actor::send_closure(SelfId, &Actor::on_result, R.is_ok() ? R.move_as_ok() : nullptr);
});
}
}
void on_result(tl_object_ptr<lite_api::liteServer_nonfinal_validatorGroupInfo> r) {
if (r) {
result_->groups_.push_back(std::move(r));
}
--pending_;
if (pending_ == 0) {
promise_.set_result(std::move(result_));
stop();
}
}
private:
std::vector<td::actor::ActorId<ValidatorGroup>> groups_;
size_t pending_;
td::Promise<tl_object_ptr<lite_api::liteServer_nonfinal_validatorGroups>> promise_;
tl_object_ptr<lite_api::liteServer_nonfinal_validatorGroups> result_ =
create_tl_object<lite_api::liteServer_nonfinal_validatorGroups>();
};
std::vector<td::actor::ActorId<ValidatorGroup>> 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<Actor>("get-validator-groups-info", std::move(groups), std::move(promise)).release();
}
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,