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

Change update_shard_configuration

Browse source
This commit is contained in:
SpyCheese 2022-08-03 15:15:42 +03:00
parent ac7a33497b
commit 212c07f2f0
14 changed files with 106 additions and 84 deletions
Download patch file Download diff file Expand all files Collapse all files

3
create-hardfork/create-hardfork.cpp
View file

@ -236,7 +236,8 @@ class HardforkCreator : public td::actor::Actor {
td::actor::send_closure(id_, &ton::validator::ValidatorManager::sync_complete,
td::PromiseCreator::lambda([](td::Unit) {}));
}
void update_shard_configuration(td::Ref<ton::validator::MasterchainState> state) override {
void update_shard_configuration(td::Ref<ton::validator::MasterchainState> state,
std::set<ton::ShardIdFull> shards_to_monitor) override {
}
void send_ihr_message(ton::AccountIdPrefixFull dst, td::BufferSlice data) override {
}

3
test/test-ton-collator.cpp
View file

@ -323,7 +323,8 @@ class TestNode : public td::actor::Actor {
td::actor::send_closure(id_, &ton::validator::ValidatorManager::sync_complete,
td::PromiseCreator::lambda([](td::Unit) {}));
}
void update_shard_configuration(td::Ref<ton::validator::MasterchainState> state) override {
void update_shard_configuration(td::Ref<ton::validator::MasterchainState> state,
std::set<ton::ShardIdFull> shards_to_monitor) override {
}
void send_ihr_message(ton::AccountIdPrefixFull dst, td::BufferSlice data) override {
}

2
validator-engine/validator-engine.cpp
View file

@ -1853,7 +1853,7 @@ void ValidatorEngine::start_full_node() {
});
full_node_ = ton::validator::fullnode::FullNode::create(
short_id, ton::adnl::AdnlNodeIdShort{config_.full_node}, validator_options_->zero_block_id().file_hash,
validator_options_, keyring_.get(), adnl_.get(), rldp_.get(),
keyring_.get(), adnl_.get(), rldp_.get(),
default_dht_node_.is_zero() ? td::actor::ActorId<ton::dht::Dht>{} : dht_nodes_[default_dht_node_].get(),
overlay_manager_.get(), validator_manager_.get(), full_node_client_.get(), db_root_, std::move(P));
for (auto &v : config_.validators) {

74
validator/full-node.cpp
View file

@ -132,52 +132,31 @@ void FullNodeImpl::initial_read_complete(BlockHandle top_handle) {
td::actor::send_closure(it->second.actor, &FullNodeShard::set_handle, top_handle, std::move(P));
}
void FullNodeImpl::update_shard_configuration(td::Ref<MasterchainState> state) {
void FullNodeImpl::update_shard_configuration(td::Ref<MasterchainState> state,
std::set<ShardIdFull> shards_to_monitor) {
std::map<ShardIdFull, BlockIdExt> new_shards;
std::set<ShardIdFull> new_active;
new_shards[ShardIdFull(masterchainId)] = state->get_block_id();
new_active.insert(ShardIdFull(masterchainId));
std::set<WorkchainId> workchains;
auto cur_time = state->get_unix_time();
auto set_active = [&](ShardIdFull shard) {
while (new_active.insert(shard).second && shard.pfx_len() > 0) {
shard = shard_parent(shard);
}
};
for (auto &info : state->get_shards()) {
auto shard = info->shard();
workchains.insert(shard.workchain);
new_shards[shard] = info->top_block_id();
bool will_split = shard.pfx_len() < max_shard_pfx_len && ((info->fsm_state() == McShardHash::FsmState::fsm_split &&
info->fsm_utime() < cur_time + 60) || info->before_split());
bool will_merge = shard.pfx_len() > 0 && ((info->fsm_state() == McShardHash::FsmState::fsm_merge &&
info->fsm_utime() < cur_time + 60) || info->before_merge());
if (opts_->need_monitor(shard)) {
set_active(shard);
}
if (will_merge && opts_->need_monitor(shard_parent(shard))) {
set_active(shard);
set_active(shard_sibling(shard));
}
for (int id = 0; id < 2; ++id) {
if (will_split && opts_->need_monitor(shard_child(shard, id))) {
set_active(shard_child(shard, id));
}
}
workchains.insert(info->shard().workchain);
new_shards[info->shard()] = info->top_block_id();
}
for (const auto &wpair : state->get_workchain_list()) {
ton::WorkchainId wc = wpair.first;
const block::WorkchainInfo *winfo = wpair.second.get();
if (workchains.count(wc) == 0 && winfo->active && winfo->enabled_since <= cur_time) {
auto shard = ShardIdFull(wc);
new_shards[shard] = BlockIdExt(wc, shard.shard, 0, winfo->zerostate_root_hash, winfo->zerostate_file_hash);
if (opts_->need_monitor(shard)) {
if (workchains.count(wc) == 0 && winfo->active && winfo->enabled_since <= state->get_unix_time()) {
new_shards[ShardIdFull(wc)] = BlockIdExt(wc, shardIdAll, 0, winfo->zerostate_root_hash, winfo->zerostate_file_hash);
}
}
for (ShardIdFull shard : shards_to_monitor) {
set_active(shard);
}
}
}
auto info_set_active = [&](ShardIdFull shard, ShardInfo& info, bool active) {
if (info.active == active) {
@ -195,10 +174,6 @@ void FullNodeImpl::update_shard_configuration(td::Ref<MasterchainState> state) {
for (auto shard : new_shards) {
auto &info = shards_[shard.first];
info.exists = true;
if (!info.active && new_active.count(shard.first)) {
td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::wait_block_state_short, shard.second, 0,
td::Timestamp::in(60.0), [](td::Result<td::Ref<ShardState>>){});
}
}
for (auto& p : shards_) {
@ -511,8 +486,9 @@ void FullNodeImpl::start_up() {
void initial_read_complete(BlockHandle handle) override {
td::actor::send_closure(id_, &FullNodeImpl::initial_read_complete, handle);
}
void update_shard_configuration(td::Ref<MasterchainState> state) override {
td::actor::send_closure(id_, &FullNodeImpl::update_shard_configuration, std::move(state));
void update_shard_configuration(td::Ref<MasterchainState> state, std::set<ShardIdFull> shards_to_monitor) override {
td::actor::send_closure(id_, &FullNodeImpl::update_shard_configuration, std::move(state),
std::move(shards_to_monitor));
}
void send_ihr_message(AccountIdPrefixFull dst, td::BufferSlice data) override {
td::actor::send_closure(id_, &FullNodeImpl::send_ihr_message, dst, std::move(data));
@ -580,16 +556,15 @@ void FullNodeImpl::start_up() {
}
FullNodeImpl::FullNodeImpl(PublicKeyHash local_id, adnl::AdnlNodeIdShort adnl_id, FileHash zero_state_file_hash,
td::Ref<ValidatorManagerOptions> opts, td::actor::ActorId<keyring::Keyring> keyring,
td::actor::ActorId<adnl::Adnl> adnl, td::actor::ActorId<rldp::Rldp> rldp,
td::actor::ActorId<dht::Dht> dht, td::actor::ActorId<overlay::Overlays> overlays,
td::actor::ActorId<keyring::Keyring> keyring, td::actor::ActorId<adnl::Adnl> adnl,
td::actor::ActorId<rldp::Rldp> rldp, td::actor::ActorId<dht::Dht> dht,
td::actor::ActorId<overlay::Overlays> overlays,
td::actor::ActorId<ValidatorManagerInterface> validator_manager,
td::actor::ActorId<adnl::AdnlExtClient> client, std::string db_root,
td::Promise<td::Unit> started_promise)
: local_id_(local_id)
, adnl_id_(adnl_id)
, zero_state_file_hash_(zero_state_file_hash)
, opts_(opts)
, keyring_(keyring)
, adnl_(adnl)
, rldp_(rldp)
@ -602,17 +577,14 @@ FullNodeImpl::FullNodeImpl(PublicKeyHash local_id, adnl::AdnlNodeIdShort adnl_id
add_shard_actor(ShardIdFull{masterchainId}, true);
}
td::actor::ActorOwn<FullNode> FullNode::create(ton::PublicKeyHash local_id, adnl::AdnlNodeIdShort adnl_id,
FileHash zero_state_file_hash, td::Ref<ValidatorManagerOptions> opts,
td::actor::ActorId<keyring::Keyring> keyring,
td::actor::ActorId<adnl::Adnl> adnl, td::actor::ActorId<rldp::Rldp> rldp,
td::actor::ActorId<dht::Dht> dht,
td::actor::ActorId<overlay::Overlays> overlays,
td::actor::ActorId<ValidatorManagerInterface> validator_manager,
td::actor::ActorId<adnl::AdnlExtClient> client, std::string db_root,
td::Promise<td::Unit> started_promise) {
return td::actor::create_actor<FullNodeImpl>("fullnode", local_id, adnl_id, zero_state_file_hash, opts, keyring, adnl,
rldp, dht, overlays, validator_manager, client, db_root,
td::actor::ActorOwn<FullNode> FullNode::create(
ton::PublicKeyHash local_id, adnl::AdnlNodeIdShort adnl_id, FileHash zero_state_file_hash,
td::actor::ActorId<keyring::Keyring> keyring, td::actor::ActorId<adnl::Adnl> adnl,
td::actor::ActorId<rldp::Rldp> rldp, td::actor::ActorId<dht::Dht> dht,
td::actor::ActorId<overlay::Overlays> overlays, td::actor::ActorId<ValidatorManagerInterface> validator_manager,
td::actor::ActorId<adnl::AdnlExtClient> client, std::string db_root, td::Promise<td::Unit> started_promise) {
return td::actor::create_actor<FullNodeImpl>("fullnode", local_id, adnl_id, zero_state_file_hash, keyring, adnl, rldp,
dht, overlays, validator_manager, client, db_root,
std::move(started_promise));
}

15
validator/full-node.h
View file

@ -72,15 +72,12 @@ class FullNode : public td::actor::Actor {
return 4ull << 30;
}
static td::actor::ActorOwn<FullNode> create(ton::PublicKeyHash local_id, adnl::AdnlNodeIdShort adnl_id,
FileHash zero_state_file_hash, td::Ref<ValidatorManagerOptions> opts,
td::actor::ActorId<keyring::Keyring> keyring,
td::actor::ActorId<adnl::Adnl> adnl, td::actor::ActorId<rldp::Rldp> rldp,
td::actor::ActorId<dht::Dht> dht,
td::actor::ActorId<overlay::Overlays> overlays,
td::actor::ActorId<ValidatorManagerInterface> validator_manager,
td::actor::ActorId<adnl::AdnlExtClient> client, std::string db_root,
td::Promise<td::Unit> started_promise);
static td::actor::ActorOwn<FullNode> create(
ton::PublicKeyHash local_id, adnl::AdnlNodeIdShort adnl_id, FileHash zero_state_file_hash,
td::actor::ActorId<keyring::Keyring> keyring, td::actor::ActorId<adnl::Adnl> adnl,
td::actor::ActorId<rldp::Rldp> rldp, td::actor::ActorId<dht::Dht> dht,
td::actor::ActorId<overlay::Overlays> overlays, td::actor::ActorId<ValidatorManagerInterface> validator_manager,
td::actor::ActorId<adnl::AdnlExtClient> client, std::string db_root, td::Promise<td::Unit> started_promise);
};
} // namespace fullnode

9
validator/full-node.hpp
View file

@ -52,7 +52,7 @@ class FullNodeImpl : public FullNode {
void update_adnl_id(adnl::AdnlNodeIdShort adnl_id, td::Promise<td::Unit> promise) override;
void update_shard_configuration(td::Ref<MasterchainState> state);
void update_shard_configuration(td::Ref<MasterchainState> state, std::set<ShardIdFull> shards_to_monitor);
void sync_completed();
@ -83,9 +83,9 @@ class FullNodeImpl : public FullNode {
void start_up() override;
FullNodeImpl(PublicKeyHash local_id, adnl::AdnlNodeIdShort adnl_id, FileHash zero_state_file_hash,
td::Ref<ValidatorManagerOptions> opts, td::actor::ActorId<keyring::Keyring> keyring,
td::actor::ActorId<adnl::Adnl> adnl, td::actor::ActorId<rldp::Rldp> rldp,
td::actor::ActorId<dht::Dht> dht, td::actor::ActorId<overlay::Overlays> overlays,
td::actor::ActorId<keyring::Keyring> keyring, td::actor::ActorId<adnl::Adnl> adnl,
td::actor::ActorId<rldp::Rldp> rldp, td::actor::ActorId<dht::Dht> dht,
td::actor::ActorId<overlay::Overlays> overlays,
td::actor::ActorId<ValidatorManagerInterface> validator_manager,
td::actor::ActorId<adnl::AdnlExtClient> client, std::string db_root,
td::Promise<td::Unit> started_promise);
@ -96,7 +96,6 @@ class FullNodeImpl : public FullNode {
PublicKeyHash local_id_;
adnl::AdnlNodeIdShort adnl_id_;
FileHash zero_state_file_hash_;
td::Ref<ValidatorManagerOptions> opts_;
td::actor::ActorId<FullNodeShard> get_shard(AccountIdPrefixFull dst);
td::actor::ActorId<FullNodeShard> get_shard(ShardIdFull shard, bool exact = false);

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

@ -134,7 +134,7 @@ class ValidatorManager : public ValidatorManagerInterface {
virtual void update_shard_client_state(BlockIdExt masterchain_block_id, td::Promise<td::Unit> promise) = 0;
virtual void get_shard_client_state(bool from_db, td::Promise<BlockIdExt> promise) = 0;
virtual void update_shard_configuration(td::Ref<MasterchainState> state) = 0;
virtual void update_shard_configuration(td::Ref<MasterchainState> state, std::set<ShardIdFull> shards_to_monitor) = 0;
virtual void update_async_serializer_state(AsyncSerializerState state, td::Promise<td::Unit> promise) = 0;
virtual void get_async_serializer_state(td::Promise<AsyncSerializerState> promise) = 0;

2
validator/manager-disk.hpp
View file

@ -261,7 +261,7 @@ class ValidatorManagerImpl : public ValidatorManager {
void update_shard_client_state(BlockIdExt masterchain_block_id, td::Promise<td::Unit> promise) override;
void get_shard_client_state(bool from_db, td::Promise<BlockIdExt> promise) override;
void update_shard_configuration(td::Ref<MasterchainState> state) override {
void update_shard_configuration(td::Ref<MasterchainState> state, std::set<ShardIdFull> shards_to_monitor) override {
}
void update_async_serializer_state(AsyncSerializerState state, td::Promise<td::Unit> promise) override {

2
validator/manager-hardfork.hpp
View file

@ -329,7 +329,7 @@ class ValidatorManagerImpl : public ValidatorManager {
void get_shard_client_state(bool from_db, td::Promise<BlockIdExt> promise) override {
UNREACHABLE();
}
void update_shard_configuration(td::Ref<MasterchainState> state) override {
void update_shard_configuration(td::Ref<MasterchainState> state, std::set<ShardIdFull> shards_to_monitor) override {
UNREACHABLE();
}

16
validator/manager.cpp
View file

@ -372,7 +372,7 @@ void ValidatorManagerImpl::new_external_message(td::BufferSlice data) {
if (!is_validator()) {
return;
}
if( ext_messages_.size() > max_mempool_num() ) {
if ((double)ext_messages_.size() > max_mempool_num()) {
return;
}
auto R = create_ext_message(std::move(data));
@ -453,7 +453,7 @@ void ValidatorManagerImpl::add_shard_block_description(td::Ref<ShardTopBlockDesc
}
shard_blocks_[ShardTopBlockDescriptionId{desc->block_id().shard_full(), desc->catchain_seqno()}] = desc;
VLOG(VALIDATOR_DEBUG) << "new shard block descr for " << desc->block_id();
if (opts_->need_monitor(desc->block_id().shard_full())) {
if (shards_to_monitor_.count(desc->block_id().shard_full())) {
auto P = td::PromiseCreator::lambda([](td::Result<td::Ref<ShardState>> R) {
if (R.is_error()) {
auto S = R.move_as_error();
@ -612,7 +612,7 @@ void ValidatorManagerImpl::wait_out_msg_queue_proof(BlockIdExt block_id, ShardId
std::move(R));
});
auto id = td::actor::create_actor<WaitOutMsgQueueProof>("waitmsgqueue", block_id, dst_shard,
opts_->need_monitor(block_id.shard_full()), priority,
shards_to_monitor_.count(block_id.shard_full()), priority,
actor_id(this), td::Timestamp::in(10.0), std::move(P))
.release();
wait_out_msg_queue_proof_[key].actor_ = id;
@ -1073,8 +1073,8 @@ void ValidatorManagerImpl::finished_wait_msg_queue(BlockIdExt block_id, ShardIdF
std::move(R));
});
auto id = td::actor::create_actor<WaitOutMsgQueueProof>("waitmsgqueue", block_id, dst_shard,
opts_->need_monitor(block_id.shard_full()), X.second,
actor_id(this), X.first, std::move(P))
shards_to_monitor_.count(block_id.shard_full()),
X.second, actor_id(this), X.first, std::move(P))
.release();
it->second.actor_ = id;
return;
@ -2425,8 +2425,10 @@ void ValidatorManagerImpl::get_shard_client_state(bool from_db, td::Promise<Bloc
}
}
void ValidatorManagerImpl::update_shard_configuration(td::Ref<MasterchainState> state) {
callback_->update_shard_configuration(state);
void ValidatorManagerImpl::update_shard_configuration(td::Ref<MasterchainState> state,
std::set<ShardIdFull> shards_to_monitor) {
shards_to_monitor_ = shards_to_monitor;
callback_->update_shard_configuration(std::move(state), std::move(shards_to_monitor));
}
void ValidatorManagerImpl::update_async_serializer_state(AsyncSerializerState state, td::Promise<td::Unit> promise) {

4
validator/manager.hpp
View file

@ -453,7 +453,7 @@ class ValidatorManagerImpl : public ValidatorManager {
void update_shard_client_state(BlockIdExt masterchain_block_id, td::Promise<td::Unit> promise) override;
void get_shard_client_state(bool from_db, td::Promise<BlockIdExt> promise) override;
void update_shard_configuration(td::Ref<MasterchainState> state) override;
void update_shard_configuration(td::Ref<MasterchainState> state, std::set<ShardIdFull> shards_to_monitor) override;
void update_async_serializer_state(AsyncSerializerState state, td::Promise<td::Unit> promise) override;
void get_async_serializer_state(td::Promise<AsyncSerializerState> promise) override;
@ -619,6 +619,8 @@ class ValidatorManagerImpl : public ValidatorManager {
std::map<adnl::AdnlNodeIdShort, td::actor::ActorOwn<CollatorNode>> collator_nodes_;
bool collating_masterchain_ = false;
std::set<ShardIdFull> shards_to_monitor_ = {ShardIdFull(masterchainId)};
};
} // namespace validator

53
validator/shard-client.cpp
View file

@ -91,7 +91,7 @@ void ShardClient::start_up_init_mode() {
auto vec = masterchain_state_->get_shards();
for (auto &shard : vec) {
if (opts_->need_monitor(shard->shard())) {
if (shards_to_monitor_.count(shard->shard())) {
auto P = td::PromiseCreator::lambda([promise = ig.get_promise()](td::Result<td::Ref<ShardState>> R) mutable {
R.ensure();
promise.set_value(td::Unit());
@ -192,7 +192,7 @@ void ShardClient::apply_all_shards() {
auto vec = masterchain_state_->get_shards();
for (auto &shard : vec) {
if (opts_->need_monitor(shard->shard())) {
if (shards_to_monitor_.count(shard->shard())) {
auto Q = td::PromiseCreator::lambda([SelfId = actor_id(this), promise = ig.get_promise(),
shard = shard->shard()](td::Result<td::Ref<ShardState>> R) mutable {
if (R.is_error()) {
@ -247,7 +247,54 @@ void ShardClient::get_processed_masterchain_block_id(td::Promise<BlockIdExt> pro
}
void ShardClient::build_shard_overlays() {
td::actor::send_closure(manager_, &ValidatorManager::update_shard_configuration, masterchain_state_);
std::set<ShardIdFull> new_shards_to_monitor;
std::set<WorkchainId> workchains;
auto cur_time = masterchain_state_->get_unix_time();
new_shards_to_monitor.insert(ShardIdFull(masterchainId));
for (const auto &info : masterchain_state_->get_shards()) {
auto shard = info->shard();
workchains.insert(shard.workchain);
bool will_split = shard.pfx_len() < max_shard_pfx_len &&
((info->fsm_state() == McShardHash::FsmState::fsm_split && info->fsm_utime() < cur_time + 60) ||
info->before_split());
bool will_merge = shard.pfx_len() > 0 &&
((info->fsm_state() == McShardHash::FsmState::fsm_merge && info->fsm_utime() < cur_time + 60) ||
info->before_merge());
if (opts_->need_monitor(shard) || (will_merge && opts_->need_monitor(shard_parent(shard)))) {
new_shards_to_monitor.insert(shard);
}
if (will_merge && opts_->need_monitor(shard_parent(shard))) {
new_shards_to_monitor.insert(shard_parent(shard));
}
if (will_split) {
for (int id = 0; id < 2; ++id) {
if (opts_->need_monitor(shard_child(shard, id))) {
new_shards_to_monitor.insert(shard_child(shard, id));
}
}
}
}
std::vector<BlockIdExt> new_workchains;
for (const auto &wpair : masterchain_state_->get_workchain_list()) {
ton::WorkchainId wc = wpair.first;
const block::WorkchainInfo *winfo = wpair.second.get();
auto shard = ShardIdFull(wc);
if (workchains.count(wc) == 0 && winfo->active && winfo->enabled_since <= cur_time && opts_->need_monitor(shard)) {
new_shards_to_monitor.insert(shard);
if (shards_to_monitor_.count(shard) == 0) {
new_workchains.push_back(BlockIdExt(wc, shardIdAll, 0, winfo->zerostate_root_hash, winfo->zerostate_file_hash));
}
}
}
td::actor::send_closure(manager_, &ValidatorManager::update_shard_configuration, masterchain_state_,
new_shards_to_monitor);
shards_to_monitor_ = std::move(new_shards_to_monitor);
for (BlockIdExt block_id : new_workchains) {
td::actor::send_closure(manager_, &ValidatorManager::wait_block_state_short, block_id, shard_client_priority(),
td::Timestamp::in(60.0), [](td::Result<td::Ref<ShardState>>) {});
}
}
void ShardClient::force_update_shard_client(BlockHandle handle, td::Promise<td::Unit> promise) {

2
validator/shard-client.hpp
View file

@ -42,7 +42,7 @@ class ShardClient : public td::actor::Actor {
td::Promise<td::Unit> promise_;
std::set<ShardIdFull> created_overlays_;
std::set<ShardIdFull> shards_to_monitor_ = {ShardIdFull(masterchainId)};
public:
ShardClient(td::Ref<ValidatorManagerOptions> opts, BlockHandle masterchain_block_handle,

3
validator/validator.h
View file

@ -112,7 +112,8 @@ class ValidatorManagerInterface : public td::actor::Actor {
virtual ~Callback() = default;
virtual void initial_read_complete(BlockHandle top_masterchain_blocks) = 0;
virtual void update_shard_configuration(td::Ref<ton::validator::MasterchainState> state) = 0;
virtual void update_shard_configuration(td::Ref<ton::validator::MasterchainState> state,
std::set<ShardIdFull> shards_to_monitor) = 0;
virtual void send_ihr_message(AccountIdPrefixFull dst, td::BufferSlice data) = 0;
virtual void send_ext_message(AccountIdPrefixFull dst, td::BufferSlice data) = 0;