external/ton
1
0
Fork 0
mirror of https://github.com/ton-blockchain/ton synced 2025-02-13 03:32:22 +00:00
Code Issues Releases Wiki Activity

Remove obsolete interface for importing blocks

Browse source
This commit is contained in:
SpyCheese 2022-08-08 12:41:28 +03:00
parent 51e6885f2c
commit 7241522de2
13 changed files with 0 additions and 385 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -704,10 +704,6 @@ engine.validator.importShardOverlayCertificate workchain:int shard:long signed_k
engine.validator.getValidatorSessionsInfo = engine.validator.ValidatorSessionsInfo;
engine.validator.generateBlockCandidate block_id:tonNode.BlockId = db.Candidate;
engine.validator.getRequiredBlockCandidates = engine.validator.RequiredBlockCandidates;
engine.validator.importBlockCandidate block:db.candidate = engine.validator.Success;
engine.validator.addCollator adnl_id:int256 shard:tonNode.shardId = engine.validator.Success;
engine.validator.addShard shard:tonNode.shardId = engine.validator.Success;

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

Binary file not shown.

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

@ -1029,69 +1029,6 @@ td::Status GetValidatorSessionsInfoQuery::receive(td::BufferSlice data) {
return td::Status::OK();
}
td::Status GenerateBlockCandidateQuery::run() {
TRY_RESULT_ASSIGN(wc_, tokenizer_.get_token<td::int32>());
TRY_RESULT_ASSIGN(shard_, tokenizer_.get_token<td::int64>() );
TRY_RESULT_ASSIGN(seqno_, tokenizer_.get_token<td::int32>());
TRY_RESULT_ASSIGN(file_, tokenizer_.get_token<std::string>());
return td::Status::OK();
}
td::Status GenerateBlockCandidateQuery::send() {
auto b = ton::create_serialize_tl_object<ton::ton_api::engine_validator_generateBlockCandidate>(
ton::create_tl_block_id_simple(ton::BlockId(wc_, shard_, seqno_)));
td::actor::send_closure(console_, &ValidatorEngineConsole::envelope_send_query, std::move(b), create_promise());
return td::Status::OK();
}
td::Status GenerateBlockCandidateQuery::receive(td::BufferSlice data) {
TRY_RESULT_PREFIX(f, ton::fetch_tl_object<ton::ton_api::db_candidate>(data.as_slice(), true),
"received incorrect answer: ");
TRY_STATUS_PREFIX(td::write_file(file_, data.as_slice()), "failed to write block to file");
td::TerminalIO::out() << "successfully written candidate to file\n";
return td::Status::OK();
}
td::Status GetRequiredBlockCandidatesQuery::run() {
TRY_STATUS(tokenizer_.check_endl());
return td::Status::OK();
}
td::Status GetRequiredBlockCandidatesQuery::send() {
auto b = ton::create_serialize_tl_object<ton::ton_api::engine_validator_getRequiredBlockCandidates>();
td::actor::send_closure(console_, &ValidatorEngineConsole::envelope_send_query, std::move(b), create_promise());
return td::Status::OK();
}
td::Status GetRequiredBlockCandidatesQuery::receive(td::BufferSlice data) {
TRY_RESULT_PREFIX(
f, ton::fetch_tl_object<ton::ton_api::engine_validator_requiredBlockCandidates>(data.as_slice(), true),
"received incorrect answer: ");
td::TerminalIO::out() << td::json_encode<std::string>(td::ToJson(*f), true);
return td::Status::OK();
}
td::Status ImportBlockCandidateQuery::run() {
TRY_RESULT_ASSIGN(file_, tokenizer_.get_token<std::string>());
return td::Status::OK();
}
td::Status ImportBlockCandidateQuery::send() {
TRY_RESULT(data, td::read_file(file_));
TRY_RESULT_PREFIX(candidate, ton::fetch_tl_object<ton::ton_api::db_candidate>(data.as_slice(), true),
"invalid file: ");
auto b = ton::create_serialize_tl_object<ton::ton_api::engine_validator_importBlockCandidate>(std::move(candidate));
td::actor::send_closure(console_, &ValidatorEngineConsole::envelope_send_query, std::move(b), create_promise());
return td::Status::OK();
}
td::Status ImportBlockCandidateQuery::receive(td::BufferSlice data) {
TRY_RESULT_PREFIX(f, ton::fetch_tl_object<ton::ton_api::engine_validator_success>(data.as_slice(), true),
"received incorrect answer: ");
td::TerminalIO::out() << "successfully imported a block candidate\n";
return td::Status::OK();
}
td::Status AddCollatorQuery::run() {
TRY_RESULT_ASSIGN(adnl_id_, tokenizer_.get_token<ton::PublicKeyHash>());
TRY_RESULT_ASSIGN(wc_, tokenizer_.get_token<td::int32>());

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

@ -1094,76 +1094,6 @@ class GetValidatorSessionsInfoQuery : public Query {
}
};
class GenerateBlockCandidateQuery : public Query {
public:
GenerateBlockCandidateQuery(td::actor::ActorId<ValidatorEngineConsole> console, Tokenizer tokenizer)
: Query(console, std::move(tokenizer)) {
}
td::Status run() override;
td::Status send() override;
td::Status receive(td::BufferSlice data) override;
static std::string get_name() {
return "genblock";
}
static std::string get_help() {
return "genblock <wc> <shard> <seqno> <file>\t"
"generate a block candidate for a given shard (seqno mush match the next seqno for the shard), "
"candidate is saved to <file>";
}
std::string name() const override {
return get_name();
}
private:
td::int32 wc_;
td::int64 shard_;
td::int32 seqno_;
std::string file_;
};
class GetRequiredBlockCandidatesQuery : public Query {
public:
GetRequiredBlockCandidatesQuery(td::actor::ActorId<ValidatorEngineConsole> console, Tokenizer tokenizer)
: Query(console, std::move(tokenizer)) {
}
td::Status run() override;
td::Status send() override;
td::Status receive(td::BufferSlice data) override;
static std::string get_name() {
return "getrequiredblockcandidates";
}
static std::string get_help() {
return "getrequiredblockcandidates\t"
"get a list of block candidates that the validator is currently waiting for";
}
std::string name() const override {
return get_name();
}
};
class ImportBlockCandidateQuery : public Query {
public:
ImportBlockCandidateQuery(td::actor::ActorId<ValidatorEngineConsole> console, Tokenizer tokenizer)
: Query(console, std::move(tokenizer)) {
}
td::Status run() override;
td::Status send() override;
td::Status receive(td::BufferSlice data) override;
static std::string get_name() {
return "importblockcandidate";
}
static std::string get_help() {
return "importblockcandidate <file>\t"
"load a block candidate from a given file";
}
std::string name() const override {
return get_name();
}
private:
std::string file_;
};
class AddCollatorQuery : public Query {
public:
AddCollatorQuery(td::actor::ActorId<ValidatorEngineConsole> console, Tokenizer tokenizer)

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

@ -141,9 +141,6 @@ void ValidatorEngineConsole::run() {
add_query_runner(std::make_unique<QueryRunnerImpl<ImportShardOverlayCertificateQuery>>());
add_query_runner(std::make_unique<QueryRunnerImpl<SignShardOverlayCertificateQuery>>());
add_query_runner(std::make_unique<QueryRunnerImpl<GetValidatorSessionsInfoQuery>>());
add_query_runner(std::make_unique<QueryRunnerImpl<GenerateBlockCandidateQuery>>());
add_query_runner(std::make_unique<QueryRunnerImpl<GetRequiredBlockCandidatesQuery>>());
add_query_runner(std::make_unique<QueryRunnerImpl<ImportBlockCandidateQuery>>());
add_query_runner(std::make_unique<QueryRunnerImpl<AddCollatorQuery>>());
add_query_runner(std::make_unique<QueryRunnerImpl<AddShardQuery>>());
}

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

@ -3393,94 +3393,6 @@ void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_getValida
std::move(P));
}
void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_generateBlockCandidate &query,
td::BufferSlice data, ton::PublicKeyHash src, td::uint32 perm,
td::Promise<td::BufferSlice> promise) {
if (!(perm & ValidatorEnginePermissions::vep_default)) {
promise.set_value(create_control_query_error(td::Status::Error(ton::ErrorCode::error, "not authorized")));
return;
}
if (validator_manager_.empty()) {
promise.set_value(
create_control_query_error(td::Status::Error(ton::ErrorCode::notready, "validator manager not started")));
return;
}
ton::BlockId block_id = ton::create_block_id_simple(query.block_id_);
td::actor::send_closure(validator_manager_, &ton::validator::ValidatorManagerInterface::generate_block_candidate,
block_id, [promise = std::move(promise)](td::Result<ton::BlockCandidate> R) mutable {
if (R.is_ok()) {
auto block = R.move_as_ok();
auto result = ton::create_serialize_tl_object<ton::ton_api::db_candidate>(
ton::PublicKey{ton::pubkeys::Ed25519{block.pubkey.as_bits256()}}.tl(),
ton::create_tl_block_id(block.id), std::move(block.data),
std::move(block.collated_data));
promise.set_result(std::move(result));
} else {
promise.set_value(create_control_query_error(R.move_as_error()));
}
});
}
void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_getRequiredBlockCandidates &query,
td::BufferSlice data, ton::PublicKeyHash src, td::uint32 perm,
td::Promise<td::BufferSlice> promise) {
if (!(perm & ValidatorEnginePermissions::vep_default)) {
promise.set_value(create_control_query_error(td::Status::Error(ton::ErrorCode::error, "not authorized")));
return;
}
if (validator_manager_.empty()) {
promise.set_value(
create_control_query_error(td::Status::Error(ton::ErrorCode::notready, "validator manager not started")));
return;
}
td::actor::send_closure(
validator_manager_, &ton::validator::ValidatorManagerInterface::get_required_block_candidates,
[promise = std::move(promise)](td::Result<std::vector<ton::BlockId>> R) mutable {
if (R.is_ok()) {
std::vector<ton::tl_object_ptr<ton::ton_api::tonNode_blockId>> block_ids;
for (const ton::BlockId &block_id : R.move_as_ok()) {
block_ids.push_back(ton::create_tl_block_id_simple(block_id));
}
auto result = ton::create_serialize_tl_object<ton::ton_api::engine_validator_requiredBlockCandidates>(
std::move(block_ids));
promise.set_result(std::move(result));
} else {
promise.set_value(create_control_query_error(R.move_as_error()));
}
});
}
void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_importBlockCandidate &query,
td::BufferSlice data, ton::PublicKeyHash src, td::uint32 perm,
td::Promise<td::BufferSlice> promise) {
if (!(perm & ValidatorEnginePermissions::vep_modify)) {
promise.set_value(create_control_query_error(td::Status::Error(ton::ErrorCode::error, "not authorized")));
return;
}
if (validator_manager_.empty()) {
promise.set_value(
create_control_query_error(td::Status::Error(ton::ErrorCode::notready, "validator manager not started")));
return;
}
auto collated_data_hash = td::sha256_bits256(query.block_->collated_data_);
auto key = ton::PublicKey{query.block_->source_};
auto e_key = ton::Ed25519_PublicKey{key.ed25519_value().raw()};
ton::BlockCandidate candidate{e_key, ton::create_block_id(query.block_->id_), collated_data_hash,
std::move(query.block_->data_), std::move(query.block_->collated_data_)};
td::actor::send_closure(validator_manager_, &ton::validator::ValidatorManagerInterface::import_block_candidate,
std::move(candidate),
[promise = std::move(promise)](td::Result<td::Unit> R) mutable {
if (R.is_ok()) {
promise.set_result(ton::serialize_tl_object(
ton::create_tl_object<ton::ton_api::engine_validator_success>(), true));
} else {
promise.set_value(create_control_query_error(R.move_as_error()));
}
});
}
void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_addCollator &query,
td::BufferSlice data, ton::PublicKeyHash src, td::uint32 perm,
td::Promise<td::BufferSlice> promise) {

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

@ -428,12 +428,6 @@ class ValidatorEngine : public td::actor::Actor {
ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise);
void run_control_query(ton::ton_api::engine_validator_getValidatorSessionsInfo &query, td::BufferSlice data,
ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise);
void run_control_query(ton::ton_api::engine_validator_generateBlockCandidate &query, td::BufferSlice data,
ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise);
void run_control_query(ton::ton_api::engine_validator_getRequiredBlockCandidates &query, td::BufferSlice data,
ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise);
void run_control_query(ton::ton_api::engine_validator_importBlockCandidate &query, td::BufferSlice data,
ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise);
void run_control_query(ton::ton_api::engine_validator_addCollator &query, td::BufferSlice data,
ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise);
void run_control_query(ton::ton_api::engine_validator_addShard &query, td::BufferSlice data,

2
validator/interfaces/validator-manager.h
View file

@ -168,8 +168,6 @@ class ValidatorManager : public ValidatorManagerInterface {
virtual void log_validator_session_stats(BlockIdExt block_id, validatorsession::ValidatorSessionStats stats) = 0;
virtual void wait_block_candidate(BlockId block_id, td::Timestamp timeout, td::Promise<BlockCandidate> promise) = 0;
static bool is_persistent_state(UnixTime ts, UnixTime prev_ts) {
return ts / (1 << 17) != prev_ts / (1 << 17);
}

12
validator/manager-disk.hpp
View file

@ -379,18 +379,6 @@ class ValidatorManagerImpl : public ValidatorManager {
td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionsInfo>> promise) override {
UNREACHABLE();
}
void generate_block_candidate(BlockId block_id, td::Promise<BlockCandidate> promise) override {
UNREACHABLE();
}
void get_required_block_candidates(td::Promise<std::vector<BlockId>> promise) override {
UNREACHABLE();
}
void import_block_candidate(BlockCandidate candidate, td::Promise<td::Unit> promise) override {
UNREACHABLE();
}
void wait_block_candidate(BlockId block_id, td::Timestamp timeout, td::Promise<BlockCandidate> promise) override {
UNREACHABLE();
}
void add_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) override {
UNREACHABLE();

12
validator/manager-hardfork.hpp
View file

@ -439,18 +439,6 @@ class ValidatorManagerImpl : public ValidatorManager {
td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionsInfo>> promise) override {
UNREACHABLE();
}
void generate_block_candidate(BlockId block_id, td::Promise<BlockCandidate> promise) override {
UNREACHABLE();
}
void get_required_block_candidates(td::Promise<std::vector<BlockId>> promise) override {
UNREACHABLE();
}
void import_block_candidate(BlockCandidate candidate, td::Promise<td::Unit> promise) override {
UNREACHABLE();
}
void wait_block_candidate(BlockId block_id, td::Timestamp timeout, td::Promise<BlockCandidate> promise) override {
UNREACHABLE();
}
void add_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) override {
UNREACHABLE();

113
validator/manager.cpp
View file

@ -2641,119 +2641,6 @@ void ValidatorManagerImpl::get_validator_sessions_info(
IntermediateData::step({std::move(groups), {}, std::move(promise)});
}
void ValidatorManagerImpl::generate_block_candidate(BlockId block_id, td::Promise<BlockCandidate> promise) {
if (!block_id.is_valid_full()) {
promise.set_error(td::Status::Error("invalid block id"));
return;
}
if (last_masterchain_state_.is_null()) {
promise.set_error(td::Status::Error("not started"));
return;
}
ShardIdFull shard_id = block_id.shard_full();
std::vector<BlockIdExt> prev;
auto shard = last_masterchain_state_->get_shard_from_config(shard_id);
if (shard.not_null()) {
if (shard->before_split()) {
promise.set_error(td::Status::Error("shard is before_split"));
return;
}
if (shard->before_merge()) {
promise.set_error(td::Status::Error("shard is before_merge"));
return;
}
prev.push_back(shard->top_block_id());
} else {
auto parent = shard_id.pfx_len() == 0 ? td::Ref<McShardHash>()
: last_masterchain_state_->get_shard_from_config(shard_parent(shard_id));
if (parent.not_null() && parent->before_split()) {
prev.push_back(parent->top_block_id());
} else {
auto child_l = last_masterchain_state_->get_shard_from_config(shard_child(shard_id, true));
auto child_r = last_masterchain_state_->get_shard_from_config(shard_child(shard_id, false));
if (child_l.not_null() && child_r.not_null() && child_l->before_merge() && child_r->before_merge()) {
prev.push_back(child_l->top_block_id());
prev.push_back(child_r->top_block_id());
}
}
if (prev.empty()) {
promise.set_error(td::Status::Error("no such shard"));
return;
}
}
BlockSeqno next_seqno = 0;
for (const BlockIdExt& prev_id : prev) {
next_seqno = std::max(next_seqno, prev_id.seqno() + 1);
}
if (next_seqno != block_id.seqno) {
promise.set_error(td::Status::Error(PSTRING() << "seqno mismatch: asked for seqno " << block_id.seqno
<< ", but actual next seqno is " << next_seqno));
return;
}
Ed25519_PublicKey local_id{Bits256::zero()};
td::Ref<ValidatorSet> validator_set = last_masterchain_state_->get_validator_set(shard_id);
if (validator_set.is_null()) {
promise.set_error(td::Status::Error("cannot get validator set"));
return;
}
run_collate_query(shard_id, last_masterchain_block_id_, std::move(prev), local_id, std::move(validator_set),
actor_id(this), td::Timestamp::in(10.0), std::move(promise));
}
void ValidatorManagerImpl::get_required_block_candidates(td::Promise<std::vector<BlockId>> promise) {
std::vector<BlockId> block_ids;
for (const auto& p : pending_block_candidates_) {
block_ids.push_back(p.first);
}
promise.set_result(std::move(block_ids));
}
void ValidatorManagerImpl::import_block_candidate(BlockCandidate candidate, td::Promise<td::Unit> promise) {
auto it = pending_block_candidates_.find(candidate.id.id);
if (it != pending_block_candidates_.end()) {
while (!it->second.empty()) {
auto promise = std::move(it->second.back().first);
it->second.pop_back();
if (it->second.empty()) {
promise.set_result(std::move(candidate));
} else {
promise.set_result(candidate.clone());
}
}
pending_block_candidates_.erase(it);
}
promise.set_result(td::Unit());
}
void ValidatorManagerImpl::wait_block_candidate(BlockId block_id, td::Timestamp timeout,
td::Promise<BlockCandidate> promise) {
pending_block_candidates_[block_id].emplace_back(std::move(promise), timeout);
delay_action([SelfId = actor_id(this), block_id, timeout]() {
td::actor::send_closure(SelfId, &ValidatorManagerImpl::cleanup_old_pending_candidates, block_id, timeout);
}, timeout);
}
void ValidatorManagerImpl::cleanup_old_pending_candidates(BlockId block_id, td::Timestamp now) {
auto it = pending_block_candidates_.find(block_id);
if (it == pending_block_candidates_.end()) {
return;
}
it->second.erase(std::remove_if(it->second.begin(), it->second.end(),
[&](std::pair<td::Promise<BlockCandidate>, td::Timestamp> &p) {
if (p.second.is_in_past(now)) {
p.first.set_error(td::Status::Error(ErrorCode::timeout, "timeout"));
return true;
}
return false;
}),
it->second.end());
if (it->second.empty()) {
pending_block_candidates_.erase(it);
}
}
void ValidatorManagerImpl::add_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) {
auto it = collator_nodes_.find(id);
if (it == collator_nodes_.end()) {

8
validator/manager.hpp
View file

@ -542,11 +542,6 @@ class ValidatorManagerImpl : public ValidatorManager {
void get_validator_sessions_info(
td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionsInfo>> promise) override;
void generate_block_candidate(BlockId block_id, td::Promise<BlockCandidate> promise) override;
void get_required_block_candidates(td::Promise<std::vector<BlockId>> promise) override;
void import_block_candidate(BlockCandidate candidate, td::Promise<td::Unit> promise) override;
void wait_block_candidate(BlockId block_id, td::Timestamp timeout, td::Promise<BlockCandidate> promise) override;
void add_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) override;
private:
@ -614,9 +609,6 @@ class ValidatorManagerImpl : public ValidatorManager {
private:
std::map<BlockSeqno, WaitList<td::actor::Actor, td::Unit>> shard_client_waiters_;
std::map<BlockId, std::vector<std::pair<td::Promise<BlockCandidate>, td::Timestamp>>> pending_block_candidates_;
void cleanup_old_pending_candidates(BlockId block_id, td::Timestamp now);
std::map<adnl::AdnlNodeIdShort, td::actor::ActorOwn<CollatorNode>> collator_nodes_;
bool collating_masterchain_ = false;

4
validator/validator.h
View file

@ -229,10 +229,6 @@ class ValidatorManagerInterface : public td::actor::Actor {
virtual void get_validator_sessions_info(
td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionsInfo>> promise) = 0;
virtual void generate_block_candidate(BlockId block_id, td::Promise<BlockCandidate> promise) = 0;
virtual void get_required_block_candidates(td::Promise<std::vector<BlockId>> promise) = 0;
virtual void import_block_candidate(BlockCandidate candidate, td::Promise<td::Unit> promise) = 0;
virtual void add_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) = 0;
};