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

Check is_applied in liteserver

Browse source
This commit is contained in:
SpyCheese 2022-08-22 10:25:28 +03:00
parent 9465fd866a
commit be824e9649
2 changed files with 149 additions and 79 deletions
Download patch file Download diff file Expand all files Collapse all files

227
validator/impl/liteserver.cpp
View file

@ -269,15 +269,21 @@ void LiteQuery::perform_getBlock(BlockIdExt blkid) {
fatal_error("invalid BlockIdExt"); fatal_error("invalid BlockIdExt");
return; return;
} }
td::actor::send_closure_later(manager_, &ValidatorManager::get_block_data_from_db_short, blkid, get_block_handle_checked(blkid, [manager = manager_, Self = actor_id(this), blkid](td::Result<ConstBlockHandle> R) {
[Self = actor_id(this), blkid](td::Result<Ref<ton::validator::BlockData>> res) { if (R.is_error()) {
if (res.is_error()) { td::actor::send_closure(Self, &LiteQuery::abort_query, R.move_as_error());
td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error()); return;
} else { }
td::actor::send_closure_later(Self, &LiteQuery::continue_getBlock, blkid, td::actor::send_closure_later(manager, &ValidatorManager::get_block_data_from_db, R.move_as_ok(),
res.move_as_ok()); [=](td::Result<Ref<ton::validator::BlockData>> 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<ton::validator::BlockData> block) { void LiteQuery::continue_getBlock(BlockIdExt blkid, Ref<ton::validator::BlockData> block) {
@ -295,15 +301,21 @@ void LiteQuery::perform_getBlockHeader(BlockIdExt blkid, int mode) {
fatal_error("invalid BlockIdExt"); fatal_error("invalid BlockIdExt");
return; return;
} }
td::actor::send_closure_later(manager_, &ValidatorManager::get_block_data_from_db_short, blkid, get_block_handle_checked(blkid, [=, manager = manager_, Self = actor_id(this)](td::Result<ConstBlockHandle> R) {
[Self = actor_id(this), blkid, mode](td::Result<Ref<ton::validator::BlockData>> res) { if (R.is_error()) {
if (res.is_error()) { td::actor::send_closure(Self, &LiteQuery::abort_query, R.move_as_error());
td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error()); return;
} else { }
td::actor::send_closure_later(Self, &LiteQuery::continue_getBlockHeader, blkid, td::actor::send_closure_later(manager, &ValidatorManager::get_block_data_from_db, R.move_as_ok(),
mode, res.move_as_ok()); [=](td::Result<Ref<ton::validator::BlockData>> 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<vm::Cell> cell); static bool visit(Ref<vm::Cell> cell);
@ -409,27 +421,33 @@ void LiteQuery::perform_getState(BlockIdExt blkid) {
fatal_error("cannot request total state: possibly too large"); fatal_error("cannot request total state: possibly too large");
return; return;
} }
if (blkid.id.seqno) { get_block_handle_checked(blkid, [=, manager = manager_, Self = actor_id(this)](td::Result<ConstBlockHandle> R) {
td::actor::send_closure_later(manager_, &ValidatorManager::get_shard_state_from_db_short, blkid, if (R.is_error()) {
[Self = actor_id(this), blkid](td::Result<Ref<ton::validator::ShardState>> res) { td::actor::send_closure(Self, &LiteQuery::abort_query, R.move_as_error());
if (res.is_error()) { return;
td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error()); }
} else { if (blkid.id.seqno) {
td::actor::send_closure_later(Self, &LiteQuery::continue_getState, blkid, td::actor::send_closure_later(manager, &ValidatorManager::get_shard_state_from_db, R.move_as_ok(),
res.move_as_ok()); [=](td::Result<Ref<ton::validator::ShardState>> res) {
} if (res.is_error()) {
}); td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error());
} else { } else {
td::actor::send_closure_later(manager_, &ValidatorManager::get_zero_state, blkid, td::actor::send_closure_later(Self, &LiteQuery::continue_getState, blkid,
[Self = actor_id(this), blkid](td::Result<td::BufferSlice> res) { res.move_as_ok());
if (res.is_error()) { }
td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error()); });
} else { } else {
td::actor::send_closure_later(Self, &LiteQuery::continue_getZeroState, blkid, td::actor::send_closure_later(manager, &ValidatorManager::get_zero_state, blkid,
res.move_as_ok()); [=](td::Result<td::BufferSlice> 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<ton::validator::ShardState> state) { void LiteQuery::continue_getState(BlockIdExt blkid, Ref<ton::validator::ShardState> state) {
@ -481,6 +499,23 @@ void LiteQuery::perform_sendMessage(td::BufferSlice data) {
}); });
} }
void LiteQuery::get_block_handle_checked(BlockIdExt blkid, td::Promise<ConstBlockHandle> promise) {
auto P = td::PromiseCreator::lambda(
[promise = std::move(promise)](td::Result<BlockHandle> R) mutable {
if (R.is_error()) {
promise.set_error(R.move_as_error());
} else {
auto handle = R.move_as_ok();
if (handle->is_applied()) {
promise.set_result(std::move(handle));
} else {
promise.set_error(td::Status::Error("block is not applied"));
}
}
});
td::actor::send_closure(manager_, &ValidatorManager::get_block_handle, blkid, false, std::move(P));
}
bool LiteQuery::request_mc_block_data(BlockIdExt blkid) { bool LiteQuery::request_mc_block_data(BlockIdExt blkid) {
if (!blkid.is_masterchain() || !blkid.is_valid_full()) { if (!blkid.is_masterchain() || !blkid.is_valid_full()) {
return fatal_error("reference block must belong to the masterchain"); return fatal_error("reference block must belong to the masterchain");
@ -579,16 +614,22 @@ bool LiteQuery::request_block_state(BlockIdExt blkid) {
} }
blk_id_ = blkid; blk_id_ = blkid;
++pending_; ++pending_;
td::actor::send_closure_later( get_block_handle_checked(blkid, [=, manager = manager_, Self = actor_id(this)](td::Result<ConstBlockHandle> R) {
manager_, &ValidatorManager::get_shard_state_from_db_short, blkid, if (R.is_error()) {
[Self = actor_id(this), blkid](td::Result<Ref<ShardState>> res) { td::actor::send_closure(Self, &LiteQuery::abort_query, R.move_as_error());
if (res.is_error()) { return;
td::actor::send_closure(Self, &LiteQuery::abort_query, }
res.move_as_error_prefix("cannot load state for "s + blkid.to_str() + " : ")); td::actor::send_closure_later(
} else { manager, &ValidatorManager::get_shard_state_from_db, R.move_as_ok(),
td::actor::send_closure_later(Self, &LiteQuery::got_block_state, blkid, res.move_as_ok()); [=](td::Result<Ref<ShardState>> 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; return true;
} }
@ -601,16 +642,22 @@ bool LiteQuery::request_block_data(BlockIdExt blkid) {
} }
blk_id_ = blkid; blk_id_ = blkid;
++pending_; ++pending_;
td::actor::send_closure_later( get_block_handle_checked(blkid, [=, manager = manager_, Self = actor_id(this)](td::Result<ConstBlockHandle> R) {
manager_, &ValidatorManager::get_block_data_from_db_short, blkid, if (R.is_error()) {
[Self = actor_id(this), blkid](td::Result<Ref<BlockData>> res) { td::actor::send_closure(Self, &LiteQuery::abort_query, R.move_as_error());
if (res.is_error()) { return;
td::actor::send_closure(Self, &LiteQuery::abort_query, }
res.move_as_error_prefix("cannot load block "s + blkid.to_str() + " : ")); td::actor::send_closure_later(
} else { manager, &ValidatorManager::get_block_data_from_db, R.move_as_ok(),
td::actor::send_closure_later(Self, &LiteQuery::got_block_data, blkid, res.move_as_ok()); [=](td::Result<Ref<BlockData>> 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; return true;
} }
@ -646,16 +693,23 @@ bool LiteQuery::request_proof_link(BlockIdExt blkid) {
}); });
}); });
} else { } else {
td::actor::send_closure_later( get_block_handle_checked(blkid, [=, manager = manager_, Self = actor_id(this)](td::Result<ConstBlockHandle> R) {
manager_, &ValidatorManager::get_block_proof_link_from_db_short, blkid, if (R.is_error()) {
[Self = actor_id(this), blkid](td::Result<Ref<ProofLink>> res) { td::actor::send_closure(Self, &LiteQuery::abort_query, R.move_as_error());
if (res.is_error()) { return;
td::actor::send_closure(Self, &LiteQuery::abort_query, }
res.move_as_error_prefix("cannot load proof link for "s + blkid.to_str() + " : ")); td::actor::send_closure_later(
} else { manager, &ValidatorManager::get_block_proof_link_from_db, R.move_as_ok(),
td::actor::send_closure_later(Self, &LiteQuery::got_block_proof_link, blkid, res.move_as_ok()); [=](td::Result<Ref<ProofLink>> res) {
} if (res.is_error()) {
}); td::actor::send_closure(
Self, &LiteQuery::abort_query,
res.move_as_error_prefix("cannot load proof link for "s + blkid.to_str() + " : "));
} else {
td::actor::send_closure_later(Self, &LiteQuery::got_block_proof_link, blkid, res.move_as_ok());
}
});
});
} }
return true; return true;
} }
@ -672,16 +726,22 @@ bool LiteQuery::request_zero_state(BlockIdExt blkid) {
} }
blk_id_ = blkid; blk_id_ = blkid;
++pending_; ++pending_;
td::actor::send_closure_later( get_block_handle_checked(blkid, [=, manager = manager_, Self = actor_id(this)](td::Result<ConstBlockHandle> R) {
manager_, &ValidatorManager::get_zero_state, blkid, if (R.is_error()) {
[Self = actor_id(this), blkid](td::Result<td::BufferSlice> res) { td::actor::send_closure(Self, &LiteQuery::abort_query, R.move_as_error());
if (res.is_error()) { return;
td::actor::send_closure(Self, &LiteQuery::abort_query, }
res.move_as_error_prefix("cannot load zerostate of "s + blkid.to_str() + " : ")); td::actor::send_closure_later(
} else { manager, &ValidatorManager::get_zero_state, blkid,
td::actor::send_closure_later(Self, &LiteQuery::got_zero_state, blkid, res.move_as_ok()); [=](td::Result<td::BufferSlice> res) {
} if (res.is_error()) {
}); td::actor::send_closure(Self, &LiteQuery::abort_query,
res.move_as_error_prefix("cannot load zerostate of "s + blkid.to_str() + " : "));
} else {
td::actor::send_closure_later(Self, &LiteQuery::got_zero_state, blkid, res.move_as_ok());
}
});
});
return true; return true;
} }
@ -1397,6 +1457,11 @@ void LiteQuery::continue_getTransactions(unsigned remaining, bool exact) {
td::actor::send_closure(Self, &LiteQuery::abort_getTransactions, res.move_as_error(), ton::BlockIdExt{}); td::actor::send_closure(Self, &LiteQuery::abort_getTransactions, res.move_as_error(), ton::BlockIdExt{});
} else { } else {
auto handle = res.move_as_ok(); auto handle = res.move_as_ok();
if (!handle->is_applied()) {
td::actor::send_closure(Self, &LiteQuery::abort_getTransactions, td::Status::Error("block is not applied"),
ton::BlockIdExt{});
return;
}
LOG(DEBUG) << "requesting data for block " << handle->id().to_str(); LOG(DEBUG) << "requesting data for block " << handle->id().to_str();
td::actor::send_closure_later(manager, &ValidatorManager::get_block_data_from_db, handle, td::actor::send_closure_later(manager, &ValidatorManager::get_block_data_from_db, handle,
[Self, blkid = handle->id(), remaining](td::Result<Ref<BlockData>> res) { [Self, blkid = handle->id(), remaining](td::Result<Ref<BlockData>> res) {
@ -1722,6 +1787,10 @@ void LiteQuery::perform_lookupBlock(BlockId blkid, int mode, LogicalTime lt, Uni
td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error()); td::actor::send_closure(Self, &LiteQuery::abort_query, res.move_as_error());
} else { } else {
auto handle = res.move_as_ok(); auto handle = res.move_as_ok();
if (!handle->is_applied()) {
td::actor::send_closure(Self, &LiteQuery::abort_query, td::Status::Error("block is not applied"));
return;
}
LOG(DEBUG) << "requesting data for block " << handle->id().to_str(); LOG(DEBUG) << "requesting data for block " << handle->id().to_str();
td::actor::send_closure_later(manager, &ValidatorManager::get_block_data_from_db, handle, td::actor::send_closure_later(manager, &ValidatorManager::get_block_data_from_db, handle,
[Self, blkid = handle->id(), mode](td::Result<Ref<BlockData>> res) { [Self, blkid = handle->id(), mode](td::Result<Ref<BlockData>> res) {

1
validator/impl/liteserver.hpp
View file

@ -152,6 +152,7 @@ class LiteQuery : public td::actor::Actor {
void finish_loadPrevKeyBlock(ton::BlockIdExt blkid, td::Result<Ref<BlockData>> res, void finish_loadPrevKeyBlock(ton::BlockIdExt blkid, td::Result<Ref<BlockData>> res,
td::Promise<std::pair<BlockIdExt, Ref<BlockQ>>> promise); td::Promise<std::pair<BlockIdExt, Ref<BlockQ>>> promise);
void get_block_handle_checked(BlockIdExt blkid, td::Promise<ConstBlockHandle> promise);
bool request_block_data(BlockIdExt blkid); bool request_block_data(BlockIdExt blkid);
bool request_block_state(BlockIdExt blkid); bool request_block_state(BlockIdExt blkid);
bool request_block_data_state(BlockIdExt blkid); bool request_block_data_state(BlockIdExt blkid);