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;
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.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";
}
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";
}
return td::Status::OK();

70
validator/full-node.cpp
View file

@ -21,6 +21,7 @@
#include "td/actor/MultiPromise.h"
#include "full-node.h"
#include "common/delay.h"
#include "ton/ton-tl.hpp"
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);
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()) {
workchains.insert(info->shard().workchain);
all_shards.insert(cut_shard(info->shard()));
}
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 <= state->get_unix_time()) {
for (const auto &[wc, winfo] : state->get_workchain_list()) {
if (!workchains.contains(wc) && winfo->active && winfo->enabled_since <= state->get_unix_time()) {
all_shards.insert(ShardIdFull(wc));
}
}
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(); ) {
if (all_shards.count(it->first)) {
if (all_shards.contains(it->first)) {
++it;
} else {
it = shards_.erase(it);
}
}
for (ShardIdFull shard : all_shards) {
bool active = new_active.count(shard);
bool active = new_active.contains(shard);
bool overlay_exists = !shards_[shard].actor.empty();
if (active || join_all_overlays || overlay_exists) {
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_) {
std::set<adnl::AdnlNodeIdShort> my_adnl_ids;
my_adnl_ids.insert(adnl_id_);
for (const auto &p : local_collator_nodes_) {
my_adnl_ids.insert(p.first);
for (const auto &[adnl_id, _] : local_collator_nodes_) {
my_adnl_ids.insert(adnl_id);
}
for (auto key : local_keys_) {
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";
return;
}
for (auto &private_overlay : custom_overlays_) {
for (auto &actor : private_overlay.second.actors_) {
auto local_id = actor.first;
if (private_overlay.second.params_.msg_senders_.count(local_id)) {
td::actor::send_closure(actor.second, &FullNodeCustomOverlay::send_external_message, data.clone());
for (auto &[_, private_overlay] : custom_overlays_) {
if (private_overlay.params_.send_shard(dst.as_leaf_shard())) {
for (auto &[local_id, actor] : private_overlay.actors_) {
if (private_overlay.params_.msg_senders_.contains(local_id)) {
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) {
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_lru_.pop();
}
for (auto &private_overlay : custom_overlays_) {
for (auto &actor : private_overlay.second.actors_) {
auto local_id = actor.first;
if (private_overlay.second.params_.block_senders_.count(local_id)) {
td::actor::send_closure(actor.second, &FullNodeCustomOverlay::send_broadcast, broadcast.clone());
for (auto &[_, private_overlay] : custom_overlays_) {
if (private_overlay.params_.send_shard(broadcast.block_id.shard_full())) {
for (auto &[local_id, actor] : private_overlay.actors_) {
if (private_overlay.params_.block_senders_.contains(local_id)) {
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_lru_.pop();
}
for (auto &private_overlay : custom_overlays_) {
for (auto &actor : private_overlay.second.actors_) {
auto local_id = actor.first;
if (private_overlay.second.params_.block_senders_.count(local_id)) {
td::actor::send_closure(actor.second, &FullNodeCustomOverlay::send_block_candidate, block_id, cc_seqno,
validator_set_hash, data.clone());
for (auto &[_, private_overlay] : custom_overlays_) {
if (private_overlay.params_.send_shard(block_id.shard_full())) {
for (auto &[local_id, actor] : private_overlay.actors_) {
if (private_overlay.params_.block_senders_.contains(local_id)) {
td::actor::send_closure(actor, &FullNodeCustomOverlay::send_block_candidate, block_id, cc_seqno,
validator_set_hash, data.clone());
}
}
}
}
@ -834,18 +831,27 @@ bool FullNodeConfig::operator!=(const FullNodeConfig &rhs) const {
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 c;
c.name_ = f.name_;
for (const auto &node : f.nodes_) {
c.nodes_.emplace_back(node->adnl_id_);
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_) {
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;
}

2
validator/full-node.h
View file

@ -60,7 +60,9 @@ struct CustomOverlayParams {
std::vector<adnl::AdnlNodeIdShort> nodes_;
std::map<adnl::AdnlNodeIdShort, int> msg_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);
};