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

Add "delshard", "delcollator" to validator-engine-console

Browse source
This commit is contained in:
SpyCheese 2022-10-17 13:24:59 +03:00
parent e3823c46f3
commit d4339b839c
13 changed files with 241 additions and 5 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -715,6 +715,8 @@ engine.validator.getValidatorSessionsInfo = engine.validator.ValidatorSessionsIn
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;
engine.validator.delShard shard:tonNode.shardId = engine.validator.Success;
---types---

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

Binary file not shown.

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

@ -1119,3 +1119,44 @@ td::Status AddShardQuery::receive(td::BufferSlice data) {
td::TerminalIO::out() << "successfully added shard\n";
return td::Status::OK();
}
td::Status DelCollatorQuery::run() {
TRY_RESULT_ASSIGN(adnl_id_, tokenizer_.get_token<ton::PublicKeyHash>());
TRY_RESULT_ASSIGN(wc_, tokenizer_.get_token<td::int32>());
TRY_RESULT_ASSIGN(shard_, tokenizer_.get_token<td::int64>());
return td::Status::OK();
}
td::Status DelCollatorQuery::send() {
auto b = ton::create_serialize_tl_object<ton::ton_api::engine_validator_delCollator>(
adnl_id_.tl(), ton::create_tl_shard_id(ton::ShardIdFull(wc_, shard_)));
td::actor::send_closure(console_, &ValidatorEngineConsole::envelope_send_query, std::move(b), create_promise());
return td::Status::OK();
}
td::Status DelCollatorQuery::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 removed collator\n";
return td::Status::OK();
}
td::Status DelShardQuery::run() {
TRY_RESULT_ASSIGN(wc_, tokenizer_.get_token<td::int32>());
TRY_RESULT_ASSIGN(shard_, tokenizer_.get_token<td::int64>());
return td::Status::OK();
}
td::Status DelShardQuery::send() {
auto b = ton::create_serialize_tl_object<ton::ton_api::engine_validator_delShard>(
ton::create_tl_shard_id(ton::ShardIdFull(wc_, shard_)));
td::actor::send_closure(console_, &ValidatorEngineConsole::envelope_send_query, std::move(b), create_promise());
return td::Status::OK();
}
td::Status DelShardQuery::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 removed shard\n";
return td::Status::OK();
}

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

@ -1162,3 +1162,50 @@ class AddShardQuery : public Query {
td::int32 wc_;
td::int64 shard_;
};
class DelCollatorQuery : public Query {
public:
DelCollatorQuery(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 "delcollator";
}
static std::string get_help() {
return "delcollator <adnl_id> <workchain> <shard>\tremove collator with given adnl_id and shard";
}
std::string name() const override {
return get_name();
}
private:
ton::PublicKeyHash adnl_id_;
td::int32 wc_;
td::int64 shard_;
};
class DelShardQuery : public Query {
public:
DelShardQuery(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 "delshard";
}
static std::string get_help() {
return "delshard <workchain> <shard>\tstop monitoring shard";
}
std::string name() const override {
return get_name();
}
private:
td::int32 wc_;
td::int64 shard_;
};

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

