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/Random.h"
#include "ton/ton-tl.hpp"
#include "tl/tl_json.h"
#include "memprof/memprof.h"
#if TD_DARWIN || TD_LINUX
@ -57,7 +54,7 @@ Config::Config() {
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_);
if (!out_port) {
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;
for (auto &x : addrs) {
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_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_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,
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>{});
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),
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),
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,
@ -600,14 +599,14 @@ void DhtServer::load_config(td::Promise<td::Unit> promise) {
}
auto conf_json = conf_json_R.move_as_ok();
ton::tl_object_ptr<ton::ton_api::engine_validator_Config> conf;
auto S = td::from_json(conf, std::move(conf_json));
ton::ton_api::engine_validator_config conf;
auto S = ton::ton_api::from_json(conf, conf_json.get_object());
if (S.is_error()) {
promise.set_error(S.move_as_error_prefix("json does not fit TL scheme"));
return;
}
config_ = Config{*ton::unpack_engine_validator_config(std::move(conf))};
config_ = Config{conf};
td::MultiPromise mp;
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_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(const ton::ton_api::engine_validator_configV2 &config);
Config(const ton::ton_api::engine_validator_config &config);
};
class DhtServer : public td::actor::Actor {

30
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();
ton::ton_api::liteclient_config_global gc;
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_) {
zstate_id_.workchain = gc.validator_->zero_state_->workchain_;
@ -137,21 +137,19 @@ void TestNode::run() {
for (auto& server : gc.liteservers_) {
LiteServer s;
ton::ton_api::downcast_call(*server,
td::overloaded(
[&](ton::ton_api::liteserver_desc& obj) {
s.addr.init_host_port(td::IPAddress::ipv4_to_str(obj.ip_), obj.port_).ensure();
s.public_key = ton::PublicKey{obj.id_};
},
[&](ton::ton_api::liteserver_descV2& obj) {
s.addr.init_host_port(td::IPAddress::ipv4_to_str(obj.ip_), obj.port_).ensure();
s.public_key = ton::PublicKey{obj.id_};
s.is_full = false;
for (const auto& shard : obj.shards_) {
s.shards.emplace_back(shard->workchain_, shard->shard_);
CHECK(s.shards.back().is_valid_ext());
}
}));
s.addr.init_host_port(td::IPAddress::ipv4_to_str(server->ip_), server->port_).ensure();
s.public_key = ton::PublicKey{server->id_};
servers_.push_back(std::move(s));
}
for (auto& server : gc.liteservers_v2_) {
LiteServer s;
s.addr.init_host_port(td::IPAddress::ipv4_to_str(server->ip_), server->port_).ensure();
s.public_key = ton::PublicKey{server->id_};
s.is_full = false;
for (const auto& shard : server->shards_) {
s.shards.emplace_back(shard->workchain_, shard->shard_);
CHECK(s.shards.back().is_valid_ext());
}
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;
liteserver.desc id:PublicKey ip:int port:int = liteserver.Desc;
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;
liteserver.descV2 id:PublicKey ip:int port:int shards:(vector tonNode.shardId) = liteserver.DescV2;
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.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.validator.fullNodeMaster port:int adnl:int256 = engine.validator.FullNodeMaster;
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)
validators:(vector engine.validator) collators:(vector engine.collator)
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);
}
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

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

@ -75,7 +75,7 @@ Config::Config() {
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();
out_port = static_cast<td::uint16>(config.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;
for (auto &x : addrs) {
if (x.second.proxy) {
@ -257,17 +257,10 @@ ton::tl_object_ptr<ton::ton_api::engine_validator_Config> Config::tl() const {
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>(
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),
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));
}
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), 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,
@ -1662,14 +1655,14 @@ void ValidatorEngine::load_config(td::Promise<td::Unit> promise) {
}
auto conf_json = conf_json_R.move_as_ok();
ton::tl_object_ptr<ton::ton_api::engine_validator_Config> conf;
auto S = td::from_json(conf, std::move(conf_json));
ton::ton_api::engine_validator_config conf;
auto S = ton::ton_api::from_json(conf, conf_json.get_object());
if (S.is_error()) {
promise.set_error(S.move_as_error_prefix("json does not fit TL scheme"));
return;
}
config_ = Config{*ton::unpack_engine_validator_config(std::move(conf))};
config_ = Config{conf};
td::MultiPromise mp;
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_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(const ton::ton_api::engine_validator_configV2 &config);
Config(const ton::ton_api::engine_validator_config &config);
};
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) {
BlockIdExt block_id = create_block_id(query.id_);
if (block_id.shard_full() != shard_) {
LOG(FULL_NODE_WARNING) << "dropping block broadcast: shard mismatch. overlay=" << shard_.to_str()
<< " block=" << block_id.to_str();
return;
}
//if (block_id.shard_full() != shard_) {
// LOG(FULL_NODE_WARNING) << "dropping block broadcast: shard mismatch. overlay=" << shard_.to_str()
// << " block=" << block_id.to_str();
// return;
//}
std::vector<BlockSignature> signatures;
for (auto &sig : query.signatures_) {