external/ton
1
0
Fork 0
mirror of https://github.com/ton-blockchain/ton synced 2025-03-09 15:40:10 +00:00
Code Issues Releases Wiki Activity

Rename private ext msg overlays to custom overlays, change interface a bit (#952)

Browse source 
Co-authored-by: SpyCheese <mikle98@yandex.ru>
This commit is contained in:
EmelyanenkoK 2024-04-01 18:24:08 +03:00 • committed by GitHub
parent 0434eadc1f
commit f7907bdd58
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
11 changed files with 121 additions and 125 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -400,7 +400,7 @@ tonNode.newShardBlockBroadcast block:tonNode.newShardBlock = tonNode.Broadcast;
tonNode.shardPublicOverlayId workchain:int shard:long zero_state_file_hash:int256 = tonNode.ShardPublicOverlayId; tonNode.shardPublicOverlayId workchain:int shard:long zero_state_file_hash:int256 = tonNode.ShardPublicOverlayId;
tonNode.privateBlockOverlayId zero_state_file_hash:int256 nodes:(vector int256) = tonNode.PrivateBlockOverlayId; tonNode.privateBlockOverlayId zero_state_file_hash:int256 nodes:(vector int256) = tonNode.PrivateBlockOverlayId;
tonNode.privateExtMsgsOverlayId zero_state_file_hash:int256 name:string nodes:(vector int256) = tonNode.PrivateExtMsgsOverlayId; tonNode.customOverlayId zero_state_file_hash:int256 name:string nodes:(vector int256) = tonNode.CustomOverlayId;
tonNode.keyBlocks blocks:(vector tonNode.blockIdExt) incomplete:Bool error:Bool = tonNode.KeyBlocks; tonNode.keyBlocks blocks:(vector tonNode.blockIdExt) incomplete:Bool error:Bool = tonNode.KeyBlocks;
@ -595,9 +595,9 @@ engine.validator.config out_port:int addrs:(vector engine.Addr) adnl:(vector eng
liteservers:(vector engine.liteServer) control:(vector engine.controlInterface) liteservers:(vector engine.liteServer) control:(vector engine.controlInterface)
gc:engine.gc = engine.validator.Config; gc:engine.gc = engine.validator.Config;
engine.validator.privateExtMsgOverlayNode adnl_id:int256 sender:Bool sender_priority:int = engine.validator.PrivateExtMsgOverlayNode; engine.validator.customOverlayNode adnl_id:int256 msg_sender:Bool msg_sender_priority:int = engine.validator.CustomOverlayNode;
engine.validator.privateExtMsgOverlay name:string nodes:(vector engine.validator.privateExtMsgOverlayNode) = engine.validator.PrivateExtMsgOverlay; engine.validator.customOverlay name:string nodes:(vector engine.validator.customOverlayNode) = engine.validator.CustomOverlay;
engine.validator.privateExtMsgOverlaysConfig overlays:(vector engine.validator.privateExtMsgOverlay) = engine.validator.PrivateExtMsgOverlaysConfig; engine.validator.customOverlaysConfig overlays:(vector engine.validator.customOverlay) = engine.validator.CustomOverlaysConfig;
---functions--- ---functions---
---types--- ---types---
@ -702,9 +702,9 @@ engine.validator.getPerfTimerStats name:string = engine.validator.PerfTimerStats
engine.validator.getShardOutQueueSize flags:# block_id:tonNode.blockId dest_wc:flags.0?int dest_shard:flags.0?long = engine.validator.ShardOutQueueSize; engine.validator.getShardOutQueueSize flags:# block_id:tonNode.blockId dest_wc:flags.0?int dest_shard:flags.0?long = engine.validator.ShardOutQueueSize;
engine.validator.setExtMessagesBroadcastDisabled disabled:Bool = engine.validator.Success; engine.validator.setExtMessagesBroadcastDisabled disabled:Bool = engine.validator.Success;
engine.validator.addPrivateExtMsgOverlay overlay:engine.validator.privateExtMsgOverlay = engine.validator.Success; engine.validator.addCustomOverlay overlay:engine.validator.customOverlay = engine.validator.Success;
engine.validator.delPrivateExtMsgOverlay name:string = engine.validator.Success; engine.validator.delCustomOverlay name:string = engine.validator.Success;
engine.validator.showPrivateExtMsgOverlays = engine.validator.PrivateExtMsgOverlaysConfig; engine.validator.showCustomOverlays = engine.validator.CustomOverlaysConfig;
---types--- ---types---

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

Binary file not shown.

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

@ -1110,69 +1110,69 @@ td::Status SetExtMessagesBroadcastDisabledQuery::receive(td::BufferSlice data) {
return td::Status::OK(); return td::Status::OK();
} }
td::Status AddPrivateExtMsgOverlayQuery::run() { td::Status AddCustomOverlayQuery::run() {
TRY_RESULT_ASSIGN(file_name_, tokenizer_.get_token<std::string>()); TRY_RESULT_ASSIGN(file_name_, tokenizer_.get_token<std::string>());
TRY_STATUS(tokenizer_.check_endl()); TRY_STATUS(tokenizer_.check_endl());
return td::Status::OK(); return td::Status::OK();
} }
td::Status AddPrivateExtMsgOverlayQuery::send() { td::Status AddCustomOverlayQuery::send() {
TRY_RESULT(data, td::read_file(file_name_)); TRY_RESULT(data, td::read_file(file_name_));
TRY_RESULT(json, td::json_decode(data.as_slice())); TRY_RESULT(json, td::json_decode(data.as_slice()));
auto overlay = ton::create_tl_object<ton::ton_api::engine_validator_privateExtMsgOverlay>(); auto overlay = ton::create_tl_object<ton::ton_api::engine_validator_customOverlay>();
TRY_STATUS(ton::ton_api::from_json(*overlay, json.get_object())); TRY_STATUS(ton::ton_api::from_json(*overlay, json.get_object()));
auto b = ton::create_serialize_tl_object<ton::ton_api::engine_validator_addPrivateExtMsgOverlay>(std::move(overlay)); auto b = ton::create_serialize_tl_object<ton::ton_api::engine_validator_addCustomOverlay>(std::move(overlay));
td::actor::send_closure(console_, &ValidatorEngineConsole::envelope_send_query, std::move(b), create_promise()); td::actor::send_closure(console_, &ValidatorEngineConsole::envelope_send_query, std::move(b), create_promise());
return td::Status::OK(); return td::Status::OK();
} }
td::Status AddPrivateExtMsgOverlayQuery::receive(td::BufferSlice data) { td::Status AddCustomOverlayQuery::receive(td::BufferSlice data) {
TRY_RESULT_PREFIX(f, ton::fetch_tl_object<ton::ton_api::engine_validator_success>(data.as_slice(), true), TRY_RESULT_PREFIX(f, ton::fetch_tl_object<ton::ton_api::engine_validator_success>(data.as_slice(), true),
"received incorrect answer: "); "received incorrect answer: ");
td::TerminalIO::out() << "success\n"; td::TerminalIO::out() << "success\n";
return td::Status::OK(); return td::Status::OK();
} }
td::Status DelPrivateExtMsgOverlayQuery::run() { td::Status DelCustomOverlayQuery::run() {
TRY_RESULT_ASSIGN(name_, tokenizer_.get_token<std::string>()); TRY_RESULT_ASSIGN(name_, tokenizer_.get_token<std::string>());
TRY_STATUS(tokenizer_.check_endl()); TRY_STATUS(tokenizer_.check_endl());
return td::Status::OK(); return td::Status::OK();
} }
td::Status DelPrivateExtMsgOverlayQuery::send() { td::Status DelCustomOverlayQuery::send() {
auto b = ton::create_serialize_tl_object<ton::ton_api::engine_validator_delPrivateExtMsgOverlay>(name_); auto b = ton::create_serialize_tl_object<ton::ton_api::engine_validator_delCustomOverlay>(name_);
td::actor::send_closure(console_, &ValidatorEngineConsole::envelope_send_query, std::move(b), create_promise()); td::actor::send_closure(console_, &ValidatorEngineConsole::envelope_send_query, std::move(b), create_promise());
return td::Status::OK(); return td::Status::OK();
} }
td::Status DelPrivateExtMsgOverlayQuery::receive(td::BufferSlice data) { td::Status DelCustomOverlayQuery::receive(td::BufferSlice data) {
TRY_RESULT_PREFIX(f, ton::fetch_tl_object<ton::ton_api::engine_validator_success>(data.as_slice(), true), TRY_RESULT_PREFIX(f, ton::fetch_tl_object<ton::ton_api::engine_validator_success>(data.as_slice(), true),
"received incorrect answer: "); "received incorrect answer: ");
td::TerminalIO::out() << "success\n"; td::TerminalIO::out() << "success\n";
return td::Status::OK(); return td::Status::OK();
} }
td::Status ShowPrivateExtMsgOverlaysQuery::run() { td::Status ShowCustomOverlaysQuery::run() {
TRY_STATUS(tokenizer_.check_endl()); TRY_STATUS(tokenizer_.check_endl());
return td::Status::OK(); return td::Status::OK();
} }
td::Status ShowPrivateExtMsgOverlaysQuery::send() { td::Status ShowCustomOverlaysQuery::send() {
auto b = ton::create_serialize_tl_object<ton::ton_api::engine_validator_showPrivateExtMsgOverlays>(); auto b = ton::create_serialize_tl_object<ton::ton_api::engine_validator_showCustomOverlays>();
td::actor::send_closure(console_, &ValidatorEngineConsole::envelope_send_query, std::move(b), create_promise()); td::actor::send_closure(console_, &ValidatorEngineConsole::envelope_send_query, std::move(b), create_promise());
return td::Status::OK(); return td::Status::OK();
} }
td::Status ShowPrivateExtMsgOverlaysQuery::receive(td::BufferSlice data) { td::Status ShowCustomOverlaysQuery::receive(td::BufferSlice data) {
TRY_RESULT_PREFIX( TRY_RESULT_PREFIX(f, ton::fetch_tl_object<ton::ton_api::engine_validator_customOverlaysConfig>(data.as_slice(), true),
f, ton::fetch_tl_object<ton::ton_api::engine_validator_privateExtMsgOverlaysConfig>(data.as_slice(), true), "received incorrect answer: ");
"received incorrect answer: "); td::TerminalIO::out() << f->overlays_.size() << " custom overlays:\n\n";
td::TerminalIO::out() << f->overlays_.size() << " private overlays:\n\n";
for (const auto &overlay : f->overlays_) { for (const auto &overlay : f->overlays_) {
td::TerminalIO::out() << "Overlay \"" << overlay->name_ << "\": " << overlay->nodes_.size() << " nodes\n"; td::TerminalIO::out() << "Overlay \"" << overlay->name_ << "\": " << overlay->nodes_.size() << " nodes\n";
for (const auto &node : overlay->nodes_) { for (const auto &node : overlay->nodes_) {
td::TerminalIO::out() << " " << node->adnl_id_ td::TerminalIO::out() << " " << node->adnl_id_
<< (node->sender_ ? (PSTRING() << " (sender, p=" << node->sender_priority_ << ")") : "") << (node->msg_sender_ ? (PSTRING() << " (sender, p=" << node->msg_sender_priority_ << ")")
: "")
<< "\n"; << "\n";
} }
td::TerminalIO::out() << "\n"; td::TerminalIO::out() << "\n";

25
validator-engine-console/validator-engine-console-query.h
View file

@ -1145,20 +1145,19 @@ class SetExtMessagesBroadcastDisabledQuery : public Query {
bool value; bool value;
}; };
class AddPrivateExtMsgOverlayQuery : public Query { class AddCustomOverlayQuery : public Query {
public: public:
AddPrivateExtMsgOverlayQuery(td::actor::ActorId<ValidatorEngineConsole> console, Tokenizer tokenizer) AddCustomOverlayQuery(td::actor::ActorId<ValidatorEngineConsole> console, Tokenizer tokenizer)
: Query(console, std::move(tokenizer)) { : Query(console, std::move(tokenizer)) {
} }
td::Status run() override; td::Status run() override;
td::Status send() override; td::Status send() override;
td::Status receive(td::BufferSlice data) override; td::Status receive(td::BufferSlice data) override;
static std::string get_name() { static std::string get_name() {
return "addprivateextmsgoverlay"; return "addcustomoverlay";
} }
static std::string get_help() { static std::string get_help() {
return "addprivateextmsgoverlay <filename>\tadd private overlay for external messages with config from file " return "addcustomoverlay <filename>\tadd custom overlay with config from file <filename>";
"<filename>";
} }
std::string name() const override { std::string name() const override {
return get_name(); return get_name();
@ -1168,19 +1167,19 @@ class AddPrivateExtMsgOverlayQuery : public Query {
std::string file_name_; std::string file_name_;
}; };
class DelPrivateExtMsgOverlayQuery : public Query { class DelCustomOverlayQuery : public Query {
public: public:
DelPrivateExtMsgOverlayQuery(td::actor::ActorId<ValidatorEngineConsole> console, Tokenizer tokenizer) DelCustomOverlayQuery(td::actor::ActorId<ValidatorEngineConsole> console, Tokenizer tokenizer)
: Query(console, std::move(tokenizer)) { : Query(console, std::move(tokenizer)) {
} }
td::Status run() override; td::Status run() override;
td::Status send() override; td::Status send() override;
td::Status receive(td::BufferSlice data) override; td::Status receive(td::BufferSlice data) override;
static std::string get_name() { static std::string get_name() {
return "delprivateextmsgoverlay"; return "delcustomoverlay";
} }
static std::string get_help() { static std::string get_help() {
return "delprivateextmsgoverlay <name>\tdelete private overlay for external messages with name <name>"; return "delcustomoverlay <name>\tdelete custom overlay with name <name>";
} }
std::string name() const override { std::string name() const override {
return get_name(); return get_name();
@ -1190,19 +1189,19 @@ class DelPrivateExtMsgOverlayQuery : public Query {
std::string name_; std::string name_;
}; };
class ShowPrivateExtMsgOverlaysQuery : public Query { class ShowCustomOverlaysQuery : public Query {
public: public:
ShowPrivateExtMsgOverlaysQuery(td::actor::ActorId<ValidatorEngineConsole> console, Tokenizer tokenizer) ShowCustomOverlaysQuery(td::actor::ActorId<ValidatorEngineConsole> console, Tokenizer tokenizer)
: Query(console, std::move(tokenizer)) { : Query(console, std::move(tokenizer)) {
} }
td::Status run() override; td::Status run() override;
td::Status send() override; td::Status send() override;
td::Status receive(td::BufferSlice data) override; td::Status receive(td::BufferSlice data) override;
static std::string get_name() { static std::string get_name() {
return "showprivateextmsgoverlays"; return "showcustomoverlays";
} }
static std::string get_help() { static std::string get_help() {
return "showprivateextmsgoverlays\tshow all private overlay for external messages"; return "showcustomoverlays\tshow all custom overlays";
} }
std::string name() const override { std::string name() const override {
return get_name(); return get_name();

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

@ -143,9 +143,9 @@ void ValidatorEngineConsole::run() {
add_query_runner(std::make_unique<QueryRunnerImpl<GetPerfTimerStatsJsonQuery>>()); add_query_runner(std::make_unique<QueryRunnerImpl<GetPerfTimerStatsJsonQuery>>());
add_query_runner(std::make_unique<QueryRunnerImpl<GetShardOutQueueSizeQuery>>()); add_query_runner(std::make_unique<QueryRunnerImpl<GetShardOutQueueSizeQuery>>());
add_query_runner(std::make_unique<QueryRunnerImpl<SetExtMessagesBroadcastDisabledQuery>>()); add_query_runner(std::make_unique<QueryRunnerImpl<SetExtMessagesBroadcastDisabledQuery>>());
add_query_runner(std::make_unique<QueryRunnerImpl<AddPrivateExtMsgOverlayQuery>>()); add_query_runner(std::make_unique<QueryRunnerImpl<AddCustomOverlayQuery>>());
add_query_runner(std::make_unique<QueryRunnerImpl<DelPrivateExtMsgOverlayQuery>>()); add_query_runner(std::make_unique<QueryRunnerImpl<DelCustomOverlayQuery>>());
add_query_runner(std::make_unique<QueryRunnerImpl<ShowPrivateExtMsgOverlaysQuery>>()); add_query_runner(std::make_unique<QueryRunnerImpl<ShowCustomOverlaysQuery>>());
} }
bool ValidatorEngineConsole::envelope_send_query(td::BufferSlice query, td::Promise<td::BufferSlice> promise) { bool ValidatorEngineConsole::envelope_send_query(td::BufferSlice query, td::Promise<td::BufferSlice> promise) {

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

@ -1843,7 +1843,7 @@ void ValidatorEngine::start_full_node() {
config_.full_node_config, keyring_.get(), adnl_.get(), rldp_.get(), rldp2_.get(), config_.full_node_config, keyring_.get(), adnl_.get(), rldp_.get(), rldp2_.get(),
default_dht_node_.is_zero() ? td::actor::ActorId<ton::dht::Dht>{} : dht_nodes_[default_dht_node_].get(), default_dht_node_.is_zero() ? td::actor::ActorId<ton::dht::Dht>{} : dht_nodes_[default_dht_node_].get(),
overlay_manager_.get(), validator_manager_.get(), full_node_client_.get(), db_root_); overlay_manager_.get(), validator_manager_.get(), full_node_client_.get(), db_root_);
load_private_ext_msg_overlays_config(); load_custom_overlays_config();
} }
for (auto &v : config_.validators) { for (auto &v : config_.validators) {
@ -2336,33 +2336,33 @@ void ValidatorEngine::try_del_proxy(td::uint32 ip, td::int32 port, std::vector<A
write_config(std::move(promise)); write_config(std::move(promise));
} }
void ValidatorEngine::load_private_ext_msg_overlays_config() { void ValidatorEngine::load_custom_overlays_config() {
private_ext_msg_overlays_config_ = custom_overlays_config_ =
ton::create_tl_object<ton::ton_api::engine_validator_privateExtMsgOverlaysConfig>(); ton::create_tl_object<ton::ton_api::engine_validator_customOverlaysConfig>();
auto data_R = td::read_file(private_ext_msg_overlays_config_file()); auto data_R = td::read_file(custom_overlays_config_file());
if (data_R.is_error()) { if (data_R.is_error()) {
return; return;
} }
auto data = data_R.move_as_ok(); auto data = data_R.move_as_ok();
auto json_R = td::json_decode(data.as_slice()); auto json_R = td::json_decode(data.as_slice());
if (json_R.is_error()) { if (json_R.is_error()) {
LOG(ERROR) << "Failed to parse private ext msg overlays config: " << json_R.move_as_error(); LOG(ERROR) << "Failed to parse custom overlays config: " << json_R.move_as_error();
return; return;
} }
auto json = json_R.move_as_ok(); auto json = json_R.move_as_ok();
auto S = ton::ton_api::from_json(*private_ext_msg_overlays_config_, json.get_object()); auto S = ton::ton_api::from_json(*custom_overlays_config_, json.get_object());
if (S.is_error()) { if (S.is_error()) {
LOG(ERROR) << "Failed to parse private ext msg overlays config: " << S; LOG(ERROR) << "Failed to parse custom overlays config: " << S;
return; return;
} }
for (auto &overlay : private_ext_msg_overlays_config_->overlays_) { for (auto &overlay : custom_overlays_config_->overlays_) {
std::vector<ton::adnl::AdnlNodeIdShort> nodes; std::vector<ton::adnl::AdnlNodeIdShort> nodes;
std::map<ton::adnl::AdnlNodeIdShort, int> senders; std::map<ton::adnl::AdnlNodeIdShort, int> senders;
for (const auto &node : overlay->nodes_) { for (const auto &node : overlay->nodes_) {
nodes.emplace_back(node->adnl_id_); nodes.emplace_back(node->adnl_id_);
if (node->sender_) { if (node->msg_sender_) {
senders[ton::adnl::AdnlNodeIdShort{node->adnl_id_}] = node->sender_priority_; senders[ton::adnl::AdnlNodeIdShort{node->adnl_id_}] = node->msg_sender_priority_;
} }
} }
td::actor::send_closure(full_node_, &ton::validator::fullnode::FullNode::add_ext_msg_overlay, std::move(nodes), td::actor::send_closure(full_node_, &ton::validator::fullnode::FullNode::add_ext_msg_overlay, std::move(nodes),
@ -2370,25 +2370,25 @@ void ValidatorEngine::load_private_ext_msg_overlays_config() {
} }
} }
td::Status ValidatorEngine::write_private_ext_msg_overlays_config() { td::Status ValidatorEngine::write_custom_overlays_config() {
auto s = td::json_encode<std::string>(td::ToJson(*private_ext_msg_overlays_config_), true); auto s = td::json_encode<std::string>(td::ToJson(*custom_overlays_config_), true);
TRY_STATUS_PREFIX(td::write_file(private_ext_msg_overlays_config_file(), s), "failed to write config: "); TRY_STATUS_PREFIX(td::write_file(custom_overlays_config_file(), s), "failed to write config: ");
return td::Status::OK(); return td::Status::OK();
} }
void ValidatorEngine::add_private_ext_msg_overlay_to_config( void ValidatorEngine::add_custom_overlay_to_config(
ton::tl_object_ptr<ton::ton_api::engine_validator_privateExtMsgOverlay> overlay, td::Promise<td::Unit> promise) { ton::tl_object_ptr<ton::ton_api::engine_validator_customOverlay> overlay, td::Promise<td::Unit> promise) {
private_ext_msg_overlays_config_->overlays_.push_back(std::move(overlay)); custom_overlays_config_->overlays_.push_back(std::move(overlay));
TRY_STATUS_PROMISE(promise, write_private_ext_msg_overlays_config()); TRY_STATUS_PROMISE(promise, write_custom_overlays_config());
promise.set_result(td::Unit()); promise.set_result(td::Unit());
} }
void ValidatorEngine::del_private_ext_msg_overlay_from_config(std::string name, td::Promise<td::Unit> promise) { void ValidatorEngine::del_custom_overlay_from_config(std::string name, td::Promise<td::Unit> promise) {
auto &overlays = private_ext_msg_overlays_config_->overlays_; auto &overlays = custom_overlays_config_->overlays_;
for (size_t i = 0; i < overlays.size(); ++i) { for (size_t i = 0; i < overlays.size(); ++i) {
if (overlays[i]->name_ == name) { if (overlays[i]->name_ == name) {
overlays.erase(overlays.begin() + i); overlays.erase(overlays.begin() + i);
TRY_STATUS_PROMISE(promise, write_private_ext_msg_overlays_config()); TRY_STATUS_PROMISE(promise, write_custom_overlays_config());
promise.set_result(td::Unit()); promise.set_result(td::Unit());
return; return;
} }
@ -3550,7 +3550,7 @@ void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_setExtMes
}); });
} }
void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_addPrivateExtMsgOverlay &query, void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_addCustomOverlay &query,
td::BufferSlice data, ton::PublicKeyHash src, td::uint32 perm, td::BufferSlice data, ton::PublicKeyHash src, td::uint32 perm,
td::Promise<td::BufferSlice> promise) { td::Promise<td::BufferSlice> promise) {
if (!(perm & ValidatorEnginePermissions::vep_modify)) { if (!(perm & ValidatorEnginePermissions::vep_modify)) {
@ -3567,8 +3567,8 @@ void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_addPrivat
std::map<ton::adnl::AdnlNodeIdShort, int> senders; std::map<ton::adnl::AdnlNodeIdShort, int> senders;
for (const auto &node : overlay->nodes_) { for (const auto &node : overlay->nodes_) {
nodes.emplace_back(node->adnl_id_); nodes.emplace_back(node->adnl_id_);
if (node->sender_) { if (node->msg_sender_) {
senders[ton::adnl::AdnlNodeIdShort{node->adnl_id_}] = node->sender_priority_; senders[ton::adnl::AdnlNodeIdShort{node->adnl_id_}] = node->msg_sender_priority_;
} }
} }
std::string name = overlay->name_; std::string name = overlay->name_;
@ -3582,7 +3582,7 @@ void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_addPrivat
return; return;
} }
td::actor::send_closure( td::actor::send_closure(
SelfId, &ValidatorEngine::add_private_ext_msg_overlay_to_config, std::move(overlay), SelfId, &ValidatorEngine::add_custom_overlay_to_config, std::move(overlay),
[promise = std::move(promise)](td::Result<td::Unit> R) mutable { [promise = std::move(promise)](td::Result<td::Unit> R) mutable {
if (R.is_error()) { if (R.is_error()) {
promise.set_value(create_control_query_error(R.move_as_error())); promise.set_value(create_control_query_error(R.move_as_error()));
@ -3593,7 +3593,7 @@ void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_addPrivat
}); });
} }
void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_delPrivateExtMsgOverlay &query, void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_delCustomOverlay &query,
td::BufferSlice data, ton::PublicKeyHash src, td::uint32 perm, td::BufferSlice data, ton::PublicKeyHash src, td::uint32 perm,
td::Promise<td::BufferSlice> promise) { td::Promise<td::BufferSlice> promise) {
if (!(perm & ValidatorEnginePermissions::vep_modify)) { if (!(perm & ValidatorEnginePermissions::vep_modify)) {
@ -3612,7 +3612,7 @@ void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_delPrivat
return; return;
} }
td::actor::send_closure( td::actor::send_closure(
SelfId, &ValidatorEngine::del_private_ext_msg_overlay_from_config, std::move(name), SelfId, &ValidatorEngine::del_custom_overlay_from_config, std::move(name),
[promise = std::move(promise)](td::Result<td::Unit> R) mutable { [promise = std::move(promise)](td::Result<td::Unit> R) mutable {
if (R.is_error()) { if (R.is_error()) {
promise.set_value(create_control_query_error(R.move_as_error())); promise.set_value(create_control_query_error(R.move_as_error()));
@ -3623,7 +3623,7 @@ void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_delPrivat
}); });
} }
void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_showPrivateExtMsgOverlays &query, void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_showCustomOverlays &query,
td::BufferSlice data, ton::PublicKeyHash src, td::uint32 perm, td::BufferSlice data, ton::PublicKeyHash src, td::uint32 perm,
td::Promise<td::BufferSlice> promise) { td::Promise<td::BufferSlice> promise) {
if (!(perm & ValidatorEnginePermissions::vep_default)) { if (!(perm & ValidatorEnginePermissions::vep_default)) {
@ -3635,8 +3635,8 @@ void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_showPriva
return; return;
} }
promise.set_value(ton::serialize_tl_object<ton::ton_api::engine_validator_privateExtMsgOverlaysConfig>( promise.set_value(ton::serialize_tl_object<ton::ton_api::engine_validator_customOverlaysConfig>(
private_ext_msg_overlays_config_, true)); custom_overlays_config_, true));
} }
void ValidatorEngine::process_control_query(td::uint16 port, ton::adnl::AdnlNodeIdShort src, void ValidatorEngine::process_control_query(td::uint16 port, ton::adnl::AdnlNodeIdShort src,

22
validator-engine/validator-engine.hpp
View file

@ -167,7 +167,7 @@ class ValidatorEngine : public td::actor::Actor {
std::shared_ptr<ton::dht::DhtGlobalConfig> dht_config_; std::shared_ptr<ton::dht::DhtGlobalConfig> dht_config_;
td::Ref<ton::validator::ValidatorManagerOptions> validator_options_; td::Ref<ton::validator::ValidatorManagerOptions> validator_options_;
Config config_; Config config_;
ton::tl_object_ptr<ton::ton_api::engine_validator_privateExtMsgOverlaysConfig> private_ext_msg_overlays_config_; ton::tl_object_ptr<ton::ton_api::engine_validator_customOverlaysConfig> custom_overlays_config_;
std::set<ton::PublicKeyHash> running_gc_; std::set<ton::PublicKeyHash> running_gc_;
@ -363,15 +363,15 @@ class ValidatorEngine : public td::actor::Actor {
void try_del_proxy(td::uint32 ip, td::int32 port, std::vector<AdnlCategory> cats, std::vector<AdnlCategory> prio_cats, void try_del_proxy(td::uint32 ip, td::int32 port, std::vector<AdnlCategory> cats, std::vector<AdnlCategory> prio_cats,
td::Promise<td::Unit> promise); td::Promise<td::Unit> promise);
std::string private_ext_msg_overlays_config_file() const { std::string custom_overlays_config_file() const {
return db_root_ + "/private-ext-msg-overlays.json"; return db_root_ + "/custom-overlays.json";
} }
void load_private_ext_msg_overlays_config(); void load_custom_overlays_config();
td::Status write_private_ext_msg_overlays_config(); td::Status write_custom_overlays_config();
void add_private_ext_msg_overlay_to_config( void add_custom_overlay_to_config(
ton::tl_object_ptr<ton::ton_api::engine_validator_privateExtMsgOverlay> overlay, td::Promise<td::Unit> promise); ton::tl_object_ptr<ton::ton_api::engine_validator_customOverlay> overlay, td::Promise<td::Unit> promise);
void del_private_ext_msg_overlay_from_config(std::string name, td::Promise<td::Unit> promise); void del_custom_overlay_from_config(std::string name, td::Promise<td::Unit> promise);
void check_key(ton::PublicKeyHash id, td::Promise<td::Unit> promise); void check_key(ton::PublicKeyHash id, td::Promise<td::Unit> promise);
@ -451,11 +451,11 @@ class ValidatorEngine : public td::actor::Actor {
ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise); ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise);
void run_control_query(ton::ton_api::engine_validator_setExtMessagesBroadcastDisabled &query, td::BufferSlice data, void run_control_query(ton::ton_api::engine_validator_setExtMessagesBroadcastDisabled &query, td::BufferSlice data,
ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise); ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise);
void run_control_query(ton::ton_api::engine_validator_addPrivateExtMsgOverlay &query, td::BufferSlice data, void run_control_query(ton::ton_api::engine_validator_addCustomOverlay &query, td::BufferSlice data,
ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise); ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise);
void run_control_query(ton::ton_api::engine_validator_delPrivateExtMsgOverlay &query, td::BufferSlice data, void run_control_query(ton::ton_api::engine_validator_delCustomOverlay &query, td::BufferSlice data,
ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise); ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise);
void run_control_query(ton::ton_api::engine_validator_showPrivateExtMsgOverlays &query, td::BufferSlice data, void run_control_query(ton::ton_api::engine_validator_showCustomOverlays &query, td::BufferSlice data,
ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise); ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise);
template <class T> template <class T>
void run_control_query(T &query, td::BufferSlice data, ton::PublicKeyHash src, td::uint32 perm, void run_control_query(T &query, td::BufferSlice data, ton::PublicKeyHash src, td::uint32 perm,

34
validator/full-node-private-overlay.cpp
View file

@ -169,8 +169,7 @@ void FullNodePrivateBlockOverlay::tear_down() {
} }
} }
void FullNodePrivateExtMsgOverlay::process_broadcast(PublicKeyHash src, void FullNodeCustomOverlay::process_broadcast(PublicKeyHash src, ton_api::tonNode_externalMessageBroadcast &query) {
ton_api::tonNode_externalMessageBroadcast &query) {
auto it = senders_.find(adnl::AdnlNodeIdShort{src}); auto it = senders_.find(adnl::AdnlNodeIdShort{src});
if (it == senders_.end()) { if (it == senders_.end()) {
return; return;
@ -181,7 +180,7 @@ void FullNodePrivateExtMsgOverlay::process_broadcast(PublicKeyHash src,
std::move(query.message_->data_), it->second); std::move(query.message_->data_), it->second);
} }
void FullNodePrivateExtMsgOverlay::receive_broadcast(PublicKeyHash src, td::BufferSlice broadcast) { void FullNodeCustomOverlay::receive_broadcast(PublicKeyHash src, td::BufferSlice broadcast) {
auto B = fetch_tl_object<ton_api::tonNode_Broadcast>(std::move(broadcast), true); auto B = fetch_tl_object<ton_api::tonNode_Broadcast>(std::move(broadcast), true);
if (B.is_error()) { if (B.is_error()) {
return; return;
@ -189,7 +188,7 @@ void FullNodePrivateExtMsgOverlay::receive_broadcast(PublicKeyHash src, td::Buff
ton_api::downcast_call(*B.move_as_ok(), [src, Self = this](auto &obj) { Self->process_broadcast(src, obj); }); ton_api::downcast_call(*B.move_as_ok(), [src, Self = this](auto &obj) { Self->process_broadcast(src, obj); });
} }
void FullNodePrivateExtMsgOverlay::send_external_message(td::BufferSlice data) { void FullNodeCustomOverlay::send_external_message(td::BufferSlice data) {
if (config_.ext_messages_broadcast_disabled_) { if (config_.ext_messages_broadcast_disabled_) {
return; return;
} }
@ -205,15 +204,14 @@ void FullNodePrivateExtMsgOverlay::send_external_message(td::BufferSlice data) {
} }
} }
void FullNodePrivateExtMsgOverlay::start_up() { void FullNodeCustomOverlay::start_up() {
std::sort(nodes_.begin(), nodes_.end()); std::sort(nodes_.begin(), nodes_.end());
nodes_.erase(std::unique(nodes_.begin(), nodes_.end()), nodes_.end()); nodes_.erase(std::unique(nodes_.begin(), nodes_.end()), nodes_.end());
std::vector<td::Bits256> nodes; std::vector<td::Bits256> nodes;
for (const adnl::AdnlNodeIdShort &id : nodes_) { for (const adnl::AdnlNodeIdShort &id : nodes_) {
nodes.push_back(id.bits256_value()); nodes.push_back(id.bits256_value());
} }
auto X = auto X = create_hash_tl_object<ton_api::tonNode_customOverlayId>(zero_state_file_hash_, name_, std::move(nodes));
create_hash_tl_object<ton_api::tonNode_privateExtMsgsOverlayId>(zero_state_file_hash_, name_, std::move(nodes));
td::BufferSlice b{32}; td::BufferSlice b{32};
b.as_slice().copy_from(as_slice(X)); b.as_slice().copy_from(as_slice(X));
overlay_id_full_ = overlay::OverlayIdFull{std::move(b)}; overlay_id_full_ = overlay::OverlayIdFull{std::move(b)};
@ -221,21 +219,21 @@ void FullNodePrivateExtMsgOverlay::start_up() {
try_init(); try_init();
} }
void FullNodePrivateExtMsgOverlay::try_init() { void FullNodeCustomOverlay::try_init() {
// Sometimes adnl id is added to validator engine later (or not at all) // Sometimes adnl id is added to validator engine later (or not at all)
td::actor::send_closure( td::actor::send_closure(
adnl_, &adnl::Adnl::check_id_exists, local_id_, [SelfId = actor_id(this)](td::Result<bool> R) { adnl_, &adnl::Adnl::check_id_exists, local_id_, [SelfId = actor_id(this)](td::Result<bool> R) {
if (R.is_ok() && R.ok()) { if (R.is_ok() && R.ok()) {
td::actor::send_closure(SelfId, &FullNodePrivateExtMsgOverlay::init); td::actor::send_closure(SelfId, &FullNodeCustomOverlay::init);
} else { } else {
delay_action([SelfId]() { td::actor::send_closure(SelfId, &FullNodePrivateExtMsgOverlay::try_init); }, delay_action([SelfId]() { td::actor::send_closure(SelfId, &FullNodeCustomOverlay::try_init); },
td::Timestamp::in(30.0)); td::Timestamp::in(30.0));
} }
}); });
} }
void FullNodePrivateExtMsgOverlay::init() { void FullNodeCustomOverlay::init() {
LOG(FULL_NODE_WARNING) << "Creating private ext msg overlay \"" << name_ << "\" for adnl id " << local_id_ << " : " LOG(FULL_NODE_WARNING) << "Creating custom overlay \"" << name_ << "\" for adnl id " << local_id_ << " : "
<< nodes_.size() << " nodes, overlay_id=" << overlay_id_; << nodes_.size() << " nodes, overlay_id=" << overlay_id_;
class Callback : public overlay::Overlays::Callback { class Callback : public overlay::Overlays::Callback {
public: public:
@ -245,16 +243,16 @@ void FullNodePrivateExtMsgOverlay::init() {
td::Promise<td::BufferSlice> promise) override { td::Promise<td::BufferSlice> promise) override {
} }
void receive_broadcast(PublicKeyHash src, overlay::OverlayIdShort overlay_id, td::BufferSlice data) override { void receive_broadcast(PublicKeyHash src, overlay::OverlayIdShort overlay_id, td::BufferSlice data) override {
td::actor::send_closure(node_, &FullNodePrivateExtMsgOverlay::receive_broadcast, src, std::move(data)); td::actor::send_closure(node_, &FullNodeCustomOverlay::receive_broadcast, src, std::move(data));
} }
void check_broadcast(PublicKeyHash src, overlay::OverlayIdShort overlay_id, td::BufferSlice data, void check_broadcast(PublicKeyHash src, overlay::OverlayIdShort overlay_id, td::BufferSlice data,
td::Promise<td::Unit> promise) override { td::Promise<td::Unit> promise) override {
} }
Callback(td::actor::ActorId<FullNodePrivateExtMsgOverlay> node) : node_(node) { Callback(td::actor::ActorId<FullNodeCustomOverlay> node) : node_(node) {
} }
private: private:
td::actor::ActorId<FullNodePrivateExtMsgOverlay> node_; td::actor::ActorId<FullNodeCustomOverlay> node_;
}; };
std::map<PublicKeyHash, td::uint32> authorized_keys; std::map<PublicKeyHash, td::uint32> authorized_keys;
@ -265,14 +263,14 @@ void FullNodePrivateExtMsgOverlay::init() {
td::actor::send_closure( td::actor::send_closure(
overlays_, &overlay::Overlays::create_private_overlay, local_id_, overlay_id_full_.clone(), nodes_, overlays_, &overlay::Overlays::create_private_overlay, local_id_, overlay_id_full_.clone(), nodes_,
std::make_unique<Callback>(actor_id(this)), rules, std::make_unique<Callback>(actor_id(this)), rules,
PSTRING() << R"({ "type": "private-ext-msg", "name": ")" << td::format::Escaped{name_} << R"(" })"); PSTRING() << R"({ "type": "custom-overlay", "name": ")" << td::format::Escaped{name_} << R"(" })");
td::actor::send_closure(rldp_, &rldp::Rldp::add_id, local_id_); td::actor::send_closure(rldp_, &rldp::Rldp::add_id, local_id_);
td::actor::send_closure(rldp2_, &rldp2::Rldp::add_id, local_id_); td::actor::send_closure(rldp2_, &rldp2::Rldp::add_id, local_id_);
} }
void FullNodePrivateExtMsgOverlay::tear_down() { void FullNodeCustomOverlay::tear_down() {
LOG(FULL_NODE_WARNING) << "Destroying private ext msg overlay \"" << name_ << "\" for adnl id " << local_id_; LOG(FULL_NODE_WARNING) << "Destroying custom overlay \"" << name_ << "\" for adnl id " << local_id_;
td::actor::send_closure(overlays_, &ton::overlay::Overlays::delete_overlay, local_id_, overlay_id_); td::actor::send_closure(overlays_, &ton::overlay::Overlays::delete_overlay, local_id_, overlay_id_);
} }

15
validator/full-node-private-overlay.hpp
View file

@ -88,7 +88,7 @@ class FullNodePrivateBlockOverlay : public td::actor::Actor {
void init(); void init();
}; };
class FullNodePrivateExtMsgOverlay : public td::actor::Actor { class FullNodeCustomOverlay : public td::actor::Actor {
public: public:
void process_broadcast(PublicKeyHash src, ton_api::tonNode_externalMessageBroadcast &query); void process_broadcast(PublicKeyHash src, ton_api::tonNode_externalMessageBroadcast &query);
template <class T> template <class T>
@ -106,13 +106,12 @@ class FullNodePrivateExtMsgOverlay : public td::actor::Actor {
void start_up() override; void start_up() override;
void tear_down() override; void tear_down() override;
FullNodePrivateExtMsgOverlay(adnl::AdnlNodeIdShort local_id, std::vector<adnl::AdnlNodeIdShort> nodes, FullNodeCustomOverlay(adnl::AdnlNodeIdShort local_id, std::vector<adnl::AdnlNodeIdShort> nodes,
std::map<adnl::AdnlNodeIdShort, int> senders, std::string name, std::map<adnl::AdnlNodeIdShort, int> senders, std::string name, FileHash zero_state_file_hash,
FileHash zero_state_file_hash, FullNodeConfig config, FullNodeConfig config, td::actor::ActorId<keyring::Keyring> keyring,
td::actor::ActorId<keyring::Keyring> keyring, td::actor::ActorId<adnl::Adnl> adnl, td::actor::ActorId<adnl::Adnl> adnl, td::actor::ActorId<rldp::Rldp> rldp,
td::actor::ActorId<rldp::Rldp> rldp, td::actor::ActorId<rldp2::Rldp> rldp2, td::actor::ActorId<rldp2::Rldp> rldp2, td::actor::ActorId<overlay::Overlays> overlays,
td::actor::ActorId<overlay::Overlays> overlays, td::actor::ActorId<ValidatorManagerInterface> validator_manager)
td::actor::ActorId<ValidatorManagerInterface> validator_manager)
: local_id_(local_id) : local_id_(local_id)
, nodes_(std::move(nodes)) , nodes_(std::move(nodes))
, senders_(std::move(senders)) , senders_(std::move(senders))

30
validator/full-node.cpp
View file

@ -36,7 +36,7 @@ void FullNodeImpl::add_permanent_key(PublicKeyHash key, td::Promise<td::Unit> pr
local_keys_.insert(key); local_keys_.insert(key);
create_private_block_overlay(key); create_private_block_overlay(key);
for (auto &p : private_ext_msg_overlays_) { for (auto &p : private_custom_overlays_) {
update_ext_msg_overlay(p.first, p.second); update_ext_msg_overlay(p.first, p.second);
} }
@ -64,7 +64,7 @@ void FullNodeImpl::del_permanent_key(PublicKeyHash key, td::Promise<td::Unit> pr
} }
local_keys_.erase(key); local_keys_.erase(key);
private_block_overlays_.erase(key); private_block_overlays_.erase(key);
for (auto &p : private_ext_msg_overlays_) { for (auto &p : private_custom_overlays_) {
update_ext_msg_overlay(p.first, p.second); update_ext_msg_overlay(p.first, p.second);
} }
@ -119,7 +119,7 @@ void FullNodeImpl::update_adnl_id(adnl::AdnlNodeIdShort adnl_id, td::Promise<td:
} }
local_id_ = adnl_id_.pubkey_hash(); local_id_ = adnl_id_.pubkey_hash();
for (auto &p : private_ext_msg_overlays_) { for (auto &p : private_custom_overlays_) {
update_ext_msg_overlay(p.first, p.second); update_ext_msg_overlay(p.first, p.second);
} }
} }
@ -132,9 +132,9 @@ void FullNodeImpl::set_config(FullNodeConfig config) {
for (auto& overlay : private_block_overlays_) { for (auto& overlay : private_block_overlays_) {
td::actor::send_closure(overlay.second, &FullNodePrivateBlockOverlay::set_config, config); td::actor::send_closure(overlay.second, &FullNodePrivateBlockOverlay::set_config, config);
} }
for (auto& overlay : private_ext_msg_overlays_) { for (auto& overlay : private_custom_overlays_) {
for (auto &actor : overlay.second.actors_) { for (auto &actor : overlay.second.actors_) {
td::actor::send_closure(actor.second, &FullNodePrivateExtMsgOverlay::set_config, config); td::actor::send_closure(actor.second, &FullNodeCustomOverlay::set_config, config);
} }
} }
} }
@ -146,13 +146,13 @@ void FullNodeImpl::add_ext_msg_overlay(std::vector<adnl::AdnlNodeIdShort> nodes,
promise.set_error(td::Status::Error("list of nodes is empty")); promise.set_error(td::Status::Error("list of nodes is empty"));
return; return;
} }
if (private_ext_msg_overlays_.count(name)) { if (private_custom_overlays_.count(name)) {
promise.set_error(td::Status::Error(PSTRING() << "duplicate overlay name \"" << name << "\"")); promise.set_error(td::Status::Error(PSTRING() << "duplicate overlay name \"" << name << "\""));
return; return;
} }
VLOG(FULL_NODE_WARNING) << "Adding private overlay for external messages \"" << name << "\", " << nodes.size() VLOG(FULL_NODE_WARNING) << "Adding private overlay for external messages \"" << name << "\", " << nodes.size()
<< " nodes"; << " nodes";
auto &p = private_ext_msg_overlays_[name]; auto &p = private_custom_overlays_[name];
p.nodes_ = nodes; p.nodes_ = nodes;
p.senders_ = senders; p.senders_ = senders;
update_ext_msg_overlay(name, p); update_ext_msg_overlay(name, p);
@ -160,12 +160,12 @@ void FullNodeImpl::add_ext_msg_overlay(std::vector<adnl::AdnlNodeIdShort> nodes,
} }
void FullNodeImpl::del_ext_msg_overlay(std::string name, td::Promise<td::Unit> promise) { void FullNodeImpl::del_ext_msg_overlay(std::string name, td::Promise<td::Unit> promise) {
auto it = private_ext_msg_overlays_.find(name); auto it = private_custom_overlays_.find(name);
if (it == private_ext_msg_overlays_.end()) { if (it == private_custom_overlays_.end()) {
promise.set_error(td::Status::Error(PSTRING() << "no such overlay \"" << name << "\"")); promise.set_error(td::Status::Error(PSTRING() << "no such overlay \"" << name << "\""));
return; return;
} }
private_ext_msg_overlays_.erase(it); private_custom_overlays_.erase(it);
promise.set_result(td::Unit()); promise.set_result(td::Unit());
} }
@ -221,11 +221,11 @@ 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 : private_ext_msg_overlays_) { for (auto &private_overlay : private_custom_overlays_) {
for (auto &actor : private_overlay.second.actors_) { for (auto &actor : private_overlay.second.actors_) {
auto local_id = actor.first; auto local_id = actor.first;
if (private_overlay.second.senders_.count(local_id)) { if (private_overlay.second.senders_.count(local_id)) {
td::actor::send_closure(actor.second, &FullNodePrivateExtMsgOverlay::send_external_message, data.clone()); td::actor::send_closure(actor.second, &FullNodeCustomOverlay::send_external_message, data.clone());
} }
} }
} }
@ -488,7 +488,7 @@ void FullNodeImpl::start_up() {
} }
void FullNodeImpl::update_private_overlays() { void FullNodeImpl::update_private_overlays() {
for (auto &p : private_ext_msg_overlays_) { for (auto &p : private_custom_overlays_) {
update_ext_msg_overlay(p.first, p.second); update_ext_msg_overlay(p.first, p.second);
} }
@ -534,8 +534,8 @@ void FullNodeImpl::update_ext_msg_overlay(const std::string &name, ExtMsgOverlay
overlay.actors_[local_id] = std::move(it->second); overlay.actors_[local_id] = std::move(it->second);
old_actors.erase(it); old_actors.erase(it);
} else { } else {
overlay.actors_[local_id] = td::actor::create_actor<FullNodePrivateExtMsgOverlay>( overlay.actors_[local_id] = td::actor::create_actor<FullNodeCustomOverlay>(
"ExtMsgPrivateOverlay", local_id, overlay.nodes_, overlay.senders_, name, zero_state_file_hash_, config_, "CustomOverlay", local_id, overlay.nodes_, overlay.senders_, name, zero_state_file_hash_, config_,
keyring_, adnl_, rldp_, rldp2_, overlays_, validator_manager_); keyring_, adnl_, rldp_, rldp2_, overlays_, validator_manager_);
} }
} }

4
validator/full-node.hpp
View file

@ -126,10 +126,10 @@ class FullNodeImpl : public FullNode {
struct ExtMsgOverlayInfo { struct ExtMsgOverlayInfo {
std::vector<adnl::AdnlNodeIdShort> nodes_; std::vector<adnl::AdnlNodeIdShort> nodes_;
std::map<adnl::AdnlNodeIdShort, int> senders_; std::map<adnl::AdnlNodeIdShort, int> senders_;
std::map<adnl::AdnlNodeIdShort, td::actor::ActorOwn<FullNodePrivateExtMsgOverlay>> std::map<adnl::AdnlNodeIdShort, td::actor::ActorOwn<FullNodeCustomOverlay>>
actors_; // our local id -> actor actors_; // our local id -> actor
}; };
std::map<std::string, ExtMsgOverlayInfo> private_ext_msg_overlays_; std::map<std::string, ExtMsgOverlayInfo> private_custom_overlays_;
void update_private_overlays(); void update_private_overlays();
void set_private_block_overlays_enable_compression(bool value); void set_private_block_overlays_enable_compression(bool value);