external/ton
1
0
Fork 0
mirror of https://github.com/ton-blockchain/ton synced 2025-02-14 20:22:19 +00:00
Code Issues Releases Wiki Activity

Use partial liteservers in blockchain-explorer

Browse source
This commit is contained in:
SpyCheese 2023-07-14 15:51:27 +03:00
parent b422d95b95
commit ac6cc3bafd
4 changed files with 112 additions and 132 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
blockchain-explorer/CMakeLists.txt
View file

@ -17,11 +17,11 @@ if (NIX)
find_package(PkgConfig REQUIRED)
pkg_check_modules(MHD libmicrohttpd)
target_include_directories(blockchain-explorer PUBLIC ${MHD_INCLUDE_DIRS} ${MHD_STATIC_INCLUDE_DIRS})
target_link_libraries(blockchain-explorer tdutils tdactor adnllite tl_lite_api tl-lite-utils ton_crypto ton_block ${MHD_LIBRARIES} ${MHD_STATIC_LIBRARIES})
target_link_libraries(blockchain-explorer tdutils tdactor adnllite tl_lite_api tl-lite-utils ton_crypto ton_block lite-client-common ${MHD_LIBRARIES} ${MHD_STATIC_LIBRARIES})
else()
find_package(MHD)
target_include_directories(blockchain-explorer PUBLIC ${MHD_INCLUDE_DIRS})
target_link_libraries(blockchain-explorer tdutils tdactor adnllite tl_lite_api tl-lite-utils ton_crypto ton_block ${MHD_LIBRARIES})
target_link_libraries(blockchain-explorer tdutils tdactor adnllite tl_lite_api tl-lite-utils ton_crypto ton_block lite-client-common ${MHD_LIBRARIES})
endif()
install(TARGETS blockchain-explorer RUNTIME DESTINATION bin)

145
blockchain-explorer/blockchain-explorer-query.cpp
View file

@ -43,6 +43,7 @@
#include "block/block-auto.h"
#include "crypto/vm/utils.h"
#include "td/utils/crypto.h"
#include "lite-client/QueryTraits.h"
#include "vm/boc.h"
#include "vm/cellops.h"
@ -237,8 +238,7 @@ void HttpQueryBlockData::finish_query() {
}
void HttpQueryBlockData::start_up() {
auto query = ton::serialize_tl_object(
ton::create_tl_object<ton::lite_api::liteServer_getBlock>(ton::create_tl_lite_block_id(block_id_)), true);
auto query = ton::create_tl_object<ton::lite_api::liteServer_getBlock>(ton::create_tl_lite_block_id(block_id_));
auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::BufferSlice> R) {
if (R.is_error()) {
@ -249,7 +249,7 @@ void HttpQueryBlockData::start_up() {
});
td::actor::send_closure(CoreActorInterface::instance_actor_id(), &CoreActorInterface::send_lite_query,
std::move(query), std::move(P));
ton::serialize_tl_object(query, true), liteclient::get_query_shard(*query), std::move(P));
}
void HttpQueryBlockData::got_block_data(td::BufferSlice data) {
@ -300,8 +300,7 @@ void HttpQueryBlockView::finish_query() {
}
void HttpQueryBlockView::start_up_query() {
auto query = ton::serialize_tl_object(
ton::create_tl_object<ton::lite_api::liteServer_getBlock>(ton::create_tl_lite_block_id(block_id_)), true);
auto query = ton::create_tl_object<ton::lite_api::liteServer_getBlock>(ton::create_tl_lite_block_id(block_id_));
auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::BufferSlice> R) {
if (R.is_error()) {
@ -312,7 +311,7 @@ void HttpQueryBlockView::start_up_query() {
});
td::actor::send_closure(CoreActorInterface::instance_actor_id(), &CoreActorInterface::send_lite_query,
std::move(query), std::move(P));
ton::serialize_tl_object(query, true), liteclient::get_query_shard(*query), std::move(P));
}
void HttpQueryBlockView::got_block_data(td::BufferSlice data) {
@ -348,11 +347,10 @@ void HttpQueryBlockInfo::start_up_query() {
td::actor::send_closure(SelfId, &HttpQueryBlockInfo::got_block_header, R.move_as_ok());
}
});
auto query = ton::serialize_tl_object(
ton::create_tl_object<ton::lite_api::liteServer_getBlockHeader>(ton::create_tl_lite_block_id(block_id_), 0),
true);
auto query =
ton::create_tl_object<ton::lite_api::liteServer_getBlockHeader>(ton::create_tl_lite_block_id(block_id_), 0);
td::actor::send_closure(CoreActorInterface::instance_actor_id(), &CoreActorInterface::send_lite_query,
std::move(query), std::move(P));
ton::serialize_tl_object(query, true), liteclient::get_query_shard(*query), std::move(P));
pending_queries_ = 1;
if (block_id_.is_masterchain()) {
@ -364,16 +362,15 @@ void HttpQueryBlockInfo::start_up_query() {
td::actor::send_closure(SelfId, &HttpQueryBlockInfo::got_shard_info, R.move_as_ok());
}
});
auto query_2 = ton::serialize_tl_object(
ton::create_tl_object<ton::lite_api::liteServer_getAllShardsInfo>(ton::create_tl_lite_block_id(block_id_)),
true);
auto query_2 =
ton::create_tl_object<ton::lite_api::liteServer_getAllShardsInfo>(ton::create_tl_lite_block_id(block_id_));
td::actor::send_closure(CoreActorInterface::instance_actor_id(), &CoreActorInterface::send_lite_query,
std::move(query_2), std::move(P_2));
ton::serialize_tl_object(query_2, true), liteclient::get_query_shard(*query_2),
std::move(P_2));
pending_queries_++;
}
auto query_3 = ton::serialize_tl_object(ton::create_tl_object<ton::lite_api::liteServer_listBlockTransactions>(
ton::create_tl_lite_block_id(block_id_), 7, 1024, nullptr, false, false),
true);
auto query_3 = ton::create_tl_object<ton::lite_api::liteServer_listBlockTransactions>(
ton::create_tl_lite_block_id(block_id_), 7, 1024, nullptr, false, false);
auto P_3 = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::BufferSlice> R) {
if (R.is_error()) {
td::actor::send_closure(SelfId, &HttpQueryBlockInfo::abort_query, R.move_as_error_prefix("litequery failed: "));
@ -382,7 +379,8 @@ void HttpQueryBlockInfo::start_up_query() {
}
});
td::actor::send_closure(CoreActorInterface::instance_actor_id(), &CoreActorInterface::send_lite_query,
std::move(query_3), std::move(P_3));
ton::serialize_tl_object(query_3, true), liteclient::get_query_shard(*query_3),
std::move(P_3));
pending_queries_++;
}
@ -435,11 +433,9 @@ void HttpQueryBlockInfo::got_transactions(td::BufferSlice data) {
if (f->incomplete_ && transactions_.size() > 0) {
const auto &T = *transactions_.rbegin();
auto query_3 = ton::serialize_tl_object(
ton::create_tl_object<ton::lite_api::liteServer_listBlockTransactions>(
ton::create_tl_lite_block_id(block_id_), 7 + 128, 1024,
ton::create_tl_object<ton::lite_api::liteServer_transactionId3>(T.addr.addr, T.lt), false, false),
true);
auto query_3 = ton::create_tl_object<ton::lite_api::liteServer_listBlockTransactions>(
ton::create_tl_lite_block_id(block_id_), 7 + 128, 1024,
ton::create_tl_object<ton::lite_api::liteServer_transactionId3>(T.addr.addr, T.lt), false, false);
auto P_3 = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::BufferSlice> R) {
if (R.is_error()) {
td::actor::send_closure(SelfId, &HttpQueryBlockInfo::abort_query, R.move_as_error_prefix("litequery failed: "));
@ -448,7 +444,8 @@ void HttpQueryBlockInfo::got_transactions(td::BufferSlice data) {
}
});
td::actor::send_closure(CoreActorInterface::instance_actor_id(), &CoreActorInterface::send_lite_query,
std::move(query_3), std::move(P_3));
ton::serialize_tl_object(query_3, true), liteclient::get_query_shard(*query_3),
std::move(P_3));
} else {
if (!--pending_queries_) {
finish_query();
@ -568,14 +565,13 @@ void HttpQueryBlockSearch::start_up_query() {
td::actor::send_closure(SelfId, &HttpQueryBlockSearch::got_block_header, R.move_as_ok());
}
});
auto query = ton::serialize_tl_object(ton::create_tl_object<ton::lite_api::liteServer_lookupBlock>(
mode_,
ton::create_tl_lite_block_id_simple(ton::BlockId{
account_prefix_.workchain, account_prefix_.account_id_prefix, seqno_}),
lt_, utime_),
true);
auto query = ton::create_tl_object<ton::lite_api::liteServer_lookupBlock>(
mode_,
ton::create_tl_lite_block_id_simple(
ton::BlockId{account_prefix_.workchain, account_prefix_.account_id_prefix, seqno_}),
lt_, utime_);
td::actor::send_closure(CoreActorInterface::instance_actor_id(), &CoreActorInterface::send_lite_query,
std::move(query), std::move(P));
ton::serialize_tl_object(query, true), liteclient::get_query_shard(*query), std::move(P));
}
void HttpQueryBlockSearch::got_block_header(td::BufferSlice data) {
@ -597,17 +593,16 @@ void HttpQueryBlockSearch::got_block_header(td::BufferSlice data) {
td::actor::send_closure(SelfId, &HttpQueryBlockSearch::got_shard_info, R.move_as_ok());
}
});
auto query_2 = ton::serialize_tl_object(
ton::create_tl_object<ton::lite_api::liteServer_getAllShardsInfo>(ton::create_tl_lite_block_id(block_id_)),
true);
auto query_2 =
ton::create_tl_object<ton::lite_api::liteServer_getAllShardsInfo>(ton::create_tl_lite_block_id(block_id_));
td::actor::send_closure(CoreActorInterface::instance_actor_id(), &CoreActorInterface::send_lite_query,
std::move(query_2), std::move(P_2));
ton::serialize_tl_object(query_2, true), liteclient::get_query_shard(*query_2),
std::move(P_2));
pending_queries_++;
}
auto query_3 = ton::serialize_tl_object(ton::create_tl_object<ton::lite_api::liteServer_listBlockTransactions>(
ton::create_tl_lite_block_id(block_id_), 7, 1024, nullptr, false, false),
true);
auto query_3 = ton::create_tl_object<ton::lite_api::liteServer_listBlockTransactions>(
ton::create_tl_lite_block_id(block_id_), 7, 1024, nullptr, false, false);
auto P_3 = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::BufferSlice> R) {
if (R.is_error()) {
td::actor::send_closure(SelfId, &HttpQueryBlockSearch::abort_query, R.move_as_error_prefix("litequery failed: "));
@ -616,7 +611,8 @@ void HttpQueryBlockSearch::got_block_header(td::BufferSlice data) {
}
});
td::actor::send_closure(CoreActorInterface::instance_actor_id(), &CoreActorInterface::send_lite_query,
std::move(query_3), std::move(P_3));
ton::serialize_tl_object(query_3, true), liteclient::get_query_shard(*query_3),
std::move(P_3));
pending_queries_++;
}
@ -656,11 +652,9 @@ void HttpQueryBlockSearch::got_transactions(td::BufferSlice data) {
if (f->incomplete_ && transactions_.size() > 0) {
const auto &T = *transactions_.rbegin();
auto query_3 = ton::serialize_tl_object(
ton::create_tl_object<ton::lite_api::liteServer_listBlockTransactions>(
ton::create_tl_lite_block_id(block_id_), 7 + 128, 1024,
ton::create_tl_object<ton::lite_api::liteServer_transactionId3>(T.addr.addr, T.lt), false, false),
true);
auto query_3 = ton::create_tl_object<ton::lite_api::liteServer_listBlockTransactions>(
ton::create_tl_lite_block_id(block_id_), 7 + 128, 1024,
ton::create_tl_object<ton::lite_api::liteServer_transactionId3>(T.addr.addr, T.lt), false, false);
auto P_3 = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::BufferSlice> R) {
if (R.is_error()) {
td::actor::send_closure(SelfId, &HttpQueryBlockSearch::abort_query,
@ -670,7 +664,8 @@ void HttpQueryBlockSearch::got_transactions(td::BufferSlice data) {
}
});
td::actor::send_closure(CoreActorInterface::instance_actor_id(), &CoreActorInterface::send_lite_query,
std::move(query_3), std::move(P_3));
ton::serialize_tl_object(query_3, true), liteclient::get_query_shard(*query_3),
std::move(P_3));
} else {
if (!--pending_queries_) {
finish_query();
@ -758,11 +753,10 @@ void HttpQueryViewAccount::start_up_query() {
}
});
auto a = ton::create_tl_object<ton::lite_api::liteServer_accountId>(addr_.workchain, addr_.addr);
auto query = ton::serialize_tl_object(ton::create_tl_object<ton::lite_api::liteServer_getAccountState>(
ton::create_tl_lite_block_id(block_id_), std::move(a)),
true);
auto query = ton::create_tl_object<ton::lite_api::liteServer_getAccountState>(ton::create_tl_lite_block_id(block_id_),
std::move(a));
td::actor::send_closure(CoreActorInterface::instance_actor_id(), &CoreActorInterface::send_lite_query,
std::move(query), std::move(P));
ton::serialize_tl_object(query, true), liteclient::get_query_shard(*query), std::move(P));
}
void HttpQueryViewAccount::got_account(td::BufferSlice data) {
@ -855,10 +849,9 @@ void HttpQueryViewTransaction::start_up_query() {
}
});
auto a = ton::create_tl_object<ton::lite_api::liteServer_accountId>(addr_.workchain, addr_.addr);
auto query = ton::serialize_tl_object(
ton::create_tl_object<ton::lite_api::liteServer_getTransactions>(1, std::move(a), lt_, hash_), true);
auto query = ton::create_tl_object<ton::lite_api::liteServer_getTransactions>(1, std::move(a), lt_, hash_);
td::actor::send_closure(CoreActorInterface::instance_actor_id(), &CoreActorInterface::send_lite_query,
std::move(query), std::move(P));
ton::serialize_tl_object(query, true), liteclient::get_query_shard(*query), std::move(P));
}
void HttpQueryViewTransaction::got_transaction(td::BufferSlice data) {
@ -946,11 +939,10 @@ void HttpQueryViewTransaction2::start_up_query() {
}
});
auto a = ton::create_tl_object<ton::lite_api::liteServer_accountId>(addr_.workchain, addr_.addr);
auto query = ton::serialize_tl_object(ton::create_tl_object<ton::lite_api::liteServer_getOneTransaction>(
ton::create_tl_lite_block_id(block_id_), std::move(a), lt_),
true);
auto query = ton::create_tl_object<ton::lite_api::liteServer_getOneTransaction>(
ton::create_tl_lite_block_id(block_id_), std::move(a), lt_);
td::actor::send_closure(CoreActorInterface::instance_actor_id(), &CoreActorInterface::send_lite_query,
std::move(query), std::move(P));
ton::serialize_tl_object(query, true), liteclient::get_query_shard(*query), std::move(P));
}
void HttpQueryViewTransaction2::got_transaction(td::BufferSlice data) {
@ -1009,9 +1001,9 @@ void HttpQueryViewLastBlock::start_up() {
}
});
auto query = ton::serialize_tl_object(ton::create_tl_object<ton::lite_api::liteServer_getMasterchainInfo>(), true);
auto query = ton::create_tl_object<ton::lite_api::liteServer_getMasterchainInfo>();
td::actor::send_closure(CoreActorInterface::instance_actor_id(), &CoreActorInterface::send_lite_query,
std::move(query), std::move(P));
ton::serialize_tl_object(query, true), liteclient::get_query_shard(*query), std::move(P));
}
void HttpQueryViewLastBlock::got_result(td::BufferSlice data) {
@ -1075,9 +1067,9 @@ void HttpQueryConfig::start_up() {
}
});
auto query = ton::serialize_tl_object(ton::create_tl_object<ton::lite_api::liteServer_getMasterchainInfo>(), true);
auto query = ton::create_tl_object<ton::lite_api::liteServer_getMasterchainInfo>();
td::actor::send_closure(CoreActorInterface::instance_actor_id(), &CoreActorInterface::send_lite_query,
std::move(query), std::move(P));
ton::serialize_tl_object(query, true), liteclient::get_query_shard(*query), std::move(P));
}
}
@ -1101,16 +1093,17 @@ void HttpQueryConfig::send_main_query() {
td::actor::send_closure(SelfId, &HttpQueryConfig::got_result, R.move_as_ok());
}
});
auto query =
params_.size() > 0
? ton::serialize_tl_object(ton::create_tl_object<ton::lite_api::liteServer_getConfigParams>(
0, ton::create_tl_lite_block_id(block_id_), std::vector<int>(params_)),
true)
: ton::serialize_tl_object(ton::create_tl_object<ton::lite_api::liteServer_getConfigAll>(
0, ton::create_tl_lite_block_id(block_id_)),
true);
td::actor::send_closure(CoreActorInterface::instance_actor_id(), &CoreActorInterface::send_lite_query,
std::move(query), std::move(P));
if (params_.size() > 0) {
auto query = ton::create_tl_object<ton::lite_api::liteServer_getConfigParams>(
0, ton::create_tl_lite_block_id(block_id_), std::vector<int>(params_));
td::actor::send_closure(CoreActorInterface::instance_actor_id(), &CoreActorInterface::send_lite_query,
ton::serialize_tl_object(query, true), liteclient::get_query_shard(*query), std::move(P));
} else {
auto query =
ton::create_tl_object<ton::lite_api::liteServer_getConfigAll>(0, ton::create_tl_lite_block_id(block_id_));
td::actor::send_closure(CoreActorInterface::instance_actor_id(), &CoreActorInterface::send_lite_query,
ton::serialize_tl_object(query, true), liteclient::get_query_shard(*query), std::move(P));
}
}
void HttpQueryConfig::got_result(td::BufferSlice data) {
@ -1252,10 +1245,9 @@ void HttpQuerySend::start_up() {
td::actor::send_closure(SelfId, &HttpQuerySend::got_result, R.move_as_ok());
}
});
auto query =
ton::serialize_tl_object(ton::create_tl_object<ton::lite_api::liteServer_sendMessage>(std::move(data_)), true);
auto query = ton::create_tl_object<ton::lite_api::liteServer_sendMessage>(std::move(data_));
td::actor::send_closure(CoreActorInterface::instance_actor_id(), &CoreActorInterface::send_lite_query,
std::move(query), std::move(P));
ton::serialize_tl_object(query, true), liteclient::get_query_shard(*query), std::move(P));
}
void HttpQuerySend::got_result(td::BufferSlice data) {
@ -1347,11 +1339,10 @@ void HttpQueryRunMethod::start_up_query() {
}
});
auto a = ton::create_tl_object<ton::lite_api::liteServer_accountId>(addr_.workchain, addr_.addr);
auto query = ton::serialize_tl_object(ton::create_tl_object<ton::lite_api::liteServer_getAccountState>(
ton::create_tl_lite_block_id(block_id_), std::move(a)),
true);
auto query = ton::create_tl_object<ton::lite_api::liteServer_getAccountState>(ton::create_tl_lite_block_id(block_id_),
std::move(a));
td::actor::send_closure(CoreActorInterface::instance_actor_id(), &CoreActorInterface::send_lite_query,
std::move(query), std::move(P));
ton::serialize_tl_object(query, true), liteclient::get_query_shard(*query), std::move(P));
}
void HttpQueryRunMethod::got_account(td::BufferSlice data) {

93
blockchain-explorer/blockchain-explorer.cpp
View file

@ -57,6 +57,7 @@
#include "auto/tl/lite_api.h"
#include "ton/lite-tl.hpp"
#include "tl-utils/lite-utils.hpp"
#include "lite-client/ext-client.h"
#include <microhttpd.h>
@ -126,7 +127,7 @@ class CoreActor : public CoreActorInterface {
private:
std::string global_config_ = "ton-global.config";
std::vector<td::actor::ActorOwn<ton::adnl::AdnlExtClient>> clients_;
td::actor::ActorOwn<liteclient::ExtClient> client_;
td::uint32 http_port_ = 80;
MHD_Daemon* daemon_ = nullptr;
@ -136,24 +137,17 @@ class CoreActor : public CoreActorInterface {
bool hide_ips_ = false;
std::unique_ptr<ton::adnl::AdnlExtClient::Callback> make_callback(td::uint32 idx) {
class Callback : public ton::adnl::AdnlExtClient::Callback {
td::unique_ptr<liteclient::ExtClient::Callback> make_callback() {
class Callback : public liteclient::ExtClient::Callback {
public:
void on_ready() override {
td::actor::send_closure(id_, &CoreActor::conn_ready, idx_);
}
void on_stop_ready() override {
td::actor::send_closure(id_, &CoreActor::conn_closed, idx_);
}
Callback(td::actor::ActorId<CoreActor> id, td::uint32 idx) : id_(std::move(id)), idx_(idx) {
Callback(td::actor::ActorId<CoreActor> id) : id_(std::move(id)) {
}
private:
td::actor::ActorId<CoreActor> id_;
td::uint32 idx_;
};
return std::make_unique<Callback>(actor_id(this), idx);
return td::make_unique<Callback>(actor_id(this));
}
std::shared_ptr<RemoteNodeStatus> new_result_;
@ -162,9 +156,8 @@ class CoreActor : public CoreActorInterface {
std::vector<bool> ready_;
void run_queries();
//void run_queries();
void got_result(td::uint32 idx, td::int32 attempt, td::Result<td::BufferSlice> data);
void send_query(td::uint32 idx);
void add_result() {
if (new_result_) {
@ -183,7 +176,7 @@ class CoreActor : public CoreActorInterface {
add_result();
}
attempt_ = t;
run_queries();
//run_queries();
alarm_timestamp() = td::Timestamp::at_unix((attempt_ + 1) * 60);
}
@ -225,10 +218,7 @@ class CoreActor : public CoreActorInterface {
hide_ips_ = value;
}
void send_lite_query(td::uint32 idx, td::BufferSlice query, td::Promise<td::BufferSlice> promise);
void send_lite_query(td::BufferSlice data, td::Promise<td::BufferSlice> promise) override {
return send_lite_query(0, std::move(data), std::move(promise));
}
void send_lite_query(td::BufferSlice query, ton::ShardIdFull shard, td::Promise<td::BufferSlice> promise) override;
void get_last_result(td::Promise<std::shared_ptr<RemoteNodeStatus>> promise) override {
}
void get_results(td::uint32 max, td::Promise<RemoteNodeStatusList> promise) override {
@ -448,23 +438,39 @@ class CoreActor : public CoreActorInterface {
}
void run() {
std::vector<liteclient::ExtClient::LiteServer> servers;
if (remote_public_key_.empty()) {
auto G = td::read_file(global_config_).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::from_json(gc, gc_j.get_object()).ensure();
CHECK(gc.liteservers_.size() > 0);
td::uint32 size = static_cast<td::uint32>(gc.liteservers_.size());
size_t size = gc.liteservers_.size() + gc.liteservers_v2_.size();
CHECK(size > 0);
ready_.resize(size, false);
for (td::uint32 i = 0; i < size; i++) {
auto& cli = gc.liteservers_[i];
for (auto& s : gc.liteservers_) {
td::IPAddress addr;
addr.init_host_port(td::IPAddress::ipv4_to_str(cli->ip_), cli->port_).ensure();
addr.init_host_port(td::IPAddress::ipv4_to_str(s->ip_), s->port_).ensure();
addrs_.push_back(addr);
clients_.emplace_back(ton::adnl::AdnlExtClient::create(ton::adnl::AdnlNodeIdFull::create(cli->id_).move_as_ok(),
addr, make_callback(i)));
liteclient::ExtClient::LiteServer serv;
serv.address = addr;
serv.adnl_id = ton::adnl::AdnlNodeIdFull::create(s->id_).move_as_ok();
servers.push_back(std::move(serv));
}
for (auto& s : gc.liteservers_v2_) {
td::IPAddress addr;
addr.init_host_port(td::IPAddress::ipv4_to_str(s->ip_), s->port_).ensure();
addrs_.push_back(addr);
liteclient::ExtClient::LiteServer serv;
serv.address = addr;
serv.adnl_id = ton::adnl::AdnlNodeIdFull::create(s->id_).move_as_ok();
serv.is_full = false;
for (auto& shard : s->shards_) {
serv.shards.emplace_back(shard->workchain_, (ton::ShardId)shard->shard_);
CHECK(serv.shards.back().is_valid_ext());
}
servers.push_back(std::move(serv));
}
} else {
if (!remote_addr_.is_valid()) {
@ -472,9 +478,12 @@ class CoreActor : public CoreActorInterface {
}
ready_.resize(1, false);
addrs_.push_back(remote_addr_);
clients_.emplace_back(ton::adnl::AdnlExtClient::create(ton::adnl::AdnlNodeIdFull{remote_public_key_},
remote_addr_, make_callback(0)));
liteclient::ExtClient::LiteServer serv;
serv.address = remote_addr_;
serv.adnl_id = ton::adnl::AdnlNodeIdFull{remote_public_key_};
servers.push_back(std::move(serv));
}
client_ = liteclient::ExtClient::create(std::move(servers), make_callback());
daemon_ = MHD_start_daemon(MHD_USE_SELECT_INTERNALLY, static_cast<td::uint16>(http_port_), nullptr, nullptr,
&process_http_request, nullptr, MHD_OPTION_NOTIFY_COMPLETED, request_completed, nullptr,
MHD_OPTION_THREAD_POOL_SIZE, 16, MHD_OPTION_END);
@ -523,23 +532,7 @@ void CoreActor::got_result(td::uint32 idx, td::int32 attempt, td::Result<td::Buf
}
}
void CoreActor::send_query(td::uint32 idx) {
if (!ready_[idx]) {
return;
}
waiting_++;
auto query = ton::create_tl_object<ton::lite_api::liteServer_getMasterchainInfo>();
auto q = ton::create_tl_object<ton::lite_api::liteServer_query>(serialize_tl_object(query, true));
auto P =
td::PromiseCreator::lambda([SelfId = actor_id(this), idx, attempt = attempt_](td::Result<td::BufferSlice> R) {
td::actor::send_closure(SelfId, &CoreActor::got_result, idx, attempt, std::move(R));
});
td::actor::send_closure(clients_[idx], &ton::adnl::AdnlExtClient::send_query, "query", serialize_tl_object(q, true),
td::Timestamp::in(10.0), std::move(P));
}
void CoreActor::run_queries() {
/*void CoreActor::run_queries() {
waiting_ = 0;
new_result_ = std::make_shared<RemoteNodeStatus>(ready_.size(), td::Timestamp::at_unix(attempt_ * 60));
for (td::uint32 i = 0; i < ready_.size(); i++) {
@ -549,13 +542,9 @@ void CoreActor::run_queries() {
if (waiting_ == 0) {
add_result();
}
}
}*/
void CoreActor::send_lite_query(td::uint32 idx, td::BufferSlice query, td::Promise<td::BufferSlice> promise) {
if (!ready_[idx]) {
promise.set_error(td::Status::Error(ton::ErrorCode::notready, "ext conn not ready"));
return;
}
void CoreActor::send_lite_query(td::BufferSlice query, ton::ShardIdFull shard, td::Promise<td::BufferSlice> promise) {
auto P = td::PromiseCreator::lambda([promise = std::move(promise)](td::Result<td::BufferSlice> R) mutable {
if (R.is_error()) {
promise.set_error(R.move_as_error());
@ -573,7 +562,7 @@ void CoreActor::send_lite_query(td::uint32 idx, td::BufferSlice query, td::Promi
promise.set_value(std::move(B));
});
auto q = ton::create_tl_object<ton::lite_api::liteServer_query>(std::move(query));
td::actor::send_closure(clients_[idx], &ton::adnl::AdnlExtClient::send_query, "query", serialize_tl_object(q, true),
td::actor::send_closure(client_, &liteclient::ExtClient::send_query, "query", serialize_tl_object(q, true), shard,
td::Timestamp::in(10.0), std::move(P));
}

2
blockchain-explorer/blockchain-explorer.hpp
View file

@ -64,7 +64,7 @@ class CoreActorInterface : public td::actor::Actor {
};
virtual ~CoreActorInterface() = default;
virtual void send_lite_query(td::BufferSlice data, td::Promise<td::BufferSlice> promise) = 0;
virtual void send_lite_query(td::BufferSlice data, ton::ShardIdFull shard, td::Promise<td::BufferSlice> promise) = 0;
virtual void get_last_result(td::Promise<std::shared_ptr<RemoteNodeStatus>> promise) = 0;
virtual void get_results(td::uint32 max, td::Promise<RemoteNodeStatusList> promise) = 0;