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

Check for close_flag as early as possible.

Browse Source
This commit is contained in:
levlam 2022-08-10 13:57:41 +03:00
parent 2865be8dd7
commit 12d852abc5
10 changed files with 79 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
td/telegram/ContactsManager.cpp
View File

@ -8057,12 +8057,13 @@ void ContactsManager::reload_created_public_dialogs(PublicDialogType type,
}
void ContactsManager::finish_get_created_public_dialogs(PublicDialogType type, Result<Unit> &&result) {
auto index = static_cast<int32>(type);
auto promises = std::move(get_created_public_channels_queries_[index]);
reset_to_empty(get_created_public_channels_queries_[index]);
if (G()->close_flag()) {
result = G()->close_status();
}
auto index = static_cast<int32>(type);
auto promises = std::move(get_created_public_channels_queries_[index]);
reset_to_empty(get_created_public_channels_queries_[index]);
if (result.is_error()) {
fail_promises(promises, result.move_as_error());
return;

8
td/telegram/GroupCallManager.cpp
View File

@ -1438,16 +1438,16 @@ void GroupCallManager::reload_group_call(InputGroupCallId input_group_call_id,
void GroupCallManager::finish_get_group_call(InputGroupCallId input_group_call_id,
Result<tl_object_ptr<telegram_api::phone_groupCall>> &&result) {
if (G()->close_flag()) {
result = Global::request_aborted_error();
}
auto it = load_group_call_queries_.find(input_group_call_id);
CHECK(it != load_group_call_queries_.end());
CHECK(!it->second.empty());
auto promises = std::move(it->second);
load_group_call_queries_.erase(it);
if (G()->close_flag()) {
result = Global::request_aborted_error();
}
if (result.is_ok()) {
td_->contacts_manager_->on_get_users(std::move(result.ok_ref()->users_), "finish_get_group_call");
td_->contacts_manager_->on_get_chats(std::move(result.ok_ref()->chats_), "finish_get_group_call");

55
td/telegram/MessagesManager.cpp
View File

@ -12288,6 +12288,9 @@ int32 MessagesManager::get_dialog_total_count(const DialogList &list) const {
}
void MessagesManager::repair_server_dialog_total_count(DialogListId dialog_list_id) {
if (G()->close_flag()) {
return;
}
if (td_->auth_manager_->is_bot()) {
return;
}
@ -12295,9 +12298,6 @@ void MessagesManager::repair_server_dialog_total_count(DialogListId dialog_list_
// can repair total count only in folders
return;
}
if (G()->close_flag()) {
return;
}
LOG(INFO) << "Repair total chat count in " << dialog_list_id;
td_->create_handler<GetDialogListQuery>(Promise<Unit>())
@ -17209,10 +17209,11 @@ void MessagesManager::reload_dialog_filters() {
void MessagesManager::on_get_dialog_filters(Result<vector<tl_object_ptr<telegram_api::DialogFilter>>> r_filters,
bool dummy) {
are_dialog_filters_being_reloaded_ = false;
if (G()->close_flag()) {
return;
}
are_dialog_filters_being_reloaded_ = false;
CHECK(!td_->auth_manager_->is_bot());
auto promises = std::move(dialog_filter_reload_queries_);
dialog_filter_reload_queries_.clear();
@ -23172,7 +23173,6 @@ void MessagesManager::on_messages_db_fts_result(Result<MessagesDbFtsResult> resu
void MessagesManager::on_messages_db_calls_result(Result<MessagesDbCallsResult> result, int64 random_id,
MessageId first_db_message_id, MessageSearchFilter filter,
Promise<> &&promise) {
CHECK(!first_db_message_id.is_scheduled());
if (G()->close_flag()) {
result = Global::request_aborted_error();
}
@ -23186,6 +23186,7 @@ void MessagesManager::on_messages_db_calls_result(Result<MessagesDbCallsResult>
CHECK(it != found_call_messages_.end());
auto &res = it->second.second;
CHECK(!first_db_message_id.is_scheduled());
res.reserve(calls_result.messages.size());
for (auto &message : calls_result.messages) {
auto m = on_get_message_from_database(message, false, "on_messages_db_calls_result");
@ -24148,12 +24149,12 @@ void MessagesManager::load_messages_impl(const Dialog *d, MessageId from_message
vector<MessageId> MessagesManager::get_dialog_scheduled_messages(DialogId dialog_id, bool force, bool ignore_result,
Promise<Unit> &&promise) {
LOG(INFO) << "Get scheduled messages in " << dialog_id;
if (G()->close_flag()) {
promise.set_error(Global::request_aborted_error());
return {};
}
LOG(INFO) << "Get scheduled messages in " << dialog_id;
Dialog *d = get_dialog_force(dialog_id, "get_dialog_scheduled_messages");
if (d == nullptr) {
promise.set_error(Status::Error(400, "Chat not found"));
@ -25805,12 +25806,12 @@ void MessagesManager::do_send_message(DialogId dialog_id, const Message *m, vect
void MessagesManager::on_message_media_uploaded(DialogId dialog_id, const Message *m,
tl_object_ptr<telegram_api::InputMedia> &&input_media, FileId file_id,
FileId thumbnail_file_id) {
CHECK(m != nullptr);
CHECK(input_media != nullptr);
if (G()->close_flag()) {
return;
}
CHECK(m != nullptr);
CHECK(input_media != nullptr);
auto message_id = m->message_id;
if (message_id.is_any_server()) {
const FormattedText *caption = get_message_content_caption(m->edited_content.get());
@ -25889,11 +25890,12 @@ void MessagesManager::on_message_media_uploaded(DialogId dialog_id, const Messag
void MessagesManager::on_secret_message_media_uploaded(DialogId dialog_id, const Message *m,
SecretInputMedia &&secret_input_media, FileId file_id,
FileId thumbnail_file_id) {
CHECK(m != nullptr);
CHECK(m->message_id.is_valid());
if (G()->close_flag()) {
return;
}
CHECK(m != nullptr);
CHECK(m->message_id.is_valid());
if (secret_input_media.empty()) {
// the media can't be sent to the chat
LOG(INFO) << "Can't send a media message to " << dialog_id;
@ -26129,15 +26131,16 @@ void MessagesManager::on_upload_message_media_finished(int64 media_album_id, Dia
}
void MessagesManager::do_send_message_group(int64 media_album_id) {
if (G()->close_flag()) {
return;
}
CHECK(media_album_id < 0);
auto it = pending_message_group_sends_.find(media_album_id);
if (it == pending_message_group_sends_.end()) {
// the group may be already sent or failed to be sent
return;
}
if (G()->close_flag()) {
return;
}
auto &request = it->second;
@ -26235,15 +26238,16 @@ void MessagesManager::do_send_message_group(int64 media_album_id) {
}
void MessagesManager::on_text_message_ready_to_send(DialogId dialog_id, MessageId message_id) {
if (G()->close_flag()) {
return;
}
LOG(INFO) << "Ready to send " << message_id << " to " << dialog_id;
auto m = get_message({dialog_id, message_id});
if (m == nullptr) {
return;
}
if (G()->close_flag()) {
return;
}
CHECK(message_id.is_yet_unsent());
@ -28058,11 +28062,12 @@ uint64 MessagesManager::save_forward_messages_log_event(DialogId to_dialog_id, D
void MessagesManager::do_forward_messages(DialogId to_dialog_id, DialogId from_dialog_id,
const vector<Message *> &messages, const vector<MessageId> &message_ids,
bool drop_author, bool drop_media_captions, uint64 log_event_id) {
CHECK(messages.size() == message_ids.size());
if (messages.empty()) {
if (G()->close_flag()) {
return;
}
if (G()->close_flag()) {
CHECK(messages.size() == message_ids.size());
if (messages.empty()) {
return;
}
@ -32837,13 +32842,13 @@ void MessagesManager::send_get_dialog_query(DialogId dialog_id, Promise<Unit> &&
auto result = get_dialog_query_log_event_id_.emplace(dialog_id, log_event_id);
CHECK(result.second);
}
if (G()->close_flag()) {
// request will be sent after restart
return;
}
LOG(INFO) << "Send get " << dialog_id << " query from " << source;
td_->create_handler<GetDialogQuery>()->send(dialog_id);
if (!G()->close_flag()) {
LOG(INFO) << "Send get " << dialog_id << " query from " << source;
td_->create_handler<GetDialogQuery>()->send(dialog_id);
} else {
// request will be sent after restart
}
}
void MessagesManager::on_get_dialog_query_finished(DialogId dialog_id, Status &&status) {

3
td/telegram/RecentDialogList.cpp
View File

@ -130,8 +130,7 @@ void RecentDialogList::on_load_dialogs(vector<string> &&found_dialogs) {
CHECK(!promises.empty());
if (G()->close_flag()) {
fail_promises(promises, Global::request_aborted_error());
return;
return fail_promises(promises, Global::request_aborted_error());
}
auto newly_found_dialogs = std::move(dialog_ids_);

7
td/telegram/SponsoredMessageManager.cpp
View File

@ -234,6 +234,10 @@ void SponsoredMessageManager::get_dialog_sponsored_message(
void SponsoredMessageManager::on_get_dialog_sponsored_messages(
DialogId dialog_id, Result<telegram_api::object_ptr<telegram_api::messages_sponsoredMessages>> &&result) {
if (result.is_ok() && G()->close_flag()) {
result = Global::request_aborted_error();
}
auto &messages = dialog_sponsored_messages_[dialog_id];
CHECK(messages != nullptr);
auto promises = std::move(messages->promises);
@ -241,9 +245,6 @@ void SponsoredMessageManager::on_get_dialog_sponsored_messages(
CHECK(messages->messages.empty());
CHECK(messages->message_random_ids.empty());
if (result.is_ok() && G()->close_flag()) {
result = Global::request_aborted_error();
}
if (result.is_error()) {
dialog_sponsored_messages_.erase(dialog_id);
fail_promises(promises, result.move_as_error());

37
td/telegram/StickersManager.cpp
View File

@ -1478,10 +1478,10 @@ void StickersManager::init() {
}
void StickersManager::reload_reactions() {
CHECK(!td_->auth_manager_->is_bot());
if (reactions_.are_being_reloaded_ || G()->close_flag()) {
if (G()->close_flag() || reactions_.are_being_reloaded_) {
return;
}
CHECK(!td_->auth_manager_->is_bot());
reactions_.are_being_reloaded_ = true;
td_->create_handler<GetAvailableReactionsQuery>()->send(reactions_.hash_);
}
@ -6348,14 +6348,12 @@ void StickersManager::on_get_featured_sticker_sets(
LOG_IF(ERROR, featured_sticker_sets_hash_[type] != featured_stickers->hash_) << "Trending sticker sets hash mismatch";
if (!G()->parameters().use_file_db || G()->close_flag()) {
return;
if (G()->parameters().use_file_db && !G()->close_flag()) {
LOG(INFO) << "Save trending sticker sets to database";
StickerSetListLogEvent log_event(featured_sticker_set_ids_[type], are_featured_sticker_sets_premium_[type]);
G()->td_db()->get_sqlite_pmc()->set(PSTRING() << "sssfeatured" << get_featured_sticker_suffix(sticker_type),
log_event_store(log_event).as_slice().str(), Auto());
}
LOG(INFO) << "Save trending sticker sets to database";
StickerSetListLogEvent log_event(featured_sticker_set_ids_[type], are_featured_sticker_sets_premium_[type]);
G()->td_db()->get_sqlite_pmc()->set(PSTRING() << "sssfeatured" << get_featured_sticker_suffix(sticker_type),
log_event_store(log_event).as_slice().str(), Auto());
}
void StickersManager::on_get_featured_sticker_sets_failed(StickerType sticker_type, int32 offset, int32 limit,
@ -7084,6 +7082,10 @@ void StickersManager::on_uploaded_sticker_file(FileId file_id, tl_object_ptr<tel
}
void StickersManager::on_new_stickers_uploaded(int64 random_id, Result<Unit> result) {
if (G()->close_flag()) {
result = Global::request_aborted_error();
}
auto it = pending_new_sticker_sets_.find(random_id);
CHECK(it != pending_new_sticker_sets_.end());
@ -7092,9 +7094,6 @@ void StickersManager::on_new_stickers_uploaded(int64 random_id, Result<Unit> res
pending_new_sticker_sets_.erase(it);
if (G()->close_flag()) {
result = Global::request_aborted_error();
}
if (result.is_error()) {
pending_new_sticker_set->promise_.set_error(result.move_as_error());
return;
@ -7193,6 +7192,10 @@ void StickersManager::do_add_sticker_to_set(UserId user_id, string short_name,
}
void StickersManager::on_added_sticker_uploaded(int64 random_id, Result<Unit> result) {
if (G()->close_flag()) {
result = Global::request_aborted_error();
}
auto it = pending_add_sticker_to_sets_.find(random_id);
CHECK(it != pending_add_sticker_to_sets_.end());
@ -7201,9 +7204,6 @@ void StickersManager::on_added_sticker_uploaded(int64 random_id, Result<Unit> re
pending_add_sticker_to_sets_.erase(it);
if (G()->close_flag()) {
result = Global::request_aborted_error();
}
if (result.is_error()) {
pending_add_sticker_to_set->promise_.set_error(result.move_as_error());
return;
@ -7292,6 +7292,10 @@ void StickersManager::do_set_sticker_set_thumbnail(UserId user_id, string short_
}
void StickersManager::on_sticker_set_thumbnail_uploaded(int64 random_id, Result<Unit> result) {
if (G()->close_flag()) {
result = Global::request_aborted_error();
}
auto it = pending_set_sticker_set_thumbnails_.find(random_id);
CHECK(it != pending_set_sticker_set_thumbnails_.end());
@ -7300,9 +7304,6 @@ void StickersManager::on_sticker_set_thumbnail_uploaded(int64 random_id, Result<
pending_set_sticker_set_thumbnails_.erase(it);
if (G()->close_flag()) {
result = Global::request_aborted_error();
}
if (result.is_error()) {
pending_set_sticker_set_thumbnail->promise_.set_error(result.move_as_error());
return;

6
td/telegram/Td.cpp
View File

@ -3154,11 +3154,11 @@ void Td::on_result(NetQueryPtr query) {
}
void Td::on_connection_state_changed(ConnectionState new_state) {
if (new_state == connection_state_) {
LOG(ERROR) << "State manager sends update about unchanged state " << static_cast<int32>(new_state);
if (G()->close_flag()) {
return;
}
if (G()->close_flag()) {
if (new_state == connection_state_) {
LOG(ERROR) << "State manager sends update about unchanged state " << static_cast<int32>(new_state);
return;
}
connection_state_ = new_state;

13
td/telegram/UpdatesManager.cpp
View File

@ -231,11 +231,11 @@ ActorShared<UpdatesManager> UpdatesManager::create_reference() {
}
void UpdatesManager::fill_pts_gap(void *td) {
CHECK(td != nullptr);
if (G()->close_flag()) {
return;
}
CHECK(td != nullptr);
auto updates_manager = static_cast<Td *>(td)->updates_manager_.get();
auto min_pts = std::numeric_limits<int32>::max();
auto max_pts = 0;
@ -252,11 +252,11 @@ void UpdatesManager::fill_pts_gap(void *td) {
}
void UpdatesManager::fill_seq_gap(void *td) {
CHECK(td != nullptr);
if (G()->close_flag()) {
return;
}
CHECK(td != nullptr);
auto updates_manager = static_cast<Td *>(td)->updates_manager_.get();
auto min_seq = std::numeric_limits<int32>::max();
auto max_seq = 0;
@ -269,11 +269,11 @@ void UpdatesManager::fill_seq_gap(void *td) {
}
void UpdatesManager::fill_qts_gap(void *td) {
CHECK(td != nullptr);
if (G()->close_flag()) {
return;
}
CHECK(td != nullptr);
auto updates_manager = static_cast<Td *>(td)->updates_manager_.get();
auto min_qts = std::numeric_limits<int32>::max();
auto max_qts = 0;
@ -290,8 +290,11 @@ void UpdatesManager::fill_get_difference_gap(void *td) {
}
void UpdatesManager::fill_gap(void *td, const char *source) {
if (G()->close_flag()) {
return;
}
CHECK(td != nullptr);
if (G()->close_flag() || !static_cast<Td *>(td)->auth_manager_->is_authorized()) {
if (!static_cast<Td *>(td)->auth_manager_->is_authorized()) {
return;
}
auto updates_manager = static_cast<Td *>(td)->updates_manager_.get();
@ -1667,11 +1670,11 @@ void UpdatesManager::schedule_data_reload() {
}
void UpdatesManager::try_reload_data_static(void *td) {
CHECK(td != nullptr);
if (G()->close_flag()) {
return;
}
CHECK(td != nullptr);
static_cast<Td *>(td)->updates_manager_->try_reload_data();
}

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

@ -1265,10 +1265,10 @@ DcOptions ConnectionCreator::get_default_dc_options(bool is_test) {
}
void ConnectionCreator::loop() {
if (!is_inited_) {
if (G()->close_flag()) {
return;
}
if (G()->close_flag()) {
if (!is_inited_) {
return;
}
if (!network_flag_) {

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

@ -111,12 +111,11 @@ class TempAuthKeyWatchdog final : public NetQueryCallback {
for (auto &id_count : id_count_) {
ids.push_back(id_count.first);
}
if (G()->close_flag()) {
return;
if (!G()->close_flag()) {
LOG(WARNING) << "Start auth_dropTempAuthKeys except keys " << format::as_array(ids);
auto query = G()->net_query_creator().create_unauth(telegram_api::auth_dropTempAuthKeys(std::move(ids)));
G()->net_query_dispatcher().dispatch_with_callback(std::move(query), actor_shared(this));
}
LOG(WARNING) << "Start auth_dropTempAuthKeys except keys " << format::as_array(ids);
auto query = G()->net_query_creator().create_unauth(telegram_api::auth_dropTempAuthKeys(std::move(ids)));
G()->net_query_dispatcher().dispatch_with_callback(std::move(query), actor_shared(this));
}
void on_result(NetQueryPtr query) final {