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

Configure shards for custom overlays

Browse source
This commit is contained in:
SpyCheese 2024-09-26 19:24:03 +03:00
parent 4fcb2cd576
commit 9dfa3fa11a
5 changed files with 48 additions and 33 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
tl/generate/scheme/ton_api.tl
View file

@ -660,7 +660,8 @@ engine.validator.config out_port:int addrs:(vector engine.Addr) adnl:(vector eng
gc:engine.gc = engine.validator.Config; gc:engine.gc = engine.validator.Config;
engine.validator.customOverlayNode adnl_id:int256 msg_sender:Bool msg_sender_priority:int block_sender:Bool = engine.validator.CustomOverlayNode; engine.validator.customOverlayNode adnl_id:int256 msg_sender:Bool msg_sender_priority:int block_sender:Bool = engine.validator.CustomOverlayNode;
engine.validator.customOverlay name:string nodes:(vector engine.validator.customOverlayNode) = engine.validator.CustomOverlay; engine.validator.customOverlay name:string nodes:(vector engine.validator.customOverlayNode) sender_shards:(vector tonNode.shardId)
= engine.validator.CustomOverlay;
engine.validator.customOverlaysConfig overlays:(vector engine.validator.customOverlay) = engine.validator.CustomOverlaysConfig; engine.validator.customOverlaysConfig overlays:(vector engine.validator.customOverlay) = engine.validator.CustomOverlaysConfig;
engine.validator.collatorOptions engine.validator.collatorOptions

BIN
tl/generate/scheme/ton_api.tlo
View file

Binary file not shown.

6
validator-engine-console/validator-engine-console-query.cpp
View file

@ -1229,6 +1229,12 @@ td::Status ShowCustomOverlaysQuery::receive(td::BufferSlice data) {
: "") : "")
<< (node->block_sender_ ? " (block sender)" : "") << "\n"; << (node->block_sender_ ? " (block sender)" : "") << "\n";
} }
if (!overlay->sender_shards_.empty()) {
td::TerminalIO::out() << "Sender shards:\n";
for (const auto &shard : overlay->sender_shards_) {
td::TerminalIO::out() << " " << ton::create_shard_id(shard).to_str() << "\n";
}
}
td::TerminalIO::out() << "\n"; td::TerminalIO::out() << "\n";
} }
return td::Status::OK(); return td::Status::OK();

70
validator/full-node.cpp
View file

@ -21,6 +21,7 @@
#include "td/actor/MultiPromise.h" #include "td/actor/MultiPromise.h"
#include "full-node.h" #include "full-node.h"
#include "common/delay.h" #include "common/delay.h"
#include "ton/ton-tl.hpp"
namespace ton { namespace ton {
@ -209,35 +210,28 @@ void FullNodeImpl::on_new_masterchain_block(td::Ref<MasterchainState> state, std
int min_split = state->monitor_min_split_depth(shard.workchain); int min_split = state->monitor_min_split_depth(shard.workchain);
return min_split < shard.pfx_len() ? shard_prefix(shard, min_split) : shard; return min_split < shard.pfx_len() ? shard_prefix(shard, min_split) : shard;
}; };
auto set_active = [&](ShardIdFull shard) {
while (new_active.emplace(shard).second && shard.pfx_len() > 0) {
shard = shard_parent(shard);
}
};
for (auto &info : state->get_shards()) { for (auto &info : state->get_shards()) {
workchains.insert(info->shard().workchain); workchains.insert(info->shard().workchain);
all_shards.insert(cut_shard(info->shard())); all_shards.insert(cut_shard(info->shard()));
} }
for (const auto &wpair : state->get_workchain_list()) { for (const auto &[wc, winfo] : state->get_workchain_list()) {
ton::WorkchainId wc = wpair.first; if (!workchains.contains(wc) && winfo->active && winfo->enabled_since <= state->get_unix_time()) {
const block::WorkchainInfo *winfo = wpair.second.get();
if (workchains.count(wc) == 0 && winfo->active && winfo->enabled_since <= state->get_unix_time()) {
all_shards.insert(ShardIdFull(wc)); all_shards.insert(ShardIdFull(wc));
} }
} }
for (ShardIdFull shard : shards_to_monitor) { for (ShardIdFull shard : shards_to_monitor) {
set_active(cut_shard(shard)); new_active.insert(cut_shard(shard));
} }
for (auto it = shards_.begin(); it != shards_.end(); ) { for (auto it = shards_.begin(); it != shards_.end(); ) {
if (all_shards.count(it->first)) { if (all_shards.contains(it->first)) {
++it; ++it;
} else { } else {
it = shards_.erase(it); it = shards_.erase(it);
} }
} }
for (ShardIdFull shard : all_shards) { for (ShardIdFull shard : all_shards) {
bool active = new_active.count(shard); bool active = new_active.contains(shard);
bool overlay_exists = !shards_[shard].actor.empty(); bool overlay_exists = !shards_[shard].actor.empty();
if (active || join_all_overlays || overlay_exists) { if (active || join_all_overlays || overlay_exists) {
update_shard_actor(shard, active); update_shard_actor(shard, active);
@ -254,8 +248,8 @@ void FullNodeImpl::on_new_masterchain_block(td::Ref<MasterchainState> state, std
if (!use_old_private_overlays_) { if (!use_old_private_overlays_) {
std::set<adnl::AdnlNodeIdShort> my_adnl_ids; std::set<adnl::AdnlNodeIdShort> my_adnl_ids;
my_adnl_ids.insert(adnl_id_); my_adnl_ids.insert(adnl_id_);
for (const auto &p : local_collator_nodes_) { for (const auto &[adnl_id, _] : local_collator_nodes_) {
my_adnl_ids.insert(p.first); my_adnl_ids.insert(adnl_id);
} }
for (auto key : local_keys_) { for (auto key : local_keys_) {
auto it = current_validators_.find(key); auto it = current_validators_.find(key);
@ -307,11 +301,12 @@ void FullNodeImpl::send_ext_message(AccountIdPrefixFull dst, td::BufferSlice dat
VLOG(FULL_NODE_WARNING) << "dropping OUT ext message to unknown shard"; VLOG(FULL_NODE_WARNING) << "dropping OUT ext message to unknown shard";
return; return;
} }
for (auto &private_overlay : custom_overlays_) { for (auto &[_, private_overlay] : custom_overlays_) {
for (auto &actor : private_overlay.second.actors_) { if (private_overlay.params_.send_shard(dst.as_leaf_shard())) {
auto local_id = actor.first; for (auto &[local_id, actor] : private_overlay.actors_) {
if (private_overlay.second.params_.msg_senders_.count(local_id)) { if (private_overlay.params_.msg_senders_.contains(local_id)) {
td::actor::send_closure(actor.second, &FullNodeCustomOverlay::send_external_message, data.clone()); td::actor::send_closure(actor, &FullNodeCustomOverlay::send_external_message, data.clone());
}
} }
} }
} }
@ -743,7 +738,7 @@ void FullNodeImpl::update_custom_overlay(CustomOverlayInfo &overlay) {
} }
} }
void FullNodeImpl::send_block_broadcast_to_custom_overlays(const BlockBroadcast& broadcast) { void FullNodeImpl::send_block_broadcast_to_custom_overlays(const BlockBroadcast &broadcast) {
if (!custom_overlays_sent_broadcasts_.insert(broadcast.block_id).second) { if (!custom_overlays_sent_broadcasts_.insert(broadcast.block_id).second) {
return; return;
} }
@ -752,11 +747,12 @@ void FullNodeImpl::send_block_broadcast_to_custom_overlays(const BlockBroadcast&
custom_overlays_sent_broadcasts_.erase(custom_overlays_sent_broadcasts_lru_.front()); custom_overlays_sent_broadcasts_.erase(custom_overlays_sent_broadcasts_lru_.front());
custom_overlays_sent_broadcasts_lru_.pop(); custom_overlays_sent_broadcasts_lru_.pop();
} }
for (auto &private_overlay : custom_overlays_) { for (auto &[_, private_overlay] : custom_overlays_) {
for (auto &actor : private_overlay.second.actors_) { if (private_overlay.params_.send_shard(broadcast.block_id.shard_full())) {
auto local_id = actor.first; for (auto &[local_id, actor] : private_overlay.actors_) {
if (private_overlay.second.params_.block_senders_.count(local_id)) { if (private_overlay.params_.block_senders_.contains(local_id)) {
td::actor::send_closure(actor.second, &FullNodeCustomOverlay::send_broadcast, broadcast.clone()); td::actor::send_closure(actor, &FullNodeCustomOverlay::send_broadcast, broadcast.clone());
}
} }
} }
} }
@ -774,12 +770,13 @@ void FullNodeImpl::send_block_candidate_broadcast_to_custom_overlays(const Block
custom_overlays_sent_broadcasts_.erase(custom_overlays_sent_broadcasts_lru_.front()); custom_overlays_sent_broadcasts_.erase(custom_overlays_sent_broadcasts_lru_.front());
custom_overlays_sent_broadcasts_lru_.pop(); custom_overlays_sent_broadcasts_lru_.pop();
} }
for (auto &private_overlay : custom_overlays_) { for (auto &[_, private_overlay] : custom_overlays_) {
for (auto &actor : private_overlay.second.actors_) { if (private_overlay.params_.send_shard(block_id.shard_full())) {
auto local_id = actor.first; for (auto &[local_id, actor] : private_overlay.actors_) {
if (private_overlay.second.params_.block_senders_.count(local_id)) { if (private_overlay.params_.block_senders_.contains(local_id)) {
td::actor::send_closure(actor.second, &FullNodeCustomOverlay::send_block_candidate, block_id, cc_seqno, td::actor::send_closure(actor, &FullNodeCustomOverlay::send_block_candidate, block_id, cc_seqno,
validator_set_hash, data.clone()); validator_set_hash, data.clone());
}
} }
} }
} }
@ -834,18 +831,27 @@ bool FullNodeConfig::operator!=(const FullNodeConfig &rhs) const {
return !(*this == rhs); return !(*this == rhs);
} }
bool CustomOverlayParams::send_shard(const ShardIdFull &shard) const {
return sender_shards_.empty() || std::ranges::any_of(sender_shards_, [&](const ShardIdFull &our_shard) {
return shard_intersects(shard, our_shard);
});
}
CustomOverlayParams CustomOverlayParams::fetch(const ton_api::engine_validator_customOverlay& f) { CustomOverlayParams CustomOverlayParams::fetch(const ton_api::engine_validator_customOverlay& f) {
CustomOverlayParams c; CustomOverlayParams c;
c.name_ = f.name_; c.name_ = f.name_;
for (const auto &node : f.nodes_) { for (const auto &node : f.nodes_) {
c.nodes_.emplace_back(node->adnl_id_); c.nodes_.emplace_back(node->adnl_id_);
if (node->msg_sender_) { if (node->msg_sender_) {
c.msg_senders_[ton::adnl::AdnlNodeIdShort{node->adnl_id_}] = node->msg_sender_priority_; c.msg_senders_[adnl::AdnlNodeIdShort{node->adnl_id_}] = node->msg_sender_priority_;
} }
if (node->block_sender_) { if (node->block_sender_) {
c.block_senders_.emplace(node->adnl_id_); c.block_senders_.emplace(node->adnl_id_);
} }
} }
for (const auto &shard : f.sender_shards_) {
c.sender_shards_.push_back(create_shard_id(shard));
}
return c; return c;
} }

2
validator/full-node.h
View file

@ -60,7 +60,9 @@ struct CustomOverlayParams {
std::vector<adnl::AdnlNodeIdShort> nodes_; std::vector<adnl::AdnlNodeIdShort> nodes_;
std::map<adnl::AdnlNodeIdShort, int> msg_senders_; std::map<adnl::AdnlNodeIdShort, int> msg_senders_;
std::set<adnl::AdnlNodeIdShort> block_senders_; std::set<adnl::AdnlNodeIdShort> block_senders_;
std::vector<ShardIdFull> sender_shards_;
bool send_shard(const ShardIdFull& shard) const;
static CustomOverlayParams fetch(const ton_api::engine_validator_customOverlay& f); static CustomOverlayParams fetch(const ton_api::engine_validator_customOverlay& f);
}; };