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

Fix compatibility

Browse source
This commit is contained in:
SpyCheese 2022-08-19 18:20:16 +03:00
parent ea7a5776fe
commit 1efd425403
9 changed files with 44 additions and 79 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
dht-server/dht-server.cpp
View file

@ -38,9 +38,6 @@
#include "td/utils/TsFileLog.h" #include "td/utils/TsFileLog.h"
#include "td/utils/Random.h" #include "td/utils/Random.h"
#include "ton/ton-tl.hpp"
#include "tl/tl_json.h"
#include "memprof/memprof.h" #include "memprof/memprof.h"
#if TD_DARWIN || TD_LINUX #if TD_DARWIN || TD_LINUX
@ -57,7 +54,7 @@ Config::Config() {
out_port = 3278; out_port = 3278;
} }
Config::Config(const ton::ton_api::engine_validator_configV2 &config) { Config::Config(const ton::ton_api::engine_validator_config &config) {
out_port = static_cast<td::uint16>(config.out_port_); out_port = static_cast<td::uint16>(config.out_port_);
if (!out_port) { if (!out_port) {
out_port = 3278; out_port = 3278;
@ -124,7 +121,7 @@ Config::Config(const ton::ton_api::engine_validator_configV2 &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; std::vector<ton::tl_object_ptr<ton::ton_api::engine_Addr>> addrs_vec;
for (auto &x : addrs) { for (auto &x : addrs) {
if (x.second.proxy) { if (x.second.proxy) {
@ -150,6 +147,7 @@ ton::tl_object_ptr<ton::ton_api::engine_validator_Config> Config::tl() const {
} }
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_collator>> col_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_fullNodeSlave>> full_node_slaves_vec;
std::vector<ton::tl_object_ptr<ton::ton_api::engine_validator_fullNodeMaster>> full_node_masters_vec; std::vector<ton::tl_object_ptr<ton::ton_api::engine_validator_fullNodeMaster>> full_node_masters_vec;
@ -165,15 +163,16 @@ ton::tl_object_ptr<ton::ton_api::engine_validator_Config> Config::tl() const {
control_vec.push_back(ton::create_tl_object<ton::ton_api::engine_controlInterface>(x.second.key.tl(), x.first, control_vec.push_back(ton::create_tl_object<ton::ton_api::engine_controlInterface>(x.second.key.tl(), x.first,
std::move(control_proc_vec))); std::move(control_proc_vec)));
} }
std::vector<ton::tl_object_ptr<ton::ton_api::tonNode_shardId>> shard_vec;
auto gc_vec = ton::create_tl_object<ton::ton_api::engine_gc>(std::vector<td::Bits256>{}); auto gc_vec = ton::create_tl_object<ton::ton_api::engine_gc>(std::vector<td::Bits256>{});
for (auto &id : gc) { for (auto &id : gc) {
gc_vec->ids_.push_back(id.tl()); gc_vec->ids_.push_back(id.tl());
} }
return ton::create_tl_object<ton::ton_api::engine_validator_config>( 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), out_port, std::move(addrs_vec), std::move(adnl_vec), std::move(dht_vec), std::move(val_vec), std::move(col_vec),
ton::PublicKeyHash::zero().tl(), std::move(full_node_slaves_vec), std::move(full_node_masters_vec), ton::PublicKeyHash::zero().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)); std::move(liteserver_vec), std::move(control_vec), std::move(shard_vec), std::move(gc_vec));
} }
td::Result<bool> Config::config_add_network_addr(td::IPAddress in_ip, td::IPAddress out_ip, td::Result<bool> Config::config_add_network_addr(td::IPAddress in_ip, td::IPAddress out_ip,
@ -600,14 +599,14 @@ void DhtServer::load_config(td::Promise<td::Unit> promise) {
} }
auto conf_json = conf_json_R.move_as_ok(); auto conf_json = conf_json_R.move_as_ok();
ton::tl_object_ptr<ton::ton_api::engine_validator_Config> conf; ton::ton_api::engine_validator_config conf;
auto S = td::from_json(conf, std::move(conf_json)); auto S = ton::ton_api::from_json(conf, conf_json.get_object());
if (S.is_error()) { if (S.is_error()) {
promise.set_error(S.move_as_error_prefix("json does not fit TL scheme")); promise.set_error(S.move_as_error_prefix("json does not fit TL scheme"));
return; return;
} }
config_ = Config{*ton::unpack_engine_validator_config(std::move(conf))}; config_ = Config{conf};
td::MultiPromise mp; td::MultiPromise mp;
auto ig = mp.init_guard(); auto ig = mp.init_guard();

4
dht-server/dht-server.hpp
View file

@ -91,10 +91,10 @@ struct Config {
td::Result<bool> config_del_control_process(td::int32 port, ton::PublicKeyHash id); td::Result<bool> config_del_control_process(td::int32 port, ton::PublicKeyHash id);
td::Result<bool> config_del_gc(ton::PublicKeyHash key); 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();
Config(const ton::ton_api::engine_validator_configV2 &config); Config(const ton::ton_api::engine_validator_config &config);
}; };
class DhtServer : public td::actor::Actor { class DhtServer : public td::actor::Actor {

22
lite-client/lite-client.cpp
View file

@ -124,7 +124,7 @@ void TestNode::run() {
auto gc_j = td::json_decode(G.as_slice()).move_as_ok(); auto gc_j = td::json_decode(G.as_slice()).move_as_ok();
ton::ton_api::liteclient_config_global gc; ton::ton_api::liteclient_config_global gc;
ton::ton_api::from_json(gc, gc_j.get_object()).ensure(); ton::ton_api::from_json(gc, gc_j.get_object()).ensure();
CHECK(gc.liteservers_.size() > 0); CHECK(gc.liteservers_.size() + gc.liteservers_v2_.size() > 0);
if (gc.validator_ && gc.validator_->zero_state_) { if (gc.validator_ && gc.validator_->zero_state_) {
zstate_id_.workchain = gc.validator_->zero_state_->workchain_; zstate_id_.workchain = gc.validator_->zero_state_->workchain_;
@ -137,21 +137,19 @@ void TestNode::run() {
for (auto& server : gc.liteservers_) { for (auto& server : gc.liteservers_) {
LiteServer s; LiteServer s;
ton::ton_api::downcast_call(*server, s.addr.init_host_port(td::IPAddress::ipv4_to_str(server->ip_), server->port_).ensure();
td::overloaded( s.public_key = ton::PublicKey{server->id_};
[&](ton::ton_api::liteserver_desc& obj) { servers_.push_back(std::move(s));
s.addr.init_host_port(td::IPAddress::ipv4_to_str(obj.ip_), obj.port_).ensure(); }
s.public_key = ton::PublicKey{obj.id_}; for (auto& server : gc.liteservers_v2_) {
}, LiteServer s;
[&](ton::ton_api::liteserver_descV2& obj) { s.addr.init_host_port(td::IPAddress::ipv4_to_str(server->ip_), server->port_).ensure();
s.addr.init_host_port(td::IPAddress::ipv4_to_str(obj.ip_), obj.port_).ensure(); s.public_key = ton::PublicKey{server->id_};
s.public_key = ton::PublicKey{obj.id_};
s.is_full = false; s.is_full = false;
for (const auto& shard : obj.shards_) { for (const auto& shard : server->shards_) {
s.shards.emplace_back(shard->workchain_, shard->shard_); s.shards.emplace_back(shard->workchain_, shard->shard_);
CHECK(s.shards.back().is_valid_ext()); CHECK(s.shards.back().is_valid_ext());
} }
}));
servers_.push_back(std::move(s)); servers_.push_back(std::move(s));
} }

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

@ -578,8 +578,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; 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; liteserver.desc id:PublicKey ip:int port:int = liteserver.Desc;
liteserver.descV2 id:PublicKey ip:int port:int shards:(vector tonNode.shardId) = liteserver.Desc; liteserver.descV2 id:PublicKey ip:int port:int shards:(vector tonNode.shardId) = liteserver.DescV2;
liteclient.config.global liteservers:(vector liteserver.Desc) validator:validator.config.global = liteclient.config.Global; liteclient.config.global liteservers:(vector liteserver.desc) liteservers_v2:(vector liteserver.descV2) validator:validator.config.global = liteclient.config.Global;
engine.adnl id:int256 category:int = engine.Adnl; engine.adnl id:int256 category:int = engine.Adnl;
engine.addr ip:int port:int categories:(vector int) priority_categories:(vector int) = engine.Addr; engine.addr ip:int port:int categories:(vector int) priority_categories:(vector int) = engine.Addr;
@ -598,14 +598,8 @@ engine.gc ids:(vector int256) = engine.Gc;
engine.dht.config dht:(vector engine.dht) gc:engine.gc = engine.dht.Config; engine.dht.config dht:(vector engine.dht) gc:engine.gc = engine.dht.Config;
engine.validator.fullNodeMaster port:int adnl:int256 = engine.validator.FullNodeMaster; engine.validator.fullNodeMaster port:int adnl:int256 = engine.validator.FullNodeMaster;
engine.validator.fullNodeSlave ip:int port:int adnl:PublicKey = engine.validator.FullNodeSlave; engine.validator.fullNodeSlave ip:int port:int adnl:PublicKey = engine.validator.FullNodeSlave;
engine.validator.config out_port:int addrs:(vector engine.Addr) adnl:(vector engine.adnl)
dht:(vector engine.dht)
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;
engine.validator.configV2 out_port:int addrs:(vector engine.Addr) adnl:(vector engine.adnl) engine.validator.config out_port:int addrs:(vector engine.Addr) adnl:(vector engine.adnl)
dht:(vector engine.dht) dht:(vector engine.dht)
validators:(vector engine.validator) collators:(vector engine.collator) validators:(vector engine.validator) collators:(vector engine.collator)
fullnode:int256 fullnodeslaves:(vector engine.validator.fullNodeSlave) fullnode:int256 fullnodeslaves:(vector engine.validator.fullNodeSlave)

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

Binary file not shown.

19
ton/ton-tl.hpp
View file

@ -62,23 +62,4 @@ inline tl_object_ptr<ton_api::tonNode_shardId> create_tl_shard_id(const ShardIdF
return create_tl_object<ton_api::tonNode_shardId>(s.workchain, s.shard); return create_tl_object<ton_api::tonNode_shardId>(s.workchain, s.shard);
} }
inline tl_object_ptr<ton_api::engine_validator_configV2> unpack_engine_validator_config(
tl_object_ptr<ton_api::engine_validator_Config> config) {
tl_object_ptr<ton_api::engine_validator_configV2> res;
ton_api::downcast_call(*config, td::overloaded(
[&](ton_api::engine_validator_config &c) {
res = create_tl_object<ton_api::engine_validator_configV2>(
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_configV2 &c) {
res = std::make_unique<ton_api::engine_validator_configV2>(std::move(c));
}));
return res;
}
} // namespace ton } // namespace ton

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

@ -75,7 +75,7 @@ Config::Config() {
full_node = ton::PublicKeyHash::zero(); full_node = ton::PublicKeyHash::zero();
} }
Config::Config(const ton::ton_api::engine_validator_configV2 &config) { Config::Config(const ton::ton_api::engine_validator_config &config) {
full_node = ton::PublicKeyHash::zero(); full_node = ton::PublicKeyHash::zero();
out_port = static_cast<td::uint16>(config.out_port_); out_port = static_cast<td::uint16>(config.out_port_);
if (!out_port) { if (!out_port) {
@ -177,7 +177,7 @@ Config::Config(const ton::ton_api::engine_validator_configV2 &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; std::vector<ton::tl_object_ptr<ton::ton_api::engine_Addr>> addrs_vec;
for (auto &x : addrs) { for (auto &x : addrs) {
if (x.second.proxy) { if (x.second.proxy) {
@ -257,18 +257,11 @@ ton::tl_object_ptr<ton::ton_api::engine_validator_Config> Config::tl() const {
gc_vec->ids_.push_back(id.tl()); gc_vec->ids_.push_back(id.tl());
} }
if (col_vec.empty() && shards_vec.empty()) {
return ton::create_tl_object<ton::ton_api::engine_validator_config>( 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));
} else {
return ton::create_tl_object<ton::ton_api::engine_validator_configV2>(
out_port, std::move(addrs_vec), std::move(adnl_vec), std::move(dht_vec), std::move(val_vec), std::move(col_vec), 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), 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)); 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, td::Result<bool> Config::config_add_network_addr(td::IPAddress in_ip, td::IPAddress out_ip,
std::shared_ptr<ton::adnl::AdnlProxy> proxy, std::shared_ptr<ton::adnl::AdnlProxy> proxy,
@ -1662,14 +1655,14 @@ void ValidatorEngine::load_config(td::Promise<td::Unit> promise) {
} }
auto conf_json = conf_json_R.move_as_ok(); auto conf_json = conf_json_R.move_as_ok();
ton::tl_object_ptr<ton::ton_api::engine_validator_Config> conf; ton::ton_api::engine_validator_config conf;
auto S = td::from_json(conf, std::move(conf_json)); auto S = ton::ton_api::from_json(conf, conf_json.get_object());
if (S.is_error()) { if (S.is_error()) {
promise.set_error(S.move_as_error_prefix("json does not fit TL scheme")); promise.set_error(S.move_as_error_prefix("json does not fit TL scheme"));
return; return;
} }
config_ = Config{*ton::unpack_engine_validator_config(std::move(conf))}; config_ = Config{conf};
td::MultiPromise mp; td::MultiPromise mp;
auto ig = mp.init_guard(); auto ig = mp.init_guard();

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

@ -137,10 +137,10 @@ struct Config {
td::Result<bool> config_del_control_process(td::int32 port, ton::PublicKeyHash id); td::Result<bool> config_del_control_process(td::int32 port, ton::PublicKeyHash id);
td::Result<bool> config_del_gc(ton::PublicKeyHash key); 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();
Config(const ton::ton_api::engine_validator_configV2 &config); Config(const ton::ton_api::engine_validator_config &config);
}; };
class ValidatorEngine : public td::actor::Actor { class ValidatorEngine : public td::actor::Actor {

10
validator/full-node-shard.cpp
View file

@ -663,11 +663,11 @@ void FullNodeShardImpl::process_broadcast(PublicKeyHash src, ton_api::tonNode_ne
void FullNodeShardImpl::process_broadcast(PublicKeyHash src, ton_api::tonNode_blockBroadcast &query) { void FullNodeShardImpl::process_broadcast(PublicKeyHash src, ton_api::tonNode_blockBroadcast &query) {
BlockIdExt block_id = create_block_id(query.id_); BlockIdExt block_id = create_block_id(query.id_);
if (block_id.shard_full() != shard_) { //if (block_id.shard_full() != shard_) {
LOG(FULL_NODE_WARNING) << "dropping block broadcast: shard mismatch. overlay=" << shard_.to_str() // LOG(FULL_NODE_WARNING) << "dropping block broadcast: shard mismatch. overlay=" << shard_.to_str()
<< " block=" << block_id.to_str(); // << " block=" << block_id.to_str();
return; // return;
} //}
std::vector<BlockSignature> signatures; std::vector<BlockSignature> signatures;
for (auto &sig : query.signatures_) { for (auto &sig : query.signatures_) {