mirror of
https://github.com/ton-blockchain/ton
synced 2025-03-09 15:40:10 +00:00
Changes in validation
* Configure collator list in validator-console * Remove "lite-validator" flags * Better compatibility in validate-query.cpp
This commit is contained in:
SpyCheese
parent
f91ed6cc31
commit
38ab70c037
16 changed files with 368 additions and 107 deletions
|
|
@ -26,7 +26,7 @@ namespace ton {
|
|||
|
||||
namespace validator {
|
||||
|
||||
enum ValidateMode { fake = 1, full_collated_data = 2 };
|
||||
enum ValidateMode { fake = 1 };
|
||||
enum CollateMode { skip_store_candidate = 1 };
|
||||
|
||||
td::actor::ActorOwn<Db> create_db_actor(td::actor::ActorId<ValidatorManager> manager, std::string db_root_,
|
||||
|
|
|
|||
|
|
@ -82,7 +82,6 @@ ValidateQuery::ValidateQuery(ShardIdFull shard, BlockIdExt min_masterchain_block
|
|||
, timeout(timeout)
|
||||
, main_promise(std::move(promise))
|
||||
, is_fake_(mode & ValidateMode::fake)
|
||||
, full_collated_data_(mode & ValidateMode::full_collated_data)
|
||||
, shard_pfx_(shard_.shard)
|
||||
, shard_pfx_len_(ton::shard_prefix_length(shard_))
|
||||
, perf_timer_("validateblock", 0.1, [manager](double duration) {
|
||||
|
|
@ -258,7 +257,6 @@ void ValidateQuery::finish_query() {
|
|||
*/
|
||||
void ValidateQuery::start_up() {
|
||||
LOG(WARNING) << "validate query for " << block_candidate.id.to_str() << " started";
|
||||
LOG(DEBUG) << "full_collated_data is " << full_collated_data_;
|
||||
alarm_timestamp() = timeout;
|
||||
rand_seed_.set_zero();
|
||||
created_by_ = block_candidate.pubkey;
|
||||
|
|
@ -359,11 +357,16 @@ void ValidateQuery::start_up() {
|
|||
td::actor::send_closure_later(
|
||||
std::move(self), &ValidateQuery::after_get_latest_mc_state, std::move(res));
|
||||
});
|
||||
// 3. load state(s) corresponding to previous block(s) (not full-collaoted-data or masterchain)
|
||||
// 3. unpack block candidate (while necessary data is being loaded)
|
||||
if (!unpack_block_candidate()) {
|
||||
reject_query("error unpacking block candidate");
|
||||
return;
|
||||
}
|
||||
// 4. load state(s) corresponding to previous block(s) (not full-collated-data or masterchain)
|
||||
prev_states.resize(prev_blocks.size());
|
||||
if (is_masterchain() || !full_collated_data_) {
|
||||
for (int i = 0; (unsigned)i < prev_blocks.size(); i++) {
|
||||
// 3.1. load state
|
||||
// 4.1. load state
|
||||
LOG(DEBUG) << "sending wait_block_state() query #" << i << " for " << prev_blocks[i].to_str() << " to Manager";
|
||||
++pending;
|
||||
td::actor::send_closure_later(manager, &ValidatorManager::wait_block_state_short, prev_blocks[i], priority(),
|
||||
|
|
@ -374,11 +377,6 @@ void ValidateQuery::start_up() {
|
|||
});
|
||||
}
|
||||
}
|
||||
// 4. unpack block candidate (while necessary data is being loaded)
|
||||
if (!unpack_block_candidate()) {
|
||||
reject_query("error unpacking block candidate");
|
||||
return;
|
||||
}
|
||||
// 5. request masterchain state referred to in the block
|
||||
if (!is_masterchain()) {
|
||||
++pending;
|
||||
|
|
@ -629,6 +627,7 @@ bool ValidateQuery::extract_collated_data_from(Ref<vm::Cell> croot, int idx) {
|
|||
if (!ins.second) {
|
||||
return reject_query("Merkle proof with duplicate virtual root hash "s + virt_hash.to_hex());
|
||||
}
|
||||
full_collated_data_ = true;
|
||||
return true;
|
||||
}
|
||||
if (block::gen::t_TopBlockDescrSet.has_valid_tag(cs)) {
|
||||
|
|
@ -666,6 +665,9 @@ bool ValidateQuery::extract_collated_data() {
|
|||
return reject_query(PSTRING() << "virtualization error " << err.get_msg());
|
||||
}
|
||||
}
|
||||
if (full_collated_data_) {
|
||||
LOG(INFO) << "full_collated_data = true";
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -373,7 +373,8 @@ void ValidatorManagerImpl::get_key_block_proof_link(BlockIdExt block_id, td::Pro
|
|||
}
|
||||
|
||||
void ValidatorManagerImpl::new_external_message(td::BufferSlice data, int priority) {
|
||||
if (!is_collator()) {
|
||||
if (!validating_masterchain() && collator_nodes_.empty() &&
|
||||
(!is_validator() || !opts_->get_collators_list()->self_collate)) {
|
||||
return;
|
||||
}
|
||||
if (last_masterchain_state_.is_null()) {
|
||||
|
|
@ -453,7 +454,7 @@ void ValidatorManagerImpl::check_external_message(td::BufferSlice data, td::Prom
|
|||
}
|
||||
|
||||
void ValidatorManagerImpl::new_ihr_message(td::BufferSlice data) {
|
||||
if (!is_collator()) {
|
||||
if (collator_nodes_.empty() && (!is_validator() || !opts_->get_collators_list()->self_collate)) {
|
||||
return;
|
||||
}
|
||||
auto R = create_ihr_message(std::move(data));
|
||||
|
|
@ -470,7 +471,7 @@ void ValidatorManagerImpl::new_ihr_message(td::BufferSlice data) {
|
|||
}
|
||||
|
||||
void ValidatorManagerImpl::new_shard_block(BlockIdExt block_id, CatchainSeqno cc_seqno, td::BufferSlice data) {
|
||||
if (!is_collator() && !is_validator()) {
|
||||
if (!is_validator()) {
|
||||
return;
|
||||
}
|
||||
if (!last_masterchain_block_handle_) {
|
||||
|
|
@ -533,7 +534,7 @@ void ValidatorManagerImpl::add_shard_block_description(td::Ref<ShardTopBlockDesc
|
|||
});
|
||||
wait_block_state_short(desc->block_id(), 0, td::Timestamp::in(60.0), std::move(P));
|
||||
}
|
||||
if (collating_masterchain()) {
|
||||
if (validating_masterchain()) {
|
||||
preload_msg_queue_to_masterchain(desc);
|
||||
}
|
||||
}
|
||||
|
|
@ -542,7 +543,8 @@ void ValidatorManagerImpl::add_shard_block_description(td::Ref<ShardTopBlockDesc
|
|||
void ValidatorManagerImpl::preload_msg_queue_to_masterchain(td::Ref<ShardTopBlockDescription> desc) {
|
||||
auto id = ShardTopBlockDescriptionId{desc->block_id().shard_full(), desc->catchain_seqno()};
|
||||
auto it = shard_blocks_.find(id);
|
||||
if (!collating_masterchain() || it == shard_blocks_.end() || it->second.latest_desc->block_id() != desc->block_id()) {
|
||||
if (!validating_masterchain() || it == shard_blocks_.end() ||
|
||||
it->second.latest_desc->block_id() != desc->block_id()) {
|
||||
return;
|
||||
}
|
||||
wait_neighbor_msg_queue_proofs(
|
||||
|
|
@ -2031,9 +2033,9 @@ void ValidatorManagerImpl::new_masterchain_block() {
|
|||
td::actor::send_closure(shard_client_, &ShardClient::new_masterchain_block_notification,
|
||||
last_masterchain_block_handle_, last_masterchain_state_);
|
||||
}
|
||||
if (is_collator()) {
|
||||
if (validating_masterchain() || !collator_nodes_.empty()) {
|
||||
std::set<ShardIdFull> collating_shards;
|
||||
if (collating_masterchain()) {
|
||||
if (validating_masterchain()) {
|
||||
collating_shards.emplace(masterchainId);
|
||||
}
|
||||
for (const auto &collator : collator_nodes_) {
|
||||
|
|
@ -2398,7 +2400,8 @@ td::actor::ActorOwn<ValidatorGroup> ValidatorManagerImpl::create_validator_group
|
|||
auto G = td::actor::create_actor<ValidatorGroup>(
|
||||
"validatorgroup", shard, validator_id, session_id, validator_set,
|
||||
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()), opts_);
|
||||
actor_id(this), init_session, opts_->check_unsafe_resync_allowed(validator_set->get_catchain_seqno()), opts_,
|
||||
opts_->need_monitor(shard, last_masterchain_state_));
|
||||
return G;
|
||||
}
|
||||
}
|
||||
|
|
@ -2845,27 +2848,12 @@ bool ValidatorManagerImpl::is_validator() {
|
|||
return temp_keys_.size() > 0 || permanent_keys_.size() > 0;
|
||||
}
|
||||
|
||||
bool ValidatorManagerImpl::is_collator() {
|
||||
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();
|
||||
}
|
||||
|
||||
bool ValidatorManagerImpl::collating_masterchain() {
|
||||
if (masterchain_collators_) {
|
||||
return true;
|
||||
}
|
||||
if (opts_->validator_mode() == ValidatorManagerOptions::validator_lite_all) {
|
||||
return false;
|
||||
}
|
||||
return validating_masterchain();
|
||||
}
|
||||
|
||||
PublicKeyHash ValidatorManagerImpl::get_validator(ShardIdFull shard, td::Ref<ValidatorSet> val_set) {
|
||||
for (auto &key : temp_keys_) {
|
||||
if (val_set->is_validator(key.bits256_value())) {
|
||||
|
|
@ -3331,6 +3319,14 @@ void ValidatorManagerImpl::update_options(td::Ref<ValidatorManagerOptions> opts)
|
|||
if (!queue_size_counter_.empty()) {
|
||||
td::actor::send_closure(queue_size_counter_, &QueueSizeCounter::update_options, opts);
|
||||
}
|
||||
for (auto &group : validator_groups_) {
|
||||
td::actor::send_closure(group.second.actor, &ValidatorGroup::update_options, opts,
|
||||
opts->need_monitor(group.second.shard, last_masterchain_state_));
|
||||
}
|
||||
for (auto &group : next_validator_groups_) {
|
||||
td::actor::send_closure(group.second.actor, &ValidatorGroup::update_options, opts,
|
||||
opts->need_monitor(group.second.shard, last_masterchain_state_));
|
||||
}
|
||||
opts_ = std::move(opts);
|
||||
}
|
||||
|
||||
|
|
@ -3376,9 +3372,6 @@ void ValidatorManagerImpl::add_collator(adnl::AdnlNodeIdShort id, ShardIdFull sh
|
|||
if (!it->second.shards.insert(shard).second) {
|
||||
return;
|
||||
}
|
||||
if (shard.is_masterchain()) {
|
||||
++masterchain_collators_;
|
||||
}
|
||||
td::actor::send_closure(it->second.actor, &CollatorNode::add_shard, shard);
|
||||
}
|
||||
|
||||
|
|
@ -3390,9 +3383,6 @@ void ValidatorManagerImpl::del_collator(adnl::AdnlNodeIdShort id, ShardIdFull sh
|
|||
if (!it->second.shards.erase(shard)) {
|
||||
return;
|
||||
}
|
||||
if (shard.is_masterchain()) {
|
||||
--masterchain_collators_;
|
||||
}
|
||||
if (it->second.shards.empty()) {
|
||||
collator_nodes_.erase(it);
|
||||
} else {
|
||||
|
|
|
|||
|
|
@ -560,9 +560,7 @@ class ValidatorManagerImpl : public ValidatorManager {
|
|||
void read_gc_list(std::vector<ValidatorSessionId> list);
|
||||
|
||||
bool is_validator();
|
||||
bool is_collator();
|
||||
bool validating_masterchain();
|
||||
bool collating_masterchain();
|
||||
PublicKeyHash get_validator(ShardIdFull shard, td::Ref<ValidatorSet> val_set);
|
||||
|
||||
ValidatorManagerImpl(td::Ref<ValidatorManagerOptions> opts, std::string db_root,
|
||||
|
|
@ -767,7 +765,6 @@ class ValidatorManagerImpl : public ValidatorManager {
|
|||
std::set<ShardIdFull> shards;
|
||||
};
|
||||
std::map<adnl::AdnlNodeIdShort, Collator> collator_nodes_;
|
||||
size_t masterchain_collators_ = 0;
|
||||
|
||||
std::set<ShardIdFull> extra_active_shards_;
|
||||
std::map<ShardIdFull, BlockSeqno> last_validated_blocks_;
|
||||
|
|
|
|||
|
|
@ -57,14 +57,7 @@ void ValidatorGroup::generate_block_candidate(
|
|||
cache = cached_collated_block_](td::Result<BlockCandidate> R) {
|
||||
td::actor::send_closure(SelfId, &ValidatorGroup::generated_block_candidate, std::move(cache), std::move(R));
|
||||
};
|
||||
if (opts_->validator_mode() == ValidatorManagerOptions::validator_lite_all ||
|
||||
(opts_->validator_mode() == ValidatorManagerOptions::validator_lite_shards && !shard_.is_masterchain())) {
|
||||
send_collate_query(round_id, td::Timestamp::in(10.0), std::move(P));
|
||||
return;
|
||||
}
|
||||
run_collate_query(shard_, min_masterchain_block_id_, prev_block_ids_,
|
||||
Ed25519_PublicKey{local_id_full_.ed25519_value().raw()}, validator_set_, manager_,
|
||||
td::Timestamp::in(10.0), std::move(P));
|
||||
collate_block(round_id, td::Timestamp::in(10.0), std::move(P));
|
||||
}
|
||||
|
||||
void ValidatorGroup::generated_block_candidate(std::shared_ptr<CachedCollatedBlock> cache,
|
||||
|
|
@ -142,8 +135,7 @@ void ValidatorGroup::validate_block_candidate(td::uint32 round_id, BlockCandidat
|
|||
}
|
||||
VLOG(VALIDATOR_DEBUG) << "validating block candidate " << next_block_id;
|
||||
run_validate_query(shard_, min_masterchain_block_id_, prev_block_ids_, std::move(block), validator_set_, manager_,
|
||||
td::Timestamp::in(15.0), std::move(P),
|
||||
collator_config_.full_collated_data ? ValidateMode::full_collated_data : 0);
|
||||
td::Timestamp::in(15.0), std::move(P));
|
||||
}
|
||||
|
||||
void ValidatorGroup::update_approve_cache(CacheKey key, UnixTime value) {
|
||||
|
|
@ -204,10 +196,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), std::move(approve_sig_set),
|
||||
send_broadcast, shard_.is_masterchain() || opts_->validator_mode() == ValidatorManagerOptions::validator_normal,
|
||||
manager_, std::move(P));
|
||||
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, apply_blocks_, manager_, std::move(P));
|
||||
}
|
||||
|
||||
void ValidatorGroup::skip_round(td::uint32 round_id) {
|
||||
|
|
@ -480,25 +470,55 @@ void ValidatorGroup::get_session_info(
|
|||
td::actor::send_closure(session_, &validatorsession::ValidatorSession::get_session_info, std::move(P));
|
||||
}
|
||||
|
||||
void ValidatorGroup::send_collate_query(td::uint32 round_id, td::Timestamp timeout, td::Promise<BlockCandidate> promise,
|
||||
unsigned max_retries) {
|
||||
void ValidatorGroup::collate_block(td::uint32 round_id, td::Timestamp timeout, td::Promise<BlockCandidate> promise,
|
||||
unsigned max_retries) {
|
||||
if (round_id < last_known_round_id_) {
|
||||
promise.set_error(td::Status::Error("too old"));
|
||||
return;
|
||||
}
|
||||
BlockId next_block_id = create_next_block_id_simple();
|
||||
adnl::AdnlNodeIdShort collator = adnl::AdnlNodeIdShort::zero();
|
||||
// TODO: some way to choose node (similar to "unreliability" in full-node)
|
||||
int cnt = 0;
|
||||
for (const block::CollatorNodeDescr &c : collator_config_.collator_nodes) {
|
||||
if (shard_intersects(shard_, c.shard)) {
|
||||
if (td::Random::fast(0, cnt) == 0) {
|
||||
collator = adnl::AdnlNodeIdShort(c.adnl_id);
|
||||
adnl::AdnlNodeIdShort collator_adnl_id = adnl::AdnlNodeIdShort::zero();
|
||||
bool self_collate = false;
|
||||
bool trusted_collator = false;
|
||||
|
||||
if (shard_.is_masterchain()) {
|
||||
self_collate = true;
|
||||
} else {
|
||||
for (const auto &s : opts_->get_collators_list()->shards) {
|
||||
if (!shard_intersects(s.shard_id, shard_)) {
|
||||
continue;
|
||||
}
|
||||
if (!s.collators.empty()) {
|
||||
const CollatorsList::Collator &col = s.collators[td::Random::fast(0, s.collators.size() - 1)];
|
||||
collator_adnl_id = col.adnl_id;
|
||||
trusted_collator = col.trusted;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (collator_adnl_id.is_zero()) {
|
||||
if (opts_->get_collators_list()->self_collate) {
|
||||
self_collate = true;
|
||||
} else if (opts_->get_collators_list()->use_config_41) {
|
||||
// TODO: some way to choose node (similar to "unreliability" in full-node)
|
||||
int cnt = 0;
|
||||
for (const block::CollatorNodeDescr &c : collator_config_.collator_nodes) {
|
||||
if (shard_intersects(shard_, c.shard)) {
|
||||
if (td::Random::fast(0, cnt) == 0) {
|
||||
collator_adnl_id = adnl::AdnlNodeIdShort(c.adnl_id);
|
||||
}
|
||||
++cnt;
|
||||
}
|
||||
}
|
||||
}
|
||||
++cnt;
|
||||
}
|
||||
}
|
||||
if (collator.is_zero()) {
|
||||
if (self_collate) {
|
||||
run_collate_query(shard_, min_masterchain_block_id_, prev_block_ids_,
|
||||
Ed25519_PublicKey{local_id_full_.ed25519_value().raw()}, validator_set_, manager_,
|
||||
td::Timestamp::in(10.0), std::move(promise));
|
||||
return;
|
||||
}
|
||||
if (collator_adnl_id.is_zero()) {
|
||||
promise.set_error(td::Status::Error(PSTRING() << "no collator for shard " << shard_.to_str()));
|
||||
return;
|
||||
}
|
||||
|
|
@ -514,7 +534,7 @@ void ValidatorGroup::send_collate_query(td::uint32 round_id, td::Timestamp timeo
|
|||
LOG(WARNING) << "collate query for " << next_block_id.to_str() << ": " << R.error() << ", time=" << timer.elapsed()
|
||||
<< "s, " << (retry ? "retrying" : "giving up");
|
||||
if (retry) {
|
||||
td::actor::send_closure(SelfId, &ValidatorGroup::send_collate_query, round_id, timeout, std::move(promise),
|
||||
td::actor::send_closure(SelfId, &ValidatorGroup::collate_block, round_id, timeout, std::move(promise),
|
||||
max_retries - 1);
|
||||
} else {
|
||||
promise.set_result(td::Status::Error(ErrorCode::timeout, "timeout"));
|
||||
|
|
@ -530,23 +550,23 @@ void ValidatorGroup::send_collate_query(td::uint32 round_id, td::Timestamp timeo
|
|||
local_id_full_.ed25519_value().raw());
|
||||
|
||||
auto P = td::PromiseCreator::lambda(
|
||||
[SelfId = actor_id(this), round_id, promise = std::move(promise)](td::Result<td::BufferSlice> R) mutable {
|
||||
[=, SelfId = actor_id(this), promise = std::move(promise)](td::Result<td::BufferSlice> R) mutable {
|
||||
if (R.is_error()) {
|
||||
promise.set_error(R.move_as_error_prefix("rldp query failed: "));
|
||||
return;
|
||||
}
|
||||
td::actor::send_closure(SelfId, &ValidatorGroup::receive_collate_query_response, round_id, R.move_as_ok(),
|
||||
std::move(promise));
|
||||
trusted_collator, std::move(promise));
|
||||
});
|
||||
LOG(INFO) << "sending collate query for " << next_block_id.to_str() << ": send to " << collator;
|
||||
LOG(INFO) << "sending collate query for " << next_block_id.to_str() << ": send to " << collator_adnl_id;
|
||||
size_t max_answer_size = config_.max_block_size + config_.max_collated_data_size + 1024;
|
||||
td::Timestamp query_timeout = td::Timestamp::in(10.0);
|
||||
query_timeout.relax(timeout);
|
||||
td::actor::send_closure(rldp_, &rldp::Rldp::send_query_ex, local_adnl_id_, collator, "collatequery", std::move(P),
|
||||
timeout, std::move(query), max_answer_size);
|
||||
td::actor::send_closure(rldp_, &rldp::Rldp::send_query_ex, local_adnl_id_, collator_adnl_id, "collatequery",
|
||||
std::move(P), timeout, std::move(query), max_answer_size);
|
||||
}
|
||||
|
||||
void ValidatorGroup::receive_collate_query_response(td::uint32 round_id, td::BufferSlice data,
|
||||
void ValidatorGroup::receive_collate_query_response(td::uint32 round_id, td::BufferSlice data, bool trusted_collator,
|
||||
td::Promise<BlockCandidate> promise) {
|
||||
if (round_id < last_known_round_id_) {
|
||||
promise.set_error(td::Status::Error("too old"));
|
||||
|
|
@ -574,6 +594,10 @@ void ValidatorGroup::receive_collate_query_response(td::uint32 round_id, td::Buf
|
|||
return;
|
||||
}
|
||||
|
||||
if (trusted_collator) {
|
||||
promise.set_result(std::move(candidate));
|
||||
return;
|
||||
}
|
||||
auto P = td::PromiseCreator::lambda(
|
||||
[candidate = candidate.clone(), promise = std::move(promise)](td::Result<std::pair<UnixTime, bool>> R) mutable {
|
||||
if (R.is_error()) {
|
||||
|
|
|
|||
|
|
@ -66,13 +66,18 @@ class ValidatorGroup : public td::actor::Actor {
|
|||
|
||||
void get_session_info(td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionInfo>> promise);
|
||||
|
||||
void update_options(td::Ref<ValidatorManagerOptions> opts, bool apply_blocks) {
|
||||
opts_ = std::move(opts);
|
||||
apply_blocks_ = apply_blocks;
|
||||
}
|
||||
|
||||
ValidatorGroup(ShardIdFull shard, PublicKeyHash local_id, ValidatorSessionId session_id,
|
||||
td::Ref<ValidatorSet> validator_set, block::CollatorConfig collator_config,
|
||||
validatorsession::ValidatorSessionOptions config,
|
||||
td::actor::ActorId<keyring::Keyring> keyring, td::actor::ActorId<adnl::Adnl> adnl,
|
||||
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,
|
||||
bool allow_unsafe_self_blocks_resync, td::Ref<ValidatorManagerOptions> opts)
|
||||
bool allow_unsafe_self_blocks_resync, td::Ref<ValidatorManagerOptions> opts, bool apply_blocks)
|
||||
: shard_(shard)
|
||||
, local_id_(std::move(local_id))
|
||||
, session_id_(session_id)
|
||||
|
|
@ -87,14 +92,16 @@ class ValidatorGroup : public td::actor::Actor {
|
|||
, manager_(validator_manager)
|
||||
, init_(create_session)
|
||||
, allow_unsafe_self_blocks_resync_(allow_unsafe_self_blocks_resync)
|
||||
, opts_(std::move(opts)) {
|
||||
, opts_(std::move(opts))
|
||||
, apply_blocks_(apply_blocks) {
|
||||
}
|
||||
|
||||
private:
|
||||
std::unique_ptr<validatorsession::ValidatorSession::Callback> make_validator_session_callback();
|
||||
void send_collate_query(td::uint32 round_id, td::Timestamp timeout, td::Promise<BlockCandidate> promise,
|
||||
void collate_block(td::uint32 round_id, td::Timestamp timeout, td::Promise<BlockCandidate> promise,
|
||||
unsigned max_retries = 4);
|
||||
void receive_collate_query_response(td::uint32 round_id, td::BufferSlice data, td::Promise<BlockCandidate> promise);
|
||||
void receive_collate_query_response(td::uint32 round_id, td::BufferSlice data, bool trusted_collator,
|
||||
td::Promise<BlockCandidate> promise);
|
||||
|
||||
struct PostponedAccept {
|
||||
RootHash root_hash;
|
||||
|
|
@ -134,6 +141,7 @@ class ValidatorGroup : public td::actor::Actor {
|
|||
bool allow_unsafe_self_blocks_resync_;
|
||||
td::Ref<ValidatorManagerOptions> opts_;
|
||||
td::uint32 last_known_round_id_ = 0;
|
||||
bool apply_blocks_ = true;
|
||||
|
||||
struct CachedCollatedBlock {
|
||||
td::optional<BlockCandidate> result;
|
||||
|
|
|
|||
|
|
@ -20,10 +20,26 @@
|
|||
|
||||
#include "ton/ton-shard.h"
|
||||
|
||||
#include <ton/ton-tl.hpp>
|
||||
|
||||
namespace ton {
|
||||
|
||||
namespace validator {
|
||||
|
||||
void CollatorsList::unpack(const ton_api::engine_validator_collatorsList& obj) {
|
||||
shards.clear();
|
||||
self_collate = obj.self_collate_;
|
||||
use_config_41 = obj.use_config_41_;
|
||||
for (const auto& shard_obj : obj.shards_) {
|
||||
shards.emplace_back();
|
||||
Shard& shard = shards.back();
|
||||
shard.shard_id = create_shard_id(shard_obj->shard_id_);
|
||||
for (const auto& collator : shard_obj->collators_) {
|
||||
shard.collators.push_back({adnl::AdnlNodeIdShort{collator->adnl_id_}, collator->trusted_});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
td::Ref<ValidatorManagerOptions> ValidatorManagerOptions::create(
|
||||
BlockIdExt zero_block_id, BlockIdExt init_block_id,
|
||||
std::function<bool(ShardIdFull)> check_shard, bool allow_blockchain_init,
|
||||
|
|
|
|||
|
|
@ -142,8 +142,8 @@ struct ValidatorManagerOptionsImpl : public ValidatorManagerOptions {
|
|||
bool get_state_serializer_enabled() const override {
|
||||
return state_serializer_enabled_;
|
||||
}
|
||||
ValidatorMode validator_mode() const override {
|
||||
return validator_mode_;
|
||||
td::Ref<CollatorsList> get_collators_list() const override {
|
||||
return collators_list_;
|
||||
}
|
||||
|
||||
void set_zero_block_id(BlockIdExt block_id) override {
|
||||
|
|
@ -228,8 +228,8 @@ struct ValidatorManagerOptionsImpl : public ValidatorManagerOptions {
|
|||
void set_state_serializer_enabled(bool value) override {
|
||||
state_serializer_enabled_ = value;
|
||||
}
|
||||
void set_validator_mode(ValidatorMode value) override {
|
||||
validator_mode_ = value;
|
||||
void set_collators_list(td::Ref<CollatorsList> list) override {
|
||||
collators_list_ = std::move(list);
|
||||
}
|
||||
|
||||
ValidatorManagerOptionsImpl *make_copy() const override {
|
||||
|
|
@ -281,7 +281,7 @@ struct ValidatorManagerOptionsImpl : public ValidatorManagerOptions {
|
|||
bool celldb_preload_all_ = false;
|
||||
td::optional<double> catchain_max_block_delay_;
|
||||
bool state_serializer_enabled_ = true;
|
||||
ValidatorMode validator_mode_ = validator_normal;
|
||||
td::Ref<CollatorsList> collators_list_{true, CollatorsList{}};
|
||||
};
|
||||
|
||||
} // namespace validator
|
||||
|
|
|
|||
|
|
@ -52,10 +52,24 @@ struct PerfTimerStats {
|
|||
std::deque<std::pair<double, double>> stats; // <Time::now(), duration>
|
||||
};
|
||||
|
||||
struct CollatorsList : public td::CntObject {
|
||||
struct Collator {
|
||||
adnl::AdnlNodeIdShort adnl_id;
|
||||
bool trusted;
|
||||
};
|
||||
struct Shard {
|
||||
ShardIdFull shard_id;
|
||||
std::vector<Collator> collators;
|
||||
};
|
||||
bool self_collate = true;
|
||||
bool use_config_41 = false;
|
||||
std::vector<Shard> shards;
|
||||
|
||||
void unpack(const ton_api::engine_validator_collatorsList& obj);
|
||||
};
|
||||
|
||||
struct ValidatorManagerOptions : public td::CntObject {
|
||||
public:
|
||||
enum ValidatorMode { validator_normal, validator_lite_shards, validator_lite_all };
|
||||
|
||||
virtual BlockIdExt zero_block_id() const = 0;
|
||||
virtual BlockIdExt init_block_id() const = 0;
|
||||
virtual bool need_monitor(ShardIdFull shard, const td::Ref<MasterchainState>& state) const = 0;
|
||||
|
|
@ -91,7 +105,7 @@ struct ValidatorManagerOptions : public td::CntObject {
|
|||
virtual bool get_celldb_preload_all() const = 0;
|
||||
virtual td::optional<double> get_catchain_max_block_delay() const = 0;
|
||||
virtual bool get_state_serializer_enabled() const = 0;
|
||||
virtual ValidatorMode validator_mode() const = 0;
|
||||
virtual td::Ref<CollatorsList> get_collators_list() const = 0;
|
||||
|
||||
virtual void set_zero_block_id(BlockIdExt block_id) = 0;
|
||||
virtual void set_init_block_id(BlockIdExt block_id) = 0;
|
||||
|
|
@ -120,7 +134,7 @@ struct ValidatorManagerOptions : public td::CntObject {
|
|||
virtual void set_celldb_preload_all(bool value) = 0;
|
||||
virtual void set_catchain_max_block_delay(double value) = 0;
|
||||
virtual void set_state_serializer_enabled(bool value) = 0;
|
||||
virtual void set_validator_mode(ValidatorMode value) = 0;
|
||||
virtual void set_collators_list(td::Ref<CollatorsList> list) = 0;
|
||||
|
||||
static td::Ref<ValidatorManagerOptions> create(
|
||||
BlockIdExt zero_block_id, BlockIdExt init_block_id,
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue