tdlight-team/tdlight
tdlight-team/tdlight
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Simplify NetQueryCreator and remove mtproto dependency on telegram_api.

Browse Source 
GitOrigin-RevId: 2edfc9d6d80eab8716dfd3722f6aebe53dba1e47
This commit is contained in:
levlam 2020-03-16 01:01:14 +03:00
parent b8848a2ab4
commit d06a786a16
19 changed files with 113 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
td/mtproto/utils.cpp
View File

@ -7,9 +7,6 @@
#include "td/mtproto/utils.h" #include "td/mtproto/utils.h"
#include "td/mtproto/mtproto_api.h" #include "td/mtproto/mtproto_api.h"
#include "td/telegram/telegram_api.h"
#include "td/utils/logging.h"
namespace td { namespace td {
@ -17,17 +14,8 @@ TLStorer<mtproto_api::Function> create_storer(const mtproto_api::Function &funct
return TLStorer<mtproto_api::Function>(function); return TLStorer<mtproto_api::Function>(function);
} }
TLStorer<telegram_api::Function> create_storer(const telegram_api::Function &function) {
LOG(DEBUG) << "Create storer for " << to_string(function);
return TLStorer<telegram_api::Function>(function);
}
TLObjectStorer<mtproto_api::Object> create_storer(const mtproto_api::Object &object) { TLObjectStorer<mtproto_api::Object> create_storer(const mtproto_api::Object &object) {
return TLObjectStorer<mtproto_api::Object>(object); return TLObjectStorer<mtproto_api::Object>(object);
} }
TLObjectStorer<telegram_api::Object> create_storer(const telegram_api::Object &object) {
return TLObjectStorer<telegram_api::Object>(object);
}
} // namespace td } // namespace td

9
td/mtproto/utils.h
View File

@ -88,17 +88,8 @@ class Object;
class Function; class Function;
} // namespace mtproto_api } // namespace mtproto_api
namespace telegram_api {
class Object;
class Function;
} // namespace telegram_api
TLStorer<mtproto_api::Function> create_storer(const mtproto_api::Function &function); TLStorer<mtproto_api::Function> create_storer(const mtproto_api::Function &function);
TLStorer<telegram_api::Function> create_storer(const telegram_api::Function &function);
TLObjectStorer<mtproto_api::Object> create_storer(const mtproto_api::Object &object); TLObjectStorer<mtproto_api::Object> create_storer(const mtproto_api::Object &object);
TLObjectStorer<telegram_api::Object> create_storer(const telegram_api::Object &object);
} // namespace td } // namespace td

52
td/telegram/AuthManager.cpp
View File

