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

Remove includes of SequenceDispatcher.h from headers.

This commit is contained in:
levlam 2022-02-01 19:34:14 +03:00
parent ad38f712e8
commit 02b99d0fbf
14 changed files with 75 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
td/telegram/GameManager.cpp
View File

@ -18,7 +18,6 @@
#include "td/telegram/net/DcId.h"
#include "td/telegram/net/NetActor.h"
#include "td/telegram/net/NetQueryCreator.h"
#include "td/telegram/SequenceDispatcher.h"
#include "td/telegram/Td.h"
#include "td/telegram/UpdatesManager.h"
@ -56,10 +55,10 @@ class SetGameScoreActor final : public NetActorOnce {
}
CHECK(input_user != nullptr);
auto query = G()->net_query_creator().create(
send_query(G()->net_query_creator().create(
telegram_api::messages_setGameScore(flags, false /*ignored*/, false /*ignored*/, std::move(input_peer),
message_id.get_server_message_id().get(), std::move(input_user), score), {sequence_dispatcher_id});
send_query(std::move(query));
message_id.get_server_message_id().get(), std::move(input_user), score),
{sequence_dispatcher_id}));
}
void on_result(BufferSlice packet) final {

84
td/telegram/MessagesManager.cpp
View File

@ -50,7 +50,6 @@
#include "td/telegram/ReplyMarkup.h"
#include "td/telegram/ReplyMarkup.hpp"
#include "td/telegram/SecretChatsManager.h"
#include "td/telegram/SequenceDispatcher.h"
#include "td/telegram/SponsoredMessageManager.h"
#include "td/telegram/Td.h"
#include "td/telegram/TdDb.h"
@ -338,7 +337,8 @@ class GetPinnedDialogsActor final : public NetActorOnce {
NetQueryRef send(FolderId folder_id, uint64 sequence_id) {
folder_id_ = folder_id;
auto query = G()->net_query_creator().create(telegram_api::messages_getPinnedDialogs(folder_id.get()), {sequence_id});
auto query =
G()->net_query_creator().create(telegram_api::messages_getPinnedDialogs(folder_id.get()), {sequence_id});
auto result = query.get_weak();
send_query(std::move(query));
return result;
@ -791,10 +791,10 @@ class GetDialogListActor final : public NetActorOnce {
int32 flags =
telegram_api::messages_getDialogs::EXCLUDE_PINNED_MASK | telegram_api::messages_getDialogs::FOLDER_ID_MASK;
auto query = G()->net_query_creator().create(
send_query(G()->net_query_creator().create(
telegram_api::messages_getDialogs(flags, false /*ignored*/, folder_id.get(), offset_date,
offset_message_id.get(), std::move(input_peer), limit, 0), {sequence_id});
send_query(std::move(query));
offset_message_id.get(), std::move(input_peer), limit, 0),
{sequence_id}));
}
void on_result(BufferSlice packet) final {
@ -3090,9 +3090,9 @@ class SaveDefaultSendAsActor final : public NetActorOnce {
auto send_as_input_peer = td_->messages_manager_->get_input_peer(send_as_dialog_id, AccessRights::Read);
CHECK(send_as_input_peer != nullptr);
auto query = G()->net_query_creator().create(
telegram_api::messages_saveDefaultSendAs(std::move(input_peer), std::move(send_as_input_peer)), {sequence_dispatcher_id});
send_query(std::move(query));
send_query(G()->net_query_creator().create(
telegram_api::messages_saveDefaultSendAs(std::move(input_peer), std::move(send_as_input_peer)),
{sequence_dispatcher_id}));
}
void on_result(BufferSlice packet) final {
@ -3190,10 +3190,12 @@ class SendMessageActor final : public NetActorOnce {
flags |= MessagesManager::SEND_MESSAGE_FLAG_HAS_SEND_AS;
}
auto query = G()->net_query_creator().create(telegram_api::messages_sendMessage(
flags, false /*ignored*/, false /*ignored*/, false /*ignored*/, false /*ignored*/, false /*ignored*/,
std::move(input_peer), reply_to_message_id.get_server_message_id().get(), text, random_id,
std::move(reply_markup), std::move(entities), schedule_date, std::move(as_input_peer)), {sequence_dispatcher_id});
auto query = G()->net_query_creator().create(
telegram_api::messages_sendMessage(
flags, false /*ignored*/, false /*ignored*/, false /*ignored*/, false /*ignored*/, false /*ignored*/,
std::move(input_peer), reply_to_message_id.get_server_message_id().get(), text, random_id,
std::move(reply_markup), std::move(entities), schedule_date, std::move(as_input_peer)),
{sequence_dispatcher_id});
if (G()->shared_config().get_option_boolean("use_quick_ack")) {
query->quick_ack_promise_ = PromiseCreator::lambda(
[random_id](Unit) {
@ -3380,12 +3382,13 @@ class SendMultiMediaActor final : public NetActorOnce {
flags |= MessagesManager::SEND_MESSAGE_FLAG_HAS_SEND_AS;
}
auto query = G()->net_query_creator().create(telegram_api::messages_sendMultiMedia(
flags, false /*ignored*/, false /*ignored*/, false /*ignored*/, false /*ignored*/, std::move(input_peer),
reply_to_message_id.get_server_message_id().get(), std::move(input_single_media), schedule_date,
std::move(as_input_peer)), {sequence_dispatcher_id});
// no quick ack, because file reference errors are very likely to happen
send_query(std::move(query));
send_query(G()->net_query_creator().create(
telegram_api::messages_sendMultiMedia(flags, false /*ignored*/, false /*ignored*/, false /*ignored*/,
false /*ignored*/, std::move(input_peer),
reply_to_message_id.get_server_message_id().get(),
std::move(input_single_media), schedule_date, std::move(as_input_peer)),
{sequence_dispatcher_id}));
}
void on_result(BufferSlice packet) final {
@ -3497,10 +3500,12 @@ class SendMediaActor final : public NetActorOnce {
flags |= MessagesManager::SEND_MESSAGE_FLAG_HAS_SEND_AS;
}
auto query = G()->net_query_creator().create(telegram_api::messages_sendMedia(
flags, false /*ignored*/, false /*ignored*/, false /*ignored*/, false /*ignored*/, std::move(input_peer),
reply_to_message_id.get_server_message_id().get(), std::move(input_media), text, random_id,
std::move(reply_markup), std::move(entities), schedule_date, std::move(as_input_peer)), {sequence_dispatcher_id});
auto query = G()->net_query_creator().create(
telegram_api::messages_sendMedia(
flags, false /*ignored*/, false /*ignored*/, false /*ignored*/, false /*ignored*/, std::move(input_peer),
reply_to_message_id.get_server_message_id().get(), std::move(input_media), text, random_id,
std::move(reply_markup), std::move(entities), schedule_date, std::move(as_input_peer)),
{sequence_dispatcher_id});
if (G()->shared_config().get_option_boolean("use_quick_ack") && was_uploaded_) {
query->quick_ack_promise_ = PromiseCreator::lambda(
[random_id](Unit) {
@ -3669,10 +3674,9 @@ class SendScheduledMessageActor final : public NetActorOnce {
}
int32 server_message_id = message_id.get_scheduled_server_message_id().get();
auto query = G()->net_query_creator().create(
telegram_api::messages_sendScheduledMessages(std::move(input_peer), {server_message_id}), {sequence_dispatcher_id});
send_query(std::move(query));
send_query(G()->net_query_creator().create(
telegram_api::messages_sendScheduledMessages(std::move(input_peer), {server_message_id}),
{sequence_dispatcher_id}));
}
void on_result(BufferSlice packet) final {
@ -3748,10 +3752,11 @@ class EditMessageActor final : public NetActorOnce {
int32 server_message_id = schedule_date != 0 ? message_id.get_scheduled_server_message_id().get()
: message_id.get_server_message_id().get();
auto query = G()->net_query_creator().create(telegram_api::messages_editMessage(
flags, false /*ignored*/, std::move(input_peer), server_message_id, text, std::move(input_media),
std::move(reply_markup), std::move(entities), schedule_date), {sequence_dispatcher_id});
send_query(std::move(query));
send_query(G()->net_query_creator().create(
telegram_api::messages_editMessage(flags, false /*ignored*/, std::move(input_peer), server_message_id, text,
std::move(input_media), std::move(reply_markup), std::move(entities),
schedule_date),
{sequence_dispatcher_id}));
}
void on_result(BufferSlice packet) final {
@ -3868,10 +3873,12 @@ class ForwardMessagesActor final : public NetActorOnce {
flags |= MessagesManager::SEND_MESSAGE_FLAG_HAS_SEND_AS;
}
auto query = G()->net_query_creator().create(telegram_api::messages_forwardMessages(
flags, false /*ignored*/, false /*ignored*/, false /*ignored*/, false /*ignored*/, false /*ignored*/,
false /*ignored*/, std::move(from_input_peer), MessagesManager::get_server_message_ids(message_ids),
std::move(random_ids), std::move(to_input_peer), schedule_date, std::move(as_input_peer)), {sequence_dispatcher_id});
auto query = G()->net_query_creator().create(
telegram_api::messages_forwardMessages(
flags, false /*ignored*/, false /*ignored*/, false /*ignored*/, false /*ignored*/, false /*ignored*/,
false /*ignored*/, std::move(from_input_peer), MessagesManager::get_server_message_ids(message_ids),
std::move(random_ids), std::move(to_input_peer), schedule_date, std::move(as_input_peer)),
{sequence_dispatcher_id});
if (G()->shared_config().get_option_boolean("use_quick_ack")) {
query->quick_ack_promise_ = PromiseCreator::lambda(
[random_ids = random_ids_](Unit) {
@ -3965,9 +3972,8 @@ class SendScreenshotNotificationQuery final : public Td::ResultHandler {
auto input_peer = td_->messages_manager_->get_input_peer(dialog_id, AccessRights::Write);
CHECK(input_peer != nullptr);
auto query = G()->net_query_creator().create(
telegram_api::messages_sendScreenshotNotification(std::move(input_peer), 0, random_id));
send_query(std::move(query));
send_query(G()->net_query_creator().create(
telegram_api::messages_sendScreenshotNotification(std::move(input_peer), 0, random_id)));
}
void on_result(BufferSlice packet) final {
@ -19586,7 +19592,7 @@ void MessagesManager::save_dialog_draft_message_on_server(DialogId dialog_id) {
});
}
// TODO do not send two queries simultaneously or use SequenceDispatcher
// TODO do not send two queries simultaneously or use InvokeAfter
td_->create_handler<SaveDraftMessageQuery>(std::move(promise))->send(dialog_id, d->draft_message);
}
@ -20151,7 +20157,7 @@ void MessagesManager::update_dialog_notification_settings_on_server(DialogId dia
void MessagesManager::send_update_dialog_notification_settings_query(const Dialog *d, Promise<Unit> &&promise) {
CHECK(!td_->auth_manager_->is_bot());
CHECK(d != nullptr);
// TODO do not send two queries simultaneously or use SequenceDispatcher
// TODO do not send two queries simultaneously or use InvokeAfter
td_->create_handler<UpdateDialogNotifySettingsQuery>(std::move(promise))
->send(d->dialog_id, d->notification_settings);
}
@ -32886,7 +32892,7 @@ void MessagesManager::set_dialog_folder_id_on_server(DialogId dialog_id, bool fr
});
}
// TODO do not send two queries simultaneously or use SequenceDispatcher
// TODO do not send two queries simultaneously or use InvokeAfter
td_->create_handler<EditPeerFoldersQuery>(std::move(promise))->send(dialog_id, d->folder_id);
}

4
td/telegram/Payments.cpp
View File

@ -567,8 +567,8 @@ class GetBankCardInfoQuery final : public Td::ResultHandler {
}
void send(const string &bank_card_number) {
send_query(G()->net_query_creator().create(telegram_api::payments_getBankCardData(bank_card_number),
{}, G()->get_webfile_dc_id()));
send_query(G()->net_query_creator().create(telegram_api::payments_getBankCardData(bank_card_number), {},
G()->get_webfile_dc_id()));
}
void on_result(BufferSlice packet) final {

1
td/telegram/PollManager.cpp
View File

@ -19,7 +19,6 @@
#include "td/telegram/net/NetActor.h"
#include "td/telegram/PollId.hpp"
#include "td/telegram/PollManager.hpp"
#include "td/telegram/SequenceDispatcher.h"
#include "td/telegram/StateManager.h"
#include "td/telegram/Td.h"
#include "td/telegram/TdDb.h"

3
td/telegram/SecretChatActor.cpp
View File

@ -70,7 +70,8 @@ SecretChatActor::SecretChatActor(int32 id, unique_ptr<Context> context, bool can
template <class T>
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)),
function, {}, DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::On);
function, {}, DcId::main(), NetQuery::Type::Common,
NetQuery::AuthFlag::On);
}
void SecretChatActor::update_chat(telegram_api::object_ptr<telegram_api::EncryptedChat> chat) {

8
td/telegram/SequenceDispatcher.cpp
View File

@ -282,7 +282,7 @@ void MultiSequenceDispatcherOld::ready_to_close() {
}
}
class MultiSequenceDispatcherNewImpl final : public MultiSequenceDispatcherNew {
class MultiSequenceDispatcherImpl final : public MultiSequenceDispatcher {
public:
void send(NetQueryPtr query) final {
auto callback = query->move_callback();
@ -371,7 +371,7 @@ class MultiSequenceDispatcherNewImpl final : public MultiSequenceDispatcherNew {
void try_resend(TaskId task_id) {
auto &node = *scheduler_.get_task_extra(task_id);
auto promise = promise_send_closure(actor_shared(this, task_id), &MultiSequenceDispatcherNewImpl::on_resend);
auto promise = promise_send_closure(actor_shared(this, task_id), &MultiSequenceDispatcherImpl::on_resend);
send_closure(node.callback, &NetQueryCallback::on_result_resendable, std::move(node.net_query), std::move(promise));
}
@ -435,8 +435,8 @@ class MultiSequenceDispatcherNewImpl final : public MultiSequenceDispatcherNew {
}
};
ActorOwn<MultiSequenceDispatcherNew> MultiSequenceDispatcherNew::create(Slice name) {
return ActorOwn<MultiSequenceDispatcherNew>(create_actor<MultiSequenceDispatcherNewImpl>(name));
ActorOwn<MultiSequenceDispatcher> MultiSequenceDispatcher::create(Slice name) {
return ActorOwn<MultiSequenceDispatcher>(create_actor<MultiSequenceDispatcherImpl>(name));
}
} // namespace td

6
td/telegram/SequenceDispatcher.h
View File

@ -94,12 +94,10 @@ class MultiSequenceDispatcherOld final : public SequenceDispatcher::Parent {
using ChainId = uint64;
using ChainIds = vector<ChainId>;
class MultiSequenceDispatcherNew : public NetQueryCallback {
class MultiSequenceDispatcher : public NetQueryCallback {
public:
virtual void send(NetQueryPtr query) = 0;
static ActorOwn<MultiSequenceDispatcherNew> create(Slice name);
static ActorOwn<MultiSequenceDispatcher> create(Slice name);
};
using MultiSequenceDispatcher = MultiSequenceDispatcherNew;
} // namespace td

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

@ -276,8 +276,8 @@ Result<std::pair<NetQueryPtr, bool>> FileDownloader::start_part(Part part, int32
auto query = telegram_api::upload_reuploadCdnFile(BufferSlice(cdn_file_token_), BufferSlice(it->second));
LOG(DEBUG) << part.id << " " << to_string(query);
net_query = G()->net_query_creator().create(
UniqueId::next(UniqueId::Type::Default, static_cast<uint8>(QueryType::ReuploadCDN)), query,
{}, remote_.get_dc_id(), net_query_type, NetQuery::AuthFlag::On);
UniqueId::next(UniqueId::Type::Default, static_cast<uint8>(QueryType::ReuploadCDN)), query, {},
remote_.get_dc_id(), net_query_type, NetQuery::AuthFlag::On);
cdn_part_reupload_token_.erase(it);
}
}

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

@ -200,8 +200,8 @@ class MapDownloadGenerateActor final : public FileGenerateActor {
LOG(INFO) << "Download " << conversion_;
auto query =
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()->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()->net_query_dispatcher().dispatch_with_callback(std::move(query), {net_callback_.get(), 0});
}

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

@ -25,12 +25,13 @@ NetQueryCreator::NetQueryCreator(std::shared_ptr<NetQueryStats> net_query_stats)
object_pool_.set_check_empty(true);
}
NetQueryPtr NetQueryCreator::create(const telegram_api::Function &function, std::vector<uint64> chains, DcId dc_id, NetQuery::Type type) {
NetQueryPtr NetQueryCreator::create(const telegram_api::Function &function, std::vector<uint64> chains, DcId dc_id,
NetQuery::Type type) {
return create(UniqueId::next(), function, std::move(chains), dc_id, type, NetQuery::AuthFlag::On);
}
NetQueryPtr NetQueryCreator::create(uint64 id, const telegram_api::Function &function, std::vector<uint64> chains, DcId dc_id, NetQuery::Type type,
NetQuery::AuthFlag auth_flag) {
NetQueryPtr NetQueryCreator::create(uint64 id, const telegram_api::Function &function, std::vector<uint64> chains,
DcId dc_id, NetQuery::Type type, NetQuery::AuthFlag auth_flag) {
LOG(INFO) << "Create query " << to_string(function);
auto storer = DefaultStorer<telegram_api::Function>(function);
BufferSlice slice(storer.size());

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

@ -36,8 +36,8 @@ class NetQueryCreator {
return create(UniqueId::next(), function, {}, dc_id, NetQuery::Type::Common, NetQuery::AuthFlag::Off);
}
NetQueryPtr create(uint64 id, const telegram_api::Function &function, std::vector<uint64> chains, DcId dc_id, NetQuery::Type type,
NetQuery::AuthFlag auth_flag);
NetQueryPtr create(uint64 id, const telegram_api::Function &function, std::vector<uint64> chains, DcId dc_id,
NetQuery::Type type, NetQuery::AuthFlag auth_flag);
private:
std::shared_ptr<NetQueryStats> net_query_stats_;

7
td/telegram/net/NetQueryDispatcher.cpp
View File

@ -15,6 +15,7 @@
#include "td/telegram/net/PublicRsaKeyShared.h"
#include "td/telegram/net/PublicRsaKeyWatchdog.h"
#include "td/telegram/net/SessionMultiProxy.h"
#include "td/telegram/SequenceDispatcher.h"
#include "td/telegram/Td.h"
#include "td/telegram/TdDb.h"
#include "td/telegram/telegram_api.h"
@ -49,9 +50,9 @@ void NetQueryDispatcher::dispatch(NetQueryPtr net_query) {
if (G()->shared_config().get_option_boolean("test_flood_wait")) {
net_query->set_error(Status::Error(429, "Too Many Requests: retry after 10"));
return complete_net_query(std::move(net_query));
// if (net_query->is_ok() && net_query->tl_constructor() == 0x0d9d75a4) {
// net_query->set_error(Status::Error(420, "FLOOD_WAIT_10"));
// }
// if (net_query->is_ok() && net_query->tl_constructor() == 0x0d9d75a4) {
// net_query->set_error(Status::Error(420, "FLOOD_WAIT_10"));
// }
}
if (net_query->tl_constructor() == telegram_api::account_getPassword::ID && false) {
net_query->set_error(Status::Error(429, "Too Many Requests: retry after 10"));

2
td/telegram/net/NetQueryDispatcher.h
View File

@ -15,7 +15,6 @@
#include "td/utils/common.h"
#include "td/utils/ScopeGuard.h"
#include "td/utils/Status.h"
#include "td/telegram/SequenceDispatcher.h"
#include <array>
#include <atomic>
@ -26,6 +25,7 @@
namespace td {
class DcAuthManager;
class MultiSequenceDispatcher;
class NetQueryDelayer;
class PublicRsaKeyShared;
class PublicRsaKeyWatchdog;

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

@ -1214,8 +1214,8 @@ bool Session::connection_send_check_main_key(ConnectionInfo *info) {
LOG(INFO) << "Check main key";
being_checked_main_auth_key_id_ = key_id;
last_check_query_id_ = UniqueId::next(UniqueId::BindKey);
NetQueryPtr query = G()->net_query_creator().create(last_check_query_id_, telegram_api::help_getNearestDc(),
{}, DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::On);
NetQueryPtr query = G()->net_query_creator().create(last_check_query_id_, telegram_api::help_getNearestDc(), {},
DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::On);
query->dispatch_ttl_ = 0;
query->set_callback(actor_shared(this));
connection_send_query(info, std::move(query));