andreacavalli/tdlib-fork
Archived
1
0
Fork 0
Code Pull Requests Releases Activity

Unify spelling of "expires_".

Browse Source 
GitOrigin-RevId: 46aaff38317dd490f9d5a1250e426d94cb8aba75
This commit is contained in:
levlam 2019-02-10 03:45:15 +03:00
parent d1022a389b
commit 0075f91e2e
15 changed files with 92 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
td/mtproto/AuthData.h
View File

@ -89,7 +89,7 @@ class AuthData {
if (tmp_auth_key_.empty()) {
return true;
}
if (now > tmp_auth_key_.expire_at() - 60 * 60 * 2 /*2 hours*/) {
if (now > tmp_auth_key_.expires_at() - 60 * 60 * 2 /*2 hours*/) {
return true;
}
if (!has_tmp_auth_key(now)) {
@ -110,7 +110,7 @@ class AuthData {
if (tmp_auth_key_.empty()) {
return false;
}
if (now > tmp_auth_key_.expire_at() - 60 * 60 /*1 hour*/) {
if (now > tmp_auth_key_.expires_at() - 60 * 60 /*1 hour*/) {
return false;
}
return true;

12
td/mtproto/AuthKey.h
View File

@ -44,12 +44,12 @@ class AuthKey {
void set_need_header(bool need_header) {
need_header_ = need_header;
}
double expire_at() const {
return expire_at_;
double expires_at() const {
return expires_at_;
}
void set_expire_at(double expire_at) {
expire_at_ = expire_at;
// expire_at_ = Time::now() + 60 * 60 + 10 * 60;
void set_expires_at(double expires_at) {
expires_at_ = expires_at;
// expires_at_ = Time::now() + 60 * 60 + 10 * 60;
}
void clear() {
auth_key_.clear();
@ -80,7 +80,7 @@ class AuthKey {
bool auth_flag_ = false;
bool was_auth_flag_ = false;
bool need_header_ = true;
double expire_at_ = 0;
double expires_at_ = 0;
};
} // namespace mtproto

10
td/mtproto/Handshake.cpp
View File

@ -91,8 +91,8 @@ Status AuthKeyHandshake::on_res_pq(Slice message, Callback *connection, PublicRs
case Mode::Temp:
r_data_size = fill_data_with_hash(
data_with_hash,
mtproto_api::p_q_inner_data_temp_dc(res_pq->pq_, p, q, nonce, server_nonce, new_nonce, dc_id_, expire_in_));
expire_at_ = Time::now() + expire_in_;
mtproto_api::p_q_inner_data_temp_dc(res_pq->pq_, p, q, nonce, server_nonce, new_nonce, dc_id_, expires_in_));
expires_at_ = Time::now() + expires_in_;
break;
case Mode::Unknown:
default:
@ -209,7 +209,7 @@ Status AuthKeyHandshake::on_server_dh_params(Slice message, Callback *connection
auth_key = AuthKey(auth_key_params.first, std::move(auth_key_params.second));
if (mode_ == Mode::Temp) {
auth_key.set_expire_at(expire_at_);
auth_key.set_expires_at(expires_at_);
}
server_salt = as<int64>(new_nonce.raw) ^ as<int64>(server_nonce.raw);
@ -252,9 +252,9 @@ Status AuthKeyHandshake::start_main(Callback *connection) {
return on_start(connection);
}
Status AuthKeyHandshake::start_tmp(Callback *connection, int32 expire_in) {
Status AuthKeyHandshake::start_tmp(Callback *connection, int32 expires_in) {
mode_ = Mode::Temp;
expire_in_ = expire_in;
expires_in_ = expires_in;
return on_start(connection);
}

16
td/mtproto/Handshake.h
View File

@ -46,30 +46,30 @@ class AuthKeyHandshake {
bool is_ready_for_start();
Status start_main(Callback *connection) TD_WARN_UNUSED_RESULT;
Status start_tmp(Callback *connection, int32 expire_in) TD_WARN_UNUSED_RESULT;
Status start_tmp(Callback *connection, int32 expires_in) TD_WARN_UNUSED_RESULT;
bool is_ready_for_message(const UInt128 &message_nonce);
bool is_ready_for_finish();
void on_finish();
AuthKeyHandshake(int32 dc_id, int32 expire_in) {
AuthKeyHandshake(int32 dc_id, int32 expires_in) {
dc_id_ = dc_id;
if (expire_in == 0) {
if (expires_in == 0) {
mode_ = Mode::Main;
} else {
mode_ = Mode::Temp;
expire_in_ = expire_in;
expires_in_ = expires_in;
}
}
void init_main() {
clear();
mode_ = Mode::Main;
}
void init_temp(int32 expire_in) {
void init_temp(int32 expires_in) {
clear();
mode_ = Mode::Temp;
expire_in_ = expire_in;
expires_in_ = expires_in;
}
void resume(Callback *connection);
Status on_message(Slice message, Callback *connection, Context *context) TD_WARN_UNUSED_RESULT;
@ -83,8 +83,8 @@ class AuthKeyHandshake {
State state_ = Start;
Mode mode_ = Mode::Unknown;
int32 dc_id_ = 0;
int32 expire_in_ = 0;
double expire_at_ = 0;
int32 expires_in_ = 0;
double expires_at_ = 0;
UInt128 nonce;
UInt128 server_nonce;

4
td/mtproto/SessionConnection.cpp
View File

@ -782,10 +782,10 @@ void SessionConnection::destroy_key() {
need_destroy_auth_key_ = true;
}
std::pair<uint64, BufferSlice> SessionConnection::encrypted_bind(int64 perm_key, int64 nonce, int32 expire_at) {
std::pair<uint64, BufferSlice> SessionConnection::encrypted_bind(int64 perm_key, int64 nonce, int32 expires_at) {
int64 temp_key = auth_data_->get_tmp_auth_key().id();
mtproto_api::bind_auth_key_inner object(nonce, temp_key, perm_key, auth_data_->get_session_id(), expire_at);
mtproto_api::bind_auth_key_inner object(nonce, temp_key, perm_key, auth_data_->get_session_id(), expires_at);
auto object_storer = create_storer(object);
auto size = object_storer.size();
auto object_packet = BufferWriter{size, 0, 0};

2
td/mtproto/SessionConnection.h
View File

@ -71,7 +71,7 @@ class SessionConnection
// Interface
Result<uint64> TD_WARN_UNUSED_RESULT send_query(BufferSlice buffer, bool gzip_flag, int64 message_id = 0,
uint64 invoke_after_id = 0, bool use_quick_ack = false);
std::pair<uint64, BufferSlice> encrypted_bind(int64 perm_key, int64 nonce, int32 expire_at);
std::pair<uint64, BufferSlice> encrypted_bind(int64 perm_key, int64 nonce, int32 expires_at);
void get_state_info(int64 message_id);
void resend_answer(int64 message_id);

57
td/telegram/ConfigManager.cpp
View File

@ -388,10 +388,10 @@ class ConfigRecoverer : public Actor {
is_online_ = is_online;
if (is_online) {
if (simple_config_.dc_options.empty()) {
simple_config_expire_at_ = 0;
simple_config_expires_at_ = 0;
}
if (full_config_ == nullptr) {
full_config_expire_at_ = 0;
full_config_expires_at_ = 0;
}
}
loop();
@ -451,7 +451,7 @@ class ConfigRecoverer : public Actor {
VLOG(config_recoverer) << "Config has expired at " << config->expires_;
}
simple_config_expire_at_ = get_config_expire_time();
simple_config_expires_at_ = get_config_expire_time();
simple_config_at_ = Time::now_cached();
for (size_t i = 1; i < simple_config_.dc_options.size(); i++) {
std::swap(simple_config_.dc_options[i], simple_config_.dc_options[Random::fast(0, static_cast<int>(i))]);
@ -459,7 +459,7 @@ class ConfigRecoverer : public Actor {
} else {
VLOG(config_recoverer) << "Get SimpleConfig error " << r_simple_config.error();
simple_config_ = DcOptions();
simple_config_expire_at_ = get_failed_config_expire_time();
simple_config_expires_at_ = get_failed_config_expire_time();
}
update_dc_options();
loop();
@ -470,12 +470,12 @@ class ConfigRecoverer : public Actor {
if (r_full_config.is_ok()) {
full_config_ = r_full_config.move_as_ok();
VLOG(config_recoverer) << "Got FullConfig " << to_string(full_config_);
full_config_expire_at_ = get_config_expire_time();
full_config_expires_at_ = get_config_expire_time();
send_closure(G()->connection_creator(), &ConnectionCreator::on_dc_options, DcOptions(full_config_->dc_options_));
} else {
VLOG(config_recoverer) << "Get FullConfig error " << r_full_config.error();
full_config_ = FullConfig();
full_config_expire_at_ = get_failed_config_expire_time();
full_config_expires_at_ = get_failed_config_expire_time();
}
loop();
}
@ -506,7 +506,7 @@ class ConfigRecoverer : public Actor {
uint32 network_generation_{0};
DcOptions simple_config_;
double simple_config_expire_at_{0};
double simple_config_expires_at_{0};
double simple_config_at_{0};
ActorOwn<> simple_config_query_;
@ -517,7 +517,7 @@ class ConfigRecoverer : public Actor {
size_t dc_options_i_;
FullConfig full_config_;
double full_config_expire_at_{0};
double full_config_expires_at_{0};
ActorOwn<> full_config_query_;
uint32 ref_cnt_{1};
@ -569,14 +569,14 @@ class ConfigRecoverer : public Actor {
bool has_connecting_problem =
is_connecting_ && check_timeout(Timestamp::at(connecting_since_ + max_connecting_delay()));
bool is_valid_simple_config = !check_timeout(Timestamp::at(simple_config_expire_at_));
bool is_valid_simple_config = !check_timeout(Timestamp::at(simple_config_expires_at_));
if (!is_valid_simple_config && !simple_config_.dc_options.empty()) {
simple_config_ = DcOptions();
update_dc_options();
}
bool need_simple_config = has_connecting_problem && !is_valid_simple_config && simple_config_query_.empty();
bool has_dc_options = !dc_options_.dc_options.empty();
bool is_valid_full_config = !check_timeout(Timestamp::at(full_config_expire_at_));
bool is_valid_full_config = !check_timeout(Timestamp::at(full_config_expires_at_));
bool need_full_config = has_connecting_problem && has_dc_options && !is_valid_full_config &&
full_config_query_.empty() &&
check_timeout(Timestamp::at(dc_options_at_ + (expect_blocking() ? 5 : 10)));
@ -665,12 +665,12 @@ void ConfigManager::start_up() {
config_recoverer_ = create_actor<ConfigRecoverer>("Recoverer", actor_shared());
send_closure(config_recoverer_, &ConfigRecoverer::on_dc_options_update, load_dc_options_update());
// }
auto expire = load_config_expire();
if (expire.is_in_past()) {
auto expire_time = load_config_expire_time();
if (expire_time.is_in_past()) {
request_config();
} else {
expire_ = expire;
set_timeout_in(expire_.in());
expire_time_ = expire_time;
set_timeout_in(expire_time_.in());
}
}
@ -684,9 +684,9 @@ void ConfigManager::hangup() {
try_stop();
}
void ConfigManager::loop() {
if (expire_ && expire_.is_in_past()) {
if (expire_time_ && expire_time_.is_in_past()) {
request_config();
expire_ = {};
expire_time_ = {};
}
}
void ConfigManager::try_stop() {
@ -707,9 +707,9 @@ void ConfigManager::on_dc_options_update(DcOptions dc_options) {
if (dc_options.dc_options.empty()) {
return;
}
expire_ = Timestamp::now();
save_config_expire(expire_);
set_timeout_in(expire_.in());
expire_time_ = Timestamp::now();
save_config_expire(expire_time_);
set_timeout_in(expire_time_.in());
}
void ConfigManager::request_config_from_dc_impl(DcId dc_id) {
@ -727,8 +727,8 @@ void ConfigManager::on_result(NetQueryPtr res) {
if (r_config.is_error()) {
if (!G()->close_flag()) {
LOG(ERROR) << "TODO: getConfig failed: " << r_config.error();
expire_ = Timestamp::in(60.0); // try again in a minute
set_timeout_in(expire_.in());
expire_time_ = Timestamp::in(60.0); // try again in a minute
set_timeout_in(expire_time_.in());
}
} else {
on_dc_options_update(DcOptions());
@ -753,18 +753,19 @@ DcOptions ConfigManager::load_dc_options_update() {
return dc_options;
}
Timestamp ConfigManager::load_config_expire() {
auto expire_in = to_integer<int32>(G()->td_db()->get_binlog_pmc()->get("config_expire")) - Clocks::system();
Timestamp ConfigManager::load_config_expire_time() {
auto expires_in = to_integer<int32>(G()->td_db()->get_binlog_pmc()->get("config_expire")) - Clocks::system();
if (expire_in < 0 || expire_in > 60 * 60 /* 1 hour */) {
if (expires_in < 0 || expires_in > 60 * 60 /* 1 hour */) {
return Timestamp::now();
} else {
return Timestamp::in(expire_in);
return Timestamp::in(expires_in);
}
}
void ConfigManager::save_config_expire(Timestamp timestamp) {
G()->td_db()->get_binlog_pmc()->set("config_expire", to_string(static_cast<int>(Clocks::system() + expire_.in())));
G()->td_db()->get_binlog_pmc()->set("config_expire",
to_string(static_cast<int>(Clocks::system() + expire_time_.in())));
}
void ConfigManager::process_config(tl_object_ptr<telegram_api::config> config) {
@ -777,8 +778,8 @@ void ConfigManager::process_config(tl_object_ptr<telegram_api::config> config) {
if (!is_from_main_dc) {
reload_in = 0;
}
expire_ = Timestamp::in(reload_in);
set_timeout_at(expire_.at());
expire_time_ = Timestamp::in(reload_in);
set_timeout_at(expire_time_.at());
LOG_IF(ERROR, config->test_mode_ != G()->is_test_dc()) << "Wrong parameter is_test";
ConfigShared &shared_config = G()->shared_config();

4
td/telegram/ConfigManager.h
View File

@ -55,7 +55,7 @@ class ConfigManager : public NetQueryCallback {
int32 config_sent_cnt_{0};
ActorOwn<ConfigRecoverer> config_recoverer_;
int ref_cnt_{1};
Timestamp expire_;
Timestamp expire_time_;
void start_up() override;
void hangup_shared() override;
@ -68,7 +68,7 @@ class ConfigManager : public NetQueryCallback {
void request_config_from_dc_impl(DcId dc_id);
void process_config(tl_object_ptr<telegram_api::config> config);
Timestamp load_config_expire();
Timestamp load_config_expire_time();
void save_config_expire(Timestamp timestamp);
void save_dc_options_update(DcOptions dc_options);
DcOptions load_dc_options_update();

28
td/telegram/MessagesDb.cpp
View File

@ -491,8 +491,8 @@ class MessagesDbImpl : public MessagesDbSyncInterface {
return Status::Error("Not found");
}
Result<std::pair<std::vector<std::pair<DialogId, BufferSlice>>, int32>> get_expiring_messages(int32 expire_from,
int32 expire_till,
Result<std::pair<std::vector<std::pair<DialogId, BufferSlice>>, int32>> get_expiring_messages(int32 expires_from,
int32 expires_till,
int32 limit) override {
SCOPE_EXIT {
get_expiring_messages_stmt_.reset();
@ -501,9 +501,9 @@ class MessagesDbImpl : public MessagesDbSyncInterface {
std::vector<std::pair<DialogId, BufferSlice>> messages;
// load messages
if (expire_from <= expire_till) {
get_expiring_messages_stmt_.bind_int32(1, expire_from).ensure();
get_expiring_messages_stmt_.bind_int32(2, expire_till).ensure();
if (expires_from <= expires_till) {
get_expiring_messages_stmt_.bind_int32(1, expires_from).ensure();
get_expiring_messages_stmt_.bind_int32(2, expires_till).ensure();
get_expiring_messages_stmt_.step().ensure();
while (get_expiring_messages_stmt_.has_row()) {
@ -514,17 +514,17 @@ class MessagesDbImpl : public MessagesDbSyncInterface {
}
}
// calc next expire_till
get_expiring_messages_helper_stmt_.bind_int32(1, expire_till).ensure();
// calc next expires_till
get_expiring_messages_helper_stmt_.bind_int32(1, expires_till).ensure();
get_expiring_messages_helper_stmt_.bind_int32(2, limit).ensure();
get_expiring_messages_helper_stmt_.step().ensure();
CHECK(get_expiring_messages_helper_stmt_.has_row());
int32 count = get_expiring_messages_helper_stmt_.view_int32(1);
int32 next_expire_till = -1;
int32 next_expires_till = -1;
if (count != 0) {
next_expire_till = get_expiring_messages_helper_stmt_.view_int32(0);
next_expires_till = get_expiring_messages_helper_stmt_.view_int32(0);
}
return std::make_pair(std::move(messages), next_expire_till);
return std::make_pair(std::move(messages), next_expires_till);
}
Result<std::vector<BufferSlice>> get_messages(MessagesDbMessagesQuery query) override {
@ -921,9 +921,9 @@ class MessagesDbAsync : public MessagesDbAsyncInterface {
send_closure_later(impl_, &Impl::get_messages_fts, std::move(query), std::move(promise));
}
void get_expiring_messages(
int32 expire_from, int32 expire_till, int32 limit,
int32 expires_from, int32 expires_till, int32 limit,
Promise<std::pair<std::vector<std::pair<DialogId, BufferSlice>>, int32>> promise) override {
send_closure_later(impl_, &Impl::get_expiring_messages, expire_from, expire_till, limit, std::move(promise));
send_closure_later(impl_, &Impl::get_expiring_messages, expires_from, expires_till, limit, std::move(promise));
}
void close(Promise<> promise) override {
@ -999,10 +999,10 @@ class MessagesDbAsync : public MessagesDbAsyncInterface {
add_read_query();
promise.set_result(sync_db_->get_messages_fts(std::move(query)));
}
void get_expiring_messages(int32 expire_from, int32 expire_till, int32 limit,
void get_expiring_messages(int32 expires_from, int32 expires_till, int32 limit,
Promise<std::pair<std::vector<std::pair<DialogId, BufferSlice>>, int32>> promise) {
add_read_query();
promise.set_result(sync_db_->get_expiring_messages(expire_from, expire_till, limit));
promise.set_result(sync_db_->get_expiring_messages(expires_from, expires_till, limit));
}
void close(Promise<> promise) {

4
td/telegram/MessagesDb.h
View File

@ -108,7 +108,7 @@ class MessagesDbSyncInterface {
int32 limit) = 0;
virtual Result<std::pair<std::vector<std::pair<DialogId, BufferSlice>>, int32>> get_expiring_messages(
int32 expire_from, int32 expire_till, int32 limit) = 0;
int32 expires_from, int32 expires_till, int32 limit) = 0;
virtual Result<MessagesDbCallsResult> get_calls(MessagesDbCallsQuery query) = 0;
virtual Result<MessagesDbFtsResult> get_messages_fts(MessagesDbFtsQuery query) = 0;
@ -156,7 +156,7 @@ class MessagesDbAsyncInterface {
virtual void get_messages_fts(MessagesDbFtsQuery query, Promise<MessagesDbFtsResult> promise) = 0;
virtual void get_expiring_messages(
int32 expire_from, int32 expire_till, int32 limit,
int32 expires_from, int32 expires_till, int32 limit,
Promise<std::pair<std::vector<std::pair<DialogId, BufferSlice>>, int32>> promise) = 0;
virtual void close(Promise<> promise) = 0;

24
td/telegram/MessagesManager.cpp
View File

@ -8926,15 +8926,15 @@ void MessagesManager::init() {
}
void MessagesManager::ttl_db_loop_start(double server_now) {
ttl_db_expire_from_ = 0;
ttl_db_expire_till_ = static_cast<int32>(server_now) + 15 /* 15 seconds */;
ttl_db_expires_from_ = 0;
ttl_db_expires_till_ = static_cast<int32>(server_now) + 15 /* 15 seconds */;
ttl_db_has_query_ = false;
ttl_db_loop(server_now);
}
void MessagesManager::ttl_db_loop(double server_now) {
LOG(INFO) << "ttl_db: loop " << tag("expire_from", ttl_db_expire_from_) << tag("expire_till", ttl_db_expire_till_)
LOG(INFO) << "ttl_db: loop " << tag("expires_from", ttl_db_expires_from_) << tag("expires_till", ttl_db_expires_till_)
<< tag("has_query", ttl_db_has_query_);
if (ttl_db_has_query_) {
return;
@ -8942,14 +8942,14 @@ void MessagesManager::ttl_db_loop(double server_now) {
auto now = static_cast<int32>(server_now);
if (ttl_db_expire_till_ < 0) {
if (ttl_db_expires_till_ < 0) {
LOG(INFO) << "ttl_db: finished";
return;
}
if (now < ttl_db_expire_from_) {
if (now < ttl_db_expires_from_) {
ttl_db_slot_.set_event(EventCreator::yield(actor_shared(this, YieldType::TtlDb)));
auto wakeup_in = ttl_db_expire_from_ - server_now;
auto wakeup_in = ttl_db_expires_from_ - server_now;
ttl_db_slot_.set_timeout_in(wakeup_in);
LOG(INFO) << "ttl_db: " << tag("wakeup in", wakeup_in);
return;
@ -8957,10 +8957,10 @@ void MessagesManager::ttl_db_loop(double server_now) {
ttl_db_has_query_ = true;
int32 limit = 50;
LOG(INFO) << "ttl_db: send query " << tag("expire_from", ttl_db_expire_from_)
<< tag("expire_till", ttl_db_expire_till_) << tag("limit", limit);
LOG(INFO) << "ttl_db: send query " << tag("expires_from", ttl_db_expires_from_)
<< tag("expires_till", ttl_db_expires_till_) << tag("limit", limit);
G()->td_db()->get_messages_db_async()->get_expiring_messages(
ttl_db_expire_from_, ttl_db_expire_till_, limit,
ttl_db_expires_from_, ttl_db_expires_till_, limit,
PromiseCreator::lambda(
[actor_id = actor_id(this)](Result<std::pair<std::vector<std::pair<DialogId, BufferSlice>>, int32>> result) {
send_closure(actor_id, &MessagesManager::ttl_db_on_result, std::move(result), false);
@ -8971,10 +8971,10 @@ void MessagesManager::ttl_db_on_result(Result<std::pair<std::vector<std::pair<Di
bool dummy) {
auto result = r_result.move_as_ok();
ttl_db_has_query_ = false;
ttl_db_expire_from_ = ttl_db_expire_till_;
ttl_db_expire_till_ = result.second;
ttl_db_expires_from_ = ttl_db_expires_till_;
ttl_db_expires_till_ = result.second;
LOG(INFO) << "ttl_db: query result " << tag("new expire_till", ttl_db_expire_till_)
LOG(INFO) << "ttl_db: query result " << tag("new expires_till", ttl_db_expires_till_)
<< tag("got messages", result.first.size());
for (auto &dialog_message : result.first) {
on_get_message_from_database(dialog_message.first, get_dialog_force(dialog_message.first), dialog_message.second,

4
td/telegram/MessagesManager.h
View File

@ -2127,8 +2127,8 @@ class MessagesManager : public Actor {
Slot ttl_slot_;
enum YieldType : int32 { None, Ttl, TtlDb }; // None must be first
int32 ttl_db_expire_from_;
int32 ttl_db_expire_till_;
int32 ttl_db_expires_from_;
int32 ttl_db_expires_till_;
bool ttl_db_has_query_;
Slot ttl_db_slot_;

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

@ -926,8 +926,8 @@ void ConnectionCreator::client_loop(ClientInfo &client) {
// Remove expired ready connections
client.ready_connections.erase(
std::remove_if(client.ready_connections.begin(), client.ready_connections.end(),
[&, expire_at = Time::now_cached() - ClientInfo::READY_CONNECTIONS_TIMEOUT](auto &v) {
bool drop = v.second < expire_at;
[&, expires_at = Time::now_cached() - ClientInfo::READY_CONNECTIONS_TIMEOUT](auto &v) {
bool drop = v.second < expires_at;
VLOG_IF(connections, drop) << "Drop expired " << tag("connection", v.first.get());
return drop;
}),

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

@ -1024,15 +1024,15 @@ bool Session::connection_send_bind_key(ConnectionInfo *info) {
int64 perm_auth_key_id = auth_data_.get_main_auth_key().id();
int64 nonce = Random::secure_int64();
int32 expire_at = static_cast<int32>(auth_data_.get_server_time(auth_data_.get_tmp_auth_key().expire_at()));
int32 expires_at = static_cast<int32>(auth_data_.get_server_time(auth_data_.get_tmp_auth_key().expires_at()));
int64 message_id;
BufferSlice encrypted;
std::tie(message_id, encrypted) = info->connection->encrypted_bind(perm_auth_key_id, nonce, expire_at);
std::tie(message_id, encrypted) = info->connection->encrypted_bind(perm_auth_key_id, nonce, expires_at);
LOG(INFO) << "Bind key: " << tag("tmp", key_id) << tag("perm", static_cast<uint64>(perm_auth_key_id));
NetQueryPtr query = G()->net_query_creator().create(
last_bind_id_,
create_storer(telegram_api::auth_bindTempAuthKey(perm_auth_key_id, nonce, expire_at, std::move(encrypted))));
create_storer(telegram_api::auth_bindTempAuthKey(perm_auth_key_id, nonce, expires_at, std::move(encrypted))));
query->dispatch_ttl = 0;
query->set_callback(actor_shared(this));
connection_send_query(info, std::move(query), message_id);

4
tdactor/td/actor/impl/Scheduler.cpp
View File

@ -423,8 +423,8 @@ void Scheduler::set_actor_timeout_in(ActorInfo *actor_info, double timeout) {
if (timeout < 0) {
timeout = 0;
}
double expire_at = Time::now() + timeout;
set_actor_timeout_at(actor_info, expire_at);
double expires_at = Time::now() + timeout;
set_actor_timeout_at(actor_info, expires_at);
}
void Scheduler::set_actor_timeout_at(ActorInfo *actor_info, double timeout_at) {