@ -176,7 +176,7 @@ void AuthManager::check_bot_token(uint64 query_id, string bot_token) {
was_check_bot_token_ = true; was_check_bot_token_ = true;
start_net_query(NetQueryType::BotAuthentication, start_net_query(NetQueryType::BotAuthentication,
G()->net_query_creator().create_unauth( G()->net_query_creator().create_unauth(
create_storer(telegram_api::auth_importBotAuthorization(0, api_id_, api_hash_, bot_token_)))); telegram_api::auth_importBotAuthorization(0, api_id_, api_hash_, bot_token_)));
} }
void AuthManager::request_qr_code_authentication(uint64 query_id, vector<int32> other_user_ids) { void AuthManager::request_qr_code_authentication(uint64 query_id, vector<int32> other_user_ids) {
@ -214,8 +214,8 @@ void AuthManager::request_qr_code_authentication(uint64 query_id, vector<int32>
void AuthManager::send_export_login_token_query() { void AuthManager::send_export_login_token_query() {
poll_export_login_code_timeout_.cancel_timeout(); poll_export_login_code_timeout_.cancel_timeout();
start_net_query(NetQueryType::RequestQrCode, start_net_query(NetQueryType::RequestQrCode,
G()->net_query_creator().create_unauth(create_storer( G()->net_query_creator().create_unauth(
telegram_api::auth_exportLoginToken(api_id_, api_hash_, vector<int32>(other_user_ids_))))); telegram_api::auth_exportLoginToken(api_id_, api_hash_, vector<int32>(other_user_ids_))));
} }
void AuthManager::set_login_token_expires_at(double login_token_expires_at) { void AuthManager::set_login_token_expires_at(double login_token_expires_at) {
@ -269,9 +269,8 @@ void AuthManager::set_phone_number(uint64 query_id, string phone_number,
on_new_query(query_id); on_new_query(query_id);
start_net_query(NetQueryType::SendCode, start_net_query(NetQueryType::SendCode, G()->net_query_creator().create_unauth(
G()->net_query_creator().create_unauth( send_code_helper_.send_code(phone_number, settings, api_id_, api_hash_)));
create_storer(send_code_helper_.send_code(phone_number, settings, api_id_, api_hash_))));
} }
void AuthManager::resend_authentication_code(uint64 query_id) { void AuthManager::resend_authentication_code(uint64 query_id) {
@ -286,8 +285,7 @@ void AuthManager::resend_authentication_code(uint64 query_id) {
on_new_query(query_id); on_new_query(query_id);
start_net_query(NetQueryType::SendCode, start_net_query(NetQueryType::SendCode, G()->net_query_creator().create_unauth(r_resend_code.move_as_ok()));
G()->net_query_creator().create_unauth(create_storer(r_resend_code.move_as_ok())));
} }
void AuthManager::check_code(uint64 query_id, string code) { void AuthManager::check_code(uint64 query_id, string code) {
@ -298,8 +296,8 @@ void AuthManager::check_code(uint64 query_id, string code) {
code_ = std::move(code); code_ = std::move(code);
on_new_query(query_id); on_new_query(query_id);
start_net_query(NetQueryType::SignIn, start_net_query(NetQueryType::SignIn,
G()->net_query_creator().create_unauth(create_storer(telegram_api::auth_signIn( G()->net_query_creator().create_unauth(telegram_api::auth_signIn(
send_code_helper_.phone_number().str(), send_code_helper_.phone_code_hash().str(), code_)))); send_code_helper_.phone_number().str(), send_code_helper_.phone_code_hash().str(), code_)));
} }
void AuthManager::register_user(uint64 query_id, string first_name, string last_name) { void AuthManager::register_user(uint64 query_id, string first_name, string last_name) {
@ -314,10 +312,9 @@ void AuthManager::register_user(uint64 query_id, string first_name, string last_
} }
last_name = clean_name(last_name, MAX_NAME_LENGTH); last_name = clean_name(last_name, MAX_NAME_LENGTH);
start_net_query( start_net_query(NetQueryType::SignUp, G()->net_query_creator().create_unauth(telegram_api::auth_signUp(
NetQueryType::SignUp, send_code_helper_.phone_number().str(),
G()->net_query_creator().create_unauth(create_storer(telegram_api::auth_signUp( send_code_helper_.phone_code_hash().str(), first_name, last_name)));
send_code_helper_.phone_number().str(), send_code_helper_.phone_code_hash().str(), first_name, last_name))));
} }
void AuthManager::check_password(uint64 query_id, string password) { void AuthManager::check_password(uint64 query_id, string password) {
@ -329,7 +326,7 @@ void AuthManager::check_password(uint64 query_id, string password) {
on_new_query(query_id); on_new_query(query_id);
password_ = std::move(password); password_ = std::move(password);
start_net_query(NetQueryType::GetPassword, start_net_query(NetQueryType::GetPassword,
G()->net_query_creator().create_unauth(create_storer(telegram_api::account_getPassword()))); G()->net_query_creator().create_unauth(telegram_api::account_getPassword()));
} }
void AuthManager::request_password_recovery(uint64 query_id) { void AuthManager::request_password_recovery(uint64 query_id) {
@ -339,7 +336,7 @@ void AuthManager::request_password_recovery(uint64 query_id) {
on_new_query(query_id); on_new_query(query_id);
start_net_query(NetQueryType::RequestPasswordRecovery, start_net_query(NetQueryType::RequestPasswordRecovery,
G()->net_query_creator().create_unauth(create_storer(telegram_api::auth_requestPasswordRecovery()))); G()->net_query_creator().create_unauth(telegram_api::auth_requestPasswordRecovery()));
} }
void AuthManager::recover_password(uint64 query_id, string code) { void AuthManager::recover_password(uint64 query_id, string code) {
@ -349,7 +346,7 @@ void AuthManager::recover_password(uint64 query_id, string code) {
on_new_query(query_id); on_new_query(query_id);
start_net_query(NetQueryType::RecoverPassword, start_net_query(NetQueryType::RecoverPassword,
G()->net_query_creator().create_unauth(create_storer(telegram_api::auth_recoverPassword(code)))); G()->net_query_creator().create_unauth(telegram_api::auth_recoverPassword(code)));
} }
void AuthManager::logout(uint64 query_id) { void AuthManager::logout(uint64 query_id) {
@ -380,7 +377,7 @@ void AuthManager::delete_account(uint64 query_id, const string &reason) {
on_new_query(query_id); on_new_query(query_id);
LOG(INFO) << "Deleting account"; LOG(INFO) << "Deleting account";
start_net_query(NetQueryType::DeleteAccount, start_net_query(NetQueryType::DeleteAccount,
G()->net_query_creator().create_unauth(create_storer(telegram_api::account_deleteAccount(reason)))); G()->net_query_creator().create_unauth(telegram_api::account_deleteAccount(reason)));
} }
void AuthManager::on_closing(bool destroy_flag) { void AuthManager::on_closing(bool destroy_flag) {
@ -512,10 +509,9 @@ void AuthManager::on_get_login_token(tl_object_ptr<telegram_api::auth_LoginToken
} }
imported_dc_id_ = token->dc_id_; imported_dc_id_ = token->dc_id_;
start_net_query(NetQueryType::ImportQrCode, start_net_query(NetQueryType::ImportQrCode, G()->net_query_creator().create_unauth(
G()->net_query_creator().create_unauth( telegram_api::auth_importLoginToken(std::move(token->token_)),
create_storer(telegram_api::auth_importLoginToken(std::move(token->token_))), DcId::internal(token->dc_id_)));
DcId::internal(token->dc_id_)));
break; break;
} }
case telegram_api::auth_loginTokenSuccess::ID: { case telegram_api::auth_loginTokenSuccess::ID: {
@ -570,8 +566,8 @@ void AuthManager::on_get_password_result(NetQueryPtr &result) {
return; return;
} else { } else {
start_net_query(NetQueryType::SignIn, start_net_query(NetQueryType::SignIn,
G()->net_query_creator().create_unauth(create_storer(telegram_api::auth_signIn( G()->net_query_creator().create_unauth(telegram_api::auth_signIn(
send_code_helper_.phone_number().str(), send_code_helper_.phone_code_hash().str(), code_)))); send_code_helper_.phone_number().str(), send_code_helper_.phone_code_hash().str(), code_)));
return; return;
} }
@ -587,8 +583,8 @@ void AuthManager::on_get_password_result(NetQueryPtr &result) {
wait_password_state_.srp_g_, wait_password_state_.srp_p_, wait_password_state_.srp_g_, wait_password_state_.srp_p_,
wait_password_state_.srp_B_, wait_password_state_.srp_id_); wait_password_state_.srp_B_, wait_password_state_.srp_id_);
start_net_query(NetQueryType::CheckPassword, G()->net_query_creator().create_unauth( start_net_query(NetQueryType::CheckPassword,
create_storer(telegram_api::auth_checkPassword(std::move(hash))))); G()->net_query_creator().create_unauth(telegram_api::auth_checkPassword(std::move(hash))));
} else { } else {
update_state(State::WaitPassword); update_state(State::WaitPassword);
if (query_id_ != 0) { if (query_id_ != 0) {
@ -763,8 +759,8 @@ void AuthManager::on_result(NetQueryPtr result) {
CHECK(DcId::is_valid(imported_dc_id_)); CHECK(DcId::is_valid(imported_dc_id_));
dc_id = DcId::internal(imported_dc_id_); dc_id = DcId::internal(imported_dc_id_);
} }
start_net_query(NetQueryType::GetPassword, G()->net_query_creator().create_unauth( start_net_query(NetQueryType::GetPassword,
create_storer(telegram_api::account_getPassword()), dc_id)); G()->net_query_creator().create_unauth(telegram_api::account_getPassword(), dc_id));
return; return;
} }
if (result->error().message() == CSlice("PHONE_NUMBER_BANNED")) { if (result->error().message() == CSlice("PHONE_NUMBER_BANNED")) {

6
td/telegram/ConfigManager.cpp
View File

@ -504,7 +504,7 @@ ActorOwn<> get_full_config(DcOption option, Promise<FullConfig> promise, ActorSh
int_dc_id, false /*is_main*/, true /*use_pfs*/, false /*is_cdn*/, int_dc_id, false /*is_main*/, true /*use_pfs*/, false /*is_cdn*/,
false /*need_destroy_auth_key*/, mtproto::AuthKey(), false /*need_destroy_auth_key*/, mtproto::AuthKey(),
std::vector<mtproto::ServerSalt>()); std::vector<mtproto::ServerSalt>());
auto query = G()->net_query_creator().create_unauth(create_storer(telegram_api::help_getConfig()), DcId::empty()); auto query = G()->net_query_creator().create_unauth(telegram_api::help_getConfig(), DcId::empty());
query->total_timeout_limit = 60 * 60 * 24; query->total_timeout_limit = 60 * 60 * 24;
query->set_callback(actor_shared(this)); query->set_callback(actor_shared(this));
query->dispatch_ttl = 0; query->dispatch_ttl = 0;
@ -931,7 +931,7 @@ void ConfigManager::get_app_config(Promise<td_api::object_ptr<td_api::JsonValue>
get_app_config_queries_.push_back(std::move(promise)); get_app_config_queries_.push_back(std::move(promise));
if (get_app_config_queries_.size() == 1) { if (get_app_config_queries_.size() == 1) {
auto query = G()->net_query_creator().create_unauth(create_storer(telegram_api::help_getAppConfig())); auto query = G()->net_query_creator().create_unauth(telegram_api::help_getAppConfig());
query->total_timeout_limit = 60 * 60 * 24; query->total_timeout_limit = 60 * 60 * 24;
G()->net_query_dispatcher().dispatch_with_callback(std::move(query), actor_shared(this, 1)); G()->net_query_dispatcher().dispatch_with_callback(std::move(query), actor_shared(this, 1));
} }
@ -987,7 +987,7 @@ void ConfigManager::on_dc_options_update(DcOptions dc_options) {
void ConfigManager::request_config_from_dc_impl(DcId dc_id) { void ConfigManager::request_config_from_dc_impl(DcId dc_id) {
config_sent_cnt_++; config_sent_cnt_++;
auto query = G()->net_query_creator().create_unauth(create_storer(telegram_api::help_getConfig()), dc_id); auto query = G()->net_query_creator().create_unauth(telegram_api::help_getConfig(), dc_id);
query->total_timeout_limit = 60 * 60 * 24; query->total_timeout_limit = 60 * 60 * 24;
G()->net_query_dispatcher().dispatch_with_callback(std::move(query), actor_shared(this, 0)); G()->net_query_dispatcher().dispatch_with_callback(std::move(query), actor_shared(this, 0));
} }

23
td/telegram/LanguagePackManager.cpp
View File

@ -384,7 +384,7 @@ void LanguagePackManager::send_language_get_difference_query(Language *language,
Promise<td_api::object_ptr<td_api::languagePackStrings>>()); Promise<td_api::object_ptr<td_api::languagePackStrings>>());
}); });
send_with_promise(G()->net_query_creator().create_unauth( send_with_promise(G()->net_query_creator().create_unauth(
create_storer(telegram_api::langpack_getDifference(language_pack_, language_code, version))), telegram_api::langpack_getDifference(language_pack_, language_code, version)),
std::move(request_promise)); std::move(request_promise));
} }
@ -797,9 +797,8 @@ void LanguagePackManager::get_languages(bool only_local,
send_closure(actor_id, &LanguagePackManager::on_get_languages, r_result.move_as_ok(), std::move(language_pack), send_closure(actor_id, &LanguagePackManager::on_get_languages, r_result.move_as_ok(), std::move(language_pack),
false, std::move(promise)); false, std::move(promise));
}); });
send_with_promise( send_with_promise(G()->net_query_creator().create_unauth(telegram_api::langpack_getLanguages(language_pack_)),
G()->net_query_creator().create_unauth(create_storer(telegram_api::langpack_getLanguages(language_pack_))), std::move(request_promise));
std::move(request_promise));
} }
void LanguagePackManager::search_language_info(string language_code, void LanguagePackManager::search_language_info(string language_code,
@ -819,9 +818,9 @@ void LanguagePackManager::search_language_info(string language_code,
send_closure(actor_id, &LanguagePackManager::on_get_language, r_result.move_as_ok(), std::move(language_pack), send_closure(actor_id, &LanguagePackManager::on_get_language, r_result.move_as_ok(), std::move(language_pack),
std::move(language_code), std::move(promise)); std::move(language_code), std::move(promise));
}); });
send_with_promise(G()->net_query_creator().create_unauth( send_with_promise(
create_storer(telegram_api::langpack_getLanguage(language_pack_, language_code))), G()->net_query_creator().create_unauth(telegram_api::langpack_getLanguage(language_pack_, language_code)),
std::move(request_promise)); std::move(request_promise));
} }
void LanguagePackManager::repair_chosen_language_info() { void LanguagePackManager::repair_chosen_language_info() {
@ -1080,9 +1079,9 @@ void LanguagePackManager::get_language_pack_strings(string language_code, vector
std::move(language_code), result->version_, false, vector<string>(), std::move(result->strings_), std::move(language_code), result->version_, false, vector<string>(), std::move(result->strings_),
std::move(promise)); std::move(promise));
}); });
send_with_promise(G()->net_query_creator().create_unauth( send_with_promise(
create_storer(telegram_api::langpack_getLangPack(language_pack_, language_code))), G()->net_query_creator().create_unauth(telegram_api::langpack_getLangPack(language_pack_, language_code)),
std::move(request_promise)); std::move(request_promise));
} else { } else {
auto request_promise = auto request_promise =
PromiseCreator::lambda([actor_id = actor_id(this), language_pack = language_pack_, language_code, keys, PromiseCreator::lambda([actor_id = actor_id(this), language_pack = language_pack_, language_code, keys,
@ -1095,8 +1094,8 @@ void LanguagePackManager::get_language_pack_strings(string language_code, vector
send_closure(actor_id, &LanguagePackManager::on_get_language_pack_strings, std::move(language_pack), send_closure(actor_id, &LanguagePackManager::on_get_language_pack_strings, std::move(language_pack),
std::move(language_code), -1, false, std::move(keys), r_result.move_as_ok(), std::move(promise)); std::move(language_code), -1, false, std::move(keys), r_result.move_as_ok(), std::move(promise));
}); });
send_with_promise(G()->net_query_creator().create_unauth(create_storer( send_with_promise(G()->net_query_creator().create_unauth(
telegram_api::langpack_getStrings(language_pack_, language_code, std::move(keys)))), telegram_api::langpack_getStrings(language_pack_, language_code, std::move(keys))),
std::move(request_promise)); std::move(request_promise));
} }
} }

