mirror of
https://github.com/ton-blockchain/ton
synced 2025-03-09 15:40:10 +00:00
Tunnel reinit support + Fixed packets recv through tunnel
This commit is contained in:
parent
d287bafa15
commit
374e75932f
11 changed files with 177 additions and 80 deletions
|
@ -76,32 +76,43 @@ size_t AdnlNetworkManagerImpl::add_listening_udp_port(td::uint16 port) {
|
|||
return idx;
|
||||
}
|
||||
|
||||
size_t AdnlNetworkManagerImpl::add_tunnel_udp_port(td::uint16 port, td::Promise<td::IPAddress> on_ready) {
|
||||
auto it = port_2_socket_.find(port);
|
||||
#define TUNNEL_FAKE_PORT 1
|
||||
|
||||
size_t AdnlNetworkManagerImpl::add_tunnel_udp_port(std::string global_config, std::string tunnel_config, td::Promise<td::IPAddress> on_ready,
|
||||
td::actor::Scheduler *scheduler) {
|
||||
auto it = port_2_socket_.find(TUNNEL_FAKE_PORT);
|
||||
if (it != port_2_socket_.end()) {
|
||||
return it->second;
|
||||
}
|
||||
class Callback : public td::UdpServer::Callback {
|
||||
class Callback : public td::UdpServer::TunnelCallback {
|
||||
public:
|
||||
Callback(td::actor::ActorShared<AdnlNetworkManagerImpl> manager, size_t idx)
|
||||
: manager_(std::move(manager)), idx_(idx) {
|
||||
Callback(td::actor::ActorShared<AdnlNetworkManagerImpl> manager, size_t idx, td::actor::Scheduler *scheduler, TunnelEventsHandler* tunnel_events_handler)
|
||||
: manager_(std::move(manager)), idx_(idx), scheduler_(scheduler), tunnel_events_handler_(tunnel_events_handler) {
|
||||
}
|
||||
|
||||
private:
|
||||
TunnelEventsHandler* tunnel_events_handler_;
|
||||
td::actor::ActorShared<AdnlNetworkManagerImpl> manager_;
|
||||
size_t idx_;
|
||||
td::actor::Scheduler *scheduler_;
|
||||
void on_udp_message(td::UdpMessage udp_message) override {
|
||||
td::actor::send_closure_later(manager_, &AdnlNetworkManagerImpl::receive_udp_message, std::move(udp_message),
|
||||
idx_);
|
||||
scheduler_->run_in_context_external([&] {
|
||||
td::actor::send_closure_later(manager_, &AdnlNetworkManagerImpl::receive_udp_message, std::move(udp_message),
|
||||
idx_);
|
||||
});
|
||||
}
|
||||
void on_in_addr_update(const td::IPAddress ip) override {
|
||||
tunnel_events_handler_->on_in_addr_update(ip);
|
||||
}
|
||||
};
|
||||
|
||||
auto idx = udp_sockets_.size();
|
||||
auto X = td::UdpServer::create_via_tunnel("udp tunnel server", port,
|
||||
std::make_unique<Callback>(actor_shared(this), idx), std::move(on_ready));
|
||||
auto X = td::UdpServer::create_via_tunnel("udp tunnel server", global_config, tunnel_config,
|
||||
std::make_unique<Callback>(actor_shared(this), idx, scheduler, tunnel_events_handler_.get()),
|
||||
std::move(on_ready));
|
||||
X.ensure();
|
||||
port_2_socket_[port] = idx;
|
||||
udp_sockets_.push_back(UdpSocketDesc{port, X.move_as_ok()});
|
||||
port_2_socket_[TUNNEL_FAKE_PORT] = idx;
|
||||
udp_sockets_.push_back(UdpSocketDesc{TUNNEL_FAKE_PORT, X.move_as_ok()});
|
||||
return idx;
|
||||
}
|
||||
|
||||
|
@ -121,12 +132,12 @@ void AdnlNetworkManagerImpl::add_self_addr(td::IPAddress addr, AdnlCategoryMask
|
|||
out_desc_[priority].push_back(std::move(d));
|
||||
}
|
||||
|
||||
void AdnlNetworkManagerImpl::add_tunnel(td::uint16 port, AdnlCategoryMask cat_mask, td::uint32 priority,
|
||||
td::Promise<td::IPAddress> on_ready) {
|
||||
size_t idx = add_tunnel_udp_port(port, std::move(on_ready));
|
||||
void AdnlNetworkManagerImpl::add_tunnel(std::string global_config, std::string tunnel_config, AdnlCategoryMask cat_mask, td::uint32 priority,
|
||||
td::Promise<td::IPAddress> on_ready, td::actor::Scheduler *scheduler) {
|
||||
size_t idx = add_tunnel_udp_port(global_config, tunnel_config, std::move(on_ready), scheduler);
|
||||
|
||||
add_in_addr(InDesc{port, nullptr, cat_mask}, idx);
|
||||
auto d = OutDesc{port, td::IPAddress{}, nullptr, idx};
|
||||
add_in_addr(InDesc{TUNNEL_FAKE_PORT, nullptr, cat_mask}, idx);
|
||||
auto d = OutDesc{TUNNEL_FAKE_PORT, td::IPAddress{}, nullptr, idx};
|
||||
for (auto &it : out_desc_[priority]) {
|
||||
if (it == d) {
|
||||
it.cat_mask |= cat_mask;
|
||||
|
|
|
@ -59,19 +59,25 @@ class AdnlNetworkManager : public td::actor::Actor {
|
|||
public:
|
||||
//using ConnHandle = td::uint64;
|
||||
class Callback {
|
||||
public:
|
||||
public:
|
||||
virtual ~Callback() = default;
|
||||
//virtual void receive_packet(td::IPAddress addr, ConnHandle conn_handle, td::BufferSlice data) = 0;
|
||||
virtual void receive_packet(td::IPAddress addr, AdnlCategoryMask cat_mask, td::BufferSlice data) = 0;
|
||||
};
|
||||
class TunnelEventsHandler {
|
||||
public:
|
||||
virtual ~TunnelEventsHandler() = default;
|
||||
virtual void on_in_addr_update(td::IPAddress ip) = 0;
|
||||
};
|
||||
static td::actor::ActorOwn<AdnlNetworkManager> create(td::uint16 out_port);
|
||||
|
||||
virtual ~AdnlNetworkManager() = default;
|
||||
|
||||
virtual void install_callback(std::unique_ptr<Callback> callback) = 0;
|
||||
virtual void install_tunnel_events_handler(std::unique_ptr<TunnelEventsHandler> handler) = 0;
|
||||
|
||||
virtual void add_tunnel(td::uint16 port, AdnlCategoryMask cat_mask, td::uint32 priority,
|
||||
td::Promise<td::IPAddress> on_ready) = 0;
|
||||
virtual void add_tunnel(std::string global_config, std::string tunnel_config, AdnlCategoryMask cat_mask, td::uint32 priority,
|
||||
td::Promise<td::IPAddress> on_ready, td::actor::Scheduler *scheduler) = 0;
|
||||
virtual void add_self_addr(td::IPAddress addr, AdnlCategoryMask cat_mask, td::uint32 priority) = 0;
|
||||
virtual void add_proxy_addr(td::IPAddress addr, td::uint16 local_port, std::shared_ptr<AdnlProxy> proxy,
|
||||
AdnlCategoryMask cat_mask, td::uint32 priority) = 0;
|
||||
|
|
|
@ -109,6 +109,10 @@ class AdnlNetworkManagerImpl : public AdnlNetworkManager {
|
|||
callback_ = std::move(callback);
|
||||
}
|
||||
|
||||
void install_tunnel_events_handler(std::unique_ptr<TunnelEventsHandler> handler) override {
|
||||
tunnel_events_handler_ = std::move(handler);
|
||||
}
|
||||
|
||||
void alarm() override;
|
||||
void start_up() override {
|
||||
alarm_timestamp() = td::Timestamp::in(60.0);
|
||||
|
@ -131,8 +135,8 @@ class AdnlNetworkManagerImpl : public AdnlNetworkManager {
|
|||
in_desc_.push_back(std::move(desc));
|
||||
}
|
||||
|
||||
void add_tunnel(td::uint16 port, AdnlCategoryMask cat_mask, td::uint32 priority,
|
||||
td::Promise<td::IPAddress> on_ready) override;
|
||||
void add_tunnel(std::string global_config, std::string tunnel_config, AdnlCategoryMask cat_mask, td::uint32 priority, td::Promise<td::IPAddress> on_ready,
|
||||
td::actor::Scheduler *scheduler) override;
|
||||
void add_self_addr(td::IPAddress addr, AdnlCategoryMask cat_mask, td::uint32 priority) override;
|
||||
void add_proxy_addr(td::IPAddress addr, td::uint16 local_port, std::shared_ptr<AdnlProxy> proxy,
|
||||
AdnlCategoryMask cat_mask, td::uint32 priority) override;
|
||||
|
@ -147,13 +151,14 @@ class AdnlNetworkManagerImpl : public AdnlNetworkManager {
|
|||
}
|
||||
}
|
||||
|
||||
size_t add_tunnel_udp_port(td::uint16 port, td::Promise<td::IPAddress> on_ready);
|
||||
size_t add_tunnel_udp_port(std::string global_config, std::string tunnel_config, td::Promise<td::IPAddress> on_ready, td::actor::Scheduler *scheduler);
|
||||
size_t add_listening_udp_port(td::uint16 port);
|
||||
void receive_udp_message(td::UdpMessage message, size_t idx);
|
||||
void proxy_register(OutDesc &desc);
|
||||
|
||||
private:
|
||||
std::unique_ptr<Callback> callback_;
|
||||
std::unique_ptr<TunnelEventsHandler> tunnel_events_handler_;
|
||||
|
||||
std::map<td::uint32, std::vector<OutDesc>> out_desc_;
|
||||
std::vector<InDesc> in_desc_;
|
||||
|
|
|
@ -34,13 +34,15 @@ class TestLoopbackNetworkManager : public ton::adnl::AdnlNetworkManager {
|
|||
callback_ = std::move(callback);
|
||||
}
|
||||
|
||||
void install_tunnel_events_handler(std::unique_ptr<TunnelEventsHandler> handler) override {};
|
||||
|
||||
void add_self_addr(td::IPAddress addr, AdnlCategoryMask cat_mask, td::uint32 priority) override {
|
||||
}
|
||||
void add_proxy_addr(td::IPAddress addr, td::uint16 local_port, std::shared_ptr<AdnlProxy> proxy,
|
||||
AdnlCategoryMask cat_mask, td::uint32 priority) override {
|
||||
}
|
||||
void add_tunnel(td::uint16 port, AdnlCategoryMask cat_mask, td::uint32 priority,
|
||||
td::Promise<td::IPAddress> on_ready) override {
|
||||
void add_tunnel(std::string global_config, std::string tunnel_config, AdnlCategoryMask cat_mask, td::uint32 priority, td::Promise<td::IPAddress> on_ready,
|
||||
td::actor::Scheduler* scheduler) override {
|
||||
}
|
||||
void send_udp_packet(ton::adnl::AdnlNodeIdShort src_id, ton::adnl::AdnlNodeIdShort dst_id, td::IPAddress dst_addr,
|
||||
td::uint32 priority, td::BufferSlice data) override {
|
||||
|
|
File diff suppressed because one or more lines are too long
|
@ -28,17 +28,21 @@ namespace td {
|
|||
class UdpServer : public td::actor::Actor {
|
||||
public:
|
||||
class Callback {
|
||||
public:
|
||||
public:
|
||||
virtual ~Callback() = default;
|
||||
virtual void on_udp_message(td::UdpMessage udp_message) = 0;
|
||||
};
|
||||
class TunnelCallback : public Callback {
|
||||
public:
|
||||
virtual void on_in_addr_update(td::IPAddress ip) = 0;
|
||||
};
|
||||
virtual void send(td::UdpMessage &&message) = 0;
|
||||
|
||||
static Result<actor::ActorOwn<UdpServer>> create(td::Slice name, int32 port, std::unique_ptr<Callback> callback);
|
||||
static Result<actor::ActorOwn<UdpServer>> create_via_tcp(td::Slice name, int32 port,
|
||||
std::unique_ptr<Callback> callback);
|
||||
static Result<actor::ActorOwn<UdpServer>> create_via_tunnel(td::Slice name, int32 port,
|
||||
std::unique_ptr<Callback> callback,
|
||||
static Result<actor::ActorOwn<UdpServer>> create_via_tunnel(td::Slice name, std::string global_config, std::string tunnel_config,
|
||||
std::unique_ptr<TunnelCallback> callback,
|
||||
td::Promise<td::IPAddress> on_ready);
|
||||
|
||||
};
|
||||
|
|
|
@ -21,6 +21,9 @@ typedef struct { const char *p; ptrdiff_t n; } _GoString_;
|
|||
|
||||
#line 3 "lib.go"
|
||||
|
||||
#include <stdint.h>
|
||||
#include <sys/socket.h>
|
||||
|
||||
typedef struct {
|
||||
size_t index;
|
||||
int ip;
|
||||
|
@ -28,14 +31,18 @@ typedef struct {
|
|||
} Tunnel;
|
||||
|
||||
// next - is pointer to class instance or callback to call method from node code
|
||||
typedef void (*RecvCallback)(void* next, char * data, size_t num);
|
||||
typedef void (*RecvCallback)(void* next, uint8_t* data, size_t num);
|
||||
|
||||
typedef void (*PullSendCallback)(void* next, char * data, size_t num);
|
||||
typedef void (*ReinitCallback)(void* next, struct sockaddr* data);
|
||||
|
||||
|
||||
// we need it because we cannot call C func by pointer directly from go
|
||||
static inline void on_recv_batch_ready(RecvCallback cb, void* next, void* data, size_t num) {
|
||||
cb(next, (char*)data, num);
|
||||
cb(next, (uint8_t*)data, num);
|
||||
}
|
||||
|
||||
static inline void on_reinit(ReinitCallback cb, void* next, void* data) {
|
||||
cb(next, (struct sockaddr*)data);
|
||||
}
|
||||
|
||||
#line 1 "cgo-generated-wrapper"
|
||||
|
@ -96,8 +103,8 @@ extern "C" {
|
|||
|
||||
|
||||
//goland:noinspection ALL
|
||||
extern Tunnel PrepareTunnel(RecvCallback onRecv, void* next, char* configJson, int configJsonLen, char* networkConfigJson, int networkConfigJsonLen);
|
||||
extern int WriteTunnel(size_t tunIdx, char* data, size_t num);
|
||||
extern Tunnel PrepareTunnel(RecvCallback onRecv, ReinitCallback onReinit, void* nextOnRecv, void* nextOnReinit, char* configJson, int configJsonLen, char* networkConfigJson, int networkConfigJsonLen);
|
||||
extern int WriteTunnel(size_t tunIdx, uint8_t* data, size_t num);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
@ -648,7 +648,7 @@ engine.validator.fullNodeMaster port:int adnl:int256 = engine.validator.FullNode
|
|||
engine.validator.fullNodeSlave ip:int port:int adnl:PublicKey = engine.validator.FullNodeSlave;
|
||||
engine.validator.fullNodeConfig ext_messages_broadcast_disabled:Bool = engine.validator.FullNodeConfig;
|
||||
engine.validator.extraConfig state_serializer_enabled:Bool = engine.validator.ExtraConfig;
|
||||
engine.validator.config out_port:int tunnel_enabled: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) fullnode:int256 fullnodeslaves:(vector engine.validator.fullNodeSlave)
|
||||
fullnodemasters:(vector engine.validator.fullNodeMaster)
|
||||
|
|
Binary file not shown.
|
@ -88,7 +88,6 @@ Config::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_);
|
||||
tunnel_enabled = true; //static_cast<td::uint8>(config.tunnel_enabled_);
|
||||
if (!out_port) {
|
||||
out_port = 3278;
|
||||
}
|
||||
|
@ -279,7 +278,7 @@ 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, 0, 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),
|
||||
full_node.tl(), std::move(full_node_slaves_vec), std::move(full_node_masters_vec),
|
||||
std::move(full_node_config_obj), std::move(extra_config_obj), std::move(liteserver_vec), std::move(control_vec),
|
||||
std::move(shards_vec), std::move(gc_vec));
|
||||
|
@ -1277,6 +1276,9 @@ void ValidatorEngine::set_local_config(std::string str) {
|
|||
void ValidatorEngine::set_global_config(std::string str) {
|
||||
global_config_ = str;
|
||||
}
|
||||
void ValidatorEngine::set_tunnel_config(std::string str) {
|
||||
tunnel_config_ = str;
|
||||
}
|
||||
void ValidatorEngine::set_db_root(std::string db_root) {
|
||||
db_root_ = db_root;
|
||||
}
|
||||
|
@ -1849,7 +1851,7 @@ void ValidatorEngine::start_adnl() {
|
|||
adnl_ = ton::adnl::Adnl::create(db_root_, keyring_.get());
|
||||
td::actor::send_closure(adnl_, &ton::adnl::Adnl::register_network_manager, adnl_network_manager_.get());
|
||||
|
||||
if (config_.tunnel_enabled) {
|
||||
if (!tunnel_config_.empty()) {
|
||||
auto on_tunnel_ready = td::PromiseCreator::lambda([SelfId = actor_id(this), this](td::Result<td::IPAddress> R) {
|
||||
R.ensure();
|
||||
auto addr = R.move_as_ok();
|
||||
|
@ -1870,14 +1872,41 @@ void ValidatorEngine::start_adnl() {
|
|||
td::actor::send_closure(SelfId, &ValidatorEngine::started_adnl);
|
||||
});
|
||||
|
||||
ton::adnl::AdnlCategoryMask cat_mask;
|
||||
cat_mask[0] = true;
|
||||
cat_mask[1] = true;
|
||||
cat_mask[2] = true;
|
||||
cat_mask[3] = true;
|
||||
class Handler : public ton::adnl::AdnlNetworkManager::TunnelEventsHandler {
|
||||
public:
|
||||
Handler(ValidatorEngine *scheduler)
|
||||
: validator_engine_(scheduler) {
|
||||
}
|
||||
|
||||
td::actor::send_closure(adnl_network_manager_, &ton::adnl::AdnlNetworkManager::add_tunnel, 3433,
|
||||
std::move(cat_mask), 0, std::move(on_tunnel_ready));
|
||||
private:
|
||||
ValidatorEngine *validator_engine_;
|
||||
void on_in_addr_update(td::IPAddress ip) override {
|
||||
validator_engine_->scheduler_->run_in_context_external([&] {
|
||||
LOG(INFO) << "[EVENT] Tunnel reinitialized, addr: " << ip;
|
||||
|
||||
validator_engine_->addr_lists_.clear();
|
||||
validator_engine_->add_addr(Config::Addr{}, Config::AddrCats{
|
||||
.in_addr = ip,
|
||||
.is_tunnel = true,
|
||||
.cats = {0, 1, 2, 3},
|
||||
});
|
||||
|
||||
for (auto &adnl : validator_engine_->config_.adnl_ids) {
|
||||
validator_engine_->add_adnl(adnl.first, adnl.second);
|
||||
}
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
td::actor::send_closure(adnl_network_manager_, &ton::adnl::AdnlNetworkManager::install_tunnel_events_handler, std::make_unique<Handler>(this));
|
||||
|
||||
ton::adnl::AdnlCategoryMask cat_mask;
|
||||
for (int i = 0; i <= 3; i++) {
|
||||
cat_mask[i] = true;
|
||||
}
|
||||
|
||||
td::actor::send_closure(adnl_network_manager_, &ton::adnl::AdnlNetworkManager::add_tunnel, global_config_, tunnel_config_,
|
||||
std::move(cat_mask), 0, std::move(on_tunnel_ready), scheduler_);
|
||||
|
||||
return;
|
||||
}
|
||||
|
@ -4342,6 +4371,10 @@ int main(int argc, char *argv[]) {
|
|||
acts.push_back(
|
||||
[&x, fname = fname.str()]() { td::actor::send_closure(x, &ValidatorEngine::set_local_config, fname); });
|
||||
});
|
||||
p.add_option('\0', "tunnel-config", "file to read tunnel config", [&](td::Slice fname) {
|
||||
acts.push_back(
|
||||
[&x, fname = fname.str()]() { td::actor::send_closure(x, &ValidatorEngine::set_tunnel_config, fname); });
|
||||
});
|
||||
p.add_checked_option('I', "ip", "ip:port of instance", [&](td::Slice arg) {
|
||||
td::IPAddress addr;
|
||||
TRY_STATUS(addr.init_host_port(arg.str()));
|
||||
|
@ -4607,7 +4640,7 @@ int main(int argc, char *argv[]) {
|
|||
|
||||
scheduler.run_in_context([&] {
|
||||
vm::init_vm().ensure();
|
||||
x = td::actor::create_actor<ValidatorEngine>("validator-engine");
|
||||
x = td::actor::create_actor<ValidatorEngine>("validator-engine", &scheduler);
|
||||
for (auto &act : acts) {
|
||||
act();
|
||||
}
|
||||
|
|
|
@ -79,7 +79,6 @@ struct Config {
|
|||
|
||||
std::map<ton::PublicKeyHash, td::uint32> keys_refcnt;
|
||||
td::uint16 out_port;
|
||||
bool tunnel_enabled;
|
||||
std::map<Addr, AddrCats> addrs;
|
||||
std::map<ton::PublicKeyHash, AdnlCategory> adnl_ids;
|
||||
std::set<ton::PublicKeyHash> dht_ids;
|
||||
|
@ -142,6 +141,8 @@ struct Config {
|
|||
|
||||
class ValidatorEngine : public td::actor::Actor {
|
||||
private:
|
||||
td::actor::Scheduler* scheduler_;
|
||||
|
||||
td::actor::ActorOwn<ton::keyring::Keyring> keyring_;
|
||||
td::actor::ActorOwn<ton::adnl::AdnlNetworkManager> adnl_network_manager_;
|
||||
td::actor::ActorOwn<ton::adnl::Adnl> adnl_;
|
||||
|
@ -158,6 +159,7 @@ class ValidatorEngine : public td::actor::Actor {
|
|||
|
||||
std::string local_config_ = "";
|
||||
std::string global_config_ = "ton-global.config";
|
||||
std::string tunnel_config_ = "";
|
||||
std::string config_file_;
|
||||
std::string temp_config_file() const {
|
||||
return config_file_ + ".tmp";
|
||||
|
@ -247,6 +249,7 @@ class ValidatorEngine : public td::actor::Actor {
|
|||
}
|
||||
void set_local_config(std::string str);
|
||||
void set_global_config(std::string str);
|
||||
void set_tunnel_config(std::string str);
|
||||
void set_fift_dir(std::string str) {
|
||||
fift_dir_ = str;
|
||||
}
|
||||
|
@ -329,7 +332,7 @@ class ValidatorEngine : public td::actor::Actor {
|
|||
}
|
||||
|
||||
void start_up() override;
|
||||
ValidatorEngine() {
|
||||
explicit ValidatorEngine(td::actor::Scheduler* scheduler): scheduler_(scheduler) {
|
||||
}
|
||||
|
||||
// load config
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue