From 79134758a8c1c017ffbb46087487d8f6bf7b22df Mon Sep 17 00:00:00 2001 From: levlam Date: Sat, 21 Nov 2020 17:38:11 +0300 Subject: [PATCH 1/8] Use "time" for monotonic time variables. --- td | 2 +- telegram-bot-api/Client.cpp | 54 +++++++++++++-------------- telegram-bot-api/Client.h | 16 ++++---- telegram-bot-api/ClientManager.cpp | 4 +- telegram-bot-api/ClientParameters.h | 2 +- telegram-bot-api/Stats.h | 3 +- telegram-bot-api/WebhookActor.cpp | 14 +++---- telegram-bot-api/WebhookActor.h | 4 +- telegram-bot-api/telegram-bot-api.cpp | 2 +- 9 files changed, 50 insertions(+), 51 deletions(-) diff --git a/td b/td index 0b751f3..5cbf90e 160000 --- a/td +++ b/td @@ -1 +1 @@ -Subproject commit 0b751f36ba3cc3b636cfc828c62ba2052d2d59a1 +Subproject commit 5cbf90e4a081567593247bd96adc4eec2e9156d8 diff --git a/telegram-bot-api/Client.cpp b/telegram-bot-api/Client.cpp index 83f88ae..d563853 100644 --- a/telegram-bot-api/Client.cpp +++ b/telegram-bot-api/Client.cpp @@ -3187,17 +3187,17 @@ ServerBotInfo Client::get_bot_info() const { auto &tqueue = parameters_->shared_data_->tqueue_; res.head_update_id_ = tqueue->get_head(tqueue_id_).value(); res.tail_update_id_ = tqueue->get_tail(tqueue_id_).value(); - res.pending_update_count_ = tqueue->get_size(tqueue_id_); res.webhook_max_connections_ = webhook_max_connections_; - res.start_timestamp_ = start_timestamp_; + res.pending_update_count_ = tqueue->get_size(tqueue_id_); + res.start_time_ = start_time_; return res; } void Client::start_up() { - start_timestamp_ = td::Time::now(); - next_bot_updates_warning_date_ = start_timestamp_ + 600; + start_time_ = td::Time::now(); + next_bot_updates_warning_time_ = start_time_ + 600; schedule_next_delete_messages_lru(); - webhook_set_date_ = start_timestamp_; + webhook_set_time_ = start_time_; sticker_set_names_[GREAT_MINDS_SET_ID] = GREAT_MINDS_SET_NAME.str(); @@ -5875,8 +5875,8 @@ void Client::on_cmd(PromisedQueryPtr query) { LOG(DEBUG) << "Process query " << *query; if (!td_client_.empty()) { if (query->method() == "close") { - auto retry_after = static_cast(10 * 60 - (td::Time::now() - start_timestamp_)); - if (retry_after > 0 && start_timestamp_ > parameters_->start_timestamp_ + 10 * 60) { + auto retry_after = static_cast(10 * 60 - (td::Time::now() - start_time_)); + if (retry_after > 0 && start_time_ > parameters_->start_time_ + 10 * 60) { return query->set_retry_after_error(retry_after); } need_close_ = true; @@ -7178,11 +7178,11 @@ td::Status Client::process_get_updates_query(PromisedQueryPtr &query) { update_allowed_update_types(query.get()); auto now = td::Time::now_cached(); - if (offset == previous_get_updates_offset_ && timeout < 3 && now < previous_get_updates_start_date_ + 3.0) { + if (offset == previous_get_updates_offset_ && timeout < 3 && now < previous_get_updates_start_time_ + 3.0) { timeout = 3; } previous_get_updates_offset_ = offset; - previous_get_updates_start_date_ = now; + previous_get_updates_start_time_ = now; do_get_updates(offset, limit, timeout, std::move(query)); return Status::OK(); } @@ -7195,15 +7195,15 @@ td::Status Client::process_set_webhook_query(PromisedQueryPtr &query) { auto now = td::Time::now_cached(); if (!new_url.empty()) { - if (now < next_allowed_set_webhook_date_) { + if (now < next_allowed_set_webhook_time_) { query->set_retry_after_error(1); return Status::OK(); } - next_allowed_set_webhook_date_ = now + 1; + next_allowed_set_webhook_time_ = now + 1; } // do not send warning just after webhook was deleted or set - next_bot_updates_warning_date_ = td::max(next_bot_updates_warning_date_, now + BOT_UPDATES_WARNING_DELAY); + next_bot_updates_warning_time_ = td::max(next_bot_updates_warning_time_, now + BOT_UPDATES_WARNING_DELAY); int32 new_max_connections = new_url.empty() ? 0 : get_webhook_max_connections(query.get()); Slice new_ip_address = new_url.empty() ? Slice() : query->arg("ip_address"); @@ -7218,8 +7218,8 @@ td::Status Client::process_set_webhook_query(PromisedQueryPtr &query) { (!new_fix_ip_address || new_ip_address == webhook_ip_address_) && !drop_pending_updates) { if (update_allowed_update_types(query.get())) { save_webhook(); - } else if (now > next_webhook_is_not_modified_warning_date_) { - next_webhook_is_not_modified_warning_date_ = now + 300; + } else if (now > next_webhook_is_not_modified_warning_time_) { + next_webhook_is_not_modified_warning_time_ = now + 300; LOG(WARNING) << "Webhook is not modified: \"" << new_url << '"'; } answer_query(td::JsonTrue(), std::move(query), @@ -7227,8 +7227,8 @@ td::Status Client::process_set_webhook_query(PromisedQueryPtr &query) { return Status::OK(); } - if (now > next_set_webhook_logging_date_ || webhook_url_ != new_url) { - next_set_webhook_logging_date_ = now + 300; + if (now > next_set_webhook_logging_time_ || webhook_url_ != new_url) { + next_set_webhook_logging_time_ = now + 300; LOG(WARNING) << "Set webhook to " << new_url << ", max_connections = " << new_max_connections << ", IP address = " << new_ip_address; } @@ -7346,7 +7346,7 @@ void Client::save_webhook() const { } void Client::webhook_success() { - next_bot_updates_warning_date_ = td::Time::now() + BOT_UPDATES_WARNING_DELAY; + next_bot_updates_warning_time_ = td::Time::now() + BOT_UPDATES_WARNING_DELAY; if (was_bot_updates_warning_) { send_request(make_object(0, ""), std::make_unique()); was_bot_updates_warning_ = false; @@ -7359,11 +7359,11 @@ void Client::webhook_error(Status status) { last_webhook_error_ = std::move(status); auto pending_update_count = get_pending_update_count(); - if (pending_update_count >= MIN_PENDING_UPDATES_WARNING && td::Time::now() > next_bot_updates_warning_date_) { + if (pending_update_count >= MIN_PENDING_UPDATES_WARNING && td::Time::now() > next_bot_updates_warning_time_) { send_request(make_object(td::narrow_cast(pending_update_count), "Webhook error. " + last_webhook_error_.message().str()), std::make_unique()); - next_bot_updates_warning_date_ = td::Time::now_cached() + BOT_UPDATES_WARNING_DELAY; + next_bot_updates_warning_time_ = td::Time::now_cached() + BOT_UPDATES_WARNING_DELAY; was_bot_updates_warning_ = true; } } @@ -7380,7 +7380,7 @@ void Client::webhook_closed(Status status) { webhook_max_connections_ = 0; webhook_ip_address_ = td::string(); webhook_fix_ip_address_ = false; - webhook_set_date_ = td::Time::now(); + webhook_set_time_ = td::Time::now(); last_webhook_error_date_ = 0; last_webhook_error_ = Status::OK(); parameters_->shared_data_->webhook_db_->erase(bot_token_with_dc_); @@ -7450,7 +7450,7 @@ void Client::do_set_webhook(PromisedQueryPtr query, bool was_deleted) { has_webhook_certificate_ = true; } webhook_url_ = new_url.str(); - webhook_set_date_ = td::Time::now(); + webhook_set_time_ = td::Time::now(); webhook_max_connections_ = get_webhook_max_connections(query.get()); webhook_ip_address_ = query->arg("ip_address").str(); webhook_fix_ip_address_ = get_webhook_fix_ip_address(query.get()); @@ -7546,9 +7546,9 @@ void Client::abort_long_poll(bool from_set_webhook) { void Client::fail_query_conflict(Slice message, PromisedQueryPtr &&query) { auto now = td::Time::now_cached(); - if (now >= next_conflict_response_date_) { + if (now >= previous_get_updates_finish_time_) { fail_query(409, message, std::move(query)); - next_conflict_response_date_ = now + 3.0; + previous_get_updates_finish_time_ = now + 3.0; } else { td::create_actor( "FailQueryConflictSleepActor", 3.0, @@ -7657,7 +7657,7 @@ void Client::do_get_updates(int32 offset, int32 limit, int32 timeout, PromisedQu return; } previous_get_updates_finish_date_ = td::Clocks::system(); // local time to output it to the log - next_bot_updates_warning_date_ = td::Time::now() + BOT_UPDATES_WARNING_DELAY; + next_bot_updates_warning_time_ = td::Time::now() + BOT_UPDATES_WARNING_DELAY; if (total_size == updates.size() && was_bot_updates_warning_) { send_request(make_object(0, ""), std::make_unique()); was_bot_updates_warning_ = false; @@ -7668,11 +7668,11 @@ void Client::do_get_updates(int32 offset, int32 limit, int32 timeout, PromisedQu void Client::long_poll_wakeup(bool force_flag) { if (!long_poll_query_) { auto pending_update_count = get_pending_update_count(); - if (pending_update_count >= MIN_PENDING_UPDATES_WARNING && td::Time::now() > next_bot_updates_warning_date_) { + if (pending_update_count >= MIN_PENDING_UPDATES_WARNING && td::Time::now() > next_bot_updates_warning_time_) { send_request(make_object(td::narrow_cast(pending_update_count), "The getUpdates method is not called for too long"), std::make_unique()); - next_bot_updates_warning_date_ = + next_bot_updates_warning_time_ = td::Time::now_cached() + BOT_UPDATES_WARNING_DELAY; // do not send warnings too often was_bot_updates_warning_ = true; } @@ -8609,7 +8609,7 @@ void Client::process_new_message_queue(int64 chat_id) { int32 message_date = message->edit_date_ == 0 ? message->date_ : message->edit_date_; auto now = get_unix_time(); - auto update_delay_time = now - td::max(message_date, parameters_->shared_data_->get_unix_time(webhook_set_date_)); + auto update_delay_time = now - td::max(message_date, parameters_->shared_data_->get_unix_time(webhook_set_time_)); const auto UPDATE_DELAY_WARNING_TIME = 10 * 60; LOG_IF(ERROR, update_delay_time > UPDATE_DELAY_WARNING_TIME) << "Receive very old update " << get_update_type_name(update_type) << " sent at " << message_date << " to chat " diff --git a/telegram-bot-api/Client.h b/telegram-bot-api/Client.h index eb1ecff..9273b96 100644 --- a/telegram-bot-api/Client.h +++ b/telegram-bot-api/Client.h @@ -796,7 +796,7 @@ class Client : public WebhookActor::Callback { td::string bot_token_id_; bool is_test_dc_; int64 tqueue_id_; - double start_timestamp_ = 0; + double start_time_ = 0; int32 my_id_ = -1; int32 authorization_date_ = -1; @@ -896,7 +896,7 @@ class Client : public WebhookActor::Callback { PromisedQueryPtr long_poll_query_; static constexpr int32 BOT_UPDATES_WARNING_DELAY = 30; - double next_bot_updates_warning_date_ = 0; + double next_bot_updates_warning_time_ = 0; bool was_bot_updates_warning_ = false; td::uint32 allowed_update_types_ = DEFAULT_ALLOWED_UPDATE_TYPES; @@ -907,23 +907,23 @@ class Client : public WebhookActor::Callback { td::ActorOwn webhook_id_; PromisedQueryPtr webhook_set_query_; td::string webhook_url_; - double webhook_set_date_ = 0; + double webhook_set_time_ = 0; int32 webhook_max_connections_ = 0; td::string webhook_ip_address_; bool webhook_fix_ip_address_ = false; int32 last_webhook_error_date_ = 0; Status last_webhook_error_; - double next_allowed_set_webhook_date_ = 0; - double next_set_webhook_logging_date_ = 0; - double next_webhook_is_not_modified_warning_date_ = 0; + double next_allowed_set_webhook_time_ = 0; + double next_set_webhook_logging_time_ = 0; + double next_webhook_is_not_modified_warning_time_ = 0; std::size_t last_pending_update_count_ = MIN_PENDING_UPDATES_WARNING; double local_unix_time_difference_ = 0; // Unix time - now() int32 previous_get_updates_offset_ = -1; - double previous_get_updates_start_date_ = 0; + double previous_get_updates_start_time_ = 0; double previous_get_updates_finish_date_ = 0; - double next_conflict_response_date_ = 0; + double previous_get_updates_finish_time_ = 0; td::uint64 webhook_generation_ = 1; diff --git a/telegram-bot-api/ClientManager.cpp b/telegram-bot-api/ClientManager.cpp index a5e7689..f275535 100644 --- a/telegram-bot-api/ClientManager.cpp +++ b/telegram-bot-api/ClientManager.cpp @@ -190,7 +190,7 @@ void ClientManager::get_stats(td::PromiseActor promise, sb << stat_.get_description() << "\n"; if (id_filter.empty()) { - sb << "uptime\t" << now - parameters_->start_timestamp_ << "\n"; + sb << "uptime\t" << now - parameters_->start_time_ << "\n"; sb << "bot_count\t" << clients_.size() << "\n"; sb << "active_bot_count\t" << active_bot_count << "\n"; auto r_mem_stat = td::mem_stat(); @@ -227,7 +227,7 @@ void ClientManager::get_stats(td::PromiseActor promise, auto bot_info = client_info->client_->get_actor_unsafe()->get_bot_info(); sb << "\n"; sb << "id\t" << bot_info.id_ << "\n"; - sb << "uptime\t" << now - bot_info.start_timestamp_ << "\n"; + sb << "uptime\t" << now - bot_info.start_time_ << "\n"; sb << "token\t" << bot_info.token_ << "\n"; sb << "username\t" << bot_info.username_ << "\n"; sb << "webhook\t" << bot_info.webhook_ << "\n"; diff --git a/telegram-bot-api/ClientParameters.h b/telegram-bot-api/ClientParameters.h index 018fca6..ee7583a 100644 --- a/telegram-bot-api/ClientParameters.h +++ b/telegram-bot-api/ClientParameters.h @@ -62,7 +62,7 @@ struct ClientParameters { td::int32 default_max_webhook_connections_ = 0; td::IPAddress webhook_proxy_ip_address_; - double start_timestamp_ = 0; + double start_time_ = 0; td::ActorId get_host_by_name_actor_id_; diff --git a/telegram-bot-api/Stats.h b/telegram-bot-api/Stats.h index a47386c..d2438d7 100644 --- a/telegram-bot-api/Stats.h +++ b/telegram-bot-api/Stats.h @@ -86,8 +86,7 @@ class ServerBotInfo { td::int32 tail_update_id_ = 0; td::int32 webhook_max_connections_ = 0; std::size_t pending_update_count_ = 0; - double start_timestamp_ = 0; - double last_query_timestamp_ = 0; + double start_time_ = 0; }; struct ServerBotStat { diff --git a/telegram-bot-api/WebhookActor.cpp b/telegram-bot-api/WebhookActor.cpp index be8ef2e..fea7de9 100644 --- a/telegram-bot-api/WebhookActor.cpp +++ b/telegram-bot-api/WebhookActor.cpp @@ -86,8 +86,8 @@ void WebhookActor::resolve_ip_address() { if (fix_ip_address_) { return; } - if (td::Time::now() < next_ip_address_resolve_timestamp_) { - relax_wakeup_at(next_ip_address_resolve_timestamp_, "resolve_ip_address"); + if (td::Time::now() < next_ip_address_resolve_time_) { + relax_wakeup_at(next_ip_address_resolve_time_, "resolve_ip_address"); return; } @@ -101,9 +101,9 @@ void WebhookActor::resolve_ip_address() { } if (future_ip_address_.is_ready()) { - next_ip_address_resolve_timestamp_ = + next_ip_address_resolve_time_ = td::Time::now() + IP_ADDRESS_CACHE_TIME + td::Random::fast(0, IP_ADDRESS_CACHE_TIME / 10); - relax_wakeup_at(next_ip_address_resolve_timestamp_, "resolve_ip_address"); + relax_wakeup_at(next_ip_address_resolve_time_, "resolve_ip_address"); auto r_ip_address = future_ip_address_.move_as_result(); if (r_ip_address.is_error()) { @@ -264,7 +264,7 @@ void WebhookActor::create_new_connections() { auto now = td::Time::now(); td::FloodControlFast *flood; bool active; - if (last_success_timestamp_ + 10 < now) { + if (last_success_time_ + 10 < now) { flood = &pending_new_connection_flood_; if (need_connections > 1) { need_connections = 1; @@ -458,7 +458,7 @@ void WebhookActor::drop_event(td::TQueue::EventId event_id) { void WebhookActor::on_update_ok(td::TQueue::EventId event_id) { last_update_was_successful_ = true; - last_success_timestamp_ = td::Time::now(); + last_success_time_ = td::Time::now(); VLOG(webhook) << "Receive ok for update " << event_id; drop_event(event_id); @@ -647,7 +647,7 @@ void WebhookActor::handle(td::unique_ptr response) { void WebhookActor::start_up() { max_loaded_updates_ = max_connections_ * 2; - last_success_timestamp_ = td::Time::now(); + last_success_time_ = td::Time::now(); active_new_connection_flood_.add_limit(1, 10 * max_connections_); active_new_connection_flood_.add_limit(5, 20 * max_connections_); diff --git a/telegram-bot-api/WebhookActor.h b/telegram-bot-api/WebhookActor.h index cedd4ca..f588b3f 100644 --- a/telegram-bot-api/WebhookActor.h +++ b/telegram-bot-api/WebhookActor.h @@ -137,7 +137,7 @@ class WebhookActor : public td::HttpOutboundConnection::Callback { td::IPAddress ip_address_; td::int32 ip_generation_ = 0; - double next_ip_address_resolve_timestamp_ = 0; + double next_ip_address_resolve_time_ = 0; td::FutureActor future_ip_address_; class Connection : public td::ListNode { @@ -168,7 +168,7 @@ class WebhookActor : public td::HttpOutboundConnection::Callback { td::ListNode ready_connections_; td::FloodControlFast active_new_connection_flood_; td::FloodControlFast pending_new_connection_flood_; - double last_success_timestamp_ = 0; + double last_success_time_ = 0; double wakeup_at_ = 0; bool last_update_was_successful_ = true; diff --git a/telegram-bot-api/telegram-bot-api.cpp b/telegram-bot-api/telegram-bot-api.cpp index 6a007d6..63ed5b7 100644 --- a/telegram-bot-api/telegram-bot-api.cpp +++ b/telegram-bot-api/telegram-bot-api.cpp @@ -133,7 +133,7 @@ int main(int argc, char *argv[]) { auto shared_data = std::make_shared(); auto parameters = std::make_unique(); parameters->shared_data_ = shared_data; - parameters->start_timestamp_ = start_time; + parameters->start_time_ = start_time; auto net_query_stats = td::create_net_query_stats(); parameters->net_query_stats_ = net_query_stats; From 4d025b1c9b66f88dcbc8a51046c5dda76e79b59a Mon Sep 17 00:00:00 2001 From: levlam Date: Sat, 21 Nov 2020 17:46:18 +0300 Subject: [PATCH 2/8] Safer handling of negative monotonic time. --- telegram-bot-api/Client.cpp | 5 +++++ telegram-bot-api/WebhookActor.cpp | 2 +- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/telegram-bot-api/Client.cpp b/telegram-bot-api/Client.cpp index d563853..c27f721 100644 --- a/telegram-bot-api/Client.cpp +++ b/telegram-bot-api/Client.cpp @@ -3198,6 +3198,11 @@ void Client::start_up() { next_bot_updates_warning_time_ = start_time_ + 600; schedule_next_delete_messages_lru(); webhook_set_time_ = start_time_; + next_allowed_set_webhook_time_ = start_time_; + next_set_webhook_logging_time_ = start_time_; + next_webhook_is_not_modified_warning_time_ = start_time_; + previous_get_updates_start_time_ = start_time_ - 100; + previous_get_updates_finish_time_ = start_time_ - 100; sticker_set_names_[GREAT_MINDS_SET_ID] = GREAT_MINDS_SET_NAME.str(); diff --git a/telegram-bot-api/WebhookActor.cpp b/telegram-bot-api/WebhookActor.cpp index fea7de9..affaeb7 100644 --- a/telegram-bot-api/WebhookActor.cpp +++ b/telegram-bot-api/WebhookActor.cpp @@ -647,7 +647,7 @@ void WebhookActor::handle(td::unique_ptr response) { void WebhookActor::start_up() { max_loaded_updates_ = max_connections_ * 2; - last_success_time_ = td::Time::now(); + next_ip_address_resolve_time_ = last_success_time_ = td::Time::now(); active_new_connection_flood_.add_limit(1, 10 * max_connections_); active_new_connection_flood_.add_limit(5, 20 * max_connections_); From 1f8116b21d9524aaaacd5135a42d0356f190cd75 Mon Sep 17 00:00:00 2001 From: levlam Date: Thu, 26 Nov 2020 18:09:18 +0300 Subject: [PATCH 3/8] Improve log messages. --- telegram-bot-api/WebhookActor.cpp | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/telegram-bot-api/WebhookActor.cpp b/telegram-bot-api/WebhookActor.cpp index affaeb7..a1f9b22 100644 --- a/telegram-bot-api/WebhookActor.cpp +++ b/telegram-bot-api/WebhookActor.cpp @@ -356,20 +356,21 @@ void WebhookActor::load_updates() { } VLOG(webhook) << "Trying to load new updates from offset " << tqueue_offset_; + auto offset = tqueue_offset_; auto limit = td::min(SharedData::TQUEUE_EVENT_BUFFER_SIZE, max_loaded_updates_ - queue_updates_.size()); auto updates = mutable_span(parameters_->shared_data_->event_buffer_, limit); auto now = td::Time::now(); auto unix_time_now = parameters_->shared_data_->get_unix_time(now); size_t total_size = 0; - if (tqueue_offset_.empty()) { + if (offset.empty()) { updates.truncate(0); } else { - auto r_size = tqueue->get(tqueue_id_, tqueue_offset_, false, unix_time_now, updates); + auto r_size = tqueue->get(tqueue_id_, offset, false, unix_time_now, updates); if (r_size.is_error()) { VLOG(webhook) << "Failed to get new updates: " << r_size.error(); - tqueue_offset_ = tqueue->get_head(tqueue_id_); - r_size = tqueue->get(tqueue_id_, tqueue_offset_, false, unix_time_now, updates); + offset = tqueue_offset_ = tqueue->get_head(tqueue_id_); + r_size = tqueue->get(tqueue_id_, offset, false, unix_time_now, updates); r_size.ensure(); } total_size = r_size.ok(); @@ -420,8 +421,8 @@ void WebhookActor::load_updates() { } } if (need_warning) { - LOG(WARNING) << "Found " << updates.size() << " updates out of " << total_size - update_map_.size() << " + " - << update_map_.size() << " in " << queues_.size() << " queues after last error \"" + LOG(WARNING) << "Loaded " << updates.size() << " updates out of " << total_size << ". Have total of " + << update_map_.size() << " loaded in " << queues_.size() << " queues after last error \"" << last_error_message_ << "\" at " << last_error_date_; } @@ -430,9 +431,9 @@ void WebhookActor::load_updates() { } if (!updates.empty()) { - VLOG(webhook) << "Loaded " << updates.size() << " new updates from offset " << tqueue_offset_ - << " out of requested " << limit << ". Have total of " << update_map_.size() << " updates loaded in " - << queue_updates_.size() << " queues"; + VLOG(webhook) << "Loaded " << updates.size() << " new updates from offset " << offset << " out of requested " + << limit << ". Have total of " << update_map_.size() << " updates loaded in " << queue_updates_.size() + << " queues"; } } From 72b3f6ea4d77d10997199ae22e538d25d2022bd7 Mon Sep 17 00:00:00 2001 From: levlam Date: Thu, 26 Nov 2020 19:11:04 +0300 Subject: [PATCH 4/8] Improve webhook updates delaying. --- telegram-bot-api/WebhookActor.cpp | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/telegram-bot-api/WebhookActor.cpp b/telegram-bot-api/WebhookActor.cpp index a1f9b22..75ade49 100644 --- a/telegram-bot-api/WebhookActor.cpp +++ b/telegram-bot-api/WebhookActor.cpp @@ -470,19 +470,24 @@ void WebhookActor::on_update_error(td::TQueue::EventId event_id, td::Slice error double now = td::Time::now(); auto it = update_map_.find(event_id); - if (parameters_->shared_data_->get_unix_time(now) > it->second.expires_at_) { + + const int MAX_RETRY_AFTER = 3600; + retry_after = td::clamp(retry_after, 0, MAX_RETRY_AFTER); + int next_delay = it->second.delay_; + int next_effective_delay = retry_after; + if (retry_after == 0 && it->second.fail_count_ > 0) { + next_delay = td::min(WEBHOOK_MAX_RESEND_TIMEOUT, next_delay * 2); + next_effective_delay = next_delay; + } + if (parameters_->shared_data_->get_unix_time(now) + next_effective_delay > it->second.expires_at_) { LOG(WARNING) << "Drop update " << event_id << ": " << error; drop_event(event_id); return; } auto &update = it->second; update.state_ = Update::State::Begin; - const int MAX_RETRY_AFTER = 3600; - retry_after = td::clamp(retry_after, 0, MAX_RETRY_AFTER); - update.delay_ = retry_after != 0 - ? retry_after - : td::min(WEBHOOK_MAX_RESEND_TIMEOUT, update.delay_ * (update.fail_count_ > 0 ? 2 : 1)); - update.wakeup_at_ = update.fail_count_ > 0 ? now + update.delay_ : now; + update.delay_ = next_delay; + update.wakeup_at_ = now + next_effective_delay; update.fail_count_++; queues_.emplace(update.wakeup_at_, update.queue_id_); VLOG(webhook) << "Delay update " << event_id << " for " << (update.wakeup_at_ - now) << " seconds because of " From 81b2334a3138eef61d24d578ffbb8db7872cd103 Mon Sep 17 00:00:00 2001 From: levlam Date: Thu, 26 Nov 2020 19:31:07 +0300 Subject: [PATCH 5/8] Fix media_group_id of messages automatically forwarded to discussion group. --- telegram-bot-api/Client.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/telegram-bot-api/Client.cpp b/telegram-bot-api/Client.cpp index c27f721..6766f4f 100644 --- a/telegram-bot-api/Client.cpp +++ b/telegram-bot-api/Client.cpp @@ -1508,7 +1508,7 @@ void Client::JsonMessage::store(JsonValueScope *scope) const { << message_->chat_id << " while storing " << source_ << " " << message_->id; } } - if (message_->media_album_id > 0) { + if (message_->media_album_id != 0) { object("media_group_id", td::to_string(message_->media_album_id)); } switch (message_->content->get_id()) { From 67a477f471a4d988619e7acfb6c93d56e40fd6c5 Mon Sep 17 00:00:00 2001 From: levlam Date: Sat, 28 Nov 2020 19:47:44 +0300 Subject: [PATCH 6/8] Update TDLib. --- td | 2 +- telegram-bot-api/telegram-bot-api.cpp | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/td b/td index 5cbf90e..eb80924 160000 --- a/td +++ b/td @@ -1 +1 @@ -Subproject commit 5cbf90e4a081567593247bd96adc4eec2e9156d8 +Subproject commit eb80924dad30af4e6d8385d058bb7e847174df5e diff --git a/telegram-bot-api/telegram-bot-api.cpp b/telegram-bot-api/telegram-bot-api.cpp index 63ed5b7..245e2bd 100644 --- a/telegram-bot-api/telegram-bot-api.cpp +++ b/telegram-bot-api/telegram-bot-api.cpp @@ -21,6 +21,7 @@ #include "td/net/HttpInboundConnection.h" #include "td/actor/actor.h" +#include "td/actor/ConcurrentScheduler.h" #include "td/actor/PromiseFuture.h" #include "td/utils/buffer.h" From 03a8573a032c098ce4cf4397f184bf18b19ef4d6 Mon Sep 17 00:00:00 2001 From: levlam Date: Sat, 28 Nov 2020 21:10:19 +0300 Subject: [PATCH 7/8] Do not update ServerCpuStat too often. --- telegram-bot-api/telegram-bot-api.cpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/telegram-bot-api/telegram-bot-api.cpp b/telegram-bot-api/telegram-bot-api.cpp index 245e2bd..cdfb4cf 100644 --- a/telegram-bot-api/telegram-bot-api.cpp +++ b/telegram-bot-api/telegram-bot-api.cpp @@ -464,6 +464,9 @@ int main(int argc, char *argv[]) { double now = td::Time::now(); if (now >= next_cron_time) { + if (now >= next_cron_time + 1.0) { + next_cron_time = now; + } next_cron_time += 1.0; ServerCpuStat::update(now); } From e2ae8dad02a7c0046e162e12bc0c0c077fff5d14 Mon Sep 17 00:00:00 2001 From: levlam Date: Sat, 28 Nov 2020 21:10:53 +0300 Subject: [PATCH 8/8] Update version to 5.0.1. --- CMakeLists.txt | 2 +- telegram-bot-api/Client.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 0ca8cae..f3eed02 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,6 +1,6 @@ cmake_minimum_required(VERSION 3.0.2 FATAL_ERROR) -project(TelegramBotApi VERSION 5.0 LANGUAGES CXX) +project(TelegramBotApi VERSION 5.0.1 LANGUAGES CXX) add_subdirectory(td EXCLUDE_FROM_ALL) diff --git a/telegram-bot-api/Client.cpp b/telegram-bot-api/Client.cpp index 6766f4f..e45d86b 100644 --- a/telegram-bot-api/Client.cpp +++ b/telegram-bot-api/Client.cpp @@ -3800,7 +3800,7 @@ void Client::on_update_authorization_state() { parameters->api_hash_ = parameters_->api_hash_; parameters->system_language_code_ = "en"; parameters->device_model_ = "server"; - parameters->application_version_ = "5.0"; + parameters->application_version_ = "5.0.1"; parameters->enable_storage_optimizer_ = true; parameters->ignore_file_names_ = true;