22
td/telegram/MessagesManager.cpp
View File

@ -2545,10 +2545,10 @@ class EditInlineMessageQuery : public Td::ResultHandler {
LOG(DEBUG) << "Edit inline message with flags " << flags; LOG(DEBUG) << "Edit inline message with flags " << flags;
auto dc_id = DcId::internal(input_bot_inline_message_id->dc_id_); auto dc_id = DcId::internal(input_bot_inline_message_id->dc_id_);
send_query(G()->net_query_creator().create_guest_dc( send_query(G()->net_query_creator().create(
create_storer(telegram_api::messages_editInlineBotMessage( telegram_api::messages_editInlineBotMessage(flags, false /*ignored*/, std::move(input_bot_inline_message_id),
flags, false /*ignored*/, std::move(input_bot_inline_message_id), text, std::move(input_media), text, std::move(input_media), std::move(reply_markup),
std::move(reply_markup), std::move(entities))), std::move(entities)),
dc_id)); dc_id));
} }
@ -2650,10 +2650,9 @@ class SetInlineGameScoreQuery : public Td::ResultHandler {
LOG(INFO) << "Set inline game score to " << score; LOG(INFO) << "Set inline game score to " << score;
auto dc_id = DcId::internal(input_bot_inline_message_id->dc_id_); auto dc_id = DcId::internal(input_bot_inline_message_id->dc_id_);
send_query(G()->net_query_creator().create_guest_dc( send_query(G()->net_query_creator().create(
create_storer(telegram_api::messages_setInlineGameScore(flags, false /*ignored*/, false /*ignored*/, telegram_api::messages_setInlineGameScore(flags, false /*ignored*/, false /*ignored*/,
std::move(input_bot_inline_message_id), std::move(input_bot_inline_message_id), std::move(input_user), score),
std::move(input_user), score)),
dc_id)); dc_id));
} }
@ -2730,10 +2729,9 @@ class GetInlineGameHighScoresQuery : public Td::ResultHandler {
random_id_ = random_id; random_id_ = random_id;
auto dc_id = DcId::internal(input_bot_inline_message_id->dc_id_); auto dc_id = DcId::internal(input_bot_inline_message_id->dc_id_);
send_query( send_query(G()->net_query_creator().create(
G()->net_query_creator().create_guest_dc(create_storer(telegram_api::messages_getInlineGameHighScores( telegram_api::messages_getInlineGameHighScores(std::move(input_bot_inline_message_id), std::move(input_user)),
std::move(input_bot_inline_message_id), std::move(input_user))), dc_id));
dc_id));
} }
void on_result(uint64 id, BufferSlice packet) override { void on_result(uint64 id, BufferSlice packet) override {

6
td/telegram/Payments.cpp
View File

@ -494,8 +494,8 @@ class GetBankCardInfoQuery : public Td::ResultHandler {
} }
void send(const string &bank_card_number) { void send(const string &bank_card_number) {
send_query(G()->net_query_creator().create_guest_dc( send_query(G()->net_query_creator().create(telegram_api::payments_getBankCardData(bank_card_number),
create_storer(telegram_api::payments_getBankCardData(bank_card_number)), G()->get_webfile_dc_id())); G()->get_webfile_dc_id()));
} }
void on_result(uint64 id, BufferSlice packet) override { void on_result(uint64 id, BufferSlice packet) override {
@ -525,7 +525,7 @@ class SendLiteRequestQuery : public Td::ResultHandler {
} }
void send(BufferSlice request) { void send(BufferSlice request) {
send_query(G()->net_query_creator().create_unauth(create_storer(telegram_api::wallet_sendLiteRequest(std::move(request))))); send_query(G()->net_query_creator().create_unauth(telegram_api::wallet_sendLiteRequest(std::move(request))));
} }
void on_result(uint64 id, BufferSlice packet) override { void on_result(uint64 id, BufferSlice packet) override {

3
td/telegram/PhoneNumberManager.cpp
View File

@ -90,8 +90,7 @@ void PhoneNumberManager::resend_authentication_code(uint64 query_id) {
on_new_query(query_id); on_new_query(query_id);
start_net_query(NetQueryType::SendCode, start_net_query(NetQueryType::SendCode, G()->net_query_creator().create_unauth(r_resend_code.move_as_ok()));
G()->net_query_creator().create_unauth(create_storer(r_resend_code.move_as_ok())));
} }
template <class T> template <class T>

3
td/telegram/SecretChatActor.cpp
View File

@ -71,8 +71,7 @@ SecretChatActor::SecretChatActor(int32 id, unique_ptr<Context> context, bool can
template <class T> template <class T>
NetQueryPtr SecretChatActor::create_net_query(QueryType type, const T &function) { NetQueryPtr SecretChatActor::create_net_query(QueryType type, const T &function) {
return context_->net_query_creator().create(UniqueId::next(UniqueId::Type::Default, static_cast<uint8>(type)), return context_->net_query_creator().create(UniqueId::next(UniqueId::Type::Default, static_cast<uint8>(type)),
create_storer(function), DcId::main(), NetQuery::Type::Common, function, DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::On);
NetQuery::AuthFlag::On);
} }
void SecretChatActor::update_chat(telegram_api::object_ptr<telegram_api::EncryptedChat> chat) { void SecretChatActor::update_chat(telegram_api::object_ptr<telegram_api::EncryptedChat> chat) {

10
td/telegram/Td.cpp
View File

@ -104,7 +104,6 @@
#include "td/mtproto/HandshakeActor.h" #include "td/mtproto/HandshakeActor.h"
#include "td/mtproto/RawConnection.h" #include "td/mtproto/RawConnection.h"
#include "td/mtproto/TransportType.h" #include "td/mtproto/TransportType.h"
#include "td/mtproto/utils.h" // for create_storer, fetch_result, etc, TODO
#include "td/utils/buffer.h" #include "td/utils/buffer.h"
#include "td/utils/filesystem.h" #include "td/utils/filesystem.h"
@ -157,7 +156,7 @@ class GetNearestDcQuery : public Td::ResultHandler {
} }
void send() { void send() {
send_query(G()->net_query_creator().create_unauth(create_storer(telegram_api::help_getNearestDc()))); send_query(G()->net_query_creator().create_unauth(telegram_api::help_getNearestDc()));
} }
void on_result(uint64 id, BufferSlice packet) override { void on_result(uint64 id, BufferSlice packet) override {
@ -431,7 +430,7 @@ class GetDeepLinkInfoQuery : public Td::ResultHandler {
pos++; pos++;
} }
link.truncate(pos); link.truncate(pos);
send_query(G()->net_query_creator().create_unauth(create_storer(telegram_api::help_getDeepLinkInfo(link.str())))); send_query(G()->net_query_creator().create_unauth(telegram_api::help_getDeepLinkInfo(link.str())));
} }
void on_result(uint64 id, BufferSlice packet) override { void on_result(uint64 id, BufferSlice packet) override {
@ -483,8 +482,7 @@ class SaveAppLogQuery : public Td::ResultHandler {
vector<telegram_api::object_ptr<telegram_api::inputAppEvent>> input_app_events; vector<telegram_api::object_ptr<telegram_api::inputAppEvent>> input_app_events;
input_app_events.push_back( input_app_events.push_back(
make_tl_object<telegram_api::inputAppEvent>(G()->server_time_cached(), type, peer_id, std::move(data))); make_tl_object<telegram_api::inputAppEvent>(G()->server_time_cached(), type, peer_id, std::move(data)));
send_query(G()->net_query_creator().create_unauth( send_query(G()->net_query_creator().create_unauth(telegram_api::help_saveAppLog(std::move(input_app_events))));
create_storer(telegram_api::help_saveAppLog(std::move(input_app_events)))));
} }
void on_result(uint64 id, BufferSlice packet) override { void on_result(uint64 id, BufferSlice packet) override {
@ -511,7 +509,7 @@ class TestQuery : public Td::ResultHandler {
} }
void send() { void send() {
send_query(G()->net_query_creator().create_unauth(create_storer(telegram_api::help_getConfig()))); send_query(G()->net_query_creator().create_unauth(telegram_api::help_getConfig()));
} }
void on_result(uint64 id, BufferSlice packet) override { void on_result(uint64 id, BufferSlice packet) override {

28
td/telegram/files/FileDownloader.cpp
View File

@ -246,15 +246,19 @@ Result<std::pair<NetQueryPtr, bool>> FileDownloader::start_part(Part part, int32
} }
#endif #endif
DcId dc_id = remote_.is_web() ? G()->get_webfile_dc_id() : remote_.get_dc_id(); DcId dc_id = remote_.is_web() ? G()->get_webfile_dc_id() : remote_.get_dc_id();
net_query = G()->net_query_creator().create( auto id = UniqueId::next(UniqueId::Type::Default, static_cast<uint8>(QueryType::Default));
UniqueId::next(UniqueId::Type::Default, static_cast<uint8>(QueryType::Default)), net_query = remote_.is_web()
remote_.is_web() ? G()->net_query_creator().create(
? create_storer(telegram_api::upload_getWebFile(remote_.as_input_web_file_location(), id,
static_cast<int32>(part.offset), static_cast<int32>(size))) telegram_api::upload_getWebFile(remote_.as_input_web_file_location(),
: create_storer(telegram_api::upload_getFile(flags, false /*ignored*/, false /*ignored*/, static_cast<int32>(part.offset), static_cast<int32>(size)),
remote_.as_input_file_location(), dc_id, net_query_type, NetQuery::AuthFlag::On)
static_cast<int32>(part.offset), static_cast<int32>(size))), : G()->net_query_creator().create(
dc_id, net_query_type, NetQuery::AuthFlag::On); id,
telegram_api::upload_getFile(flags, false /*ignored*/, false /*ignored*/,
remote_.as_input_file_location(),
static_cast<int32>(part.offset), static_cast<int32>(size)),
dc_id, net_query_type, NetQuery::AuthFlag::On);
} else { } else {
if (remote_.is_web()) { if (remote_.is_web()) {
return Status::Error("Can't download web file from CDN"); return Status::Error("Can't download web file from CDN");
@ -267,12 +271,12 @@ Result<std::pair<NetQueryPtr, bool>> FileDownloader::start_part(Part part, int32
LOG(DEBUG) << part.id << " " << to_string(query); LOG(DEBUG) << part.id << " " << to_string(query);
net_query = net_query =
G()->net_query_creator().create(UniqueId::next(UniqueId::Type::Default, static_cast<uint8>(QueryType::CDN)), G()->net_query_creator().create(UniqueId::next(UniqueId::Type::Default, static_cast<uint8>(QueryType::CDN)),
create_storer(query), cdn_dc_id_, net_query_type, NetQuery::AuthFlag::Off); query, cdn_dc_id_, net_query_type, NetQuery::AuthFlag::Off);
} else { } else {
auto query = telegram_api::upload_reuploadCdnFile(BufferSlice(cdn_file_token_), BufferSlice(it->second)); auto query = telegram_api::upload_reuploadCdnFile(BufferSlice(cdn_file_token_), BufferSlice(it->second));
LOG(DEBUG) << part.id << " " << to_string(query); LOG(DEBUG) << part.id << " " << to_string(query);
net_query = G()->net_query_creator().create( net_query = G()->net_query_creator().create(
UniqueId::next(UniqueId::Type::Default, static_cast<uint8>(QueryType::ReuploadCDN)), create_storer(query), UniqueId::next(UniqueId::Type::Default, static_cast<uint8>(QueryType::ReuploadCDN)), query,
remote_.get_dc_id(), net_query_type, NetQuery::AuthFlag::On); remote_.get_dc_id(), net_query_type, NetQuery::AuthFlag::On);
cdn_part_reupload_token_.erase(it); cdn_part_reupload_token_.erase(it);
} }
@ -466,7 +470,7 @@ Result<FileLoader::CheckInfo> FileDownloader::check_loop(int64 checked_prefix_si
auto query = auto query =
telegram_api::upload_getFileHashes(remote_.as_input_file_location(), narrow_cast<int32>(checked_prefix_size)); telegram_api::upload_getFileHashes(remote_.as_input_file_location(), narrow_cast<int32>(checked_prefix_size));
auto net_query_type = is_small_ ? NetQuery::Type::DownloadSmall : NetQuery::Type::Download; auto net_query_type = is_small_ ? NetQuery::Type::DownloadSmall : NetQuery::Type::Download;
auto net_query = G()->net_query_creator().create(create_storer(query), remote_.get_dc_id(), net_query_type); auto net_query = G()->net_query_creator().create(query, remote_.get_dc_id(), net_query_type);
info.queries.push_back(std::move(net_query)); info.queries.push_back(std::move(net_query));
break; break;
} }

6
td/telegram/files/FileGenerateManager.cpp
View File

@ -203,9 +203,9 @@ class MapDownloadGenerateActor : public FileGenerateActor {
net_callback_ = create_actor<Callback>("MapDownloadGenerateCallback", actor_id(this)); net_callback_ = create_actor<Callback>("MapDownloadGenerateCallback", actor_id(this));
LOG(INFO) << "Download " << conversion_; LOG(INFO) << "Download " << conversion_;
auto query = G()->net_query_creator().create( auto query =
create_storer(telegram_api::upload_getWebFile(r_input_web_file.move_as_ok(), 0, 1 << 20)), G()->net_query_creator().create(telegram_api::upload_getWebFile(r_input_web_file.move_as_ok(), 0, 1 << 20),
G()->get_webfile_dc_id(), NetQuery::Type::DownloadSmall); G()->get_webfile_dc_id(), NetQuery::Type::DownloadSmall);
G()->net_query_dispatcher().dispatch_with_callback(std::move(query), {net_callback_.get(), 0}); G()->net_query_dispatcher().dispatch_with_callback(std::move(query), {net_callback_.get(), 0});
} }

4
td/telegram/files/FileUploader.cpp
View File

@ -277,10 +277,10 @@ Result<std::pair<NetQueryPtr, bool>> FileUploader::start_part(Part part, int32 p
if (big_flag_) { if (big_flag_) {
auto query = auto query =
telegram_api::upload_saveBigFilePart(file_id_, part.id, local_is_ready_ ? part_count : -1, std::move(bytes)); telegram_api::upload_saveBigFilePart(file_id_, part.id, local_is_ready_ ? part_count : -1, std::move(bytes));
net_query = G()->net_query_creator().create(create_storer(query), DcId::main(), NetQuery::Type::Upload); net_query = G()->net_query_creator().create(query, DcId::main(), NetQuery::Type::Upload);
} else { } else {
auto query = telegram_api::upload_saveFilePart(file_id_, part.id, std::move(bytes)); auto query = telegram_api::upload_saveFilePart(file_id_, part.id, std::move(bytes));
net_query = G()->net_query_creator().create(create_storer(query), DcId::main(), NetQuery::Type::Upload); net_query = G()->net_query_creator().create(query, DcId::main(), NetQuery::Type::Upload);
} }
net_query->file_type_ = narrow_cast<int32>(file_type_); net_query->file_type_ = narrow_cast<int32>(file_type_);
return std::make_pair(std::move(net_query), false); return std::make_pair(std::move(net_query), false);

9
td/telegram/net/DcAuthManager.cpp
View File

@ -171,9 +171,8 @@ void DcAuthManager::dc_loop(DcInfo &dc) {
// send auth.exportAuthorization to auth_dc // send auth.exportAuthorization to auth_dc
VLOG(dc) << "Send exportAuthorization to " << dc.dc_id; VLOG(dc) << "Send exportAuthorization to " << dc.dc_id;
auto id = UniqueId::next(); auto id = UniqueId::next();
auto query = G()->net_query_creator().create( auto query = G()->net_query_creator().create(id, telegram_api::auth_exportAuthorization(dc.dc_id.get_raw_id()),
id, create_storer(telegram_api::auth_exportAuthorization(dc.dc_id.get_raw_id())), DcId::main(), DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::On);
NetQuery::Type::Common, NetQuery::AuthFlag::On);
query->total_timeout_limit = 60 * 60 * 24; query->total_timeout_limit = 60 * 60 * 24;
G()->net_query_dispatcher().dispatch_with_callback(std::move(query), actor_shared(this, dc.dc_id.get_raw_id())); G()->net_query_dispatcher().dispatch_with_callback(std::move(query), actor_shared(this, dc.dc_id.get_raw_id()));
dc.wait_id = id; dc.wait_id = id;
@ -189,8 +188,8 @@ void DcAuthManager::dc_loop(DcInfo &dc) {
uint64 id = UniqueId::next(); uint64 id = UniqueId::next();
VLOG(dc) << "Send importAuthorization to " << dc.dc_id; VLOG(dc) << "Send importAuthorization to " << dc.dc_id;
auto query = G()->net_query_creator().create( auto query = G()->net_query_creator().create(
id, create_storer(telegram_api::auth_importAuthorization(dc.export_id, std::move(dc.export_bytes))), id, telegram_api::auth_importAuthorization(dc.export_id, std::move(dc.export_bytes)), dc.dc_id,
dc.dc_id, NetQuery::Type::Common, NetQuery::AuthFlag::Off); NetQuery::Type::Common, NetQuery::AuthFlag::Off);
query->total_timeout_limit = 60 * 60 * 24; query->total_timeout_limit = 60 * 60 * 24;
G()->net_query_dispatcher().dispatch_with_callback(std::move(query), actor_shared(this, dc.dc_id.get_raw_id())); G()->net_query_dispatcher().dispatch_with_callback(std::move(query), actor_shared(this, dc.dc_id.get_raw_id()));
dc.wait_id = id; dc.wait_id = id;

5
td/telegram/net/NetQuery.h
View File

@ -13,7 +13,7 @@
#include "td/actor/PromiseFuture.h" #include "td/actor/PromiseFuture.h"
#include "td/actor/SignalSlot.h" #include "td/actor/SignalSlot.h"
#include "td/mtproto/utils.h" // for create_storer, fetch_result TODO #include "td/mtproto/utils.h" // for fetch_result TODO
#include "td/utils/buffer.h" #include "td/utils/buffer.h"
#include "td/utils/common.h" #include "td/utils/common.h"
@ -365,6 +365,7 @@ inline StringBuilder &operator<<(StringBuilder &stream, const NetQuery &net_quer
stream << "]"; stream << "]";
return stream; return stream;
} }
inline StringBuilder &operator<<(StringBuilder &stream, const NetQueryPtr &net_query_ptr) { inline StringBuilder &operator<<(StringBuilder &stream, const NetQueryPtr &net_query_ptr) {
return stream << *net_query_ptr; return stream << *net_query_ptr;
} }
@ -397,6 +398,7 @@ Result<typename T::ReturnType> fetch_result(Result<NetQueryPtr> r_query) {
inline void NetQueryCallback::on_result(NetQueryPtr query) { inline void NetQueryCallback::on_result(NetQueryPtr query) {
on_result_resendable(std::move(query), Auto()); on_result_resendable(std::move(query), Auto());
} }
inline void NetQueryCallback::on_result_resendable(NetQueryPtr query, Promise<NetQueryPtr> promise) { inline void NetQueryCallback::on_result_resendable(NetQueryPtr query, Promise<NetQueryPtr> promise) {
on_result(std::move(query)); on_result(std::move(query));
} }
@ -404,6 +406,7 @@ inline void NetQueryCallback::on_result_resendable(NetQueryPtr query, Promise<Ne
inline void start_migrate(NetQueryPtr &net_query, int32 sched_id) { inline void start_migrate(NetQueryPtr &net_query, int32 sched_id) {
net_query->start_migrate(sched_id); net_query->start_migrate(sched_id);
} }
inline void finish_migrate(NetQueryPtr &net_query) { inline void finish_migrate(NetQueryPtr &net_query) {
net_query->finish_migrate(); net_query->finish_migrate();
} }

11
td/telegram/net/NetQueryCreator.cpp
View File

@ -6,19 +6,24 @@
// //
#include "td/telegram/net/NetQueryCreator.h" #include "td/telegram/net/NetQueryCreator.h"
#include "td/telegram/telegram_api.h"
#include "td/utils/format.h" #include "td/utils/format.h"
#include "td/utils/Gzip.h" #include "td/utils/Gzip.h"
#include "td/utils/logging.h" #include "td/utils/logging.h"
#include "td/utils/Slice.h" #include "td/utils/Slice.h"
#include "td/utils/Storer.h"
namespace td { namespace td {
NetQueryPtr NetQueryCreator::create_regular(const Storer &storer) { NetQueryPtr NetQueryCreator::create(const telegram_api::Function &function, DcId dc_id, NetQuery::Type type) {
return create(UniqueId::next(), storer, DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::On); return create(UniqueId::next(), function, dc_id, type, NetQuery::AuthFlag::On);
} }
NetQueryPtr NetQueryCreator::create(uint64 id, const Storer &storer, DcId dc_id, NetQuery::Type type, NetQueryPtr NetQueryCreator::create(uint64 id, const telegram_api::Function &function, DcId dc_id, NetQuery::Type type,
NetQuery::AuthFlag auth_flag) { NetQuery::AuthFlag auth_flag) {
LOG(DEBUG) << "Create query " << to_string(function);
auto storer = DefaultStorer<telegram_api::Function>(function);
BufferSlice slice(storer.size()); BufferSlice slice(storer.size());
auto real_size = storer.store(slice.as_slice().ubegin()); auto real_size = storer.store(slice.as_slice().ubegin());
LOG_CHECK(real_size == slice.size()) << real_size << " " << slice.size() << " " LOG_CHECK(real_size == slice.size()) << real_size << " " << slice.size() << " "

32
td/telegram/net/NetQueryCreator.h
View File

@ -6,18 +6,19 @@
// //
#pragma once #pragma once
#include "td/mtproto/utils.h"
#include "td/telegram/net/DcId.h" #include "td/telegram/net/DcId.h"
#include "td/telegram/net/NetQuery.h" #include "td/telegram/net/NetQuery.h"
#include "td/telegram/UniqueId.h" #include "td/telegram/UniqueId.h"
#include "td/utils/buffer.h" #include "td/utils/buffer.h"
#include "td/utils/ObjectPool.h" #include "td/utils/ObjectPool.h"
#include "td/utils/StorerBase.h"
namespace td { namespace td {
namespace telegram_api {
class Function;
} // namespace telegram_api
class NetQueryCreator { class NetQueryCreator {
public: public:
NetQueryCreator() { NetQueryCreator() {
@ -33,26 +34,15 @@ class NetQueryCreator {
NetQuery::Type::Common, NetQuery::AuthFlag::On, NetQuery::GzipFlag::Off, 0); NetQuery::Type::Common, NetQuery::AuthFlag::On, NetQuery::GzipFlag::Off, 0);
} }
template <class T> NetQueryPtr create(const telegram_api::Function &function, DcId dc_id = DcId::main(),
NetQueryPtr create(const T &function) { NetQuery::Type type = NetQuery::Type::Common);
return create_regular(create_storer(function));
NetQueryPtr create_unauth(const telegram_api::Function &function, DcId dc_id = DcId::main()) {
return create(UniqueId::next(), function, dc_id, NetQuery::Type::Common, NetQuery::AuthFlag::Off);
} }
NetQueryPtr create(const Storer &storer, DcId dc_id, NetQuery::Type type) { NetQueryPtr create(uint64 id, const telegram_api::Function &function, DcId dc_id, NetQuery::Type type,
return create(UniqueId::next(), storer, dc_id, type, NetQuery::AuthFlag::On); NetQuery::AuthFlag auth_flag);
}
NetQueryPtr create_regular(const Storer &storer);
NetQueryPtr create_guest_dc(const Storer &storer, DcId dc_id) {
return create(UniqueId::next(), storer, dc_id, NetQuery::Type::Common, NetQuery::AuthFlag::On);
}
NetQueryPtr create_unauth(const Storer &storer, DcId dc_id = DcId::main()) {
return create(UniqueId::next(), storer, dc_id, NetQuery::Type::Common, NetQuery::AuthFlag::Off);
}
NetQueryPtr create(uint64 id, const Storer &storer, DcId dc_id, NetQuery::Type type, NetQuery::AuthFlag auth_flag);
private: private:
ObjectPool<NetQuery> object_pool_; ObjectPool<NetQuery> object_pool_;

17
td/telegram/net/Session.cpp
View File

@ -25,6 +25,7 @@
#include "td/mtproto/SessionConnection.h" #include "td/mtproto/SessionConnection.h"
#include "td/mtproto/TransportType.h" #include "td/mtproto/TransportType.h"
#include "td/utils/as.h"
#include "td/utils/format.h" #include "td/utils/format.h"
#include "td/utils/logging.h" #include "td/utils/logging.h"
#include "td/utils/misc.h" #include "td/utils/misc.h"
@ -540,11 +541,8 @@ void Session::on_session_created(uint64 unique_id, uint64 first_id) {
LOG(INFO) << "New session " << unique_id << " created with first message_id " << first_id; LOG(INFO) << "New session " << unique_id << " created with first message_id " << first_id;
if (is_main_) { if (is_main_) {
LOG(DEBUG) << "Sending updatesTooLong to force getDifference"; LOG(DEBUG) << "Sending updatesTooLong to force getDifference";
telegram_api::updatesTooLong too_long; BufferSlice packet(4);
auto storer = create_storer(too_long); as<int32>(packet.as_slice().begin()) = telegram_api::updatesTooLong::ID;
BufferSlice packet(storer.size());
auto real_size = storer.store(packet.as_slice().ubegin());
CHECK(real_size == packet.size());
return_query(G()->net_query_creator().create_update(std::move(packet))); return_query(G()->net_query_creator().create_update(std::move(packet)));
} }
@ -1105,9 +1103,8 @@ bool Session::connection_send_check_main_key(ConnectionInfo *info) {
LOG(INFO) << "Check main key"; LOG(INFO) << "Check main key";
being_checked_main_auth_key_id_ = key_id; being_checked_main_auth_key_id_ = key_id;
last_check_query_id_ = UniqueId::next(UniqueId::BindKey); last_check_query_id_ = UniqueId::next(UniqueId::BindKey);
NetQueryPtr query = NetQueryPtr query = G()->net_query_creator().create(last_check_query_id_, telegram_api::help_getNearestDc(),
G()->net_query_creator().create(last_check_query_id_, create_storer(telegram_api::help_getNearestDc()), DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::On);
DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::On);
query->dispatch_ttl = 0; query->dispatch_ttl = 0;
query->set_callback(actor_shared(this)); query->set_callback(actor_shared(this));
connection_send_query(info, std::move(query)); connection_send_query(info, std::move(query));
@ -1143,8 +1140,8 @@ bool Session::connection_send_bind_key(ConnectionInfo *info) {
LOG(INFO) << "Bind key: " << tag("tmp", key_id) << tag("perm", static_cast<uint64>(perm_auth_key_id)); LOG(INFO) << "Bind key: " << tag("tmp", key_id) << tag("perm", static_cast<uint64>(perm_auth_key_id));
NetQueryPtr query = G()->net_query_creator().create( NetQueryPtr query = G()->net_query_creator().create(
last_bind_query_id_, last_bind_query_id_,
create_storer(telegram_api::auth_bindTempAuthKey(perm_auth_key_id, nonce, expires_at, std::move(encrypted))), telegram_api::auth_bindTempAuthKey(perm_auth_key_id, nonce, expires_at, std::move(encrypted)), DcId::main(),
DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::On); NetQuery::Type::Common, NetQuery::AuthFlag::On);
query->dispatch_ttl = 0; query->dispatch_ttl = 0;
query->set_callback(actor_shared(this)); query->set_callback(actor_shared(this));
connection_send_query(info, std::move(query), message_id); connection_send_query(info, std::move(query), message_id);

3
td/telegram/net/TempAuthKeyWatchdog.h
View File

@ -111,8 +111,7 @@ class TempAuthKeyWatchdog : public NetQueryCallback {
return; return;
} }
LOG(WARNING) << "Start auth_dropTempAuthKeys except keys " << format::as_array(ids); LOG(WARNING) << "Start auth_dropTempAuthKeys except keys " << format::as_array(ids);
auto query = auto query = G()->net_query_creator().create_unauth(telegram_api::auth_dropTempAuthKeys(std::move(ids)));
G()->net_query_creator().create_unauth(create_storer(telegram_api::auth_dropTempAuthKeys(std::move(ids))));
G()->net_query_dispatcher().dispatch_with_callback(std::move(query), actor_shared(this)); G()->net_query_dispatcher().dispatch_with_callback(std::move(query), actor_shared(this));
} }