mirror of
https://github.com/ton-blockchain/ton
synced 2025-02-14 20:22:19 +00:00
Update validator config format; partial liteservers and their support in liteclient
This commit is contained in:
SpyCheese
parent
a792565afa
commit
51e6885f2c
12 changed files with 657 additions and 363 deletions
|
|
@ -38,6 +38,9 @@
|
|||
#include "td/utils/TsFileLog.h"
|
||||
#include "td/utils/Random.h"
|
||||
|
||||
#include "ton/ton-tl.hpp"
|
||||
#include "tl/tl_json.h"
|
||||
|
||||
#include "memprof/memprof.h"
|
||||
|
||||
#if TD_DARWIN || TD_LINUX
|
||||
|
|
@ -54,7 +57,7 @@ Config::Config() {
|
|||
out_port = 3278;
|
||||
}
|
||||
|
||||
Config::Config(ton::ton_api::engine_validator_config &config) {
|
||||
Config::Config(const ton::ton_api::engine_validator_config_v2 &config) {
|
||||
out_port = static_cast<td::uint16>(config.out_port_);
|
||||
if (!out_port) {
|
||||
out_port = 3278;
|
||||
|
|
@ -121,7 +124,7 @@ Config::Config(ton::ton_api::engine_validator_config &config) {
|
|||
}
|
||||
}
|
||||
|
||||
ton::tl_object_ptr<ton::ton_api::engine_validator_config> Config::tl() const {
|
||||
ton::tl_object_ptr<ton::ton_api::engine_validator_Config> Config::tl() const {
|
||||
std::vector<ton::tl_object_ptr<ton::ton_api::engine_Addr>> addrs_vec;
|
||||
for (auto &x : addrs) {
|
||||
if (x.second.proxy) {
|
||||
|
|
@ -146,7 +149,7 @@ ton::tl_object_ptr<ton::ton_api::engine_validator_config> Config::tl() const {
|
|||
dht_vec.push_back(ton::create_tl_object<ton::ton_api::engine_dht>(x.tl()));
|
||||
}
|
||||
|
||||
std::vector<ton::tl_object_ptr<ton::ton_api::engine_Validator>> val_vec;
|
||||
std::vector<ton::tl_object_ptr<ton::ton_api::engine_validator>> val_vec;
|
||||
|
||||
std::vector<ton::tl_object_ptr<ton::ton_api::engine_validator_fullNodeSlave>> full_node_slaves_vec;
|
||||
std::vector<ton::tl_object_ptr<ton::ton_api::engine_validator_fullNodeMaster>> full_node_masters_vec;
|
||||
|
|
@ -597,14 +600,14 @@ void DhtServer::load_config(td::Promise<td::Unit> promise) {
|
|||
}
|
||||
auto conf_json = conf_json_R.move_as_ok();
|
||||
|
||||
ton::ton_api::engine_validator_config conf;
|
||||
auto S = ton::ton_api::from_json(conf, conf_json.get_object());
|
||||
ton::tl_object_ptr<ton::ton_api::engine_validator_Config> conf;
|
||||
auto S = td::from_json(conf, std::move(conf_json));
|
||||
if (S.is_error()) {
|
||||
promise.set_error(S.move_as_error_prefix("json does not fit TL scheme"));
|
||||
return;
|
||||
}
|
||||
|
||||
config_ = Config{conf};
|
||||
config_ = Config{*ton::unpack_engine_validator_config(std::move(conf))};
|
||||
|
||||
td::MultiPromise mp;
|
||||
auto ig = mp.init_guard();
|
||||
|
|
|
|||
|
|
@ -91,10 +91,10 @@ struct Config {
|
|||
td::Result<bool> config_del_control_process(td::int32 port, ton::PublicKeyHash id);
|
||||
td::Result<bool> config_del_gc(ton::PublicKeyHash key);
|
||||
|
||||
ton::tl_object_ptr<ton::ton_api::engine_validator_config> tl() const;
|
||||
ton::tl_object_ptr<ton::ton_api::engine_validator_Config> tl() const;
|
||||
|
||||
Config();
|
||||
Config(ton::ton_api::engine_validator_config &config);
|
||||
Config(const ton::ton_api::engine_validator_config_v2 &config);
|
||||
};
|
||||
|
||||
class DhtServer : public td::actor::Actor {
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -45,22 +45,41 @@ class TestNode : public td::actor::Actor {
|
|||
min_ls_version = 0x101,
|
||||
min_ls_capabilities = 1
|
||||
}; // server version >= 1.1, capabilities at least +1 = build proof chains
|
||||
td::actor::ActorOwn<ton::adnl::AdnlExtClient> client_;
|
||||
td::actor::ActorOwn<td::TerminalIO> io_;
|
||||
|
||||
struct LiteServer {
|
||||
td::IPAddress addr;
|
||||
ton::PublicKey public_key;
|
||||
bool is_full = true;
|
||||
std::vector<ton::ShardIdFull> shards;
|
||||
|
||||
td::actor::ActorOwn<ton::adnl::AdnlExtClient> client;
|
||||
bool client_ready = false;
|
||||
std::vector<td::Promise<td::Unit>> wait_client_ready;
|
||||
|
||||
int max_common_prefix(ton::ShardIdFull shard) const;
|
||||
bool supports_shard(ton::ShardIdFull shard) const;
|
||||
};
|
||||
std::vector<LiteServer> servers_;
|
||||
|
||||
td::int32 single_liteserver_idx_ = -1;
|
||||
td::IPAddress single_remote_addr_;
|
||||
ton::PublicKey single_remote_public_key_;
|
||||
|
||||
std::map<ton::ShardIdFull, td::int32> shard_server_idx_cached_;
|
||||
|
||||
bool readline_enabled_ = true;
|
||||
bool server_ok_ = false;
|
||||
td::int32 liteserver_idx_ = -1;
|
||||
int print_limit_ = 1024;
|
||||
|
||||
bool ready_ = false;
|
||||
bool inited_ = false;
|
||||
std::string db_root_;
|
||||
|
||||
int server_time_ = 0;
|
||||
int server_time_got_at_ = 0;
|
||||
int server_version_ = 0;
|
||||
long long server_capabilities_ = 0;
|
||||
// mc_server is the server for queries to masterchain
|
||||
int mc_server_idx_ = -1;
|
||||
int mc_server_time_ = 0;
|
||||
int mc_server_time_got_at_ = 0;
|
||||
int mc_server_version_ = 0;
|
||||
long long mc_server_capabilities_ = 0;
|
||||
bool mc_server_ok_ = false;
|
||||
|
||||
ton::ZeroStateIdExt zstate_id_;
|
||||
ton::BlockIdExt mc_last_id_;
|
||||
|
|
@ -75,9 +94,6 @@ class TestNode : public td::actor::Actor {
|
|||
const char *parse_ptr_, *parse_end_;
|
||||
td::Status error_;
|
||||
|
||||
td::IPAddress remote_addr_;
|
||||
ton::PublicKey remote_public_key_;
|
||||
|
||||
std::vector<ton::BlockIdExt> known_blk_ids_;
|
||||
std::size_t shown_blk_ids_ = 0;
|
||||
|
||||
|
|
@ -88,8 +104,6 @@ class TestNode : public td::actor::Actor {
|
|||
|
||||
std::map<td::Bits256, Ref<vm::Cell>> cell_cache_;
|
||||
|
||||
std::unique_ptr<ton::adnl::AdnlExtClient::Callback> make_callback();
|
||||
|
||||
using creator_stats_func_t =
|
||||
std::function<bool(const td::Bits256&, const block::DiscountedCounter&, const block::DiscountedCounter&)>;
|
||||
|
||||
|
|
@ -182,8 +196,8 @@ class TestNode : public td::actor::Actor {
|
|||
void got_server_mc_block_id(ton::BlockIdExt blkid, ton::ZeroStateIdExt zstateid, int created_at);
|
||||
void got_server_mc_block_id_ext(ton::BlockIdExt blkid, ton::ZeroStateIdExt zstateid, int mode, int version,
|
||||
long long capabilities, int last_utime, int server_now);
|
||||
void set_server_version(td::int32 version, td::int64 capabilities);
|
||||
void set_server_time(int server_utime);
|
||||
void set_mc_server_version(td::int32 version, td::int64 capabilities);
|
||||
void set_mc_server_time(int server_utime);
|
||||
bool request_block(ton::BlockIdExt blkid);
|
||||
bool request_state(ton::BlockIdExt blkid);
|
||||
void got_mc_block(ton::BlockIdExt blkid, td::BufferSlice data);
|
||||
|
|
@ -358,16 +372,6 @@ class TestNode : public td::actor::Actor {
|
|||
static const tlb::TypenameLookup& get_tlb_dict();
|
||||
|
||||
public:
|
||||
void conn_ready() {
|
||||
LOG(ERROR) << "conn ready";
|
||||
ready_ = true;
|
||||
if (!inited_) {
|
||||
run_init_queries();
|
||||
}
|
||||
}
|
||||
void conn_closed() {
|
||||
ready_ = false;
|
||||
}
|
||||
void set_global_config(std::string str) {
|
||||
global_config_ = str;
|
||||
}
|
||||
|
|
@ -378,10 +382,10 @@ class TestNode : public td::actor::Actor {
|
|||
readline_enabled_ = value;
|
||||
}
|
||||
void set_liteserver_idx(td::int32 idx) {
|
||||
liteserver_idx_ = idx;
|
||||
single_liteserver_idx_ = idx;
|
||||
}
|
||||
void set_remote_addr(td::IPAddress addr) {
|
||||
remote_addr_ = addr;
|
||||
single_remote_addr_ = addr;
|
||||
}
|
||||
void set_public_key(td::BufferSlice file_name) {
|
||||
auto R = [&]() -> td::Result<ton::PublicKey> {
|
||||
|
|
@ -392,7 +396,7 @@ class TestNode : public td::actor::Actor {
|
|||
if (R.is_error()) {
|
||||
LOG(FATAL) << "bad server public key: " << R.move_as_error();
|
||||
}
|
||||
remote_public_key_ = R.move_as_ok();
|
||||
single_remote_public_key_ = R.move_as_ok();
|
||||
}
|
||||
void decode_public_key(td::BufferSlice b64_key) {
|
||||
auto R = [&]() -> td::Result<ton::PublicKey> {
|
||||
|
|
@ -404,7 +408,7 @@ class TestNode : public td::actor::Actor {
|
|||
if (R.is_error()) {
|
||||
LOG(FATAL) << "bad b64 server public key: " << R.move_as_error();
|
||||
}
|
||||
remote_public_key_ = R.move_as_ok();
|
||||
single_remote_public_key_ = R.move_as_ok();
|
||||
}
|
||||
void set_fail_timeout(td::Timestamp ts) {
|
||||
fail_timeout_ = ts;
|
||||
|
|
@ -439,7 +443,18 @@ class TestNode : public td::actor::Actor {
|
|||
|
||||
void got_result(td::Result<td::BufferSlice> R, td::Promise<td::BufferSlice> promise);
|
||||
void after_got_result(bool ok);
|
||||
bool envelope_send_query(td::BufferSlice query, td::Promise<td::BufferSlice> promise);
|
||||
bool envelope_send_query_to_any(td::BufferSlice query, td::Promise<td::BufferSlice> promise);
|
||||
bool envelope_send_query_to_shard(ton::ShardIdFull shard, td::BufferSlice query,
|
||||
td::Promise<td::BufferSlice> promise);
|
||||
bool envelope_send_query_to_account(ton::AccountIdPrefixFull prefix, td::BufferSlice query,
|
||||
td::Promise<td::BufferSlice> promise);
|
||||
|
||||
bool envelope_send_query_to_server(td::int32 server_idx, td::BufferSlice query, td::Promise<td::BufferSlice> promise);
|
||||
|
||||
void start_client(int server_idx);
|
||||
void conn_ready(int server_idx);
|
||||
void conn_closed(int server_idx);
|
||||
|
||||
void parse_line(td::BufferSlice data);
|
||||
|
||||
TestNode() {
|
||||
|
|
|
|||
|
|
@ -364,6 +364,7 @@ tonNode.blockSignature who:int256 signature:bytes = tonNode.BlockSignature;
|
|||
tonNode.blockId workchain:int shard:long seqno:int = tonNode.BlockId;
|
||||
tonNode.blockIdExt workchain:int shard:long seqno:int root_hash:int256 file_hash:int256 = tonNode.BlockIdExt;
|
||||
tonNode.zeroStateIdExt workchain:int root_hash:int256 file_hash:int256 = tonNode.ZeroStateIdExt;
|
||||
tonNode.shardId workchain:int shard:long = tonNode.ShardId;
|
||||
|
||||
tonNode.blockDescriptionEmpty = tonNode.BlockDescription;
|
||||
tonNode.blockDescription id:tonNode.blockIdExt = tonNode.BlockDescription;
|
||||
|
|
@ -568,7 +569,8 @@ validator.config.global zero_state:tonNode.blockIdExt init_block:tonNode.blockId
|
|||
config.global adnl:adnl.config.global dht:dht.config.global validator:validator.config.global = config.Global;
|
||||
|
||||
liteserver.desc id:PublicKey ip:int port:int = liteserver.Desc;
|
||||
liteclient.config.global liteservers:(vector liteserver.desc) validator:validator.config.global = liteclient.config.Global;
|
||||
liteserver.descV2 id:PublicKey ip:int port:int shards:(vector tonNode.shardId) = liteserver.Desc;
|
||||
liteclient.config.global liteservers:(vector liteserver.Desc) validator:validator.config.global = liteclient.config.Global;
|
||||
|
||||
engine.adnl id:int256 category:int = engine.Adnl;
|
||||
engine.addr ip:int port:int categories:(vector int) priority_categories:(vector int) = engine.Addr;
|
||||
|
|
@ -578,7 +580,7 @@ engine.dht id:int256 = engine.Dht;
|
|||
engine.validatorTempKey key:int256 expire_at:int = engine.ValidatorTempKey;
|
||||
engine.validatorAdnlAddress id:int256 expire_at:int = engine.ValidatorAdnlAddress;
|
||||
engine.validator id:int256 temp_keys:(vector engine.validatorTempKey) adnl_addrs:(vector engine.validatorAdnlAddress) election_date:int expire_at:int = engine.Validator;
|
||||
engine.collator adnl_id:int256 workchain:int shard:long = engine.Validator;
|
||||
engine.collator adnl_id:int256 shard:tonNode.shardId = engine.Collator;
|
||||
engine.liteServer id:int256 port:int = engine.LiteServer;
|
||||
engine.controlProcess id:int256 permissions:int = engine.ControlProcess;
|
||||
engine.controlInterface id:int256 port:int allowed:(vector engine.controlProcess) = engine.ControlInterface;
|
||||
|
|
@ -592,7 +594,16 @@ engine.validator.config out_port:int addrs:(vector engine.Addr) adnl:(vector eng
|
|||
validators:(vector engine.Validator) fullnode:int256 fullnodeslaves:(vector engine.validator.fullNodeSlave)
|
||||
fullnodemasters:(vector engine.validator.fullNodeMaster)
|
||||
liteservers:(vector engine.liteServer) control:(vector engine.controlInterface)
|
||||
gc:engine.gc = engine.validator.Config;
|
||||
gc:engine.gc = engine.validator.Config;
|
||||
|
||||
engine.validator.config_v2 out_port:int addrs:(vector engine.Addr) adnl:(vector engine.adnl)
|
||||
dht:(vector engine.dht)
|
||||
validators:(vector engine.validator) collators:(vector engine.collator)
|
||||
fullnode:int256 fullnodeslaves:(vector engine.validator.fullNodeSlave)
|
||||
fullnodemasters:(vector engine.validator.fullNodeMaster)
|
||||
liteservers:(vector engine.liteServer) control:(vector engine.controlInterface)
|
||||
shards_to_monitor:(vector tonNode.shardId)
|
||||
gc:engine.gc = engine.validator.Config;
|
||||
|
||||
---functions---
|
||||
---types---
|
||||
|
|
@ -697,7 +708,8 @@ 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 workchain:int shard:long = engine.validator.Success;
|
||||
engine.validator.addCollator adnl_id:int256 shard:tonNode.shardId = engine.validator.Success;
|
||||
engine.validator.addShard shard:tonNode.shardId = engine.validator.Success;
|
||||
|
||||
---types---
|
||||
|
||||
|
|
|
|||
Binary file not shown.
|
|
@ -19,7 +19,8 @@
|
|||
#pragma once
|
||||
|
||||
#include "ton-types.h"
|
||||
#include "auto/tl/ton_api.h"
|
||||
#include "auto/tl/ton_api.hpp"
|
||||
#include "td/utils/overloaded.h"
|
||||
|
||||
namespace ton {
|
||||
|
||||
|
|
@ -53,4 +54,31 @@ inline ZeroStateIdExt create_zero_state_id(tl_object_ptr<ton_api::tonNode_zeroSt
|
|||
return ZeroStateIdExt{B->workchain_, B->root_hash_, B->file_hash_};
|
||||
}
|
||||
|
||||
inline ShardIdFull create_shard_id(const tl_object_ptr<ton_api::tonNode_shardId> &s) {
|
||||
return ShardIdFull{s->workchain_, static_cast<td::uint64>(s->shard_)};
|
||||
}
|
||||
|
||||
inline tl_object_ptr<ton_api::tonNode_shardId> create_tl_shard_id(const ShardIdFull &s) {
|
||||
return create_tl_object<ton_api::tonNode_shardId>(s.workchain, s.shard);
|
||||
}
|
||||
|
||||
inline tl_object_ptr<ton_api::engine_validator_config_v2> unpack_engine_validator_config(
|
||||
tl_object_ptr<ton_api::engine_validator_Config> config) {
|
||||
tl_object_ptr<ton_api::engine_validator_config_v2> res;
|
||||
ton_api::downcast_call(*config, td::overloaded(
|
||||
[&](ton_api::engine_validator_config &c) {
|
||||
res = create_tl_object<ton_api::engine_validator_config_v2>(
|
||||
c.out_port_, std::move(c.addrs_), std::move(c.adnl_), std::move(c.dht_),
|
||||
std::move(c.validators_),
|
||||
std::vector<tl_object_ptr<ton_api::engine_collator>>(), c.fullnode_,
|
||||
std::move(c.fullnodeslaves_), std::move(c.fullnodemasters_),
|
||||
std::move(c.liteservers_), std::move(c.control_),
|
||||
std::vector<tl_object_ptr<ton_api::tonNode_shardId>>(), std::move(c.gc_));
|
||||
},
|
||||
[&](ton_api::engine_validator_config_v2 &c) {
|
||||
res = std::make_unique<ton_api::engine_validator_config_v2>(std::move(c));
|
||||
}));
|
||||
return res;
|
||||
}
|
||||
|
||||
} // namespace ton
|
||||
|
|
|
|||
|
|
@ -1101,7 +1101,7 @@ td::Status AddCollatorQuery::run() {
|
|||
|
||||
td::Status AddCollatorQuery::send() {
|
||||
auto b = ton::create_serialize_tl_object<ton::ton_api::engine_validator_addCollator>(
|
||||
adnl_id_.tl(), wc_, shard_);
|
||||
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();
|
||||
}
|
||||
|
|
@ -1112,3 +1112,23 @@ td::Status AddCollatorQuery::receive(td::BufferSlice data) {
|
|||
td::TerminalIO::out() << "successfully added collator\n";
|
||||
return td::Status::OK();
|
||||
}
|
||||
|
||||
td::Status AddShardQuery::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 AddShardQuery::send() {
|
||||
auto b = ton::create_serialize_tl_object<ton::ton_api::engine_validator_addShard>(
|
||||
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 AddShardQuery::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 added shard\n";
|
||||
return td::Status::OK();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1187,3 +1187,26 @@ class AddCollatorQuery : public Query {
|
|||
td::int32 wc_;
|
||||
td::int64 shard_;
|
||||
};
|
||||
|
||||
class AddShardQuery : public Query {
|
||||
public:
|
||||
AddShardQuery(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 "addshard";
|
||||
}
|
||||
static std::string get_help() {
|
||||
return "addshard <workchain> <shard>\tstart monitoring shard";
|
||||
}
|
||||
std::string name() const override {
|
||||
return get_name();
|
||||
}
|
||||
|
||||
private:
|
||||
td::int32 wc_;
|
||||
td::int64 shard_;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -145,6 +145,7 @@ void ValidatorEngineConsole::run() {
|
|||
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>>());
|
||||
}
|
||||
|
||||
bool ValidatorEngineConsole::envelope_send_query(td::BufferSlice query, td::Promise<td::BufferSlice> promise) {
|
||||
|
|
|
|||
|
|
@ -54,6 +54,7 @@
|
|||
#include "td/utils/Random.h"
|
||||
|
||||
#include "auto/tl/lite_api.h"
|
||||
#include "tl/tl_json.h"
|
||||
|
||||
#include "memprof/memprof.h"
|
||||
|
||||
|
|
@ -74,7 +75,7 @@ Config::Config() {
|
|||
full_node = ton::PublicKeyHash::zero();
|
||||
}
|
||||
|
||||
Config::Config(ton::ton_api::engine_validator_config &config) {
|
||||
Config::Config(const ton::ton_api::engine_validator_config_v2 &config) {
|
||||
full_node = ton::PublicKeyHash::zero();
|
||||
out_port = static_cast<td::uint16>(config.out_port_);
|
||||
if (!out_port) {
|
||||
|
|
@ -87,7 +88,7 @@ Config::Config(ton::ton_api::engine_validator_config &config) {
|
|||
std::vector<AdnlCategory> categories;
|
||||
std::vector<AdnlCategory> priority_categories;
|
||||
ton::ton_api::downcast_call(
|
||||
*addr.get(),
|
||||
*addr,
|
||||
td::overloaded(
|
||||
[&](const ton::ton_api::engine_addr &obj) {
|
||||
in_ip.init_ipv4_port(td::IPAddress::ipv4_to_str(obj.ip_), static_cast<td::uint16>(obj.port_)).ensure();
|
||||
|
|
@ -125,24 +126,20 @@ Config::Config(ton::ton_api::engine_validator_config &config) {
|
|||
for (auto &dht : config.dht_) {
|
||||
config_add_dht_node(ton::PublicKeyHash{dht->id_}).ensure();
|
||||
}
|
||||
for (auto &v : config.validators_) {
|
||||
ton::ton_api::downcast_call(
|
||||
*v, td::overloaded(
|
||||
[&](ton::ton_api::engine_validator &val) {
|
||||
auto key = ton::PublicKeyHash{val.id_};
|
||||
config_add_validator_permanent_key(key, val.election_date_, val.expire_at_).ensure();
|
||||
for (auto &temp : val.temp_keys_) {
|
||||
config_add_validator_temp_key(key, ton::PublicKeyHash{temp->key_}, temp->expire_at_).ensure();
|
||||
}
|
||||
for (auto &adnl : val.adnl_addrs_) {
|
||||
config_add_validator_adnl_id(key, ton::PublicKeyHash{adnl->id_}, adnl->expire_at_).ensure();
|
||||
}
|
||||
},
|
||||
[&](ton::ton_api::engine_collator &col) {
|
||||
auto key = ton::PublicKeyHash{col.adnl_id_};
|
||||
ton::ShardIdFull shard(col.workchain_, col.shard_);
|
||||
config_add_collator(key, shard).ensure();
|
||||
}));
|
||||
for (auto &val : config.validators_) {
|
||||
auto key = ton::PublicKeyHash{val->id_};
|
||||
config_add_validator_permanent_key(key, val->election_date_, val->expire_at_).ensure();
|
||||
for (auto &temp : val->temp_keys_) {
|
||||
config_add_validator_temp_key(key, ton::PublicKeyHash{temp->key_}, temp->expire_at_).ensure();
|
||||
}
|
||||
for (auto &adnl : val->adnl_addrs_) {
|
||||
config_add_validator_adnl_id(key, ton::PublicKeyHash{adnl->id_}, adnl->expire_at_).ensure();
|
||||
}
|
||||
}
|
||||
for (auto &col : config.collators_) {
|
||||
auto key = ton::PublicKeyHash{col->adnl_id_};
|
||||
ton::ShardIdFull shard = ton::create_shard_id(col->shard_);
|
||||
config_add_collator(key, shard).ensure();
|
||||
}
|
||||
config_add_full_node_adnl_id(ton::PublicKeyHash{config.fullnode_}).ensure();
|
||||
|
||||
|
|
@ -169,6 +166,10 @@ Config::Config(ton::ton_api::engine_validator_config &config) {
|
|||
}
|
||||
}
|
||||
|
||||
for (auto &shard : config.shards_to_monitor_) {
|
||||
config_add_shard(ton::create_shard_id(shard)).ensure();
|
||||
}
|
||||
|
||||
if (config.gc_) {
|
||||
for (auto &gc : config.gc_->ids_) {
|
||||
config_add_gc(ton::PublicKeyHash{gc}).ensure();
|
||||
|
|
@ -176,7 +177,7 @@ Config::Config(ton::ton_api::engine_validator_config &config) {
|
|||
}
|
||||
}
|
||||
|
||||
ton::tl_object_ptr<ton::ton_api::engine_validator_config> Config::tl() const {
|
||||
ton::tl_object_ptr<ton::ton_api::engine_validator_config_v2> Config::tl() const {
|
||||
std::vector<ton::tl_object_ptr<ton::ton_api::engine_Addr>> addrs_vec;
|
||||
for (auto &x : addrs) {
|
||||
if (x.second.proxy) {
|
||||
|
|
@ -201,7 +202,7 @@ ton::tl_object_ptr<ton::ton_api::engine_validator_config> Config::tl() const {
|
|||
dht_vec.push_back(ton::create_tl_object<ton::ton_api::engine_dht>(x.tl()));
|
||||
}
|
||||
|
||||
std::vector<ton::tl_object_ptr<ton::ton_api::engine_Validator>> val_vec;
|
||||
std::vector<ton::tl_object_ptr<ton::ton_api::engine_validator>> val_vec;
|
||||
for (auto &val : validators) {
|
||||
std::vector<ton::tl_object_ptr<ton::ton_api::engine_validatorTempKey>> temp_vec;
|
||||
for (auto &t : val.second.temp_keys) {
|
||||
|
|
@ -214,9 +215,10 @@ ton::tl_object_ptr<ton::ton_api::engine_validator_config> Config::tl() const {
|
|||
val_vec.push_back(ton::create_tl_object<ton::ton_api::engine_validator>(
|
||||
val.first.tl(), std::move(temp_vec), std::move(adnl_val_vec), val.second.election_date, val.second.expire_at));
|
||||
}
|
||||
std::vector<ton::tl_object_ptr<ton::ton_api::engine_collator>> col_vec;
|
||||
for (auto &col : collators) {
|
||||
val_vec.push_back(ton::create_tl_object<ton::ton_api::engine_collator>(
|
||||
col.adnl_id.tl(), col.shard.workchain, col.shard.shard));
|
||||
col_vec.push_back(
|
||||
ton::create_tl_object<ton::ton_api::engine_collator>(col.adnl_id.tl(), ton::create_tl_shard_id(col.shard)));
|
||||
}
|
||||
|
||||
std::vector<ton::tl_object_ptr<ton::ton_api::engine_validator_fullNodeSlave>> full_node_slaves_vec;
|
||||
|
|
@ -245,14 +247,19 @@ ton::tl_object_ptr<ton::ton_api::engine_validator_config> Config::tl() const {
|
|||
std::move(control_proc_vec)));
|
||||
}
|
||||
|
||||
std::vector<ton::tl_object_ptr<ton::ton_api::tonNode_shardId>> shards_vec;
|
||||
for (auto &shard : shards_to_monitor) {
|
||||
shards_vec.push_back(ton::create_tl_shard_id(shard));
|
||||
}
|
||||
|
||||
auto gc_vec = ton::create_tl_object<ton::ton_api::engine_gc>(std::vector<td::Bits256>{});
|
||||
for (auto &id : gc) {
|
||||
gc_vec->ids_.push_back(id.tl());
|
||||
}
|
||||
return ton::create_tl_object<ton::ton_api::engine_validator_config>(
|
||||
out_port, std::move(addrs_vec), std::move(adnl_vec), std::move(dht_vec), std::move(val_vec), full_node.tl(),
|
||||
std::move(full_node_slaves_vec), std::move(full_node_masters_vec), std::move(liteserver_vec),
|
||||
std::move(control_vec), std::move(gc_vec));
|
||||
return ton::create_tl_object<ton::ton_api::engine_validator_config_v2>(
|
||||
out_port, std::move(addrs_vec), std::move(adnl_vec), std::move(dht_vec), std::move(val_vec), std::move(col_vec),
|
||||
full_node.tl(), std::move(full_node_slaves_vec), std::move(full_node_masters_vec), std::move(liteserver_vec),
|
||||
std::move(control_vec), std::move(shards_vec), std::move(gc_vec));
|
||||
}
|
||||
|
||||
td::Result<bool> Config::config_add_network_addr(td::IPAddress in_ip, td::IPAddress out_ip,
|
||||
|
|
@ -527,6 +534,17 @@ td::Result<bool> Config::config_add_control_process(ton::PublicKeyHash key, td::
|
|||
}
|
||||
}
|
||||
|
||||
td::Result<bool> Config::config_add_shard(ton::ShardIdFull shard) {
|
||||
if (!shard.is_valid_ext()) {
|
||||
return td::Status::Error(PSTRING() << "invalid shard " << shard.to_str());
|
||||
}
|
||||
if (std::find(shards_to_monitor.begin(), shards_to_monitor.end(), shard) != shards_to_monitor.end()) {
|
||||
return false;
|
||||
}
|
||||
shards_to_monitor.push_back(shard);
|
||||
return true;
|
||||
}
|
||||
|
||||
td::Result<bool> Config::config_add_gc(ton::PublicKeyHash key) {
|
||||
return gc.insert(key).second;
|
||||
}
|
||||
|
|
@ -1393,6 +1411,11 @@ void ValidatorEngine::init_validator_options() {
|
|||
for (const auto& c : config_.collators) {
|
||||
shards.push_back(c.shard);
|
||||
}
|
||||
for (const auto& s : config_.shards_to_monitor) {
|
||||
shards.push_back(s);
|
||||
}
|
||||
std::sort(shards.begin(), shards.end());
|
||||
shards.erase(std::unique(shards.begin(), shards.end()), shards.end());
|
||||
validator_options_.write().set_shard_check_function(
|
||||
[shards = std::move(shards)](ton::ShardIdFull shard, ton::CatchainSeqno cc_seqno,
|
||||
ton::validator::ValidatorManagerOptions::ShardCheckMode mode) -> bool {
|
||||
|
|
@ -1643,14 +1666,14 @@ void ValidatorEngine::load_config(td::Promise<td::Unit> promise) {
|
|||
}
|
||||
auto conf_json = conf_json_R.move_as_ok();
|
||||
|
||||
ton::ton_api::engine_validator_config conf;
|
||||
auto S = ton::ton_api::from_json(conf, conf_json.get_object());
|
||||
ton::tl_object_ptr<ton::ton_api::engine_validator_Config> conf;
|
||||
auto S = td::from_json(conf, std::move(conf_json));
|
||||
if (S.is_error()) {
|
||||
promise.set_error(S.move_as_error_prefix("json does not fit TL scheme"));
|
||||
return;
|
||||
}
|
||||
|
||||
config_ = Config{conf};
|
||||
config_ = Config{*ton::unpack_engine_validator_config(std::move(conf))};
|
||||
|
||||
td::MultiPromise mp;
|
||||
auto ig = mp.init_guard();
|
||||
|
|
@ -3471,15 +3494,10 @@ void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_addCollat
|
|||
}
|
||||
|
||||
auto id = ton::PublicKeyHash{query.adnl_id_};
|
||||
auto shard = ton::ShardIdFull(query.workchain_, query.shard_);
|
||||
if (!shard.is_valid_ext()) {
|
||||
promise.set_value(create_control_query_error(td::Status::Error(ton::ErrorCode::error, "invalid shard")));
|
||||
return;
|
||||
}
|
||||
|
||||
auto shard = ton::create_shard_id(query.shard_);
|
||||
auto R = config_.config_add_collator(id, shard);
|
||||
if (R.is_error()) {
|
||||
promise.set_value(create_control_query_error(td::Status::Error(ton::ErrorCode::error, "not authorized")));
|
||||
promise.set_value(create_control_query_error(R.move_as_error()));
|
||||
return;
|
||||
}
|
||||
if (!R.move_as_ok()) {
|
||||
|
|
@ -3499,6 +3517,27 @@ void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_addCollat
|
|||
});
|
||||
}
|
||||
|
||||
void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_addShard &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_add_shard(shard);
|
||||
if (R.is_error()) {
|
||||
promise.set_value(create_control_query_error(R.move_as_error()));
|
||||
return;
|
||||
}
|
||||
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) {
|
||||
|
|
@ -3532,7 +3571,7 @@ void ValidatorEngine::process_control_query(td::uint16 port, ton::adnl::AdnlNode
|
|||
}
|
||||
auto f = F.move_as_ok();
|
||||
|
||||
ton::ton_api::downcast_call(*f.get(), [&](auto &obj) {
|
||||
ton::ton_api::downcast_call(*f, [&](auto &obj) {
|
||||
run_control_query(obj, std::move(data), src.pubkey_hash(), it->second, std::move(promise));
|
||||
});
|
||||
}
|
||||
|
|
@ -3752,7 +3791,7 @@ int main(int argc, char *argv[]) {
|
|||
});
|
||||
return td::Status::OK();
|
||||
});
|
||||
p.add_option('M', "masterchain-only", "don't track shardchains", [&]() {
|
||||
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_masterchain_only); });
|
||||
});
|
||||
td::uint32 threads = 7;
|
||||
|
|
|
|||
|
|
@ -96,6 +96,7 @@ struct Config {
|
|||
std::map<td::int32, ton::PublicKeyHash> liteservers;
|
||||
std::map<td::int32, Control> controls;
|
||||
std::set<ton::PublicKeyHash> gc;
|
||||
std::vector<ton::ShardIdFull> shards_to_monitor;
|
||||
|
||||
void decref(ton::PublicKeyHash key);
|
||||
void incref(ton::PublicKeyHash key) {
|
||||
|
|
@ -121,6 +122,7 @@ struct Config {
|
|||
td::Result<bool> config_add_control_interface(ton::PublicKeyHash key, td::int32 port);
|
||||
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_add_gc(ton::PublicKeyHash key);
|
||||
td::Result<bool> config_del_network_addr(td::IPAddress addr, std::vector<AdnlCategory> cats,
|
||||
std::vector<AdnlCategory> prio_cats);
|
||||
|
|
@ -135,10 +137,10 @@ struct Config {
|
|||
td::Result<bool> config_del_control_process(td::int32 port, ton::PublicKeyHash id);
|
||||
td::Result<bool> config_del_gc(ton::PublicKeyHash key);
|
||||
|
||||
ton::tl_object_ptr<ton::ton_api::engine_validator_config> tl() const;
|
||||
ton::tl_object_ptr<ton::ton_api::engine_validator_config_v2> tl() const;
|
||||
|
||||
Config();
|
||||
Config(ton::ton_api::engine_validator_config &config);
|
||||
Config(const ton::ton_api::engine_validator_config_v2 &config);
|
||||
};
|
||||
|
||||
class ValidatorEngine : public td::actor::Actor {
|
||||
|
|
@ -434,6 +436,8 @@ 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_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,
|
||||
ton::PublicKeyHash src, td::uint32 perm, td::Promise<td::BufferSlice> promise);
|
||||
template <class T>
|
||||
void run_control_query(T &query, td::BufferSlice data, ton::PublicKeyHash src, td::uint32 perm,
|
||||
td::Promise<td::BufferSlice> promise) {
|
||||
|
|
|
|||
Loading…
Reference in a new issue