external/ton
1
0
Fork 0
mirror of https://github.com/ton-blockchain/ton synced 2025-02-15 04:32:21 +00:00
Code Issues Releases Wiki Activity

Changes in fast sync overlays

Browse source 
Join all overlays (not only monitoring shards) in order to be able to send broadcasts to other overlays
This commit is contained in:
SpyCheese 2024-07-18 12:43:55 +03:00
parent 36b98e8aa0
commit 5743dbf335
2 changed files with 36 additions and 17 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

48
validator/full-node-fast-sync-overlays.cpp
View file

@ -201,8 +201,8 @@ void FullNodeFastSyncOverlay::init() {
current_validators_adnl_.end();
if (!shard_.is_masterchain()) {
options.default_permanent_members_flags_ = overlay::OverlayMemberFlags::DoNotReceiveBroadcasts;
options.local_overlay_member_flags_ = is_validator ? overlay::OverlayMemberFlags::DoNotReceiveBroadcasts : 0;
}
options.local_overlay_member_flags_ = receive_broadcasts_ ? 0 : overlay::OverlayMemberFlags::DoNotReceiveBroadcasts;
options.max_slaves_in_semiprivate_overlay_ = 100000; // TODO: set lower limit (high limit for testing)
td::actor::send_closure(overlays_, &overlay::Overlays::create_semiprivate_overlay, local_id_,
overlay_id_full_.clone(), current_validators_adnl_, root_public_keys_, member_certificate_,
@ -235,6 +235,17 @@ void FullNodeFastSyncOverlay::set_member_certificate(overlay::OverlayMemberCerti
}
}
void FullNodeFastSyncOverlay::set_receive_broadcasts(bool value) {
if (value == receive_broadcasts_) {
return;
}
receive_broadcasts_ = value;
if (inited_) {
td::actor::send_closure(overlays_, &ton::overlay::Overlays::delete_overlay, local_id_, overlay_id_);
init();
}
}
void FullNodeFastSyncOverlay::get_stats_extra(td::Promise<std::string> promise) {
auto res = create_tl_object<ton_api::engine_validator_fastSyncOverlayStats>();
res->shard_ = shard_.to_str();
@ -278,19 +289,21 @@ void FullNodeFastSyncOverlays::update_overlays(td::Ref<MasterchainState> state,
monitoring_shards.insert(ShardIdFull{masterchainId});
std::set<ShardIdFull> all_shards;
all_shards.insert(ShardIdFull{masterchainId});
td::uint32 monitor_min_split = state->monitor_min_split_depth(basechainId);
for (td::uint64 i = 0; i < (1ULL << monitor_min_split); ++i) {
all_shards.insert(ShardIdFull{basechainId, (i * 2 + 1) << (63 - monitor_min_split)});
for (const auto& desc : state->get_shards()) {
ShardIdFull shard = desc->shard();
td::uint32 monitor_min_split = state->monitor_min_split_depth(shard.workchain);
if (shard.pfx_len() > monitor_min_split) {
shard = shard_prefix(shard, monitor_min_split);
}
all_shards.insert(shard);
}
// Remove overlays for removed adnl ids and shards
for (auto it = id_to_overlays_.begin(); it != id_to_overlays_.end();) {
if (my_adnl_ids.count(it->first)) {
auto &overlays_info = it->second;
;
auto &current_shards = overlays_info.is_validator_ ? all_shards : monitoring_shards;
for (auto it2 = overlays_info.overlays_.begin(); it2 != overlays_info.overlays_.end();) {
if (current_shards.count(it2->first)) {
if (all_shards.count(it2->first)) {
++it2;
} else {
it2 = overlays_info.overlays_.erase(it2);
@ -330,7 +343,7 @@ void FullNodeFastSyncOverlays::update_overlays(td::Ref<MasterchainState> state,
for (auto &[local_id, overlays_info] : id_to_overlays_) {
overlays_info.is_validator_ =
std::binary_search(current_validators_adnl_.begin(), current_validators_adnl_.end(), local_id);
for (auto &[_, overlay] : overlays_info.overlays_) {
for (auto &[shard, overlay] : overlays_info.overlays_) {
td::actor::send_closure(overlay, &FullNodeFastSyncOverlay::set_validators, root_public_keys_,
current_validators_adnl_);
}
@ -388,17 +401,20 @@ void FullNodeFastSyncOverlays::update_overlays(td::Ref<MasterchainState> state,
}
// Update shard overlays
auto &current_shards = overlays_info.is_validator_ ? all_shards : monitoring_shards;
for (ShardIdFull shard_id : current_shards) {
auto &overlay = overlays_info.overlays_[shard_id];
for (ShardIdFull shard : all_shards) {
bool receive_broadcasts = overlays_info.is_validator_ ? shard.is_masterchain() : monitoring_shards.count(shard);
auto &overlay = overlays_info.overlays_[shard];
if (overlay.empty()) {
overlay = td::actor::create_actor<FullNodeFastSyncOverlay>(
PSTRING() << "FastSyncOv" << shard_id.to_str(), local_id, shard_id, zero_state_file_hash,
root_public_keys_, current_validators_adnl_, overlays_info.current_certificate_, keyring, adnl, overlays,
PSTRING() << "FastSyncOv" << shard.to_str(), local_id, shard, zero_state_file_hash, root_public_keys_,
current_validators_adnl_, overlays_info.current_certificate_, receive_broadcasts, keyring, adnl, overlays,
validator_manager, full_node);
} else if (changed_certificate) {
td::actor::send_closure(overlay, &FullNodeFastSyncOverlay::set_member_certificate,
overlays_info.current_certificate_);
} else {
td::actor::send_closure(overlay, &FullNodeFastSyncOverlay::set_receive_broadcasts, receive_broadcasts);
if (changed_certificate) {
td::actor::send_closure(overlay, &FullNodeFastSyncOverlay::set_member_certificate,
overlays_info.current_certificate_);
}
}
}
}

5
validator/full-node-fast-sync-overlays.hpp
View file

@ -49,11 +49,12 @@ class FullNodeFastSyncOverlay : public td::actor::Actor {
void set_validators(std::vector<PublicKeyHash> root_public_keys,
std::vector<adnl::AdnlNodeIdShort> current_validators_adnl);
void set_member_certificate(overlay::OverlayMemberCertificate member_certificate);
void set_receive_broadcasts(bool value);
FullNodeFastSyncOverlay(adnl::AdnlNodeIdShort local_id, ShardIdFull shard, FileHash zero_state_file_hash,
std::vector<PublicKeyHash> root_public_keys,
std::vector<adnl::AdnlNodeIdShort> current_validators_adnl,
overlay::OverlayMemberCertificate member_certificate,
overlay::OverlayMemberCertificate member_certificate, bool receive_broadcasts,
td::actor::ActorId<keyring::Keyring> keyring, td::actor::ActorId<adnl::Adnl> adnl,
td::actor::ActorId<overlay::Overlays> overlays,
td::actor::ActorId<ValidatorManagerInterface> validator_manager,
@ -63,6 +64,7 @@ class FullNodeFastSyncOverlay : public td::actor::Actor {
, root_public_keys_(std::move(root_public_keys))
, current_validators_adnl_(std::move(current_validators_adnl))
, member_certificate_(std::move(member_certificate))
, receive_broadcasts_(receive_broadcasts)
, zero_state_file_hash_(zero_state_file_hash)
, keyring_(keyring)
, adnl_(adnl)
@ -77,6 +79,7 @@ class FullNodeFastSyncOverlay : public td::actor::Actor {
std::vector<PublicKeyHash> root_public_keys_;
std::vector<adnl::AdnlNodeIdShort> current_validators_adnl_;
overlay::OverlayMemberCertificate member_certificate_;
bool receive_broadcasts_;
FileHash zero_state_file_hash_;
td::actor::ActorId<keyring::Keyring> keyring_;