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

Remove unused get validator session stats query

Browse source
This commit is contained in:
SpyCheese 2024-08-19 20:31:33 +03:00
parent dbe51d6d13
commit faedb4635c
17 changed files with 0 additions and 160 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -712,10 +712,6 @@ engine.validator.perfTimerStats stats:(vector engine.validator.PerfTimerStatsByN
engine.validator.shardOutQueueSize size:long = engine.validator.ShardOutQueueSize;
engine.validator.validatorSessionInfo current_block:tonNode.blockId self:int256 current_round:int next_producers:(vector int256) = engine.validator.ValidatorSessionInfo;
engine.validator.validatorSessionsInfo sessions:(vector engine.validator.validatorSessionInfo) = engine.validator.ValidatorSessionsInfo;
engine.validator.requiredBlockCandidates block_ids:(vector tonNode.blockId) = engine.validator.RequiredBlockCandidates;
---functions---
@ -779,8 +775,6 @@ engine.validator.setStateSerializerEnabled enabled:Bool = engine.validator.Succe
engine.validator.setCollatorOptionsJson json:string = engine.validator.Success;
engine.validator.getCollatorOptionsJson = engine.validator.JsonConfig;
engine.validator.getValidatorSessionsInfo = engine.validator.ValidatorSessionsInfo;
engine.validator.addCollator adnl_id:int256 shard:tonNode.shardId = engine.validator.Success;
engine.validator.addShard shard:tonNode.shardId = engine.validator.Success;
engine.validator.delCollator adnl_id:int256 shard:tonNode.shardId = engine.validator.Success;

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

Binary file not shown.

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

@ -1291,26 +1291,6 @@ td::Status GetCollatorOptionsJsonQuery::receive(td::BufferSlice data) {
return td::Status::OK();
}
td::Status GetValidatorSessionsInfoQuery::run() {
TRY_STATUS(tokenizer_.check_endl());
return td::Status::OK();
}
td::Status GetValidatorSessionsInfoQuery::send() {
auto b = ton::create_serialize_tl_object<ton::ton_api::engine_validator_getValidatorSessionsInfo>();
td::actor::send_closure(console_, &ValidatorEngineConsole::envelope_send_query, std::move(b), create_promise());
return td::Status::OK();
}
td::Status GetValidatorSessionsInfoQuery::receive(td::BufferSlice data) {
TRY_RESULT_PREFIX(
f, ton::fetch_tl_object<ton::ton_api::engine_validator_validatorSessionsInfo>(data.as_slice(), true),
"received incorrect answer: ");
std::string s = td::json_encode<std::string>(td::ToJson(*f), true);
td::TerminalIO::out() << "---------\n" << s << "--------\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>());

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

@ -1293,25 +1293,6 @@ class GetCollatorOptionsJsonQuery : public Query {
std::string file_name_;
};
class GetValidatorSessionsInfoQuery : public Query {
public:
GetValidatorSessionsInfoQuery(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 "getvalidatorsessions";
}
static std::string get_help() {
return "getvalidatorsessions\tprint info about validator session";
}
std::string name() const override {
return get_name();
}
};
class AddCollatorQuery : public Query {
public:
AddCollatorQuery(td::actor::ActorId<ValidatorEngineConsole> console, Tokenizer tokenizer)

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

@ -150,7 +150,6 @@ void ValidatorEngineConsole::run() {
add_query_runner(std::make_unique<QueryRunnerImpl<SetCollatorOptionsJsonQuery>>());
add_query_runner(std::make_unique<QueryRunnerImpl<ResetCollatorOptionsQuery>>());
add_query_runner(std::make_unique<QueryRunnerImpl<GetCollatorOptionsJsonQuery>>());
add_query_runner(std::make_unique<QueryRunnerImpl<GetValidatorSessionsInfoQuery>>());
add_query_runner(std::make_unique<QueryRunnerImpl<AddCollatorQuery>>());
add_query_runner(std::make_unique<QueryRunnerImpl<AddShardQuery>>());
add_query_runner(std::make_unique<QueryRunnerImpl<DelShardQuery>>());

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

@ -4081,33 +4081,6 @@ void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_showColla
}
}
void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_getValidatorSessionsInfo &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;
}
auto P = td::PromiseCreator::lambda(
[promise = std::move(promise)](
td::Result<ton::tl_object_ptr<ton::ton_api::engine_validator_validatorSessionsInfo>> R) mutable {
if (R.is_error()) {
promise.set_value(create_control_query_error(R.move_as_error()));
} else {
promise.set_value(ton::serialize_tl_object(R.move_as_ok(), true));
}
});
td::actor::send_closure(validator_manager_, &ton::validator::ValidatorManagerInterface::get_validator_sessions_info,
std::move(P));
}
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) {

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

@ -504,8 +504,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_getOverlaysStats &query, td::BufferSlice data,
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_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,

12
validator-session/validator-session.cpp
View file

@ -1206,18 +1206,6 @@ void ValidatorSessionImpl::stats_process_action(td::uint32 node_id, ton_api::val
[](const auto &) {}));
}
void ValidatorSessionImpl::get_session_info(
td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionInfo>> promise) {
std::vector<td::Bits256> next_producers;
for (td::uint32 round = cur_round_; round < cur_round_ + 20; ++round) {
td::uint32 node = description().get_node_by_priority(round, 0);
next_producers.push_back(description().get_source_id(node).bits256_value());
}
promise.set_result(create_tl_object<ton_api::engine_validator_validatorSessionInfo>(
create_tl_block_id_simple(BlockId{}), description().get_source_id(local_idx()).bits256_value(),
cur_round_, std::move(next_producers)));
}
td::actor::ActorOwn<ValidatorSession> ValidatorSession::create(
catchain::CatChainSessionId session_id, ValidatorSessionOptions opts, PublicKeyHash local_id,
std::vector<ValidatorSessionNode> nodes, std::unique_ptr<Callback> callback,

2
validator-session/validator-session.h
View file

@ -110,8 +110,6 @@ class ValidatorSession : public td::actor::Actor {
td::Promise<std::vector<tl_object_ptr<lite_api::liteServer_nonfinal_candidateInfo>>> promise) = 0;
virtual void set_catchain_max_block_delay(double value) = 0;
virtual void get_session_info(td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionInfo>> promise) = 0;
static td::actor::ActorOwn<ValidatorSession> create(
catchain::CatChainSessionId session_id, ValidatorSessionOptions opts, PublicKeyHash local_id,
std::vector<ValidatorSessionNode> nodes, std::unique_ptr<Callback> callback,

2
validator-session/validator-session.hpp
View file

@ -175,8 +175,6 @@ class ValidatorSessionImpl : public ValidatorSession {
ValidatorSessionCandidateId candidate_id);
void stats_process_action(td::uint32 node_id, ton_api::validatorSession_round_Message &action);
void get_session_info(td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionInfo>> promise) override;
public:
ValidatorSessionImpl(catchain::CatChainSessionId session_id, ValidatorSessionOptions opts, PublicKeyHash local_id,
std::vector<ValidatorSessionNode> nodes, std::unique_ptr<Callback> callback,

5
validator/manager-disk.hpp
View file

@ -441,11 +441,6 @@ class ValidatorManagerImpl : public ValidatorManager {
void add_persistent_state_description(td::Ref<PersistentStateDescription> desc) override {
}
void get_validator_sessions_info(
td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionsInfo>> promise) override {
UNREACHABLE();
}
void add_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) override {
UNREACHABLE();
}

4
validator/manager-hardfork.hpp
View file

@ -506,10 +506,6 @@ class ValidatorManagerImpl : public ValidatorManager {
}
void add_persistent_state_description(td::Ref<PersistentStateDescription> desc) override {
}
void get_validator_sessions_info(
td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionsInfo>> promise) override {
UNREACHABLE();
}
void add_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) override {
UNREACHABLE();

33
validator/manager.cpp
View file

@ -3394,39 +3394,6 @@ void ValidatorManagerImpl::update_options(td::Ref<ValidatorManagerOptions> opts)
opts_ = std::move(opts);
}
void ValidatorManagerImpl::get_validator_sessions_info(
td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionsInfo>> promise) {
std::vector<td::actor::ActorId<ValidatorGroup>> groups;
for (const auto& g : validator_groups_) {
groups.push_back(g.second.actor.get());
}
struct IntermediateData {
std::vector<td::actor::ActorId<ValidatorGroup>> groups;
std::vector<tl_object_ptr<ton_api::engine_validator_validatorSessionInfo>> result;
td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionsInfo>> promise;
static void step(IntermediateData data) {
if (data.groups.empty()) {
data.promise.set_result(
create_tl_object<ton_api::engine_validator_validatorSessionsInfo>(std::move(data.result)));
return;
}
auto group = std::move(data.groups.back());
data.groups.pop_back();
auto P = td::PromiseCreator::lambda(
[data =
std::move(data)](td::Result<tl_object_ptr<ton_api::engine_validator_validatorSessionInfo>> R) mutable {
if (R.is_ok()) {
data.result.push_back(R.move_as_ok());
}
step(std::move(data));
});
td::actor::send_closure(group, &ValidatorGroup::get_session_info, std::move(P));
}
};
IntermediateData::step({std::move(groups), {}, std::move(promise)});
}
void ValidatorManagerImpl::add_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) {
if (shard.is_masterchain() || !shard.is_valid_ext()) {
LOG(WARNING) << "cannot collate shard " << shard.to_str();

3
validator/manager.hpp
View file

@ -622,9 +622,6 @@ class ValidatorManagerImpl : public ValidatorManager {
void update_options(td::Ref<ValidatorManagerOptions> opts) override;
void get_validator_sessions_info(
td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionsInfo>> promise) override;
void add_persistent_state_description(td::Ref<PersistentStateDescription> desc) override;
void add_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) override;

19
validator/validator-group.cpp
View file

@ -448,25 +448,6 @@ void ValidatorGroup::get_validator_group_info_for_litequery_cont(
promise.set_result(std::move(result));
}
void ValidatorGroup::get_session_info(
td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionInfo>> promise) {
if (session_.empty() || !started_) {
promise.set_error(td::Status::Error(ErrorCode::notready, "session not started"));
}
auto P = td::PromiseCreator::lambda(
[promise = std::move(promise), block_id = create_next_block_id_simple()](
td::Result<tl_object_ptr<ton_api::engine_validator_validatorSessionInfo>> R) mutable {
if (R.is_error()) {
promise.set_error(R.move_as_error());
return;
}
auto info = R.move_as_ok();
info->current_block_ = create_tl_block_id_simple(block_id);
promise.set_result(std::move(info));
});
td::actor::send_closure(session_, &validatorsession::ValidatorSession::get_session_info, std::move(P));
}
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_) {

2
validator/validator-group.hpp
View file

@ -64,8 +64,6 @@ class ValidatorGroup : public td::actor::Actor {
void get_validator_group_info_for_litequery(
td::Promise<tl_object_ptr<lite_api::liteServer_nonfinal_validatorGroupInfo>> promise);
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);
monitoring_shard_ = apply_blocks;

3
validator/validator.h
View file

@ -302,9 +302,6 @@ class ValidatorManagerInterface : public td::actor::Actor {
virtual void update_options(td::Ref<ValidatorManagerOptions> opts) = 0;
virtual void get_validator_sessions_info(
td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionsInfo>> promise) = 0;
virtual void add_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) = 0;
virtual void del_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) = 0;
};