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

Use state with applied shards in liteserver (#553)

Browse source 
Co-authored-by: SpyCheese <mikle98@yandex.ru>
This commit is contained in:
EmelyanenkoK 2022-12-13 17:46:54 +03:00 • committed by GitHub
parent 6f63be6140
commit 1b106ef270
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
9 changed files with 59 additions and 18 deletions
Download patch file Download diff file Expand all files Collapse all files

14
validator/impl/liteserver.cpp
View file

@ -232,7 +232,7 @@ void LiteQuery::perform_getMasterchainInfo(int mode) {
return;
}
td::actor::send_closure_later(
manager_, &ton::validator::ValidatorManager::get_top_masterchain_state_block,
manager_, &ton::validator::ValidatorManager::get_last_liteserver_state_block,
[Self = actor_id(this), return_state = bool(acc_state_promise_), mode](td::Result<std::pair<Ref<ton::validator::MasterchainState>, BlockIdExt>> res) {
if (res.is_error()) {
td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error());
@ -776,9 +776,9 @@ void LiteQuery::perform_getAccountState(BlockIdExt blkid, WorkchainId workchain,
set_continuation([&]() -> void { continue_getAccountState(); });
request_mc_block_data_state(blkid);
} else {
LOG(INFO) << "sending a get_top_masterchain_state_block query to manager";
LOG(INFO) << "sending a get_last_liteserver_state_block query to manager";
td::actor::send_closure_later(
manager_, &ton::validator::ValidatorManager::get_top_masterchain_state_block,
manager_, &ton::validator::ValidatorManager::get_last_liteserver_state_block,
[Self = actor_id(this)](td::Result<std::pair<Ref<ton::validator::MasterchainState>, BlockIdExt>> res) -> void {
if (res.is_error()) {
td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error());
@ -855,7 +855,7 @@ void LiteQuery::perform_getLibraries(std::vector<td::Bits256> library_list) {
sort( library_list.begin(), library_list.end() );
library_list.erase( unique( library_list.begin(), library_list.end() ), library_list.end() );
td::actor::send_closure_later(
manager_, &ton::validator::ValidatorManager::get_top_masterchain_state_block,
manager_, &ton::validator::ValidatorManager::get_last_liteserver_state_block,
[Self = actor_id(this), library_list](td::Result<std::pair<Ref<ton::validator::MasterchainState>, BlockIdExt>> res) -> void {
if (res.is_error()) {
td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error());
@ -1542,7 +1542,7 @@ void LiteQuery::perform_getShardInfo(BlockIdExt blkid, ShardIdFull shard, bool e
}
void LiteQuery::load_prevKeyBlock(ton::BlockIdExt blkid, td::Promise<std::pair<BlockIdExt, Ref<BlockQ>>> promise) {
td::actor::send_closure_later(manager_, &ton::validator::ValidatorManager::get_top_masterchain_state_block,
td::actor::send_closure_later(manager_, &ton::validator::ValidatorManager::get_last_liteserver_state_block,
[Self = actor_id(this), blkid, promise = std::move(promise)](
td::Result<std::pair<Ref<MasterchainState>, BlockIdExt>> res) mutable {
td::actor::send_closure_later(Self, &LiteQuery::continue_loadPrevKeyBlock, blkid,
@ -1965,7 +1965,7 @@ void LiteQuery::perform_getBlockProof(ton::BlockIdExt from, ton::BlockIdExt to,
});
} else {
td::actor::send_closure_later(
manager_, &ton::validator::ValidatorManager::get_top_masterchain_state_block,
manager_, &ton::validator::ValidatorManager::get_last_liteserver_state_block,
[Self = actor_id(this), from, to, mode](td::Result<std::pair<Ref<MasterchainState>, BlockIdExt>> res) {
if (res.is_error()) {
td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error());
@ -1978,7 +1978,7 @@ void LiteQuery::perform_getBlockProof(ton::BlockIdExt from, ton::BlockIdExt to,
}
} else if (mode & 2) {
td::actor::send_closure_later(
manager_, &ton::validator::ValidatorManager::get_top_masterchain_state_block,
manager_, &ton::validator::ValidatorManager::get_last_liteserver_state_block,
[Self = actor_id(this), from, mode](td::Result<std::pair<Ref<MasterchainState>, BlockIdExt>> res) {
if (res.is_error()) {
td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error());

3
validator/interfaces/validator-manager.h
View file

@ -161,7 +161,8 @@ class ValidatorManager : public ValidatorManagerInterface {
virtual void update_last_known_key_block(BlockHandle handle, bool send_request) = 0;
virtual void update_gc_block_handle(BlockHandle handle, td::Promise<td::Unit> promise) = 0;
virtual void update_shard_client_block_handle(BlockHandle handle, td::Promise<td::Unit> promise) = 0;
virtual void update_shard_client_block_handle(BlockHandle handle, td::Ref<MasterchainState> state,
td::Promise<td::Unit> promise) = 0;
virtual void truncate(BlockSeqno seqno, ConstBlockHandle handle, td::Promise<td::Unit> promise) = 0;

4
validator/manager-disk.cpp
View file

@ -875,6 +875,10 @@ void ValidatorManagerImpl::get_top_masterchain_state_block(
std::pair<td::Ref<MasterchainState>, BlockIdExt>{last_masterchain_state_, last_masterchain_block_id_});
}
void get_last_liteserver_state_block(td::Promise<std::pair<td::Ref<MasterchainState>, BlockIdExt>> promise) {
return get_top_masterchain_state_block(std::move(promise));
}
void ValidatorManagerImpl::send_get_block_request(BlockIdExt id, td::uint32 priority,
td::Promise<ReceivedBlock> promise) {
UNREACHABLE();

4
validator/manager-disk.hpp
View file

@ -224,6 +224,7 @@ class ValidatorManagerImpl : public ValidatorManager {
void get_top_masterchain_state(td::Promise<td::Ref<MasterchainState>> promise) override;
void get_top_masterchain_block(td::Promise<BlockIdExt> promise) override;
void get_top_masterchain_state_block(td::Promise<std::pair<td::Ref<MasterchainState>, BlockIdExt>> promise) override;
void get_last_liteserver_state_block(td::Promise<std::pair<td::Ref<MasterchainState>, BlockIdExt>> promise) override;
void send_get_block_request(BlockIdExt id, td::uint32 priority, td::Promise<ReceivedBlock> promise) override;
void send_get_zero_state_request(BlockIdExt id, td::uint32 priority, td::Promise<td::BufferSlice> promise) override;
@ -351,7 +352,8 @@ class ValidatorManagerImpl : public ValidatorManager {
}
void update_last_known_key_block(BlockHandle handle, bool send_request) override {
}
void update_shard_client_block_handle(BlockHandle handle, td::Promise<td::Unit> promise) override {
void update_shard_client_block_handle(BlockHandle handle, td::Ref<MasterchainState> state,
td::Promise<td::Unit> promise) override {
}
void prepare_stats(td::Promise<std::vector<std::pair<std::string, std::string>>> promise) override {

6
validator/manager-hardfork.hpp
View file

@ -280,6 +280,9 @@ class ValidatorManagerImpl : public ValidatorManager {
void get_top_masterchain_state_block(td::Promise<std::pair<td::Ref<MasterchainState>, BlockIdExt>> promise) override {
UNREACHABLE();
}
void get_last_liteserver_state_block(td::Promise<std::pair<td::Ref<MasterchainState>, BlockIdExt>> promise) override {
UNREACHABLE();
}
void send_get_block_request(BlockIdExt id, td::uint32 priority, td::Promise<ReceivedBlock> promise) override {
UNREACHABLE();
@ -410,7 +413,8 @@ class ValidatorManagerImpl : public ValidatorManager {
}
void update_last_known_key_block(BlockHandle handle, bool send_request) override {
}
void update_shard_client_block_handle(BlockHandle handle, td::Promise<td::Unit> promise) override {
void update_shard_client_block_handle(BlockHandle handle, td::Ref<MasterchainState> state,
td::Promise<td::Unit> promise) override {
}
void prepare_stats(td::Promise<std::vector<std::pair<std::string, std::string>>> promise) override {

31
validator/manager.cpp
View file

@ -401,11 +401,12 @@ void ValidatorManagerImpl::add_external_message(td::Ref<ExtMessage> msg) {
}
}
void ValidatorManagerImpl::check_external_message(td::BufferSlice data, td::Promise<td::Ref<ExtMessage>> promise) {
if (last_masterchain_state_.is_null()) {
auto state = do_get_last_liteserver_state();
if (state.is_null()) {
promise.set_error(td::Status::Error(ErrorCode::notready, "not ready"));
return;
}
run_check_external_message(std::move(data), last_masterchain_state_->get_ext_msg_limits(), actor_id(this),
run_check_external_message(std::move(data), state->get_ext_msg_limits(), actor_id(this),
std::move(promise));
}
@ -1342,6 +1343,16 @@ void ValidatorManagerImpl::get_top_masterchain_state(td::Promise<td::Ref<Masterc
}
}
td::Ref<MasterchainState> ValidatorManagerImpl::do_get_last_liteserver_state() {
if (last_masterchain_state_.is_null()) {
return {};
}
if (last_liteserver_state_.is_null() || last_liteserver_state_->get_unix_time() < td::Clocks::system() - 30) {
last_liteserver_state_ = last_masterchain_state_;
}
return last_liteserver_state_;
}
void ValidatorManagerImpl::get_top_masterchain_block(td::Promise<BlockIdExt> promise) {
if (!last_masterchain_block_id_.is_valid()) {
promise.set_error(td::Status::Error(ton::ErrorCode::notready, "not started"));
@ -1360,6 +1371,16 @@ void ValidatorManagerImpl::get_top_masterchain_state_block(
}
}
void ValidatorManagerImpl::get_last_liteserver_state_block(
td::Promise<std::pair<td::Ref<MasterchainState>, BlockIdExt>> promise) {
auto state = do_get_last_liteserver_state();
if (state.is_null()) {
promise.set_error(td::Status::Error(ton::ErrorCode::notready, "not started"));
} else {
promise.set_result(std::pair<td::Ref<MasterchainState>, BlockIdExt>{state, state->get_block_id()});
}
}
void ValidatorManagerImpl::send_get_block_request(BlockIdExt id, td::uint32 priority,
td::Promise<ReceivedBlock> promise) {
callback_->download_block(id, priority, td::Timestamp::in(10.0), std::move(promise));
@ -2274,9 +2295,13 @@ void ValidatorManagerImpl::advance_gc(BlockHandle handle, td::Ref<MasterchainSta
try_advance_gc_masterchain_block();
}
void ValidatorManagerImpl::update_shard_client_block_handle(BlockHandle handle, td::Promise<td::Unit> promise) {
void ValidatorManagerImpl::update_shard_client_block_handle(BlockHandle handle, td::Ref<MasterchainState> state,
td::Promise<td::Unit> promise) {
shard_client_handle_ = std::move(handle);
auto seqno = shard_client_handle_->id().seqno();
if (last_liteserver_state_.is_null() || last_liteserver_state_->get_block_id().seqno() < seqno) {
last_liteserver_state_ = std::move(state);
}
shard_client_update(seqno);
promise.set_value(td::Unit());
}

7
validator/manager.hpp
View file

@ -245,6 +245,9 @@ class ValidatorManagerImpl : public ValidatorManager {
BlockHandle last_key_block_handle_;
BlockHandle last_known_key_block_handle_;
BlockHandle shard_client_handle_;
td::Ref<MasterchainState> last_liteserver_state_;
td::Ref<MasterchainState> do_get_last_liteserver_state();
BlockHandle gc_masterchain_handle_;
td::Ref<MasterchainState> gc_masterchain_state_;
@ -269,7 +272,8 @@ class ValidatorManagerImpl : public ValidatorManager {
void advance_gc(BlockHandle handle, td::Ref<MasterchainState> state);
void try_advance_gc_masterchain_block();
void update_gc_block_handle(BlockHandle handle, td::Promise<td::Unit> promise) override;
void update_shard_client_block_handle(BlockHandle handle, td::Promise<td::Unit> promise) override;
void update_shard_client_block_handle(BlockHandle handle, td::Ref<MasterchainState> state,
td::Promise<td::Unit> promise) override;
bool out_of_sync();
void applied_hardfork();
@ -430,6 +434,7 @@ class ValidatorManagerImpl : public ValidatorManager {
void get_top_masterchain_state(td::Promise<td::Ref<MasterchainState>> promise) override;
void get_top_masterchain_block(td::Promise<BlockIdExt> promise) override;
void get_top_masterchain_state_block(td::Promise<std::pair<td::Ref<MasterchainState>, BlockIdExt>> promise) override;
void get_last_liteserver_state_block(td::Promise<std::pair<td::Ref<MasterchainState>, BlockIdExt>> promise) override;
void send_get_block_request(BlockIdExt id, td::uint32 priority, td::Promise<ReceivedBlock> promise) override;
void send_get_zero_state_request(BlockIdExt id, td::uint32 priority, td::Promise<td::BufferSlice> promise) override;

6
validator/shard-client.cpp
View file

@ -107,9 +107,6 @@ void ShardClient::start_up_init_mode() {
void ShardClient::applied_all_shards() {
LOG(DEBUG) << "shardclient: " << masterchain_block_handle_->id() << " finished";
masterchain_state_.clear();
auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::Unit> R) {
R.ensure();
td::actor::send_closure(SelfId, &ShardClient::saved_to_db);
@ -121,7 +118,8 @@ void ShardClient::applied_all_shards() {
void ShardClient::saved_to_db() {
CHECK(masterchain_block_handle_);
td::actor::send_closure(manager_, &ValidatorManager::update_shard_client_block_handle, masterchain_block_handle_,
[](td::Unit) {});
std::move(masterchain_state_), [](td::Unit) {});
masterchain_state_.clear();
if (promise_) {
promise_.set_value(td::Unit());
}

2
validator/validator.h
View file

@ -166,6 +166,8 @@ class ValidatorManagerInterface : public td::actor::Actor {
virtual void get_top_masterchain_block(td::Promise<BlockIdExt> promise) = 0;
virtual void get_top_masterchain_state_block(
td::Promise<std::pair<td::Ref<MasterchainState>, BlockIdExt>> promise) = 0;
virtual void get_last_liteserver_state_block(
td::Promise<std::pair<td::Ref<MasterchainState>, BlockIdExt>> promise) = 0;
virtual void get_block_data(BlockHandle handle, td::Promise<td::BufferSlice> promise) = 0;
virtual void check_zero_state_exists(BlockIdExt block_id, td::Promise<bool> promise) = 0;