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

Option for collating masterchain on validators

Browse source
This commit is contained in:
SpyCheese 2023-01-16 19:30:15 +03:00
parent d324fa5820
commit 225f71238b
9 changed files with 72 additions and 41 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1419,7 +1419,7 @@ td::Status ValidatorEngine::load_global_config() {
h.push_back(b); h.push_back(b);
} }
validator_options_.write().set_hardforks(std::move(h)); validator_options_.write().set_hardforks(std::move(h));
validator_options_.write().set_validator_lite_mode(validator_lite_mode_); validator_options_.write().set_validator_mode(validator_mode_);
return td::Status::OK(); return td::Status::OK();
} }
@ -3866,9 +3866,20 @@ int main(int argc, char *argv[]) {
p.add_option('M', "not-all-shards", "monitor only a necessary set of shards instead of all", [&]() { p.add_option('M', "not-all-shards", "monitor only a necessary set of shards instead of all", [&]() {
acts.push_back([&x]() { td::actor::send_closure(x, &ValidatorEngine::set_not_all_shards); }); acts.push_back([&x]() { td::actor::send_closure(x, &ValidatorEngine::set_not_all_shards); });
}); });
p.add_option('\0', "lite-validator", "lite-mode validator (don't collate blocks, use collator nodes instead)", [&]() { p.add_option('\0', "lite-validator-shards",
acts.push_back([&x]() { td::actor::send_closure(x, &ValidatorEngine::set_validator_lite_mode); }); "lite-mode validator for shard blocks (don't collate blocks, use collator nodes instead)", [&]() {
}); acts.push_back([&x]() {
td::actor::send_closure(x, &ValidatorEngine::set_validator_mode,
ton::validator::ValidatorManagerOptions::validator_lite_shards);
});
});
p.add_option('\0', "lite-validator-all",
"lite-mode validator for all blocks (don't collate blocks, use collator nodes instead)", [&]() {
acts.push_back([&x]() {
td::actor::send_closure(x, &ValidatorEngine::set_validator_mode,
ton::validator::ValidatorManagerOptions::validator_lite_all);
});
});
td::uint32 threads = 7; td::uint32 threads = 7;
p.add_checked_option( p.add_checked_option(
't', "threads", PSTRING() << "number of threads (default=" << threads << ")", [&](td::Slice fname) { 't', "threads", PSTRING() << "number of threads (default=" << threads << ")", [&](td::Slice fname) {

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

@ -217,7 +217,8 @@ class ValidatorEngine : public td::actor::Actor {
ton::BlockSeqno truncate_seqno_{0}; ton::BlockSeqno truncate_seqno_{0};
std::string session_logs_file_; std::string session_logs_file_;
bool not_all_shards_ = false; bool not_all_shards_ = false;
bool validator_lite_mode_ = false; ton::validator::ValidatorManagerOptions::ValidatorMode validator_mode_ =
ton::validator::ValidatorManagerOptions::validator_normal;
std::set<ton::CatchainSeqno> unsafe_catchains_; std::set<ton::CatchainSeqno> unsafe_catchains_;
std::map<ton::BlockSeqno, std::pair<ton::CatchainSeqno, td::uint32>> unsafe_catchain_rotations_; std::map<ton::BlockSeqno, std::pair<ton::CatchainSeqno, td::uint32>> unsafe_catchain_rotations_;
@ -272,8 +273,8 @@ class ValidatorEngine : public td::actor::Actor {
void set_not_all_shards() { void set_not_all_shards() {
not_all_shards_ = true; not_all_shards_ = true;
} }
void set_validator_lite_mode() { void set_validator_mode(ton::validator::ValidatorManagerOptions::ValidatorMode mode) {
validator_lite_mode_ = true; validator_mode_ = mode;
} }
void start_up() override; void start_up() override;

26
validator/collator-node.cpp
View file

@ -160,19 +160,19 @@ void CollatorNode::receive_query_cont(adnl::AdnlNodeIdShort src, ShardIdFull sha
td::Ref<MasterchainState> min_mc_state, std::vector<BlockIdExt> prev_blocks, td::Ref<MasterchainState> min_mc_state, std::vector<BlockIdExt> prev_blocks,
Ed25519_PublicKey creator, td::Promise<td::BufferSlice> promise) { Ed25519_PublicKey creator, td::Promise<td::BufferSlice> promise) {
auto P = td::PromiseCreator::lambda([promise = std::move(promise), src](td::Result<BlockCandidate> R) mutable { auto P = td::PromiseCreator::lambda([promise = std::move(promise), src](td::Result<BlockCandidate> R) mutable {
if (R.is_error()) { if (R.is_error()) {
LOG(WARNING) << "Query from " << src << ", error: " << R.error(); LOG(WARNING) << "Query from " << src << ", error: " << R.error();
promise.set_result(serialize_error(R.move_as_error())); promise.set_result(serialize_error(R.move_as_error()));
} else { } else {
LOG(INFO) << "Query from " << src << ", success"; LOG(INFO) << "Query from " << src << ", success";
auto block = R.move_as_ok(); auto block = R.move_as_ok();
auto result = create_serialize_tl_object<ton_api::collatorNode_generateBlockSuccess>( auto result = create_serialize_tl_object<ton_api::collatorNode_generateBlockSuccess>(
create_tl_object<ton_api::db_candidate>(PublicKey{pubkeys::Ed25519{block.pubkey.as_bits256()}}.tl(), create_tl_object<ton_api::db_candidate>(PublicKey{pubkeys::Ed25519{block.pubkey.as_bits256()}}.tl(),
create_tl_block_id(block.id), std::move(block.data), create_tl_block_id(block.id), std::move(block.data),
std::move(block.collated_data))); std::move(block.collated_data)));
promise.set_result(std::move(result)); promise.set_result(std::move(result));
} }
}); });
run_collate_query(shard, min_mc_state->get_block_id(), std::move(prev_blocks), creator, run_collate_query(shard, min_mc_state->get_block_id(), std::move(prev_blocks), creator,
min_mc_state->get_validator_set(shard), manager_, td::Timestamp::in(10.0), std::move(P)); min_mc_state->get_validator_set(shard), manager_, td::Timestamp::in(10.0), std::move(P));

31
validator/manager.cpp
View file

@ -18,11 +18,9 @@
*/ */
#include "manager.hpp" #include "manager.hpp"
#include "validator-group.hpp" #include "validator-group.hpp"
#include "adnl/utils.hpp"
#include "downloaders/wait-block-state.hpp" #include "downloaders/wait-block-state.hpp"
#include "downloaders/wait-block-state-merge.hpp" #include "downloaders/wait-block-state-merge.hpp"
#include "downloaders/wait-block-data.hpp" #include "downloaders/wait-block-data.hpp"
#include "validator-group.hpp"
#include "fabric.h" #include "fabric.h"
#include "manager.h" #include "manager.h"
#include "validate-broadcast.hpp" #include "validate-broadcast.hpp"
@ -199,7 +197,7 @@ void ValidatorManagerImpl::validate_block(ReceivedBlock block, td::Promise<Block
CHECK(blkid.is_masterchain()); CHECK(blkid.is_masterchain());
auto P = td::PromiseCreator::lambda( auto P = td::PromiseCreator::lambda(
[SelfId = actor_id(this), promise = std::move(promise), id = block.id](td::Result<td::Unit> R) mutable { [SelfId = actor_id(this), promise = std::move(promise), id = blkid](td::Result<td::Unit> R) mutable {
if (R.is_error()) { if (R.is_error()) {
promise.set_error(R.move_as_error()); promise.set_error(R.move_as_error());
} else { } else {
@ -1241,7 +1239,7 @@ void ValidatorManagerImpl::write_handle(BlockHandle handle, td::Promise<td::Unit
void ValidatorManagerImpl::written_handle(BlockHandle handle, td::Promise<td::Unit> promise) { void ValidatorManagerImpl::written_handle(BlockHandle handle, td::Promise<td::Unit> promise) {
bool received = handle->received(); bool received = handle->received();
bool inited_state = handle->received_state(); bool inited_state = handle->received_state();
bool inited_proof = handle->id().is_masterchain() ? handle->inited_proof() : handle->inited_proof(); bool inited_proof = handle->inited_proof();
if (handle->need_flush()) { if (handle->need_flush()) {
handle->flush(actor_id(this), handle, std::move(promise)); handle->flush(actor_id(this), handle, std::move(promise));
@ -1712,13 +1710,14 @@ bool ValidatorManagerImpl::out_of_sync() {
void ValidatorManagerImpl::prestart_sync() { void ValidatorManagerImpl::prestart_sync() {
auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::Unit> R) { auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::Unit> R) {
R.ensure(); R.ensure();
td::actor::send_closure(SelfId, &ValidatorManagerImpl::download_next_archive); // Don't download archives
td::actor::send_closure(SelfId, &ValidatorManagerImpl::finish_prestart_sync);
}); });
td::actor::send_closure(db_, &Db::set_async_mode, false, std::move(P)); td::actor::send_closure(db_, &Db::set_async_mode, false, std::move(P));
} }
void ValidatorManagerImpl::download_next_archive() { void ValidatorManagerImpl::download_next_archive() {
if (true) { if (!out_of_sync()) {
finish_prestart_sync(); finish_prestart_sync();
return; return;
} }
@ -1836,6 +1835,13 @@ void ValidatorManagerImpl::new_masterchain_block() {
for (auto &c : collator_nodes_) { for (auto &c : collator_nodes_) {
td::actor::send_closure(c.second.actor, &CollatorNode::new_masterchain_block_notification, last_masterchain_state_); td::actor::send_closure(c.second.actor, &CollatorNode::new_masterchain_block_notification, last_masterchain_state_);
} }
if (opts_->validator_mode() == ValidatorManagerOptions::validator_lite_shards && validating_masterchain()) {
// Prepare neighboours' queues for collating masterchain
for (const auto &desc : last_masterchain_state_->get_shards()) {
wait_out_msg_queue_proof(desc->top_block_id(), ShardIdFull(masterchainId), 0, td::Timestamp::in(10.0),
[](td::Ref<OutMsgQueueProof>) {});
}
}
if (last_masterchain_seqno_ % 1024 == 0) { if (last_masterchain_seqno_ % 1024 == 0) {
LOG(WARNING) << "applied masterchain block " << last_masterchain_block_id_; LOG(WARNING) << "applied masterchain block " << last_masterchain_block_id_;
@ -2174,7 +2180,7 @@ td::actor::ActorOwn<ValidatorGroup> ValidatorManagerImpl::create_validator_group
"validatorgroup", shard, validator_id, session_id, validator_set, "validatorgroup", shard, validator_id, session_id, validator_set,
last_masterchain_state_->get_collator_config(true), opts, keyring_, adnl_, rldp_, overlays_, db_root_, last_masterchain_state_->get_collator_config(true), opts, keyring_, adnl_, rldp_, overlays_, db_root_,
actor_id(this), init_session, opts_->check_unsafe_resync_allowed(validator_set->get_catchain_seqno()), actor_id(this), init_session, opts_->check_unsafe_resync_allowed(validator_set->get_catchain_seqno()),
opts_->validator_lite_mode()); opts_->validator_mode());
return G; return G;
} }
} }
@ -2348,7 +2354,7 @@ void ValidatorManagerImpl::allow_block_state_gc(BlockIdExt block_id, td::Promise
return; return;
} }
auto shards = gc_masterchain_state_->get_shards(); auto shards = gc_masterchain_state_->get_shards();
for (auto shard : shards) { for (const auto &shard : shards) {
if (shard_intersects(shard->shard(), block_id.shard_full())) { if (shard_intersects(shard->shard(), block_id.shard_full())) {
promise.set_result(block_id.id.seqno < shard->top_block_id().id.seqno); promise.set_result(block_id.id.seqno < shard->top_block_id().id.seqno);
return; return;
@ -2564,7 +2570,14 @@ bool ValidatorManagerImpl::is_validator() {
} }
bool ValidatorManagerImpl::is_collator() { bool ValidatorManagerImpl::is_collator() {
return !collator_nodes_.empty() || (!opts_->validator_lite_mode() && is_validator()); return !collator_nodes_.empty() ||
(opts_->validator_mode() != ValidatorManagerOptions::validator_lite_all && is_validator());
}
bool ValidatorManagerImpl::validating_masterchain() {
return !get_validator(ShardIdFull(masterchainId),
last_masterchain_state_->get_validator_set(ShardIdFull(masterchainId)))
.is_zero();
} }
PublicKeyHash ValidatorManagerImpl::get_validator(ShardIdFull shard, td::Ref<ValidatorSet> val_set) { PublicKeyHash ValidatorManagerImpl::get_validator(ShardIdFull shard, td::Ref<ValidatorSet> val_set) {

1
validator/manager.hpp
View file

@ -506,6 +506,7 @@ class ValidatorManagerImpl : public ValidatorManager {
bool is_validator(); bool is_validator();
bool is_collator(); bool is_collator();
bool validating_masterchain();
PublicKeyHash get_validator(ShardIdFull shard, td::Ref<ValidatorSet> val_set); PublicKeyHash get_validator(ShardIdFull shard, td::Ref<ValidatorSet> val_set);
ValidatorManagerImpl(td::Ref<ValidatorManagerOptions> opts, std::string db_root, ValidatorManagerImpl(td::Ref<ValidatorManagerOptions> opts, std::string db_root,

6
validator/validator-group.cpp
View file

@ -50,7 +50,8 @@ void ValidatorGroup::generate_block_candidate(td::uint32 round_id, td::Promise<B
cache = cached_collated_block_](td::Result<BlockCandidate> R) { cache = cached_collated_block_](td::Result<BlockCandidate> R) {
td::actor::send_closure(SelfId, &ValidatorGroup::generated_block_candidate, std::move(cache), std::move(R)); td::actor::send_closure(SelfId, &ValidatorGroup::generated_block_candidate, std::move(cache), std::move(R));
}; };
if (lite_mode_) { if (mode_ == ValidatorManagerOptions::validator_lite_all ||
(mode_ == ValidatorManagerOptions::validator_lite_shards && !shard_.is_masterchain())) {
send_collate_query(round_id, td::Timestamp::in(10.0), std::move(P)); send_collate_query(round_id, td::Timestamp::in(10.0), std::move(P));
return; return;
} }
@ -197,7 +198,8 @@ void ValidatorGroup::accept_block_query(BlockIdExt block_id, td::Ref<BlockData>
}); });
run_accept_block_query(block_id, std::move(block), std::move(prev), validator_set_, std::move(sig_set), run_accept_block_query(block_id, std::move(block), std::move(prev), validator_set_, std::move(sig_set),
std::move(approve_sig_set), send_broadcast, shard_.is_masterchain() || !lite_mode_, manager_, std::move(approve_sig_set), send_broadcast,
shard_.is_masterchain() || mode_ == ValidatorManagerOptions::validator_normal, manager_,
std::move(P)); std::move(P));
} }

7
validator/validator-group.hpp
View file

@ -65,7 +65,8 @@ class ValidatorGroup : public td::actor::Actor {
td::actor::ActorId<keyring::Keyring> keyring, td::actor::ActorId<adnl::Adnl> adnl, td::actor::ActorId<keyring::Keyring> keyring, td::actor::ActorId<adnl::Adnl> adnl,
td::actor::ActorId<rldp::Rldp> rldp, td::actor::ActorId<overlay::Overlays> overlays, td::actor::ActorId<rldp::Rldp> rldp, td::actor::ActorId<overlay::Overlays> overlays,
std::string db_root, td::actor::ActorId<ValidatorManager> validator_manager, bool create_session, std::string db_root, td::actor::ActorId<ValidatorManager> validator_manager, bool create_session,
bool allow_unsafe_self_blocks_resync, bool lite_mode = false) bool allow_unsafe_self_blocks_resync,
ValidatorManagerOptions::ValidatorMode mode = ValidatorManagerOptions::validator_normal)
: shard_(shard) : shard_(shard)
, local_id_(std::move(local_id)) , local_id_(std::move(local_id))
, session_id_(session_id) , session_id_(session_id)
@ -80,7 +81,7 @@ class ValidatorGroup : public td::actor::Actor {
, manager_(validator_manager) , manager_(validator_manager)
, init_(create_session) , init_(create_session)
, allow_unsafe_self_blocks_resync_(allow_unsafe_self_blocks_resync) , allow_unsafe_self_blocks_resync_(allow_unsafe_self_blocks_resync)
, lite_mode_(lite_mode) { , mode_(mode) {
} }
private: private:
@ -125,7 +126,7 @@ class ValidatorGroup : public td::actor::Actor {
bool init_ = false; bool init_ = false;
bool started_ = false; bool started_ = false;
bool allow_unsafe_self_blocks_resync_; bool allow_unsafe_self_blocks_resync_;
bool lite_mode_ = false; ValidatorManagerOptions::ValidatorMode mode_;
td::uint32 last_known_round_id_ = 0; td::uint32 last_known_round_id_ = 0;
struct CachedCollatedBlock { struct CachedCollatedBlock {

10
validator/validator-options.hpp
View file

@ -112,8 +112,8 @@ struct ValidatorManagerOptionsImpl : public ValidatorManagerOptions {
std::string get_session_logs_file() const override { std::string get_session_logs_file() const override {
return session_logs_file_; return session_logs_file_;
} }
bool validator_lite_mode() const override { ValidatorMode validator_mode() const override {
return validator_lite_mode_; return validator_mode_;
} }
void set_zero_block_id(BlockIdExt block_id) override { void set_zero_block_id(BlockIdExt block_id) override {
@ -168,8 +168,8 @@ struct ValidatorManagerOptionsImpl : public ValidatorManagerOptions {
void set_session_logs_file(std::string f) override { void set_session_logs_file(std::string f) override {
session_logs_file_ = std::move(f); session_logs_file_ = std::move(f);
} }
void set_validator_lite_mode(bool value) override { void set_validator_mode(ValidatorMode value) override {
validator_lite_mode_ = value; validator_mode_ = value;
} }
ValidatorManagerOptionsImpl *make_copy() const override { ValidatorManagerOptionsImpl *make_copy() const override {
@ -211,7 +211,7 @@ struct ValidatorManagerOptionsImpl : public ValidatorManagerOptions {
BlockSeqno truncate_{0}; BlockSeqno truncate_{0};
BlockSeqno sync_upto_{0}; BlockSeqno sync_upto_{0};
std::string session_logs_file_; std::string session_logs_file_;
bool validator_lite_mode_ = false; ValidatorMode validator_mode_ = validator_normal;
}; };
} // namespace validator } // namespace validator

6
validator/validator.h
View file

@ -54,6 +54,8 @@ struct PerfTimerStats {
struct ValidatorManagerOptions : public td::CntObject { struct ValidatorManagerOptions : public td::CntObject {
public: public:
enum ValidatorMode { validator_normal, validator_lite_shards, validator_lite_all };
virtual BlockIdExt zero_block_id() const = 0; virtual BlockIdExt zero_block_id() const = 0;
virtual BlockIdExt init_block_id() const = 0; virtual BlockIdExt init_block_id() const = 0;
virtual bool need_monitor(ShardIdFull shard, const td::Ref<MasterchainState>& state) const = 0; virtual bool need_monitor(ShardIdFull shard, const td::Ref<MasterchainState>& state) const = 0;
@ -79,7 +81,7 @@ struct ValidatorManagerOptions : public td::CntObject {
virtual BlockSeqno get_truncate_seqno() const = 0; virtual BlockSeqno get_truncate_seqno() const = 0;
virtual BlockSeqno sync_upto() const = 0; virtual BlockSeqno sync_upto() const = 0;
virtual std::string get_session_logs_file() const = 0; virtual std::string get_session_logs_file() const = 0;
virtual bool validator_lite_mode() const = 0; virtual ValidatorMode validator_mode() const = 0;
virtual void set_zero_block_id(BlockIdExt block_id) = 0; virtual void set_zero_block_id(BlockIdExt block_id) = 0;
virtual void set_init_block_id(BlockIdExt block_id) = 0; virtual void set_init_block_id(BlockIdExt block_id) = 0;
@ -98,7 +100,7 @@ struct ValidatorManagerOptions : public td::CntObject {
virtual void truncate_db(BlockSeqno seqno) = 0; virtual void truncate_db(BlockSeqno seqno) = 0;
virtual void set_sync_upto(BlockSeqno seqno) = 0; virtual void set_sync_upto(BlockSeqno seqno) = 0;
virtual void set_session_logs_file(std::string f) = 0; virtual void set_session_logs_file(std::string f) = 0;
virtual void set_validator_lite_mode(bool value) = 0; virtual void set_validator_mode(ValidatorMode value) = 0;
static td::Ref<ValidatorManagerOptions> create( static td::Ref<ValidatorManagerOptions> create(
BlockIdExt zero_block_id, BlockIdExt init_block_id, BlockIdExt zero_block_id, BlockIdExt init_block_id,