@ -418,6 +418,19 @@ td::Result<bool> Config::config_add_collator(ton::PublicKeyHash addr, ton::Shard
return true;
}
td::Result<bool> Config::config_del_collator(ton::PublicKeyHash addr, ton::ShardIdFull shard) {
if (!shard.is_valid_ext()) {
return td::Status::Error(PSTRING() << "invalid shard: " << shard.to_str());
}
Collator c{addr, shard};
auto it = std::find(collators.begin(), collators.end(), c);
if (it == collators.end()) {
return false;
}
collators.erase(it);
return true;
}
td::Result<bool> Config::config_add_full_node_adnl_id(ton::PublicKeyHash id) {
if (full_node == id) {
return false;
@ -548,6 +561,18 @@ td::Result<bool> Config::config_add_shard(ton::ShardIdFull shard) {
return true;
}
td::Result<bool> Config::config_del_shard(ton::ShardIdFull shard) {
if (!shard.is_valid_ext()) {
return td::Status::Error(PSTRING() << "invalid shard " << shard.to_str());
}
auto it = std::find(shards_to_monitor.begin(), shards_to_monitor.end(), shard);
if (it == shards_to_monitor.end()) {
return false;
}
shards_to_monitor.erase(it);
return true;
}
td::Result<bool> Config::config_add_gc(ton::PublicKeyHash key) {
return gc.insert(key).second;
}
@ -3506,6 +3531,85 @@ void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_addShard
});
}
void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_delCollator &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 (!started_) {
promise.set_value(create_control_query_error(td::Status::Error(ton::ErrorCode::notready, "not started")));
return;
}
auto id = ton::PublicKeyHash{query.adnl_id_};
auto shard = ton::create_shard_id(query.shard_);
auto R = config_.config_del_collator(id, shard);
if (R.is_error()) {
promise.set_value(create_control_query_error(R.move_as_error()));
return;
}
if (!R.move_as_ok()) {
promise.set_value(create_control_query_error(td::Status::Error("No such collator")));
return;
}
if (!R.move_as_ok()) {
promise.set_value(ton::serialize_tl_object(ton::create_tl_object<ton::ton_api::engine_validator_success>(), true));
return;
}
set_shard_check_function();
if (!validator_manager_.empty()) {
td::actor::send_closure(validator_manager_, &ton::validator::ValidatorManagerInterface::update_options,
validator_options_);
td::actor::send_closure(validator_manager_, &ton::validator::ValidatorManagerInterface::del_collator,
ton::adnl::AdnlNodeIdShort(id), shard);
}
write_config([promise = std::move(promise)](td::Result<td::Unit> 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(ton::create_tl_object<ton::ton_api::engine_validator_success>(), true));
}
});
}
void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_delShard &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 (!started_) {
promise.set_value(create_control_query_error(td::Status::Error(ton::ErrorCode::notready, "not started")));
return;
}
auto shard = ton::create_shard_id(query.shard_);
auto R = config_.config_del_shard(shard);
if (R.is_error()) {
promise.set_value(create_control_query_error(R.move_as_error()));
return;
}
if (!R.move_as_ok()) {
promise.set_value(create_control_query_error(td::Status::Error("No such shard")));
return;
}
set_shard_check_function();
if (!validator_manager_.empty()) {
td::actor::send_closure(validator_manager_, &ton::validator::ValidatorManagerInterface::update_options,
validator_options_);
}
write_config([promise = std::move(promise)](td::Result<td::Unit> 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(ton::create_tl_object<ton::ton_api::engine_validator_success>(), true));
}
});
}
void ValidatorEngine::process_control_query(td::uint16 port, ton::adnl::AdnlNodeIdShort src,
ton::adnl::AdnlNodeIdShort dst, td::BufferSlice data,
td::Promise<td::BufferSlice> promise) {

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

@ -115,6 +115,7 @@ struct Config {
td::Result<bool> config_add_validator_adnl_id(ton::PublicKeyHash perm_key, ton::PublicKeyHash adnl_id,
ton::UnixTime expire_at);
td::Result<bool> config_add_collator(ton::PublicKeyHash addr, ton::ShardIdFull shard);
td::Result<bool> config_del_collator(ton::PublicKeyHash addr, ton::ShardIdFull shard);
td::Result<bool> config_add_full_node_adnl_id(ton::PublicKeyHash id);
td::Result<bool> config_add_full_node_slave(td::IPAddress addr, ton::PublicKey id);
td::Result<bool> config_add_full_node_master(td::int32 port, ton::PublicKeyHash id);
@ -123,6 +124,7 @@ struct Config {
td::Result<bool> config_add_control_process(ton::PublicKeyHash key, td::int32 port, ton::PublicKeyHash id,
td::uint32 permissions);
td::Result<bool> config_add_shard(ton::ShardIdFull shard);
td::Result<bool> config_del_shard(ton::ShardIdFull shard);
td::Result<bool> config_add_gc(ton::PublicKeyHash key);
td::Result<bool> config_del_network_addr(td::IPAddress addr, std::vector<AdnlCategory> cats,
std::vector<AdnlCategory> prio_cats);
@ -437,6 +439,10 @@ 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_addShard &query, td::BufferSlice data,
ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise);
void run_control_query(ton::ton_api::engine_validator_delCollator &query, td::BufferSlice data,
ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise);
void run_control_query(ton::ton_api::engine_validator_delShard &query, td::BufferSlice data,
ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise);
void run_control_query(ton::ton_api::engine_validator_getPerfTimerStats &query, td::BufferSlice data,
ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise);
template <class T>

10
validator/collator-node.cpp
View file

@ -54,10 +54,20 @@ void CollatorNode::tear_down() {
}
void CollatorNode::add_shard(ShardIdFull shard) {
if (std::find(shards_.begin(), shards_.end(), shard) != shards_.end()) {
return;
}
LOG(INFO) << "Collator node: local_id=" << local_id_ << " , shard=" << shard.to_str();
shards_.push_back(shard);
}
void CollatorNode::del_shard(ShardIdFull shard) {
auto it = std::find(shards_.begin(), shards_.end(), shard);
if (it != shards_.end()) {
shards_.erase(it);
}
}
void CollatorNode::new_masterchain_block_notification(td::Ref<MasterchainState> state) {
std::vector<BlockIdExt> top_blocks = {state->get_block_id()};
std::vector<ShardIdFull> next_shards;

1
validator/collator-node.hpp
View file

@ -32,6 +32,7 @@ class CollatorNode : public td::actor::Actor {
void start_up() override;
void tear_down() override;
void add_shard(ShardIdFull shard);
void del_shard(ShardIdFull shard);
void new_masterchain_block_notification(td::Ref<MasterchainState> state);

3
validator/manager-disk.hpp
View file

@ -395,6 +395,9 @@ class ValidatorManagerImpl : public ValidatorManager {
void add_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) override {
UNREACHABLE();
}
void del_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) override {
UNREACHABLE();
}
void update_options(td::Ref<ValidatorManagerOptions> opts) override {
opts_ = std::move(opts);

3
validator/manager-hardfork.hpp
View file

@ -454,6 +454,9 @@ class ValidatorManagerImpl : public ValidatorManager {
void add_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) override {
UNREACHABLE();
}
void del_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) override {
UNREACHABLE();
}
void update_options(td::Ref<ValidatorManagerOptions> opts) override {
opts_ = std::move(opts);
}

21
validator/manager.cpp
View file

@ -1795,7 +1795,7 @@ void ValidatorManagerImpl::new_masterchain_block() {
last_masterchain_block_handle_, last_masterchain_state_);
}
for (auto &c : collator_nodes_) {
td::actor::send_closure(c.second, &CollatorNode::new_masterchain_block_notification, last_masterchain_state_);
td::actor::send_closure(c.second.actor, &CollatorNode::new_masterchain_block_notification, last_masterchain_state_);
}
if (last_masterchain_seqno_ % 1024 == 0) {
@ -2722,10 +2722,23 @@ void ValidatorManagerImpl::get_validator_sessions_info(
void ValidatorManagerImpl::add_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) {
auto it = collator_nodes_.find(id);
if (it == collator_nodes_.end()) {
auto actor = td::actor::create_actor<CollatorNode>("collatornode", id, actor_id(this), adnl_, rldp_);
it = collator_nodes_.emplace(id, std::move(actor)).first;
it = collator_nodes_.emplace(id, Collator()).first;
it->second.actor = td::actor::create_actor<CollatorNode>("collatornode", id, actor_id(this), adnl_, rldp_);
}
it->second.shards.insert(shard);
td::actor::send_closure(it->second.actor, &CollatorNode::add_shard, shard);
}
void ValidatorManagerImpl::del_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) {
auto it = collator_nodes_.find(id);
if (it == collator_nodes_.end()) {
return;
}
td::actor::send_closure(it->second.actor, &CollatorNode::del_shard, shard);
it->second.shards.erase(shard);
if (it->second.shards.empty()) {
collator_nodes_.erase(it);
}
td::actor::send_closure(it->second, &CollatorNode::add_shard, shard);
}
void ValidatorManagerImpl::update_options(td::Ref<ValidatorManagerOptions> opts) {

7
validator/manager.hpp
View file

@ -563,6 +563,7 @@ class ValidatorManagerImpl : public ValidatorManager {
void add_persistent_state_description(td::Ref<PersistentStateDescription> desc) override;
void add_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) override;
void del_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) override;
void update_options(td::Ref<ValidatorManagerOptions> opts) override;
private:
@ -639,7 +640,11 @@ class ValidatorManagerImpl : public ValidatorManager {
std::map<BlockSeqno, WaitList<td::actor::Actor, td::Unit>> shard_client_waiters_;
std::map<adnl::AdnlNodeIdShort, td::actor::ActorOwn<CollatorNode>> collator_nodes_;
struct Collator {
td::actor::ActorOwn<CollatorNode> actor;
std::set<ShardIdFull> shards;
};
std::map<adnl::AdnlNodeIdShort, Collator> collator_nodes_;
std::set<ShardIdFull> extra_active_shards_;
std::map<ShardIdFull, BlockSeqno> last_validated_blocks_;

1
validator/validator.h
View file

@ -238,6 +238,7 @@ class ValidatorManagerInterface : public td::actor::Actor {
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;
virtual void update_options(td::Ref<ValidatorManagerOptions> opts) = 0;
};