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

fullnode: support for TCP master/slave replication

Browse source
This commit is contained in:
ton 2019-09-19 23:15:32 +04:00
parent bfa166d66c
commit f40822b58a
50 changed files with 1109 additions and 244 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -121,6 +121,18 @@ Config::Config(ton::ton_api::engine_validator_config &config) {
}
config_add_full_node_adnl_id(ton::PublicKeyHash{config.fullnode_}).ensure();
if (config.fullnodeslave_) {
td::IPAddress ip;
ip.init_ipv4_port(td::IPAddress::ipv4_to_str(config.fullnodeslave_->ip_),
static_cast<td::uint16>(config.fullnodeslave_->port_))
.ensure();
config_add_full_node_slave(ip, ton::PublicKey{config.fullnodeslave_->adnl_}).ensure();
}
for (auto &s : config.fullnodemasters_) {
config_add_full_node_master(s->port_, ton::PublicKeyHash{s->adnl_}).ensure();
}
for (auto &serv : config.liteservers_) {
config_add_lite_server(ton::PublicKeyHash{serv->id_}, serv->port_).ensure();
}
@ -180,6 +192,17 @@ ton::tl_object_ptr<ton::ton_api::engine_validator_config> Config::tl() const {
val.first.tl(), std::move(temp_vec), std::move(adnl_val_vec), val.second.election_date, val.second.expire_at));
}
ton::tl_object_ptr<ton::ton_api::engine_validator_fullNodeSlave> full_node_slave = nullptr;
if (!full_node_slave_adnl_id.empty()) {
full_node_slave = ton::create_tl_object<ton::ton_api::engine_validator_fullNodeSlave>(
full_node_slave_addr.get_ipv4(), full_node_slave_addr.get_port(), full_node_slave_adnl_id.tl());
}
std::vector<ton::tl_object_ptr<ton::ton_api::engine_validator_fullNodeMaster>> full_node_masters_vec;
for (auto &x : full_node_masters) {
full_node_masters_vec.push_back(
ton::create_tl_object<ton::ton_api::engine_validator_fullNodeMaster>(x.first, x.second.tl()));
}
std::vector<ton::tl_object_ptr<ton::ton_api::engine_liteServer>> liteserver_vec;
for (auto &x : liteservers) {
liteserver_vec.push_back(ton::create_tl_object<ton::ton_api::engine_liteServer>(x.second.tl(), x.first));
@ -201,7 +224,8 @@ ton::tl_object_ptr<ton::ton_api::engine_validator_config> Config::tl() const {
}
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(liteserver_vec), std::move(control_vec), std::move(gc_vec));
std::move(full_node_slave), std::move(full_node_masters_vec), std::move(liteserver_vec), std::move(control_vec),
std::move(gc_vec));
}
td::Result<bool> Config::config_add_network_addr(td::IPAddress in_ip, td::IPAddress out_ip,
@ -362,6 +386,36 @@ td::Result<bool> Config::config_add_full_node_adnl_id(ton::PublicKeyHash id) {
return true;
}
td::Result<bool> Config::config_add_full_node_slave(td::IPAddress addr, ton::PublicKey id) {
if (full_node_slave_adnl_id == id && addr == full_node_slave_addr) {
return false;
}
full_node_slave_adnl_id = id;
full_node_slave_addr = addr;
return true;
}
td::Result<bool> Config::config_add_full_node_master(td::int32 port, ton::PublicKeyHash id) {
if (adnl_ids.count(id) == 0) {
return td::Status::Error(ton::ErrorCode::notready,
"to-be-added full node master adnl address not in adnl nodes list");
}
auto it = full_node_masters.find(port);
if (it != full_node_masters.end()) {
if (it->second == id) {
return false;
} else {
return td::Status::Error("duplicate master port");
}
}
if (liteservers.count(port) > 0 || controls.count(port) > 0) {
return td::Status::Error("duplicate master port");
}
incref(id);
full_node_masters.emplace(port, id);
return true;
}
td::Result<bool> Config::config_add_lite_server(ton::PublicKeyHash key, td::int32 port) {
if (controls.count(port) > 0) {
return td::Status::Error(ton::ErrorCode::error, "duplicate port");
@ -1351,8 +1405,11 @@ void ValidatorEngine::start_dht() {
add_dht(dht);
}
CHECK(!default_dht_node_.is_zero());
td::actor::send_closure(adnl_, &ton::adnl::Adnl::register_dht_node, dht_nodes_[default_dht_node_].get());
if (default_dht_node_.is_zero()) {
LOG(ERROR) << "trying to work without DHT";
} else {
td::actor::send_closure(adnl_, &ton::adnl::Adnl::register_dht_node, dht_nodes_[default_dht_node_].get());
}
started_dht();
}
@ -1371,8 +1428,10 @@ void ValidatorEngine::started_rldp() {
}
void ValidatorEngine::start_overlays() {
overlay_manager_ =
ton::overlay::Overlays::create(db_root_, keyring_.get(), adnl_.get(), dht_nodes_[default_dht_node_].get());
if (!default_dht_node_.is_zero()) {
overlay_manager_ =
ton::overlay::Overlays::create(db_root_, keyring_.get(), adnl_.get(), dht_nodes_[default_dht_node_].get());
}
started_overlays();
}
@ -1403,14 +1462,26 @@ void ValidatorEngine::started_validator() {
}
void ValidatorEngine::start_full_node() {
if (!config_.full_node.is_zero()) {
if (!config_.full_node.is_zero() || !config_.full_node_slave_adnl_id.empty()) {
auto pk = ton::PrivateKey{ton::privkeys::Ed25519::random()};
auto short_id = pk.compute_short_id();
td::actor::send_closure(keyring_, &ton::keyring::Keyring::add_key, std::move(pk), true, [](td::Unit) {});
if (!config_.full_node_slave_adnl_id.empty()) {
class Cb : public ton::adnl::AdnlExtClient::Callback {
public:
void on_ready() override {
}
void on_stop_ready() override {
}
};
full_node_client_ = ton::adnl::AdnlExtClient::create(ton::adnl::AdnlNodeIdFull{config_.full_node_slave_adnl_id},
config_.full_node_slave_addr, std::make_unique<Cb>());
}
full_node_ = ton::validator::fullnode::FullNode::create(
short_id, ton::adnl::AdnlNodeIdShort{config_.full_node}, validator_options_->zero_block_id().file_hash,
keyring_.get(), adnl_.get(), rldp_.get(), dht_nodes_[default_dht_node_].get(), overlay_manager_.get(),
validator_manager_.get(), db_root_);
keyring_.get(), adnl_.get(), rldp_.get(),
default_dht_node_.is_zero() ? td::actor::ActorId<ton::dht::Dht>{} : dht_nodes_[default_dht_node_].get(),
overlay_manager_.get(), validator_manager_.get(), full_node_client_.get(), db_root_);
}
for (auto &v : config_.validators) {
@ -1499,6 +1570,21 @@ void ValidatorEngine::started_control_interface(td::actor::ActorOwn<ton::adnl::A
add_control_process(s.second.key, static_cast<td::uint16>(s.first), p.first, p.second);
}
}
start_full_node_masters();
}
void ValidatorEngine::start_full_node_masters() {
for (auto &x : config_.full_node_masters) {
full_node_masters_.emplace(
static_cast<td::uint16>(x.first),
ton::validator::fullnode::FullNodeMaster::create(
ton::adnl::AdnlNodeIdShort{x.second}, static_cast<td::uint16>(x.first),
validator_options_->zero_block_id().file_hash, keyring_.get(), adnl_.get(), validator_manager_.get()));
}
started_full_node_masters();
}
void ValidatorEngine::started_full_node_masters() {
started();
}