mirror of
https://github.com/ton-blockchain/ton
synced 2025-03-09 15:40:10 +00:00
Fast-sync overlays
* Semiprivate overlays * Fast sync overlays in full-node * Adjust shard overlays
This commit is contained in:
SpyCheese
parent
ac3b8d6088
commit
3a8ef60bbb
38 changed files with 2545 additions and 964 deletions
|
|
@ -153,8 +153,8 @@ set(FULL_NODE_SOURCE
|
|||
full-node-private-overlay.cpp
|
||||
full-node-serializer.hpp
|
||||
full-node-serializer.cpp
|
||||
full-node-private-overlay-v2.hpp
|
||||
full-node-private-overlay-v2.cpp
|
||||
full-node-fast-sync-overlays.hpp
|
||||
full-node-fast-sync-overlays.cpp
|
||||
|
||||
net/download-block.hpp
|
||||
net/download-block.cpp
|
||||
|
|
|
|||
416
validator/full-node-fast-sync-overlays.cpp
Normal file
416
validator/full-node-fast-sync-overlays.cpp
Normal file
|
|
@ -0,0 +1,416 @@
|
|||
/*
|
||||
This file is part of TON Blockchain Library.
|
||||
|
||||
TON Blockchain Library is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published by
|
||||
the Free Software Foundation, either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
TON Blockchain Library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with TON Blockchain Library. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "full-node-fast-sync-overlays.hpp"
|
||||
|
||||
#include "checksum.h"
|
||||
#include "ton/ton-tl.hpp"
|
||||
#include "common/delay.h"
|
||||
#include "td/utils/JsonBuilder.h"
|
||||
#include "tl/tl_json.h"
|
||||
#include "auto/tl/ton_api_json.h"
|
||||
#include "full-node-serializer.hpp"
|
||||
|
||||
namespace ton::validator::fullnode {
|
||||
|
||||
void FullNodeFastSyncOverlay::process_broadcast(PublicKeyHash src, ton_api::tonNode_blockBroadcast &query) {
|
||||
process_block_broadcast(src, query);
|
||||
}
|
||||
|
||||
void FullNodeFastSyncOverlay::process_broadcast(PublicKeyHash src, ton_api::tonNode_blockBroadcastCompressed &query) {
|
||||
process_block_broadcast(src, query);
|
||||
}
|
||||
|
||||
void FullNodeFastSyncOverlay::process_block_broadcast(PublicKeyHash src, ton_api::tonNode_Broadcast &query) {
|
||||
auto B = deserialize_block_broadcast(query, overlay::Overlays::max_fec_broadcast_size());
|
||||
if (B.is_error()) {
|
||||
LOG(DEBUG) << "dropped broadcast: " << B.move_as_error();
|
||||
return;
|
||||
}
|
||||
VLOG(FULL_NODE_DEBUG) << "Received block broadcast in fast sync overlay from " << src << ": "
|
||||
<< B.ok().block_id.to_str();
|
||||
td::actor::send_closure(full_node_, &FullNode::process_block_broadcast, B.move_as_ok());
|
||||
}
|
||||
|
||||
void FullNodeFastSyncOverlay::process_broadcast(PublicKeyHash src, ton_api::tonNode_newShardBlockBroadcast &query) {
|
||||
BlockIdExt block_id = create_block_id(query.block_->block_);
|
||||
VLOG(FULL_NODE_DEBUG) << "Received newShardBlockBroadcast in fast sync overlay from " << src << ": "
|
||||
<< block_id.to_str();
|
||||
td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::new_shard_block, block_id,
|
||||
query.block_->cc_seqno_, std::move(query.block_->data_));
|
||||
}
|
||||
|
||||
void FullNodeFastSyncOverlay::process_broadcast(PublicKeyHash src, ton_api::tonNode_newBlockCandidateBroadcast &query) {
|
||||
process_block_candidate_broadcast(src, query);
|
||||
}
|
||||
|
||||
void FullNodeFastSyncOverlay::process_broadcast(PublicKeyHash src,
|
||||
ton_api::tonNode_newBlockCandidateBroadcastCompressed &query) {
|
||||
process_block_candidate_broadcast(src, query);
|
||||
}
|
||||
|
||||
void FullNodeFastSyncOverlay::process_block_candidate_broadcast(PublicKeyHash src, ton_api::tonNode_Broadcast &query) {
|
||||
BlockIdExt block_id;
|
||||
CatchainSeqno cc_seqno;
|
||||
td::uint32 validator_set_hash;
|
||||
td::BufferSlice data;
|
||||
auto S = deserialize_block_candidate_broadcast(query, block_id, cc_seqno, validator_set_hash, data,
|
||||
overlay::Overlays::max_fec_broadcast_size());
|
||||
if (S.is_error()) {
|
||||
LOG(DEBUG) << "dropped broadcast: " << S;
|
||||
return;
|
||||
}
|
||||
if (data.size() > FullNode::max_block_size()) {
|
||||
VLOG(FULL_NODE_WARNING) << "received block candidate with too big size from " << src;
|
||||
return;
|
||||
}
|
||||
if (td::sha256_bits256(data.as_slice()) != block_id.file_hash) {
|
||||
VLOG(FULL_NODE_WARNING) << "received block candidate with incorrect file hash from " << src;
|
||||
return;
|
||||
}
|
||||
VLOG(FULL_NODE_DEBUG) << "Received newBlockCandidate in fast sync overlay from " << src << ": " << block_id.to_str();
|
||||
td::actor::send_closure(full_node_, &FullNode::process_block_candidate_broadcast, block_id, cc_seqno,
|
||||
validator_set_hash, std::move(data));
|
||||
}
|
||||
|
||||
void FullNodeFastSyncOverlay::receive_broadcast(PublicKeyHash src, td::BufferSlice broadcast) {
|
||||
auto B = fetch_tl_object<ton_api::tonNode_Broadcast>(std::move(broadcast), true);
|
||||
if (B.is_error()) {
|
||||
return;
|
||||
}
|
||||
|
||||
ton_api::downcast_call(*B.move_as_ok(), [src, Self = this](auto &obj) { Self->process_broadcast(src, obj); });
|
||||
}
|
||||
|
||||
void FullNodeFastSyncOverlay::send_shard_block_info(BlockIdExt block_id, CatchainSeqno cc_seqno, td::BufferSlice data) {
|
||||
if (!inited_) {
|
||||
return;
|
||||
}
|
||||
VLOG(FULL_NODE_DEBUG) << "Sending newShardBlockBroadcast in fast sync overlay: " << block_id.to_str();
|
||||
auto B = create_serialize_tl_object<ton_api::tonNode_newShardBlockBroadcast>(
|
||||
create_tl_object<ton_api::tonNode_newShardBlock>(create_tl_block_id(block_id), cc_seqno, std::move(data)));
|
||||
if (B.size() <= overlay::Overlays::max_simple_broadcast_size()) {
|
||||
td::actor::send_closure(overlays_, &overlay::Overlays::send_broadcast_ex, local_id_, overlay_id_,
|
||||
local_id_.pubkey_hash(), 0, std::move(B));
|
||||
} else {
|
||||
td::actor::send_closure(overlays_, &overlay::Overlays::send_broadcast_fec_ex, local_id_, overlay_id_,
|
||||
local_id_.pubkey_hash(), overlay::Overlays::BroadcastFlagAnySender(), std::move(B));
|
||||
}
|
||||
}
|
||||
|
||||
void FullNodeFastSyncOverlay::send_broadcast(BlockBroadcast broadcast) {
|
||||
if (!inited_) {
|
||||
return;
|
||||
}
|
||||
VLOG(FULL_NODE_DEBUG) << "Sending block broadcast in fast sync overlay (with compression): "
|
||||
<< broadcast.block_id.to_str();
|
||||
auto B = serialize_block_broadcast(broadcast, true); // compression_enabled = true
|
||||
if (B.is_error()) {
|
||||
VLOG(FULL_NODE_WARNING) << "failed to serialize block broadcast: " << B.move_as_error();
|
||||
return;
|
||||
}
|
||||
td::actor::send_closure(overlays_, &overlay::Overlays::send_broadcast_fec_ex, local_id_, overlay_id_,
|
||||
local_id_.pubkey_hash(), overlay::Overlays::BroadcastFlagAnySender(), B.move_as_ok());
|
||||
}
|
||||
|
||||
void FullNodeFastSyncOverlay::send_block_candidate(BlockIdExt block_id, CatchainSeqno cc_seqno,
|
||||
td::uint32 validator_set_hash, td::BufferSlice data) {
|
||||
if (!inited_) {
|
||||
return;
|
||||
}
|
||||
auto B =
|
||||
serialize_block_candidate_broadcast(block_id, cc_seqno, validator_set_hash, data, true); // compression enabled
|
||||
if (B.is_error()) {
|
||||
VLOG(FULL_NODE_WARNING) << "failed to serialize block candidate broadcast: " << B.move_as_error();
|
||||
return;
|
||||
}
|
||||
VLOG(FULL_NODE_DEBUG) << "Sending newBlockCandidate in fast sync overlay (with compression): " << block_id.to_str();
|
||||
td::actor::send_closure(overlays_, &overlay::Overlays::send_broadcast_fec_ex, local_id_, overlay_id_,
|
||||
local_id_.pubkey_hash(), overlay::Overlays::BroadcastFlagAnySender(), B.move_as_ok());
|
||||
}
|
||||
|
||||
void FullNodeFastSyncOverlay::start_up() {
|
||||
auto X = create_hash_tl_object<ton_api::tonNode_fastSyncOverlayId>(zero_state_file_hash_, create_tl_shard_id(shard_));
|
||||
td::BufferSlice b{32};
|
||||
b.as_slice().copy_from(as_slice(X));
|
||||
overlay_id_full_ = overlay::OverlayIdFull{std::move(b)};
|
||||
overlay_id_ = overlay_id_full_.compute_short_id();
|
||||
|
||||
try_init();
|
||||
}
|
||||
|
||||
void FullNodeFastSyncOverlay::try_init() {
|
||||
// Sometimes adnl id is added to validator engine later (or not at all)
|
||||
td::actor::send_closure(
|
||||
adnl_, &adnl::Adnl::check_id_exists, local_id_, [SelfId = actor_id(this)](td::Result<bool> R) {
|
||||
if (R.is_ok() && R.ok()) {
|
||||
td::actor::send_closure(SelfId, &FullNodeFastSyncOverlay::init);
|
||||
} else {
|
||||
delay_action([SelfId]() { td::actor::send_closure(SelfId, &FullNodeFastSyncOverlay::try_init); },
|
||||
td::Timestamp::in(30.0));
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
void FullNodeFastSyncOverlay::init() {
|
||||
LOG(INFO) << "Creating fast sync overlay for shard " << shard_.to_str() << ", adnl_id=" << local_id_;
|
||||
class Callback : public overlay::Overlays::Callback {
|
||||
public:
|
||||
void receive_message(adnl::AdnlNodeIdShort src, overlay::OverlayIdShort overlay_id, td::BufferSlice data) override {
|
||||
}
|
||||
void receive_query(adnl::AdnlNodeIdShort src, overlay::OverlayIdShort overlay_id, td::BufferSlice data,
|
||||
td::Promise<td::BufferSlice> promise) override {
|
||||
}
|
||||
void receive_broadcast(PublicKeyHash src, overlay::OverlayIdShort overlay_id, td::BufferSlice data) override {
|
||||
td::actor::send_closure(node_, &FullNodeFastSyncOverlay::receive_broadcast, src, std::move(data));
|
||||
}
|
||||
void check_broadcast(PublicKeyHash src, overlay::OverlayIdShort overlay_id, td::BufferSlice data,
|
||||
td::Promise<td::Unit> promise) override {
|
||||
}
|
||||
void get_stats_extra(td::Promise<std::string> promise) override {
|
||||
td::actor::send_closure(node_, &FullNodeFastSyncOverlay::get_stats_extra, std::move(promise));
|
||||
}
|
||||
explicit Callback(td::actor::ActorId<FullNodeFastSyncOverlay> node) : node_(node) {
|
||||
}
|
||||
|
||||
private:
|
||||
td::actor::ActorId<FullNodeFastSyncOverlay> node_;
|
||||
};
|
||||
|
||||
overlay::OverlayPrivacyRules rules{overlay::Overlays::max_fec_broadcast_size(),
|
||||
overlay::CertificateFlags::AllowFec | overlay::CertificateFlags::Trusted,
|
||||
{}};
|
||||
std::string scope = PSTRING() << R"({ "type": "fast-sync", "shard_id": )" << shard_.shard
|
||||
<< ", \"workchain_id\": " << shard_.workchain << " }";
|
||||
overlay::OverlayOptions options;
|
||||
bool is_validator = std::find(current_validators_adnl_.begin(), current_validators_adnl_.end(), local_id_) !=
|
||||
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.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_,
|
||||
std::make_unique<Callback>(actor_id(this)), rules, std::move(scope), options);
|
||||
|
||||
inited_ = true;
|
||||
}
|
||||
|
||||
void FullNodeFastSyncOverlay::tear_down() {
|
||||
if (inited_) {
|
||||
td::actor::send_closure(overlays_, &ton::overlay::Overlays::delete_overlay, local_id_, overlay_id_);
|
||||
}
|
||||
}
|
||||
|
||||
void FullNodeFastSyncOverlay::set_validators(std::vector<PublicKeyHash> root_public_keys,
|
||||
std::vector<adnl::AdnlNodeIdShort> current_validators_adnl) {
|
||||
root_public_keys_ = std::move(root_public_keys);
|
||||
current_validators_adnl_ = std::move(current_validators_adnl);
|
||||
if (inited_) {
|
||||
td::actor::send_closure(overlays_, &ton::overlay::Overlays::delete_overlay, local_id_, overlay_id_);
|
||||
init();
|
||||
}
|
||||
}
|
||||
|
||||
void FullNodeFastSyncOverlay::set_member_certificate(overlay::OverlayMemberCertificate member_certificate) {
|
||||
member_certificate_ = std::move(member_certificate);
|
||||
if (inited_) {
|
||||
td::actor::send_closure(overlays_, &overlay::Overlays::update_member_certificate, local_id_, overlay_id_,
|
||||
member_certificate_);
|
||||
}
|
||||
}
|
||||
|
||||
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();
|
||||
for (const auto &x : current_validators_adnl_) {
|
||||
res->validators_adnl_.push_back(x.bits256_value());
|
||||
}
|
||||
for (const auto &x : root_public_keys_) {
|
||||
res->root_public_keys_.push_back(x.bits256_value());
|
||||
}
|
||||
res->member_certificate_ = member_certificate_.tl();
|
||||
promise.set_result(td::json_encode<std::string>(td::ToJson(*res), true));
|
||||
}
|
||||
|
||||
td::actor::ActorId<FullNodeFastSyncOverlay> FullNodeFastSyncOverlays::choose_overlay(ShardIdFull shard) {
|
||||
for (auto &p : id_to_overlays_) {
|
||||
auto &overlays = p.second.overlays_;
|
||||
ShardIdFull cur_shard = shard;
|
||||
while (true) {
|
||||
auto it = overlays.find(cur_shard);
|
||||
if (it != overlays.end()) {
|
||||
return it->second.get();
|
||||
}
|
||||
if (cur_shard.pfx_len() == 0) {
|
||||
break;
|
||||
}
|
||||
cur_shard = shard_parent(cur_shard);
|
||||
}
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
void FullNodeFastSyncOverlays::update_overlays(td::Ref<MasterchainState> state,
|
||||
std::set<adnl::AdnlNodeIdShort> my_adnl_ids,
|
||||
std::set<ShardIdFull> monitoring_shards,
|
||||
const FileHash &zero_state_file_hash,
|
||||
const td::actor::ActorId<keyring::Keyring> &keyring,
|
||||
const td::actor::ActorId<adnl::Adnl> &adnl,
|
||||
const td::actor::ActorId<overlay::Overlays> &overlays,
|
||||
const td::actor::ActorId<ValidatorManagerInterface> &validator_manager,
|
||||
const td::actor::ActorId<FullNode> &full_node) {
|
||||
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)});
|
||||
}
|
||||
|
||||
// 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 ¤t_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)) {
|
||||
++it2;
|
||||
} else {
|
||||
it2 = overlays_info.overlays_.erase(it2);
|
||||
}
|
||||
}
|
||||
++it;
|
||||
} else {
|
||||
it = id_to_overlays_.erase(it);
|
||||
}
|
||||
}
|
||||
|
||||
// On new keyblock - update validator set
|
||||
bool updated_validators = false;
|
||||
if (!last_key_block_seqno_ || last_key_block_seqno_.value() != state->last_key_block_id().seqno()) {
|
||||
updated_validators = true;
|
||||
last_key_block_seqno_ = state->last_key_block_id().seqno();
|
||||
root_public_keys_.clear();
|
||||
current_validators_adnl_.clear();
|
||||
// Previous, current and next validator sets
|
||||
for (int i = -1; i <= 1; ++i) {
|
||||
auto val_set = state->get_total_validator_set(i);
|
||||
if (val_set.is_null()) {
|
||||
continue;
|
||||
}
|
||||
for (const ValidatorDescr &val : val_set->export_vector()) {
|
||||
PublicKeyHash public_key_hash = ValidatorFullId{val.key}.compute_short_id();
|
||||
root_public_keys_.push_back(public_key_hash);
|
||||
if (i == 0) {
|
||||
current_validators_adnl_.emplace_back(val.addr.is_zero() ? public_key_hash.bits256_value() : val.addr);
|
||||
}
|
||||
}
|
||||
}
|
||||
std::sort(root_public_keys_.begin(), root_public_keys_.end());
|
||||
root_public_keys_.erase(std::unique(root_public_keys_.begin(), root_public_keys_.end()), root_public_keys_.end());
|
||||
std::sort(current_validators_adnl_.begin(), current_validators_adnl_.end());
|
||||
|
||||
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_) {
|
||||
td::actor::send_closure(overlay, &FullNodeFastSyncOverlay::set_validators, root_public_keys_,
|
||||
current_validators_adnl_);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Cleanup outdated certificates
|
||||
double now = td::Clocks::system();
|
||||
for (auto &[_, certificates] : member_certificates_) {
|
||||
certificates.erase(std::remove_if(certificates.begin(), certificates.end(),
|
||||
[&](const overlay::OverlayMemberCertificate &certificate) {
|
||||
return certificate.is_expired(now);
|
||||
}),
|
||||
certificates.end());
|
||||
}
|
||||
|
||||
for (adnl::AdnlNodeIdShort local_id : my_adnl_ids) {
|
||||
bool is_new = !id_to_overlays_.count(local_id);
|
||||
auto &overlays_info = id_to_overlays_[local_id];
|
||||
// Update is_validator and current_certificate
|
||||
if (is_new) {
|
||||
overlays_info.is_validator_ =
|
||||
std::binary_search(current_validators_adnl_.begin(), current_validators_adnl_.end(), local_id);
|
||||
}
|
||||
bool changed_certificate = false;
|
||||
// Check if certificate is outdated or no longer authorized by current root keys
|
||||
if (!overlays_info.current_certificate_.empty() && overlays_info.current_certificate_.is_expired(now)) {
|
||||
changed_certificate = true;
|
||||
overlays_info.current_certificate_ = {};
|
||||
}
|
||||
if (!overlays_info.current_certificate_.empty() && updated_validators &&
|
||||
!std::binary_search(root_public_keys_.begin(), root_public_keys_.end(),
|
||||
overlays_info.current_certificate_.issued_by().compute_short_id())) {
|
||||
changed_certificate = true;
|
||||
overlays_info.current_certificate_ = {};
|
||||
}
|
||||
if (overlays_info.current_certificate_.empty()) {
|
||||
auto it = member_certificates_.find(local_id);
|
||||
if (it != member_certificates_.end()) {
|
||||
for (const overlay::OverlayMemberCertificate &certificate : it->second) {
|
||||
if (std::binary_search(root_public_keys_.begin(), root_public_keys_.end(),
|
||||
certificate.issued_by().compute_short_id())) {
|
||||
changed_certificate = true;
|
||||
overlays_info.current_certificate_ = it->second.front();
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Remove if it is not authorized
|
||||
if (!overlays_info.is_validator_ && overlays_info.current_certificate_.empty()) {
|
||||
id_to_overlays_.erase(local_id);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Update shard overlays
|
||||
auto ¤t_shards = overlays_info.is_validator_ ? all_shards : monitoring_shards;
|
||||
for (ShardIdFull shard_id : current_shards) {
|
||||
auto &overlay = overlays_info.overlays_[shard_id];
|
||||
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,
|
||||
validator_manager, full_node);
|
||||
} else if (changed_certificate) {
|
||||
td::actor::send_closure(overlay, &FullNodeFastSyncOverlay::set_member_certificate,
|
||||
overlays_info.current_certificate_);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void FullNodeFastSyncOverlays::add_member_certificate(adnl::AdnlNodeIdShort local_id,
|
||||
overlay::OverlayMemberCertificate member_certificate) {
|
||||
if (member_certificate.empty() || member_certificate.is_expired()) {
|
||||
return;
|
||||
}
|
||||
member_certificates_[local_id].push_back(std::move(member_certificate));
|
||||
// Overlays will be updated in the next update_overlays
|
||||
}
|
||||
|
||||
} // namespace ton::validator::fullnode
|
||||
|
|
@ -20,7 +20,7 @@
|
|||
|
||||
namespace ton::validator::fullnode {
|
||||
|
||||
class FullNodePrivateOverlayV2 : public td::actor::Actor {
|
||||
class FullNodeFastSyncOverlay : public td::actor::Actor {
|
||||
public:
|
||||
void process_broadcast(PublicKeyHash src, ton_api::tonNode_blockBroadcast& query);
|
||||
void process_broadcast(PublicKeyHash src, ton_api::tonNode_blockBroadcastCompressed& query);
|
||||
|
|
@ -28,9 +28,9 @@ class FullNodePrivateOverlayV2 : public td::actor::Actor {
|
|||
|
||||
void process_broadcast(PublicKeyHash src, ton_api::tonNode_newShardBlockBroadcast& query);
|
||||
|
||||
void process_broadcast(PublicKeyHash src, ton_api::tonNode_newBlockCandidateBroadcast &query);
|
||||
void process_broadcast(PublicKeyHash src, ton_api::tonNode_newBlockCandidateBroadcastCompressed &query);
|
||||
void process_block_candidate_broadcast(PublicKeyHash src, ton_api::tonNode_Broadcast &query);
|
||||
void process_broadcast(PublicKeyHash src, ton_api::tonNode_newBlockCandidateBroadcast& query);
|
||||
void process_broadcast(PublicKeyHash src, ton_api::tonNode_newBlockCandidateBroadcastCompressed& query);
|
||||
void process_block_candidate_broadcast(PublicKeyHash src, ton_api::tonNode_Broadcast& query);
|
||||
|
||||
template <class T>
|
||||
void process_broadcast(PublicKeyHash, T&) {
|
||||
|
|
@ -46,26 +46,26 @@ class FullNodePrivateOverlayV2 : public td::actor::Actor {
|
|||
void start_up() override;
|
||||
void tear_down() override;
|
||||
|
||||
void destroy() {
|
||||
stop();
|
||||
}
|
||||
void set_validators(std::vector<PublicKeyHash> root_public_keys,
|
||||
std::vector<adnl::AdnlNodeIdShort> current_validators_adnl);
|
||||
void set_member_certificate(overlay::OverlayMemberCertificate member_certificate);
|
||||
|
||||
FullNodePrivateOverlayV2(adnl::AdnlNodeIdShort local_id, ShardIdFull shard, std::vector<adnl::AdnlNodeIdShort> nodes,
|
||||
std::vector<adnl::AdnlNodeIdShort> senders, 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<rldp2::Rldp> rldp2,
|
||||
td::actor::ActorId<overlay::Overlays> overlays,
|
||||
td::actor::ActorId<ValidatorManagerInterface> validator_manager,
|
||||
td::actor::ActorId<FullNode> full_node)
|
||||
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,
|
||||
td::actor::ActorId<keyring::Keyring> keyring, td::actor::ActorId<adnl::Adnl> adnl,
|
||||
td::actor::ActorId<overlay::Overlays> overlays,
|
||||
td::actor::ActorId<ValidatorManagerInterface> validator_manager,
|
||||
td::actor::ActorId<FullNode> full_node)
|
||||
: local_id_(local_id)
|
||||
, shard_(shard)
|
||||
, nodes_(std::move(nodes))
|
||||
, senders_(std::move(senders))
|
||||
, root_public_keys_(std::move(root_public_keys))
|
||||
, current_validators_adnl_(std::move(current_validators_adnl))
|
||||
, member_certificate_(std::move(member_certificate))
|
||||
, zero_state_file_hash_(zero_state_file_hash)
|
||||
, keyring_(keyring)
|
||||
, adnl_(adnl)
|
||||
, rldp_(rldp)
|
||||
, rldp2_(rldp2)
|
||||
, overlays_(overlays)
|
||||
, validator_manager_(validator_manager)
|
||||
, full_node_(full_node) {
|
||||
|
|
@ -74,14 +74,13 @@ class FullNodePrivateOverlayV2 : public td::actor::Actor {
|
|||
private:
|
||||
adnl::AdnlNodeIdShort local_id_;
|
||||
ShardIdFull shard_;
|
||||
std::vector<adnl::AdnlNodeIdShort> nodes_;
|
||||
std::vector<adnl::AdnlNodeIdShort> senders_;
|
||||
std::vector<PublicKeyHash> root_public_keys_;
|
||||
std::vector<adnl::AdnlNodeIdShort> current_validators_adnl_;
|
||||
overlay::OverlayMemberCertificate member_certificate_;
|
||||
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<rldp2::Rldp> rldp2_;
|
||||
td::actor::ActorId<overlay::Overlays> overlays_;
|
||||
td::actor::ActorId<ValidatorManagerInterface> validator_manager_;
|
||||
td::actor::ActorId<FullNode> full_node_;
|
||||
|
|
@ -96,29 +95,30 @@ class FullNodePrivateOverlayV2 : public td::actor::Actor {
|
|||
void get_stats_extra(td::Promise<std::string> promise);
|
||||
};
|
||||
|
||||
class FullNodePrivateBlockOverlaysV2 {
|
||||
class FullNodeFastSyncOverlays {
|
||||
public:
|
||||
td::actor::ActorId<FullNodePrivateOverlayV2> choose_overlay(ShardIdFull shard);
|
||||
td::actor::ActorId<FullNodeFastSyncOverlay> choose_overlay(ShardIdFull shard);
|
||||
void update_overlays(td::Ref<MasterchainState> state, std::set<adnl::AdnlNodeIdShort> my_adnl_ids,
|
||||
const FileHash& zero_state_file_hash, const td::actor::ActorId<keyring::Keyring>& keyring,
|
||||
const td::actor::ActorId<adnl::Adnl>& adnl, const td::actor::ActorId<rldp::Rldp>& rldp,
|
||||
const td::actor::ActorId<rldp2::Rldp>& rldp2,
|
||||
std::set<ShardIdFull> monitoring_shards, const FileHash& zero_state_file_hash,
|
||||
const td::actor::ActorId<keyring::Keyring>& keyring, const td::actor::ActorId<adnl::Adnl>& adnl,
|
||||
const td::actor::ActorId<overlay::Overlays>& overlays,
|
||||
const td::actor::ActorId<ValidatorManagerInterface>& validator_manager,
|
||||
const td::actor::ActorId<FullNode>& full_node);
|
||||
void destroy_overlays();
|
||||
void add_member_certificate(adnl::AdnlNodeIdShort local_id, overlay::OverlayMemberCertificate member_certificate);
|
||||
|
||||
private:
|
||||
struct Overlays {
|
||||
struct ShardOverlay {
|
||||
td::actor::ActorOwn<FullNodePrivateOverlayV2> overlay_;
|
||||
std::vector<adnl::AdnlNodeIdShort> nodes_, senders_;
|
||||
bool is_sender_ = false;
|
||||
};
|
||||
std::map<ShardIdFull, ShardOverlay> overlays_;
|
||||
std::map<ShardIdFull, td::actor::ActorOwn<FullNodeFastSyncOverlay>> overlays_;
|
||||
overlay::OverlayMemberCertificate current_certificate_;
|
||||
bool is_validator_{false};
|
||||
};
|
||||
|
||||
std::map<adnl::AdnlNodeIdShort, Overlays> id_to_overlays_; // local_id -> overlays
|
||||
std::map<adnl::AdnlNodeIdShort, std::vector<overlay::OverlayMemberCertificate>> member_certificates_;
|
||||
|
||||
td::optional<BlockSeqno> last_key_block_seqno_;
|
||||
std::vector<PublicKeyHash> root_public_keys_;
|
||||
std::vector<adnl::AdnlNodeIdShort> current_validators_adnl_;
|
||||
};
|
||||
|
||||
} // namespace ton::validator::fullnode
|
||||
|
|
@ -1,384 +0,0 @@
|
|||
/*
|
||||
This file is part of TON Blockchain Library.
|
||||
|
||||
TON Blockchain Library is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published by
|
||||
the Free Software Foundation, either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
TON Blockchain Library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with TON Blockchain Library. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "full-node-private-overlay-v2.hpp"
|
||||
|
||||
#include "checksum.h"
|
||||
#include "ton/ton-tl.hpp"
|
||||
#include "common/delay.h"
|
||||
#include "td/utils/JsonBuilder.h"
|
||||
#include "tl/tl_json.h"
|
||||
#include "auto/tl/ton_api_json.h"
|
||||
#include "full-node-serializer.hpp"
|
||||
|
||||
namespace ton::validator::fullnode {
|
||||
|
||||
void FullNodePrivateOverlayV2::process_broadcast(PublicKeyHash src, ton_api::tonNode_blockBroadcast &query) {
|
||||
process_block_broadcast(src, query);
|
||||
}
|
||||
|
||||
void FullNodePrivateOverlayV2::process_broadcast(PublicKeyHash src, ton_api::tonNode_blockBroadcastCompressed &query) {
|
||||
process_block_broadcast(src, query);
|
||||
}
|
||||
|
||||
void FullNodePrivateOverlayV2::process_block_broadcast(PublicKeyHash src, ton_api::tonNode_Broadcast &query) {
|
||||
auto B = deserialize_block_broadcast(query, overlay::Overlays::max_fec_broadcast_size());
|
||||
if (B.is_error()) {
|
||||
LOG(DEBUG) << "dropped broadcast: " << B.move_as_error();
|
||||
return;
|
||||
}
|
||||
VLOG(FULL_NODE_DEBUG) << "Received block broadcast in private overlay from " << src << ": "
|
||||
<< B.ok().block_id.to_str();
|
||||
td::actor::send_closure(full_node_, &FullNode::process_block_broadcast, B.move_as_ok());
|
||||
}
|
||||
|
||||
void FullNodePrivateOverlayV2::process_broadcast(PublicKeyHash src, ton_api::tonNode_newShardBlockBroadcast &query) {
|
||||
BlockIdExt block_id = create_block_id(query.block_->block_);
|
||||
VLOG(FULL_NODE_DEBUG) << "Received newShardBlockBroadcast in private overlay from " << src << ": "
|
||||
<< block_id.to_str();
|
||||
td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::new_shard_block, block_id,
|
||||
query.block_->cc_seqno_, std::move(query.block_->data_));
|
||||
}
|
||||
|
||||
void FullNodePrivateOverlayV2::process_broadcast(PublicKeyHash src,
|
||||
ton_api::tonNode_newBlockCandidateBroadcast &query) {
|
||||
process_block_candidate_broadcast(src, query);
|
||||
}
|
||||
|
||||
void FullNodePrivateOverlayV2::process_broadcast(PublicKeyHash src,
|
||||
ton_api::tonNode_newBlockCandidateBroadcastCompressed &query) {
|
||||
process_block_candidate_broadcast(src, query);
|
||||
}
|
||||
|
||||
void FullNodePrivateOverlayV2::process_block_candidate_broadcast(PublicKeyHash src, ton_api::tonNode_Broadcast &query) {
|
||||
BlockIdExt block_id;
|
||||
CatchainSeqno cc_seqno;
|
||||
td::uint32 validator_set_hash;
|
||||
td::BufferSlice data;
|
||||
auto S = deserialize_block_candidate_broadcast(query, block_id, cc_seqno, validator_set_hash, data,
|
||||
overlay::Overlays::max_fec_broadcast_size());
|
||||
if (S.is_error()) {
|
||||
LOG(DEBUG) << "dropped broadcast: " << S;
|
||||
return;
|
||||
}
|
||||
if (data.size() > FullNode::max_block_size()) {
|
||||
VLOG(FULL_NODE_WARNING) << "received block candidate with too big size from " << src;
|
||||
return;
|
||||
}
|
||||
if (td::sha256_bits256(data.as_slice()) != block_id.file_hash) {
|
||||
VLOG(FULL_NODE_WARNING) << "received block candidate with incorrect file hash from " << src;
|
||||
return;
|
||||
}
|
||||
VLOG(FULL_NODE_DEBUG) << "Received newBlockCandidate in private overlay from " << src << ": " << block_id.to_str();
|
||||
td::actor::send_closure(full_node_, &FullNode::process_block_candidate_broadcast, block_id, cc_seqno,
|
||||
validator_set_hash, std::move(data));
|
||||
}
|
||||
|
||||
void FullNodePrivateOverlayV2::receive_broadcast(PublicKeyHash src, td::BufferSlice broadcast) {
|
||||
auto B = fetch_tl_object<ton_api::tonNode_Broadcast>(std::move(broadcast), true);
|
||||
if (B.is_error()) {
|
||||
return;
|
||||
}
|
||||
|
||||
ton_api::downcast_call(*B.move_as_ok(), [src, Self = this](auto &obj) { Self->process_broadcast(src, obj); });
|
||||
}
|
||||
|
||||
void FullNodePrivateOverlayV2::send_shard_block_info(BlockIdExt block_id, CatchainSeqno cc_seqno,
|
||||
td::BufferSlice data) {
|
||||
if (!inited_) {
|
||||
return;
|
||||
}
|
||||
VLOG(FULL_NODE_DEBUG) << "Sending newShardBlockBroadcast in private overlay: " << block_id.to_str();
|
||||
auto B = create_serialize_tl_object<ton_api::tonNode_newShardBlockBroadcast>(
|
||||
create_tl_object<ton_api::tonNode_newShardBlock>(create_tl_block_id(block_id), cc_seqno, std::move(data)));
|
||||
if (B.size() <= overlay::Overlays::max_simple_broadcast_size()) {
|
||||
td::actor::send_closure(overlays_, &overlay::Overlays::send_broadcast_ex, local_id_, overlay_id_,
|
||||
local_id_.pubkey_hash(), 0, std::move(B));
|
||||
} else {
|
||||
td::actor::send_closure(overlays_, &overlay::Overlays::send_broadcast_fec_ex, local_id_, overlay_id_,
|
||||
local_id_.pubkey_hash(), overlay::Overlays::BroadcastFlagAnySender(), std::move(B));
|
||||
}
|
||||
}
|
||||
|
||||
void FullNodePrivateOverlayV2::send_broadcast(BlockBroadcast broadcast) {
|
||||
if (!inited_) {
|
||||
return;
|
||||
}
|
||||
VLOG(FULL_NODE_DEBUG) << "Sending block broadcast in private overlay (with compression): "
|
||||
<< broadcast.block_id.to_str();
|
||||
auto B = serialize_block_broadcast(broadcast, true); // compression_enabled = true
|
||||
if (B.is_error()) {
|
||||
VLOG(FULL_NODE_WARNING) << "failed to serialize block broadcast: " << B.move_as_error();
|
||||
return;
|
||||
}
|
||||
td::actor::send_closure(overlays_, &overlay::Overlays::send_broadcast_fec_ex, local_id_, overlay_id_,
|
||||
local_id_.pubkey_hash(), overlay::Overlays::BroadcastFlagAnySender(), B.move_as_ok());
|
||||
}
|
||||
|
||||
void FullNodePrivateOverlayV2::send_block_candidate(BlockIdExt block_id, CatchainSeqno cc_seqno,
|
||||
td::uint32 validator_set_hash, td::BufferSlice data) {
|
||||
if (!inited_) {
|
||||
return;
|
||||
}
|
||||
auto B =
|
||||
serialize_block_candidate_broadcast(block_id, cc_seqno, validator_set_hash, data, true); // compression enabled
|
||||
if (B.is_error()) {
|
||||
VLOG(FULL_NODE_WARNING) << "failed to serialize block candidate broadcast: " << B.move_as_error();
|
||||
return;
|
||||
}
|
||||
VLOG(FULL_NODE_DEBUG) << "Sending newBlockCandidate in private overlay (with compression): " << block_id.to_str();
|
||||
td::actor::send_closure(overlays_, &overlay::Overlays::send_broadcast_fec_ex, local_id_, overlay_id_,
|
||||
local_id_.pubkey_hash(), overlay::Overlays::BroadcastFlagAnySender(), B.move_as_ok());
|
||||
}
|
||||
|
||||
void FullNodePrivateOverlayV2::start_up() {
|
||||
std::sort(nodes_.begin(), nodes_.end());
|
||||
nodes_.erase(std::unique(nodes_.begin(), nodes_.end()), nodes_.end());
|
||||
|
||||
std::vector<td::Bits256> nodes, senders;
|
||||
for (const adnl::AdnlNodeIdShort &id : nodes_) {
|
||||
nodes.push_back(id.bits256_value());
|
||||
}
|
||||
for (const adnl::AdnlNodeIdShort &id : senders_) {
|
||||
senders.push_back(id.bits256_value());
|
||||
}
|
||||
auto X = create_hash_tl_object<ton_api::tonNode_privateBlockOverlayIdV2>(
|
||||
zero_state_file_hash_, shard_.workchain, shard_.shard, std::move(nodes), std::move(senders));
|
||||
td::BufferSlice b{32};
|
||||
b.as_slice().copy_from(as_slice(X));
|
||||
overlay_id_full_ = overlay::OverlayIdFull{std::move(b)};
|
||||
overlay_id_ = overlay_id_full_.compute_short_id();
|
||||
|
||||
try_init();
|
||||
}
|
||||
|
||||
void FullNodePrivateOverlayV2::try_init() {
|
||||
// Sometimes adnl id is added to validator engine later (or not at all)
|
||||
td::actor::send_closure(
|
||||
adnl_, &adnl::Adnl::check_id_exists, local_id_, [SelfId = actor_id(this)](td::Result<bool> R) {
|
||||
if (R.is_ok() && R.ok()) {
|
||||
td::actor::send_closure(SelfId, &FullNodePrivateOverlayV2::init);
|
||||
} else {
|
||||
delay_action([SelfId]() { td::actor::send_closure(SelfId, &FullNodePrivateOverlayV2::try_init); },
|
||||
td::Timestamp::in(30.0));
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
void FullNodePrivateOverlayV2::init() {
|
||||
LOG(FULL_NODE_INFO) << "Creating private block overlay for shard " << shard_.to_str() << ", adnl_id=" << local_id_
|
||||
<< " : " << nodes_.size() << " nodes";
|
||||
class Callback : public overlay::Overlays::Callback {
|
||||
public:
|
||||
void receive_message(adnl::AdnlNodeIdShort src, overlay::OverlayIdShort overlay_id, td::BufferSlice data) override {
|
||||
}
|
||||
void receive_query(adnl::AdnlNodeIdShort src, overlay::OverlayIdShort overlay_id, td::BufferSlice data,
|
||||
td::Promise<td::BufferSlice> promise) override {
|
||||
}
|
||||
void receive_broadcast(PublicKeyHash src, overlay::OverlayIdShort overlay_id, td::BufferSlice data) override {
|
||||
td::actor::send_closure(node_, &FullNodePrivateOverlayV2::receive_broadcast, src, std::move(data));
|
||||
}
|
||||
void check_broadcast(PublicKeyHash src, overlay::OverlayIdShort overlay_id, td::BufferSlice data,
|
||||
td::Promise<td::Unit> promise) override {
|
||||
}
|
||||
void get_stats_extra(td::Promise<std::string> promise) override {
|
||||
td::actor::send_closure(node_, &FullNodePrivateOverlayV2::get_stats_extra, std::move(promise));
|
||||
}
|
||||
Callback(td::actor::ActorId<FullNodePrivateOverlayV2> node) : node_(node) {
|
||||
}
|
||||
|
||||
private:
|
||||
td::actor::ActorId<FullNodePrivateOverlayV2> node_;
|
||||
};
|
||||
|
||||
std::map<PublicKeyHash, td::uint32> authorized_keys;
|
||||
for (const adnl::AdnlNodeIdShort &sender : senders_) {
|
||||
authorized_keys[sender.pubkey_hash()] = overlay::Overlays::max_fec_broadcast_size();
|
||||
}
|
||||
overlay::OverlayPrivacyRules rules{overlay::Overlays::max_fec_broadcast_size(), 0, std::move(authorized_keys)};
|
||||
std::string scope = PSTRING() << R"({ "type": "private-blocks-v2", "shard_id": )" << shard_.shard
|
||||
<< ", \"workchain_id\": " << shard_.workchain << " }";
|
||||
td::actor::send_closure(overlays_, &overlay::Overlays::create_private_overlay, local_id_, overlay_id_full_.clone(),
|
||||
nodes_, std::make_unique<Callback>(actor_id(this)), rules, std::move(scope));
|
||||
|
||||
td::actor::send_closure(rldp_, &rldp::Rldp::add_id, local_id_);
|
||||
td::actor::send_closure(rldp2_, &rldp2::Rldp::add_id, local_id_);
|
||||
inited_ = true;
|
||||
}
|
||||
|
||||
void FullNodePrivateOverlayV2::tear_down() {
|
||||
if (inited_) {
|
||||
td::actor::send_closure(overlays_, &ton::overlay::Overlays::delete_overlay, local_id_, overlay_id_);
|
||||
}
|
||||
}
|
||||
|
||||
void FullNodePrivateOverlayV2::get_stats_extra(td::Promise<std::string> promise) {
|
||||
auto res = create_tl_object<ton_api::engine_validator_privateBlockOverlayV2Stats>();
|
||||
res->shard_ = shard_.to_str();
|
||||
for (const auto &x : nodes_) {
|
||||
res->nodes_.push_back(x.bits256_value());
|
||||
}
|
||||
for (const auto &x : senders_) {
|
||||
res->senders_.push_back(x.bits256_value());
|
||||
}
|
||||
res->created_at_ = created_at_;
|
||||
promise.set_result(td::json_encode<std::string>(td::ToJson(*res), true));
|
||||
}
|
||||
|
||||
td::actor::ActorId<FullNodePrivateOverlayV2> FullNodePrivateBlockOverlaysV2::choose_overlay(ShardIdFull shard) {
|
||||
for (auto &p : id_to_overlays_) {
|
||||
auto &overlays = p.second.overlays_;
|
||||
ShardIdFull cur_shard = shard;
|
||||
while (true) {
|
||||
auto it = overlays.find(cur_shard);
|
||||
if (it != overlays.end() && it->second.is_sender_) {
|
||||
return it->second.overlay_.get();
|
||||
}
|
||||
if (cur_shard.pfx_len() == 0) {
|
||||
break;
|
||||
}
|
||||
cur_shard = shard_parent(cur_shard);
|
||||
}
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
void FullNodePrivateBlockOverlaysV2::update_overlays(
|
||||
td::Ref<MasterchainState> state, std::set<adnl::AdnlNodeIdShort> my_adnl_ids, const FileHash &zero_state_file_hash,
|
||||
const td::actor::ActorId<keyring::Keyring> &keyring, const td::actor::ActorId<adnl::Adnl> &adnl,
|
||||
const td::actor::ActorId<rldp::Rldp> &rldp, const td::actor::ActorId<rldp2::Rldp> &rldp2,
|
||||
const td::actor::ActorId<overlay::Overlays> &overlays,
|
||||
const td::actor::ActorId<ValidatorManagerInterface> &validator_manager,
|
||||
const td::actor::ActorId<FullNode> &full_node) {
|
||||
if (my_adnl_ids.empty()) {
|
||||
id_to_overlays_.clear();
|
||||
return;
|
||||
}
|
||||
auto collators = state->get_collator_config(true);
|
||||
auto all_validators = state->get_total_validator_set(0);
|
||||
|
||||
struct OverlayInfo {
|
||||
std::vector<adnl::AdnlNodeIdShort> nodes, senders;
|
||||
};
|
||||
std::map<ShardIdFull, OverlayInfo> overlay_infos;
|
||||
|
||||
// Masterchain overlay: all validators + collators
|
||||
OverlayInfo &mc_overlay = overlay_infos[ShardIdFull(masterchainId)];
|
||||
for (const auto &x : all_validators->export_vector()) {
|
||||
td::Bits256 addr = x.addr.is_zero() ? ValidatorFullId(x.key).compute_short_id().bits256_value() : x.addr;
|
||||
mc_overlay.nodes.emplace_back(addr);
|
||||
mc_overlay.senders.emplace_back(addr);
|
||||
}
|
||||
for (const auto &x : collators.collator_nodes) {
|
||||
mc_overlay.nodes.emplace_back(x.adnl_id);
|
||||
}
|
||||
|
||||
// Shard overlays: validators of the shard + collators of the shard
|
||||
// See ValidatorManagerImpl::update_shards
|
||||
std::set<ShardIdFull> new_shards;
|
||||
for (auto &v : state->get_shards()) {
|
||||
ShardIdFull shard = v->shard();
|
||||
if (shard.is_masterchain()) {
|
||||
continue;
|
||||
}
|
||||
if (v->before_split()) {
|
||||
ShardIdFull l_shard{shard.workchain, shard_child(shard.shard, true)};
|
||||
ShardIdFull r_shard{shard.workchain, shard_child(shard.shard, false)};
|
||||
new_shards.insert(l_shard);
|
||||
new_shards.insert(r_shard);
|
||||
} else if (v->before_merge()) {
|
||||
ShardIdFull p_shard{shard.workchain, shard_parent(shard.shard)};
|
||||
new_shards.insert(p_shard);
|
||||
} else {
|
||||
new_shards.insert(shard);
|
||||
}
|
||||
}
|
||||
for (ShardIdFull shard : new_shards) {
|
||||
auto val_set = state->get_validator_set(shard);
|
||||
td::uint32 min_split = state->monitor_min_split_depth(shard.workchain);
|
||||
OverlayInfo &overlay =
|
||||
overlay_infos[shard_prefix_length(shard) <= min_split ? shard : shard_prefix(shard, min_split)];
|
||||
for (const auto &x : val_set->export_vector()) {
|
||||
td::Bits256 addr = x.addr.is_zero() ? ValidatorFullId(x.key).compute_short_id().bits256_value() : x.addr;
|
||||
overlay.nodes.emplace_back(addr);
|
||||
overlay.senders.emplace_back(addr);
|
||||
}
|
||||
}
|
||||
for (auto &p : overlay_infos) {
|
||||
ShardIdFull shard = p.first;
|
||||
OverlayInfo &overlay = p.second;
|
||||
if (!shard.is_masterchain()) {
|
||||
for (const auto &collator : collators.collator_nodes) {
|
||||
if (shard_intersects(collator.shard, shard)) {
|
||||
overlay.nodes.emplace_back(collator.adnl_id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::sort(overlay.nodes.begin(), overlay.nodes.end());
|
||||
overlay.nodes.erase(std::unique(overlay.nodes.begin(), overlay.nodes.end()), overlay.nodes.end());
|
||||
std::sort(overlay.senders.begin(), overlay.senders.end());
|
||||
overlay.senders.erase(std::unique(overlay.senders.begin(), overlay.senders.end()), overlay.senders.end());
|
||||
}
|
||||
|
||||
std::map<adnl::AdnlNodeIdShort, Overlays> old_private_block_overlays = std::move(id_to_overlays_);
|
||||
id_to_overlays_.clear();
|
||||
|
||||
for (const auto &p : overlay_infos) {
|
||||
ShardIdFull shard = p.first;
|
||||
const OverlayInfo &new_overlay_info = p.second;
|
||||
for (adnl::AdnlNodeIdShort local_id : new_overlay_info.nodes) {
|
||||
if (!my_adnl_ids.count(local_id)) {
|
||||
continue;
|
||||
}
|
||||
Overlays::ShardOverlay &new_overlay = id_to_overlays_[local_id].overlays_[shard];
|
||||
Overlays::ShardOverlay &old_overlay = old_private_block_overlays[local_id].overlays_[shard];
|
||||
if (!old_overlay.overlay_.empty() && old_overlay.nodes_ == new_overlay_info.nodes &&
|
||||
old_overlay.senders_ == new_overlay_info.senders) {
|
||||
new_overlay = std::move(old_overlay);
|
||||
old_overlay = {};
|
||||
} else {
|
||||
new_overlay.nodes_ = new_overlay_info.nodes;
|
||||
new_overlay.senders_ = new_overlay_info.senders;
|
||||
new_overlay.is_sender_ = std::binary_search(new_overlay.senders_.begin(), new_overlay.senders_.end(), local_id);
|
||||
new_overlay.overlay_ = td::actor::create_actor<FullNodePrivateOverlayV2>(
|
||||
PSTRING() << "BlocksPrivateOverlay" << shard.to_str(), local_id, shard, new_overlay.nodes_,
|
||||
new_overlay.senders_, zero_state_file_hash, keyring, adnl, rldp, rldp2, overlays, validator_manager,
|
||||
full_node);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Delete old overlays, but not immediately
|
||||
for (auto &p : old_private_block_overlays) {
|
||||
for (auto &x : p.second.overlays_) {
|
||||
if (x.second.overlay_.empty()) {
|
||||
continue;
|
||||
}
|
||||
td::actor::ActorId<FullNodePrivateOverlayV2> id = x.second.overlay_.release();
|
||||
delay_action([id = std::move(id)]() { td::actor::send_closure(id, &FullNodePrivateOverlayV2::destroy); },
|
||||
td::Timestamp::in(30.0));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void FullNodePrivateBlockOverlaysV2::destroy_overlays() {
|
||||
id_to_overlays_.clear();
|
||||
}
|
||||
|
||||
|
||||
} // namespace ton::validator::fullnode
|
||||
|
|
@ -1419,9 +1419,9 @@ td::actor::ActorOwn<FullNodeShard> FullNodeShard::create(
|
|||
td::actor::ActorId<rldp::Rldp> rldp, td::actor::ActorId<rldp2::Rldp> rldp2,
|
||||
td::actor::ActorId<overlay::Overlays> overlays, td::actor::ActorId<ValidatorManagerInterface> validator_manager,
|
||||
td::actor::ActorId<adnl::AdnlExtClient> client, td::actor::ActorId<FullNode> full_node, FullNodeShardMode mode) {
|
||||
return td::actor::create_actor<FullNodeShardImpl>("tonnode", shard, local_id, adnl_id, zero_state_file_hash, config,
|
||||
keyring, adnl, rldp, rldp2, overlays, validator_manager, client,
|
||||
full_node, mode);
|
||||
return td::actor::create_actor<FullNodeShardImpl>(PSTRING() << "tonnode" << shard.to_str(), shard, local_id, adnl_id,
|
||||
zero_state_file_hash, config, keyring, adnl, rldp, rldp2, overlays,
|
||||
validator_manager, client, full_node, mode);
|
||||
}
|
||||
|
||||
} // namespace fullnode
|
||||
|
|
|
|||
|
|
@ -198,8 +198,8 @@ 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, std::set<ShardIdFull> shards_to_monitor,
|
||||
std::set<ShardIdFull> temporary_shards) {
|
||||
void FullNodeImpl::on_new_masterchain_block(td::Ref<MasterchainState> state, std::set<ShardIdFull> shards_to_monitor,
|
||||
std::set<ShardIdFull> temporary_shards) {
|
||||
CHECK(shards_to_monitor.count(ShardIdFull(masterchainId)));
|
||||
std::set<ShardIdFull> new_shards;
|
||||
std::map<ShardIdFull, FullNodeShardMode> new_active;
|
||||
|
|
@ -232,7 +232,7 @@ void FullNodeImpl::update_shard_configuration(td::Ref<MasterchainState> state, s
|
|||
set_active(cut_shard(shard), FullNodeShardMode::active_temp);
|
||||
}
|
||||
|
||||
auto info_set_mode = [&](ShardIdFull shard, ShardInfo& info, FullNodeShardMode mode) {
|
||||
auto info_set_mode = [&](ShardIdFull shard, ShardInfo &info, FullNodeShardMode mode) {
|
||||
if (info.mode == mode) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -251,7 +251,7 @@ void FullNodeImpl::update_shard_configuration(td::Ref<MasterchainState> state, s
|
|||
info.exists = true;
|
||||
}
|
||||
|
||||
for (auto& p : shards_) {
|
||||
for (auto &p : shards_) {
|
||||
ShardIdFull shard = p.first;
|
||||
ShardInfo &info = p.second;
|
||||
info.exists = new_shards.count(shard);
|
||||
|
|
@ -259,7 +259,7 @@ void FullNodeImpl::update_shard_configuration(td::Ref<MasterchainState> state, s
|
|||
info_set_mode(shard, info, it == new_active.end() ? FullNodeShardMode::inactive : it->second);
|
||||
}
|
||||
|
||||
for (const auto& s : new_active) {
|
||||
for (const auto &s : new_active) {
|
||||
info_set_mode(s.first, shards_[s.first], s.second);
|
||||
}
|
||||
|
||||
|
|
@ -276,21 +276,25 @@ void FullNodeImpl::update_shard_configuration(td::Ref<MasterchainState> state, s
|
|||
}
|
||||
}
|
||||
|
||||
std::set<adnl::AdnlNodeIdShort> my_adnl_ids;
|
||||
for (const auto &p : local_collator_nodes_) {
|
||||
my_adnl_ids.insert(p.first);
|
||||
}
|
||||
for (auto key : local_keys_) {
|
||||
auto it = current_validators_.find(key);
|
||||
if (it != current_validators_.end()) {
|
||||
my_adnl_ids.insert(it->second);
|
||||
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);
|
||||
}
|
||||
}
|
||||
if (use_old_private_overlays_) {
|
||||
private_block_overlays_v2_.destroy_overlays();
|
||||
} else {
|
||||
private_block_overlays_v2_.update_overlays(state, std::move(my_adnl_ids), zero_state_file_hash_, keyring_, adnl_,
|
||||
rldp_, rldp2_, overlays_, validator_manager_, actor_id(this));
|
||||
for (auto key : local_keys_) {
|
||||
auto it = current_validators_.find(key);
|
||||
if (it != current_validators_.end()) {
|
||||
my_adnl_ids.insert(it->second);
|
||||
}
|
||||
}
|
||||
std::set<ShardIdFull> monitoring_shards;
|
||||
for (ShardIdFull shard : shards_to_monitor) {
|
||||
monitoring_shards.insert(cut_shard(shard));
|
||||
}
|
||||
fast_sync_overlays_.update_overlays(state, std::move(my_adnl_ids), std::move(monitoring_shards),
|
||||
zero_state_file_hash_, keyring_, adnl_, overlays_, validator_manager_,
|
||||
actor_id(this));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -348,9 +352,9 @@ void FullNodeImpl::send_shard_block_info(BlockIdExt block_id, CatchainSeqno cc_s
|
|||
td::actor::send_closure(private_block_overlays_.begin()->second,
|
||||
&FullNodePrivateBlockOverlay::send_shard_block_info, block_id, cc_seqno, data.clone());
|
||||
}
|
||||
auto private_overlay = private_block_overlays_v2_.choose_overlay(ShardIdFull(masterchainId));
|
||||
auto private_overlay = fast_sync_overlays_.choose_overlay(ShardIdFull(masterchainId));
|
||||
if (!private_overlay.empty()) {
|
||||
td::actor::send_closure(private_overlay, &FullNodePrivateOverlayV2::send_shard_block_info, block_id, cc_seqno,
|
||||
td::actor::send_closure(private_overlay, &FullNodeFastSyncOverlay::send_shard_block_info, block_id, cc_seqno,
|
||||
data.clone());
|
||||
}
|
||||
td::actor::send_closure(shard, &FullNodeShard::send_shard_block_info, block_id, cc_seqno, std::move(data));
|
||||
|
|
@ -368,9 +372,9 @@ void FullNodeImpl::send_block_candidate(BlockIdExt block_id, CatchainSeqno cc_se
|
|||
td::actor::send_closure(private_block_overlays_.begin()->second, &FullNodePrivateBlockOverlay::send_block_candidate,
|
||||
block_id, cc_seqno, validator_set_hash, data.clone());
|
||||
}
|
||||
auto private_overlay = private_block_overlays_v2_.choose_overlay(block_id.shard_full());
|
||||
auto private_overlay = fast_sync_overlays_.choose_overlay(block_id.shard_full());
|
||||
if (!private_overlay.empty()) {
|
||||
td::actor::send_closure(private_overlay, &FullNodePrivateOverlayV2::send_block_candidate, block_id, cc_seqno,
|
||||
td::actor::send_closure(private_overlay, &FullNodeFastSyncOverlay::send_block_candidate, block_id, cc_seqno,
|
||||
validator_set_hash, data.clone());
|
||||
}
|
||||
if (broadcast_block_candidates_in_public_overlay_) {
|
||||
|
|
@ -393,9 +397,9 @@ void FullNodeImpl::send_broadcast(BlockBroadcast broadcast, bool custom_overlays
|
|||
td::actor::send_closure(private_block_overlays_.begin()->second, &FullNodePrivateBlockOverlay::send_broadcast,
|
||||
broadcast.clone());
|
||||
}
|
||||
auto private_overlay = private_block_overlays_v2_.choose_overlay(broadcast.block_id.shard_full());
|
||||
auto private_overlay = fast_sync_overlays_.choose_overlay(broadcast.block_id.shard_full());
|
||||
if (!private_overlay.empty()) {
|
||||
td::actor::send_closure(private_overlay, &FullNodePrivateOverlayV2::send_broadcast, broadcast.clone());
|
||||
td::actor::send_closure(private_overlay, &FullNodeFastSyncOverlay::send_broadcast, broadcast.clone());
|
||||
}
|
||||
td::actor::send_closure(shard, &FullNodeShard::send_broadcast, std::move(broadcast));
|
||||
}
|
||||
|
|
@ -645,9 +649,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, std::set<ShardIdFull> shards_to_monitor,
|
||||
std::set<ShardIdFull> temporary_shards) override {
|
||||
td::actor::send_closure(id_, &FullNodeImpl::update_shard_configuration, std::move(state),
|
||||
void on_new_masterchain_block(td::Ref<MasterchainState> state, std::set<ShardIdFull> shards_to_monitor,
|
||||
std::set<ShardIdFull> temporary_shards) override {
|
||||
td::actor::send_closure(id_, &FullNodeImpl::on_new_masterchain_block, std::move(state),
|
||||
std::move(shards_to_monitor), std::move(temporary_shards));
|
||||
}
|
||||
void send_ihr_message(AccountIdPrefixFull dst, td::BufferSlice data) override {
|
||||
|
|
|
|||
|
|
@ -92,6 +92,9 @@ class FullNode : public td::actor::Actor {
|
|||
virtual void process_block_candidate_broadcast(BlockIdExt block_id, CatchainSeqno cc_seqno,
|
||||
td::uint32 validator_set_hash, td::BufferSlice data) = 0;
|
||||
|
||||
virtual void import_fast_sync_member_certificate(adnl::AdnlNodeIdShort local_id,
|
||||
overlay::OverlayMemberCertificate cert) = 0;
|
||||
|
||||
static constexpr td::uint32 max_block_size() {
|
||||
return 4 << 20;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@
|
|||
#include "interfaces/proof.h"
|
||||
#include "interfaces/shard.h"
|
||||
#include "full-node-private-overlay.hpp"
|
||||
#include "full-node-private-overlay-v2.hpp"
|
||||
#include "full-node-fast-sync-overlays.hpp"
|
||||
|
||||
#include <map>
|
||||
#include <set>
|
||||
|
|
@ -47,9 +47,8 @@ class FullNodeImpl : public FullNode {
|
|||
void add_collator_adnl_id(adnl::AdnlNodeIdShort id) override;
|
||||
void del_collator_adnl_id(adnl::AdnlNodeIdShort id) override;
|
||||
|
||||
void sign_shard_overlay_certificate(ShardIdFull shard_id, PublicKeyHash signed_key,
|
||||
td::uint32 expiry_at, td::uint32 max_size,
|
||||
td::Promise<td::BufferSlice> promise) override;
|
||||
void sign_shard_overlay_certificate(ShardIdFull shard_id, PublicKeyHash signed_key, td::uint32 expiry_at,
|
||||
td::uint32 max_size, td::Promise<td::BufferSlice> promise) override;
|
||||
void import_shard_overlay_certificate(ShardIdFull shard_id, PublicKeyHash signed_key,
|
||||
std::shared_ptr<ton::overlay::Certificate> cert,
|
||||
td::Promise<td::Unit> promise) override;
|
||||
|
|
@ -60,7 +59,7 @@ class FullNodeImpl : public FullNode {
|
|||
void add_custom_overlay(CustomOverlayParams params, td::Promise<td::Unit> promise) override;
|
||||
void del_custom_overlay(std::string name, td::Promise<td::Unit> promise) override;
|
||||
|
||||
void update_shard_configuration(td::Ref<MasterchainState> state, std::set<ShardIdFull> shards_to_monitor,
|
||||
void on_new_masterchain_block(td::Ref<MasterchainState> state, std::set<ShardIdFull> shards_to_monitor,
|
||||
std::set<ShardIdFull> temporary_shards);
|
||||
|
||||
void sync_completed();
|
||||
|
|
@ -95,6 +94,11 @@ class FullNodeImpl : public FullNode {
|
|||
void process_block_candidate_broadcast(BlockIdExt block_id, CatchainSeqno cc_seqno, td::uint32 validator_set_hash,
|
||||
td::BufferSlice data) override;
|
||||
|
||||
void import_fast_sync_member_certificate(adnl::AdnlNodeIdShort local_id,
|
||||
overlay::OverlayMemberCertificate cert) override {
|
||||
fast_sync_overlays_.add_member_certificate(local_id, std::move(cert));
|
||||
}
|
||||
|
||||
void start_up() override;
|
||||
|
||||
FullNodeImpl(PublicKeyHash local_id, adnl::AdnlNodeIdShort adnl_id, FileHash zero_state_file_hash,
|
||||
|
|
@ -145,12 +149,13 @@ class FullNodeImpl : public FullNode {
|
|||
FullNodeConfig config_;
|
||||
|
||||
// Private overlays:
|
||||
// Old overlays - one overlay for all validators
|
||||
// New overlays (v2) - overlay per shard (monitor_min_split depth).
|
||||
bool use_old_private_overlays_ = false; // TODO: set from config
|
||||
// Old overlays - one private overlay for all validators
|
||||
// New overlays (fast sync overlays) - semiprivate overlay per shard (monitor_min_split depth)
|
||||
// for validators and authorized nodes
|
||||
bool use_old_private_overlays_ = false; // TODO: set from config or something
|
||||
std::map<PublicKeyHash, td::actor::ActorOwn<FullNodePrivateBlockOverlay>> private_block_overlays_;
|
||||
bool broadcast_block_candidates_in_public_overlay_ = false;
|
||||
FullNodePrivateBlockOverlaysV2 private_block_overlays_v2_;
|
||||
FullNodeFastSyncOverlays fast_sync_overlays_;
|
||||
|
||||
struct CustomOverlayInfo {
|
||||
CustomOverlayParams params_;
|
||||
|
|
|
|||
|
|
@ -57,6 +57,8 @@ using ValidateCandidateResult = td::Variant<UnixTime, CandidateReject>;
|
|||
|
||||
class ValidatorManager : public ValidatorManagerInterface {
|
||||
public:
|
||||
virtual void init_last_masterchain_state(td::Ref<MasterchainState> state) {
|
||||
}
|
||||
virtual void set_block_state(BlockHandle handle, td::Ref<ShardState> state,
|
||||
td::Promise<td::Ref<ShardState>> promise) = 0;
|
||||
virtual void get_cell_db_reader(td::Promise<std::shared_ptr<vm::CellDbReader>> promise) = 0;
|
||||
|
|
@ -140,7 +142,6 @@ 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, 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;
|
||||
|
|
|
|||
|
|
@ -272,8 +272,6 @@ 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, std::set<ShardIdFull> shards_to_monitor) override {
|
||||
}
|
||||
|
||||
void update_async_serializer_state(AsyncSerializerState state, td::Promise<td::Unit> promise) override {
|
||||
UNREACHABLE();
|
||||
|
|
|
|||
|
|
@ -344,9 +344,6 @@ 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, std::set<ShardIdFull> shards_to_monitor) override {
|
||||
UNREACHABLE();
|
||||
}
|
||||
|
||||
void update_async_serializer_state(AsyncSerializerState state, td::Promise<td::Unit> promise) override {
|
||||
UNREACHABLE();
|
||||
|
|
|
|||
|
|
@ -268,6 +268,7 @@ void ValidatorManagerMasterchainReiniter::downloaded_masterchain_state(td::Ref<S
|
|||
CHECK(handle_->received_state());
|
||||
CHECK(handle_->is_applied());
|
||||
LOG(INFO) << "downloaded masterchain state";
|
||||
td::actor::send_closure(manager_, &ValidatorManager::init_last_masterchain_state, state_);
|
||||
auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::Unit> R) {
|
||||
R.ensure();
|
||||
td::actor::send_closure(SelfId, &ValidatorManagerMasterchainReiniter::downloaded_all_shards);
|
||||
|
|
|
|||
|
|
@ -1740,6 +1740,7 @@ void ValidatorManagerImpl::send_top_shard_block_description(td::Ref<ShardTopBloc
|
|||
} else {
|
||||
out_shard_blocks_[ShardTopBlockDescriptionId{desc->block_id().shard_full(), desc->catchain_seqno()}] = desc;
|
||||
callback_->send_shard_block_info(desc->block_id(), desc->catchain_seqno(), desc->serialize());
|
||||
add_shard_block_description(desc);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1826,6 +1827,14 @@ void ValidatorManagerImpl::start_up() {
|
|||
alarm_timestamp().relax(check_waiters_at_);
|
||||
}
|
||||
|
||||
void ValidatorManagerImpl::init_last_masterchain_state(td::Ref<MasterchainState> state) {
|
||||
if (last_masterchain_state_.not_null()) {
|
||||
return;
|
||||
}
|
||||
last_masterchain_state_ = std::move(state);
|
||||
update_shard_overlays();
|
||||
}
|
||||
|
||||
void ValidatorManagerImpl::started(ValidatorManagerInitResult R) {
|
||||
CHECK(R.handle);
|
||||
CHECK(R.state.not_null());
|
||||
|
|
@ -1873,6 +1882,7 @@ void ValidatorManagerImpl::started(ValidatorManagerInitResult R) {
|
|||
}
|
||||
});
|
||||
td::actor::send_closure(db_, &Db::get_persistent_state_descriptions, std::move(Q));
|
||||
update_shard_overlays();
|
||||
}
|
||||
|
||||
void ValidatorManagerImpl::read_gc_list(std::vector<ValidatorSessionId> list) {
|
||||
|
|
@ -2049,6 +2059,7 @@ void ValidatorManagerImpl::new_masterchain_block() {
|
|||
}
|
||||
}
|
||||
|
||||
update_shard_overlays();
|
||||
update_shards();
|
||||
update_shard_blocks();
|
||||
|
||||
|
|
@ -2081,6 +2092,26 @@ void ValidatorManagerImpl::new_masterchain_block() {
|
|||
}
|
||||
}
|
||||
|
||||
void ValidatorManagerImpl::update_shard_overlays() {
|
||||
CHECK(last_masterchain_state_.not_null());
|
||||
std::set<ShardIdFull> shards_to_monitor;
|
||||
shards_to_monitor.insert(ShardIdFull{masterchainId});
|
||||
std::set<WorkchainId> workchains;
|
||||
for (const auto& shard : last_masterchain_state_->get_shards()) {
|
||||
workchains.insert(shard->shard().workchain);
|
||||
if (opts_->need_monitor(shard->shard(),last_masterchain_state_)) {
|
||||
shards_to_monitor.insert(shard->shard());
|
||||
}
|
||||
}
|
||||
for (const auto &[wc, desc] : last_masterchain_state_->get_workchain_list()) {
|
||||
if (!workchains.count(wc) && desc->active &&
|
||||
opts_->need_monitor(ShardIdFull{wc, shardIdAll}, last_masterchain_state_)) {
|
||||
shards_to_monitor.insert(ShardIdFull{wc, shardIdAll});
|
||||
}
|
||||
}
|
||||
callback_->on_new_masterchain_block(last_masterchain_state_, std::move(shards_to_monitor), extra_active_shards_);
|
||||
}
|
||||
|
||||
void ValidatorManagerImpl::update_shards() {
|
||||
if ((last_masterchain_state_->rotated_all_shards() || last_masterchain_seqno_ == 0) &&
|
||||
opts_->get_last_fork_masterchain_seqno() <= last_masterchain_seqno_) {
|
||||
|
|
@ -2836,11 +2867,6 @@ void ValidatorManagerImpl::get_shard_client_state(bool from_db, td::Promise<Bloc
|
|||
}
|
||||
}
|
||||
|
||||
void ValidatorManagerImpl::update_shard_configuration(td::Ref<MasterchainState> state,
|
||||
std::set<ShardIdFull> shards_to_monitor) {
|
||||
callback_->update_shard_configuration(std::move(state), std::move(shards_to_monitor), extra_active_shards_);
|
||||
}
|
||||
|
||||
void ValidatorManagerImpl::update_async_serializer_state(AsyncSerializerState state, td::Promise<td::Unit> promise) {
|
||||
td::actor::send_closure(db_, &Db::update_async_serializer_state, std::move(state), std::move(promise));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -319,6 +319,7 @@ class ValidatorManagerImpl : public ValidatorManager {
|
|||
std::vector<PerfTimerStats> perf_timer_stats;
|
||||
|
||||
void new_masterchain_block();
|
||||
void update_shard_overlays();
|
||||
void update_shards();
|
||||
void update_shard_blocks();
|
||||
void written_destroyed_validator_sessions(std::vector<td::actor::ActorId<ValidatorGroup>> groups);
|
||||
|
|
@ -521,7 +522,6 @@ 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, 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;
|
||||
|
|
@ -557,6 +557,7 @@ class ValidatorManagerImpl : public ValidatorManager {
|
|||
void finished_wait_data(BlockHandle handle, td::Result<td::Ref<BlockData>> R);
|
||||
|
||||
void start_up() override;
|
||||
void init_last_masterchain_state(td::Ref<MasterchainState> state) override;
|
||||
void started(ValidatorManagerInitResult result);
|
||||
void read_gc_list(std::vector<ValidatorSessionId> list);
|
||||
|
||||
|
|
|
|||
|
|
@ -70,19 +70,13 @@ void ShardClient::got_init_handle_from_db(BlockHandle handle) {
|
|||
}
|
||||
|
||||
void ShardClient::got_init_state_from_db(td::Ref<MasterchainState> state) {
|
||||
masterchain_state_ = std::move(state);
|
||||
build_shard_overlays();
|
||||
masterchain_state_.clear();
|
||||
|
||||
saved_to_db();
|
||||
}
|
||||
|
||||
void ShardClient::start_up_init_mode() {
|
||||
build_shard_overlays();
|
||||
|
||||
auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::Unit> R) {
|
||||
R.ensure();
|
||||
td::actor::send_closure(SelfId, &ShardClient::applied_all_shards);
|
||||
td::actor::send_closure(SelfId, &ShardClient::apply_all_shards);
|
||||
});
|
||||
|
||||
td::MultiPromise mp;
|
||||
|
|
@ -166,7 +160,6 @@ void ShardClient::download_masterchain_state() {
|
|||
|
||||
void ShardClient::got_masterchain_block_state(td::Ref<MasterchainState> state) {
|
||||
masterchain_state_ = std::move(state);
|
||||
build_shard_overlays();
|
||||
if (started_) {
|
||||
apply_all_shards();
|
||||
}
|
||||
|
|
@ -189,7 +182,9 @@ void ShardClient::apply_all_shards() {
|
|||
ig.add_promise(std::move(P));
|
||||
|
||||
auto vec = masterchain_state_->get_shards();
|
||||
std::set<WorkchainId> workchains;
|
||||
for (auto &shard : vec) {
|
||||
workchains.insert(shard->shard().workchain);
|
||||
if (opts_->need_monitor(shard->shard(), masterchain_state_)) {
|
||||
auto Q = td::PromiseCreator::lambda([SelfId = actor_id(this), promise = ig.get_promise(),
|
||||
shard = shard->shard()](td::Result<td::Ref<ShardState>> R) mutable {
|
||||
|
|
@ -203,6 +198,21 @@ void ShardClient::apply_all_shards() {
|
|||
shard_client_priority(), td::Timestamp::in(1500), std::move(Q));
|
||||
}
|
||||
}
|
||||
for (const auto &[wc, desc] : masterchain_state_->get_workchain_list()) {
|
||||
if (!workchains.count(wc) && desc->active && opts_->need_monitor(ShardIdFull{wc, shardIdAll}, masterchain_state_)) {
|
||||
auto Q = td::PromiseCreator::lambda(
|
||||
[SelfId = actor_id(this), promise = ig.get_promise(), wc](td::Result<td::Ref<ShardState>> R) mutable {
|
||||
if (R.is_error()) {
|
||||
promise.set_error(R.move_as_error_prefix(PSTRING() << "workchain " << wc << ": "));
|
||||
} else {
|
||||
td::actor::send_closure(SelfId, &ShardClient::downloaded_shard_state, R.move_as_ok(), std::move(promise));
|
||||
}
|
||||
});
|
||||
td::actor::send_closure(manager_, &ValidatorManager::wait_block_state_short,
|
||||
BlockIdExt{wc, shardIdAll, 0, desc->zerostate_root_hash, desc->zerostate_file_hash},
|
||||
shard_client_priority(), td::Timestamp::in(1500), std::move(Q));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ShardClient::downloaded_shard_state(td::Ref<ShardState> state, td::Promise<td::Unit> promise) {
|
||||
|
|
@ -223,7 +233,6 @@ void ShardClient::new_masterchain_block_notification(BlockHandle handle, td::Ref
|
|||
masterchain_block_handle_ = std::move(handle);
|
||||
masterchain_state_ = std::move(state);
|
||||
waiting_ = false;
|
||||
build_shard_overlays();
|
||||
|
||||
apply_all_shards();
|
||||
}
|
||||
|
|
@ -244,42 +253,6 @@ void ShardClient::get_processed_masterchain_block_id(td::Promise<BlockIdExt> pro
|
|||
}
|
||||
}
|
||||
|
||||
void ShardClient::build_shard_overlays() {
|
||||
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);
|
||||
if (opts_->need_monitor(shard, masterchain_state_)) {
|
||||
new_shards_to_monitor.insert(shard);
|
||||
}
|
||||
}
|
||||
|
||||
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, masterchain_state_)) {
|
||||
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) {
|
||||
CHECK(!init_mode_);
|
||||
CHECK(!started_);
|
||||
|
|
@ -310,7 +283,6 @@ void ShardClient::force_update_shard_client_ex(BlockHandle handle, td::Ref<Maste
|
|||
masterchain_block_handle_ = std::move(handle);
|
||||
masterchain_state_ = std::move(state);
|
||||
promise_ = std::move(promise);
|
||||
build_shard_overlays();
|
||||
applied_all_shards();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -42,8 +42,6 @@ class ShardClient : public td::actor::Actor {
|
|||
|
||||
td::Promise<td::Unit> promise_;
|
||||
|
||||
std::set<ShardIdFull> shards_to_monitor_ = {ShardIdFull(masterchainId)};
|
||||
|
||||
public:
|
||||
ShardClient(td::Ref<ValidatorManagerOptions> opts, BlockHandle masterchain_block_handle,
|
||||
td::Ref<MasterchainState> masterchain_state, td::actor::ActorId<ValidatorManager> manager,
|
||||
|
|
@ -64,8 +62,6 @@ class ShardClient : public td::actor::Actor {
|
|||
return 2;
|
||||
}
|
||||
|
||||
void build_shard_overlays();
|
||||
|
||||
void start_up() override;
|
||||
void start_up_init_mode();
|
||||
void start_up_init_mode_finished();
|
||||
|
|
|
|||
|
|
@ -169,9 +169,9 @@ 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,
|
||||
std::set<ShardIdFull> shards_to_monitor,
|
||||
std::set<ShardIdFull> temporary_shards) = 0;
|
||||
virtual void on_new_masterchain_block(td::Ref<ton::validator::MasterchainState> state,
|
||||
std::set<ShardIdFull> shards_to_monitor,
|
||||
std::set<ShardIdFull> temporary_shards) = 0;
|
||||
|
||||
virtual void send_ihr_message(AccountIdPrefixFull dst, td::BufferSlice data) = 0;
|
||||
virtual void send_ext_message(AccountIdPrefixFull dst, td::BufferSlice data) = 0;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue