use std::collections::HashMap;
use std::fmt;
use std::net::SocketAddr;
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, Mutex, PoisonError, RwLock};
use std::time::Duration;
use tokio::sync::{OwnedSemaphorePermit, Semaphore};
use crate::connection::{Options, Proxy, Transport};
use crate::crypto::rsa::PublicKey;
use crate::dispatcher::cache::Caches;
use crate::dispatcher::listeners::UNEXPECTED_CLICK;
use crate::dispatcher::router::run_hook;
use crate::dispatcher::{Recover, Routes};
use crate::enums::ParseMode;
use crate::errors::{Error, Result};
use crate::handlers::UpdateKind;
use crate::methods::{StreamShared, invoke_sleeping_floods};
use crate::raw::{RemoteCall, Serializable, base, functions};
use crate::session::internals::data_center::{self, Dc};
use crate::session::pacer::{Direction, Pacer, Plan, TransferSettings};
use crate::session::transfer::{Auth, Lease, TransferPool};
use crate::session::{
AutoSleep, Call, Events, Observer, RateLimiter, RateLimits, Retry, RetryPolicy, Salt, Session, UpdatesRx,
init_connection,
};
use crate::storage::recording::Recorder;
use crate::storage::{
FileStorage, MemoryStorage, PeerCache, SessionData, Storage, Store, StoredState, UpdateState, session_string,
};
use crate::types::{Json, LinkPreviewOptions};
const DEFAULT_DC: i32 = 2;
const LISTENER_TIMEOUT: Duration = Duration::from_secs(300);
#[must_use = "call .start() or .connect() to get a client"]
pub struct ClientBuilder {
name: String,
api_id: i32,
api_hash: String,
session_string: Option<String>,
test_mode: bool,
ipv6: bool,
pfs: bool,
#[cfg(feature = "dns-config")]
dns_fallback: bool,
#[cfg(all(test, feature = "dns-config"))]
dns_config: Option<crate::connection::DnsConfig>,
login: Login,
parse_mode: ParseMode,
link_preview_options: Option<LinkPreviewOptions>,
options: Options,
ordered: bool,
catch_up: bool,
max_concurrent_handlers: Option<usize>,
record: Option<PathBuf>,
engine: Option<Arc<dyn Storage>>,
workdir: Option<PathBuf>,
client_platform: String,
listener_timeout: Option<Duration>,
unallowed_click_alert: Option<Arc<str>>,
max_listeners: Option<usize>,
max_concurrent_transmissions: Option<usize>,
transfer_settings: TransferSettings,
max_message_cache_size: usize,
max_topic_cache_size: usize,
fetch: Fetch,
max_sticker_set_name_cache_size: usize,
rate_limits: Option<RateLimits>,
auto_sleep: AutoSleep,
retry_policy: Option<Retry>,
auto_no_updates: bool,
}
#[derive(Default)]
pub(crate) struct Login {
pub(crate) bot_token: Option<String>,
pub(crate) phone_number: Option<String>,
pub(crate) phone_code: Option<String>,
pub(crate) password: Option<String>,
}
impl ClientBuilder {
pub fn bot_token(mut self, token: impl Into<String>) -> Self {
self.login.bot_token = Some(token.into());
self
}
pub fn phone_number(mut self, phone_number: impl Into<String>) -> Self {
self.login.phone_number = Some(phone_number.into());
self
}
pub fn phone_code(mut self, phone_code: impl Into<String>) -> Self {
self.login.phone_code = Some(phone_code.into());
self
}
pub fn password(mut self, password: impl Into<String>) -> Self {
self.login.password = Some(password.into());
self
}
pub fn device_model(mut self, model: impl Into<String>) -> Self {
self.options.device.model = model.into();
self
}
pub fn system_version(mut self, version: impl Into<String>) -> Self {
self.options.device.system_version = version.into();
self
}
pub fn app_version(mut self, version: impl Into<String>) -> Self {
self.options.device.app_version = version.into();
self
}
pub fn lang_code(mut self, code: impl Into<String>) -> Self {
self.options.device.lang_code = code.into();
self
}
pub fn lang_pack(mut self, pack: impl Into<String>) -> Self {
self.options.device.lang_pack = pack.into();
self
}
pub fn system_lang_code(mut self, code: impl Into<String>) -> Self {
self.options.device.system_lang_code = Some(code.into());
self
}
pub fn tz_offset(mut self, seconds: i32) -> Self {
self.options.device.tz_offset = Some(seconds);
self
}
pub fn init_connection_params(mut self, params: Json) -> Self {
self.options.device.params = Some(params);
self
}
pub fn session_string(mut self, s: impl Into<String>) -> Self {
self.session_string = Some(s.into());
self.engine = None;
self
}
pub fn transport(mut self, transport: Transport) -> Self {
self.options.transport = transport;
self
}
pub fn obfuscated(mut self) -> Self {
self.options.obfuscated = true;
self
}
pub fn proxy(mut self, proxy: Proxy) -> Self {
self.options.proxy = Some(proxy);
self
}
#[cfg(feature = "websocket")]
pub fn websocket(mut self) -> Self {
self.options.websocket = true;
self
}
#[cfg(feature = "dns-config")]
pub fn dns_fallback(mut self) -> Self {
self.dns_fallback = true;
self
}
pub fn connection_factory(mut self, factory: impl crate::connection::ConnectionFactory + 'static) -> Self {
self.options.connection_factory = Some(Arc::new(factory));
self
}
pub fn test_mode(mut self) -> Self {
self.test_mode = true;
self
}
pub fn ipv6(mut self) -> Self {
self.ipv6 = true;
self
}
pub fn pfs(mut self) -> Self {
self.pfs = true;
self
}
pub fn ordered(mut self, ordered: bool) -> Self {
self.ordered = ordered;
self
}
pub fn catch_up(mut self, catch_up: bool) -> Self {
self.catch_up = catch_up;
self
}
pub fn max_concurrent_handlers(mut self, n: usize) -> Self {
self.max_concurrent_handlers = Some(n);
self
}
pub fn max_listeners(mut self, n: usize) -> Self {
self.max_listeners = Some(n.max(1));
self
}
pub fn max_concurrent_transmissions(mut self, n: usize) -> Self {
self.max_concurrent_transmissions = Some(n.max(1));
self
}
pub fn download_connections(mut self, n: usize) -> Self {
self.transfer_settings.download.connections = Some(n);
self
}
pub fn upload_connections(mut self, n: usize) -> Self {
self.transfer_settings.upload.connections = Some(n);
self
}
pub fn max_download_bytes_per_sec(mut self, rate: Option<u64>) -> Self {
self.transfer_settings.download.max_bytes_per_sec = Some(rate);
self
}
pub fn max_upload_bytes_per_sec(mut self, rate: Option<u64>) -> Self {
self.transfer_settings.upload.max_bytes_per_sec = Some(rate);
self
}
pub fn max_message_cache_size(mut self, n: usize) -> Self {
self.max_message_cache_size = n;
self
}
pub fn max_topic_cache_size(mut self, n: usize) -> Self {
self.max_topic_cache_size = n;
self
}
pub fn fetch_replies(mut self, enabled: bool) -> Self {
self.fetch.replies = enabled;
self
}
pub fn fetch_topics(mut self, enabled: bool) -> Self {
self.fetch.topics = enabled;
self
}
pub fn fetch_stories(mut self, enabled: bool) -> Self {
self.fetch.stories = enabled;
self
}
pub fn fetch_stickers(mut self, enabled: bool) -> Self {
self.fetch.stickers = enabled;
self
}
pub fn max_sticker_set_name_cache_size(mut self, n: usize) -> Self {
self.max_sticker_set_name_cache_size = n;
self
}
pub fn rate_limits(mut self, limits: RateLimits) -> Self {
self.rate_limits = Some(limits);
self
}
pub fn no_updates(mut self) -> Self {
self.options.no_updates = true;
self
}
pub fn auto_no_updates(mut self, on: bool) -> Self {
self.auto_no_updates = on;
self
}
pub fn parse_mode(mut self, mode: ParseMode) -> Self {
self.parse_mode = mode;
self
}
pub fn link_preview_options(mut self, options: LinkPreviewOptions) -> Self {
self.link_preview_options = Some(options);
self
}
pub fn request_timeout(mut self, timeout: Duration) -> Self {
self.options.request_timeout = timeout;
self
}
pub fn flood_sleep_threshold(mut self, threshold: Duration) -> Self {
self.auto_sleep.threshold = threshold;
self
}
pub fn max_flood_sleeps(mut self, n: usize) -> Self {
self.auto_sleep.tries = n;
self
}
pub fn retry_policy(mut self, policy: impl RetryPolicy) -> Self {
self.retry_policy = Some(Retry::new(policy));
self
}
pub fn updates_capacity(mut self, n: usize) -> Self {
self.options.updates_capacity = n.max(1);
self
}
pub fn observer(mut self, f: impl Fn(&Call<'_>) + Send + Sync + 'static) -> Self {
self.options.observer = Some(Observer(Arc::new(f)));
self
}
pub fn record(mut self, path: impl Into<PathBuf>) -> Self {
self.record = Some(path.into());
self
}
pub fn storage_engine(mut self, engine: impl Storage) -> Self {
self.engine = Some(Arc::new(engine));
self.session_string = None;
self
}
pub fn in_memory(self) -> Self {
self.storage_engine(MemoryStorage::new())
}
pub fn workdir(mut self, dir: impl Into<PathBuf>) -> Self {
self.workdir = Some(dir.into());
self
}
fn default_engine(&self) -> FileStorage {
match &self.workdir {
Some(dir) => FileStorage::new(dir.join(&self.name)),
None => FileStorage::new(Path::new(&self.name)),
}
}
pub fn client_platform(mut self, platform: impl Into<String>) -> Self {
self.client_platform = platform.into();
self
}
pub fn listener_timeout(mut self, timeout: Duration) -> Self {
self.listener_timeout = Some(timeout);
self
}
pub fn no_listener_timeout(mut self) -> Self {
self.listener_timeout = None;
self
}
pub fn unallowed_click_alert(mut self, text: impl Into<String>) -> Self {
let text: String = text.into();
self.unallowed_click_alert = Some(text.into());
self
}
pub fn no_unallowed_click_alert(mut self) -> Self {
self.unallowed_click_alert = None;
self
}
pub async fn start(self) -> Result<Client> {
let (client, login) = self.open().await?;
if client.0.me.lock().unwrap().id == 0 {
client.authorize(login).await?;
}
Ok(client)
}
pub async fn connect(self) -> Result<Client> {
Ok(self.open().await?.0)
}
async fn open(mut self) -> Result<(Client, Login)> {
let device = &self.options.device;
if device.tz_offset.is_some() && device.params.as_ref().is_some_and(|p| !matches!(p, Json::Object(_))) {
return Err(Error::InvalidArgument("init_connection_params must be an object to carry tz_offset"));
}
if let Some(limits) = &self.rate_limits {
limits.validate()?;
}
self.transfer_settings.validate()?;
self.options.retry = self.retry_policy.take().unwrap_or_else(|| Retry::new(self.auto_sleep));
if let Some(path) = &self.record {
self.options.record = Some(Recorder::create(path)?);
}
let engine: Arc<dyn Storage> = match (self.engine.take(), &self.session_string) {
(Some(engine), _) => engine,
(None, Some(_)) => Arc::new(MemoryStorage::new()),
(None, None) => Arc::new(self.default_engine()),
};
let events = Arc::new(Events::default());
let store = Arc::new(Store::new(engine, events.clone()));
store.open().await?;
let stored = match &self.session_string {
Some(s) => Some(session_string::parse(s).map_err(Error::InvalidSession)?),
None => store.load_session().await?,
};
let (dc_id, auth_key, user_id, is_bot, test_mode, addr) = match &stored {
Some(s) => (s.dc_id, Some(s.auth_key), s.user_id, s.is_bot, s.test_mode, s.addr),
None => (DEFAULT_DC, None, 0, false, self.test_mode, None),
};
let built_in = data_center::address(dc_id, test_mode, self.ipv6);
let pinned = addr.filter(|a| a.ip().is_loopback());
let first = pinned.or_else(|| addr.filter(|a| a.is_ipv6() == self.ipv6)).or(built_in);
let first = first.ok_or(Error::InvalidDc(dc_id))?;
let dc = |addr| Dc { id: dc_id, addr, test: test_mode, media: false };
let (state, salt) = store.load_state(user_id).await?;
let warm = store.warm().await?;
let saved = auth_key.map(|key| (key, salt));
let try_addr = |addr| connect(dc(addr), saved, self.api_id, &self.options, events.clone(), self.pfs);
let result = match (try_addr(first).await, built_in) {
(Err(_), Some(built_in)) if built_in != first && pinned.is_none() => try_addr(built_in).await,
(result, _) => result,
};
#[cfg(feature = "dns-config")]
let result = match result {
Err(error) if self.dns_fallback && pinned.is_none() && self.dials_directly() => {
let mut result = Err(error);
for addr in self.dns_addresses(dc_id, test_mode).await {
result = try_addr(addr).await;
if result.is_ok() {
break;
}
}
result
}
result => result,
};
let (session, updates, dc_options) = result?;
let mut inner = Inner::new(session, updates, store);
inner.peers.get_mut().unwrap_or_else(PoisonError::into_inner).load(warm);
inner.api_id = self.api_id;
inner.api_hash = self.api_hash;
inner.dcs = RwLock::new(data_center::table(&dc_options, self.ipv6, false));
inner.media_dcs = RwLock::new(data_center::table(&dc_options, self.ipv6, true));
inner.test_mode = test_mode;
inner.pinned = pinned;
inner.ipv6 = self.ipv6;
inner.options = self.options;
inner.parse_mode = Mutex::new(self.parse_mode);
inner.link_preview_options = Mutex::new(self.link_preview_options);
inner.state = Mutex::new(state);
inner.me = Mutex::new(Me { id: user_id, is_bot, premium: None, username: None });
inner.ordered = self.ordered;
inner.catch_up = self.catch_up;
inner.handler_permits = self.max_concurrent_handlers.map(|n| Arc::new(Semaphore::new(n.max(1))));
inner.client_platform = self.client_platform;
inner.listener_timeout = self.listener_timeout;
inner.unallowed_click_alert = self.unallowed_click_alert;
if let Some(n) = self.max_listeners {
inner.handlers.listeners.limit(n);
}
inner.transmissions = self.max_concurrent_transmissions.map(Transmissions::new);
inner.transfer_settings = self.transfer_settings;
let set_names = if self.fetch.stickers { self.max_sticker_set_name_cache_size } else { 0 };
inner.caches = Caches::new(self.max_message_cache_size, self.max_topic_cache_size).with_set_names(set_names);
inner.fetch = self.fetch;
inner.limiter = self.rate_limits.as_ref().map(RateLimiter::new);
inner.auto_no_updates = self.auto_no_updates;
let client = Client(Arc::new(inner), None);
let imported = self.session_string.as_deref().is_some_and(session_string::is_import);
if imported && user_id == 0 {
match client.get_me_raw().await {
Ok(me) => client.set_me(&me),
Err(Error::Rpc(e)) if e.code == 401 => {}
Err(e) => return Err(e),
}
}
client.save().await?;
Ok((client, self.login))
}
#[cfg(feature = "dns-config")]
fn dials_directly(&self) -> bool {
self.options.proxy.is_none() && self.options.connection_factory.is_none() && !self.options.uses_websocket()
}
#[cfg(feature = "dns-config")]
async fn dns_addresses(&self, dc_id: i32, test_mode: bool) -> Vec<SocketAddr> {
use crate::connection::DnsConfig;
let now = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map_or(0, |d| d.as_secs());
#[cfg(test)]
if let Some(config) = &self.dns_config {
return config.plain_addresses(dc_id, now);
}
DnsConfig::fetch(test_mode).await.map(|config| config.plain_addresses(dc_id, now)).unwrap_or_default()
}
}
#[derive(Clone)]
pub struct Client(pub(crate) Arc<Inner>, pub(crate) Option<i64>);
impl fmt::Debug for Client {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Client").finish_non_exhaustive()
}
}
pub(crate) struct Inner {
session: RwLock<Session>,
pub(crate) transfers: TransferPool,
pub(crate) updates: tokio::sync::Mutex<UpdatesRx>,
pub(crate) api_id: i32,
pub(crate) api_hash: String,
dcs: RwLock<Vec<(i32, SocketAddr)>>,
media_dcs: RwLock<Vec<(i32, SocketAddr)>>,
cdn_keys: Mutex<Vec<(i32, PublicKey)>>,
test_mode: bool,
ipv6: bool,
pinned: Option<SocketAddr>,
pub(crate) store: Arc<Store>,
pub(crate) options: Options,
pub(crate) parse_mode: Mutex<ParseMode>,
pub(crate) link_preview_options: Mutex<Option<LinkPreviewOptions>>,
pub(crate) state: Mutex<Option<UpdateState>>,
pub(crate) account: AtomicU64,
pub(crate) me: Mutex<Me>,
pub(crate) peers: Mutex<PeerCache>,
pub(crate) handlers: Routes,
pub(crate) ordered: bool,
pub(crate) catch_up: bool,
pub(crate) handler_permits: Option<Arc<Semaphore>>,
pub(crate) client_platform: String,
pub(crate) listener_timeout: Option<Duration>,
pub(crate) unallowed_click_alert: Option<Arc<str>>,
pub(crate) transmissions: Option<Transmissions>,
pub(crate) transfer_settings: TransferSettings,
pub(crate) limiter: Option<RateLimiter>,
pub(crate) auto_no_updates: bool,
pub(crate) events: Arc<Events>,
pub(crate) streams: Mutex<HashMap<i64, Arc<StreamShared>>>,
pub(crate) stop: tokio::sync::watch::Sender<bool>,
pub(crate) running: AtomicBool,
pub(crate) disconnected: AtomicBool,
pub(crate) recover: Mutex<Option<tokio::sync::mpsc::UnboundedSender<Recover>>>,
pub(crate) caches: Caches,
pub(crate) fetch: Fetch,
}
#[derive(Clone, Copy, Default, Debug)]
pub(crate) struct Fetch {
pub(crate) replies: bool,
pub(crate) topics: bool,
pub(crate) stories: bool,
pub(crate) stickers: bool,
}
impl Fetch {
pub(crate) fn any(self) -> bool {
self.replies || self.topics || self.stories || self.stickers
}
}
pub(crate) struct Transmissions {
pub(crate) downloads: Arc<Semaphore>,
pub(crate) uploads: Arc<Semaphore>,
}
impl Transmissions {
pub(crate) fn new(n: usize) -> Transmissions {
Transmissions { downloads: Arc::new(Semaphore::new(n)), uploads: Arc::new(Semaphore::new(n)) }
}
}
impl Client {
pub(crate) async fn download_slot(&self) -> Option<OwnedSemaphorePermit> {
self.slot(|t| &t.downloads).await
}
pub(crate) async fn upload_slot(&self) -> Option<OwnedSemaphorePermit> {
self.slot(|t| &t.uploads).await
}
async fn slot(&self, pick: fn(&Transmissions) -> &Arc<Semaphore>) -> Option<OwnedSemaphorePermit> {
let slots = pick(self.0.transmissions.as_ref()?).clone();
slots.acquire_owned().await.ok()
}
}
pub(crate) use me::Me;
mod me {
use std::sync::Arc;
#[derive(Clone, Debug, Default)]
pub struct Me {
pub(crate) id: i64,
pub(crate) is_bot: bool,
pub(crate) premium: Option<bool>,
pub(crate) username: Option<Arc<str>>,
}
}
impl Inner {
fn new(session: Session, updates: UpdatesRx, store: Arc<Store>) -> Inner {
Inner {
session: RwLock::new(session),
events: updates.events.clone(),
updates: tokio::sync::Mutex::new(updates),
api_id: 0,
api_hash: String::new(),
dcs: RwLock::new(Vec::new()),
media_dcs: RwLock::new(Vec::new()),
cdn_keys: Mutex::new(Vec::new()),
test_mode: false,
ipv6: false,
pinned: None,
peers: Mutex::new(PeerCache::new(store.clone())),
store,
options: Options::default(),
parse_mode: Mutex::new(ParseMode::Disabled),
link_preview_options: Mutex::new(None),
transfers: TransferPool::default(),
state: Mutex::new(None),
account: AtomicU64::new(0),
me: Mutex::new(Me::default()),
handlers: Routes::default(),
ordered: false,
catch_up: true,
handler_permits: None,
client_platform: "unknown".into(),
listener_timeout: Some(LISTENER_TIMEOUT),
unallowed_click_alert: Some(UNEXPECTED_CLICK.clone()),
transmissions: None,
transfer_settings: TransferSettings::default(),
limiter: None,
auto_no_updates: false,
streams: Mutex::new(HashMap::new()),
stop: tokio::sync::watch::Sender::new(false),
running: AtomicBool::new(false),
disconnected: AtomicBool::new(false),
recover: Mutex::new(None),
caches: Caches::default(),
fetch: Fetch::default(),
}
}
fn stored(&self, update: Option<UpdateState>) -> StoredState {
let owner = self.me.lock().unwrap_or_else(PoisonError::into_inner).id;
let salt = self.session.read().unwrap_or_else(PoisonError::into_inner).salt();
StoredState::new(owner, salt, update)
}
pub(crate) async fn save_state(&self, state: &UpdateState) {
self.store.queue_state(self.stored(Some(state.clone())));
self.store.flush().await;
}
pub(crate) fn save_state_in_background(&self, state: &UpdateState) {
self.store.queue_state(self.stored(Some(state.clone())));
}
#[cfg(test)]
pub(crate) fn set_store(&mut self, engine: Arc<dyn Storage>) {
self.store = Arc::new(Store::new(engine, self.events.clone()));
self.peers.get_mut().unwrap().set_store(self.store.clone());
}
pub(crate) fn finish_store(&self) {
let update = self.state.lock().unwrap_or_else(PoisonError::into_inner).clone();
let state = self.stored(update);
if state.update.is_some() {
self.store.finish(Some(state));
} else {
if state.owner != 0 {
self.store.queue_salt(state.owner, state.salt);
}
self.store.finish(None);
}
}
}
impl Drop for Inner {
fn drop(&mut self) {
self.finish_store();
}
}
impl Client {
pub fn builder(name: impl Into<String>, api_id: i32, api_hash: impl Into<String>) -> ClientBuilder {
ClientBuilder {
name: name.into(),
api_id,
api_hash: api_hash.into(),
session_string: None,
test_mode: false,
ipv6: false,
pfs: false,
#[cfg(feature = "dns-config")]
dns_fallback: false,
#[cfg(all(test, feature = "dns-config"))]
dns_config: None,
login: Login::default(),
parse_mode: ParseMode::Disabled,
link_preview_options: None,
options: Options::default(),
ordered: false,
catch_up: true,
max_concurrent_handlers: None,
record: None,
engine: None,
workdir: None,
client_platform: "unknown".into(),
listener_timeout: Some(LISTENER_TIMEOUT),
unallowed_click_alert: Some(UNEXPECTED_CLICK.clone()),
max_listeners: None,
max_concurrent_transmissions: None,
transfer_settings: TransferSettings::default(),
max_message_cache_size: 0,
max_topic_cache_size: 0,
fetch: Fetch::default(),
max_sticker_set_name_cache_size: 250,
rate_limits: None,
auto_sleep: AutoSleep::default(),
retry_policy: None,
auto_no_updates: false,
}
}
#[cfg(test)]
pub(crate) fn offline() -> Client {
let updates = UpdatesRx::offline();
let store = Arc::new(Store::new(Arc::new(MemoryStorage::new()), updates.events.clone()));
let mut inner = Inner::new(Session::offline(), updates, store);
inner.me.get_mut().unwrap().is_bot = true;
Client(Arc::new(inner), None)
}
#[cfg(test)]
pub(crate) fn recording() -> (Client, tokio::sync::mpsc::UnboundedReceiver<Vec<u8>>) {
Client::scripted(Vec::new())
}
#[cfg(test)]
pub(crate) fn scripted(replies: Vec<Result<Vec<u8>>>) -> (Client, tokio::sync::mpsc::UnboundedReceiver<Vec<u8>>) {
let (session, sent) = Session::scripted(replies);
(Client::with_session(session), sent)
}
#[cfg(test)]
pub(crate) fn scripted_tags(replies: Vec<Result<Vec<u8>>>) -> (Client, crate::session::TaggedBodies) {
let (session, sent) = Session::scripted_tags(replies);
(Client::with_session(session), sent)
}
#[cfg(test)]
pub(crate) fn with_session(session: Session) -> Client {
let client = Client::offline();
client.0.transfers.insert(client.dc(2).unwrap(), &session);
*client.0.session.write().unwrap() = session;
client
}
#[cfg(test)]
pub(crate) fn serve_cdn(&self, dc_id: i32, session: &Session) {
self.0.dcs.write().unwrap().push((dc_id, SocketAddr::from(([127, 0, 0, 1], 443))));
self.0.cdn_keys.lock().unwrap().push((dc_id, PublicKey::test()));
self.0.transfers.insert(self.dc(dc_id).unwrap(), session);
}
#[cfg(test)]
pub(crate) fn set_options(&mut self, options: Options) {
let inner = Arc::get_mut(&mut self.0).expect("set_options needs the only handle");
inner.session.get_mut().unwrap().set_options(options.clone());
inner.options = options;
}
pub(crate) fn feed_updates(&self, updates: base::Updates) {
self.0.events.nested(updates);
}
pub(crate) fn session(&self) -> Session {
self.0.session.read().unwrap().clone()
}
pub(crate) fn set_me(&self, user: &base::User) {
if let base::User::User(u) = user {
let username = u.username.as_deref().map(Arc::from);
*self.0.me.lock().unwrap() = Me { id: u.id, is_bot: u.bot, premium: Some(u.premium), username };
}
}
pub(crate) async fn is_premium(&self) -> Result<bool> {
let reconnected = self.0.events.take_reconnected();
let known = {
let mut me = self.0.me.lock().unwrap();
if reconnected {
me.premium = None;
}
if me.is_bot { Some(false) } else { me.premium }
};
if let Some(premium) = known {
return Ok(premium);
}
let me = self.get_me_raw().await?;
self.set_me(&me);
Ok(matches!(me, base::User::User(u) if u.premium))
}
pub(crate) fn transfer_plan(&self, direction: Direction, premium: bool, bytes: Option<u64>) -> Plan {
let bot = self.0.me.lock().unwrap().is_bot;
self.0.transfer_settings.plan(direction, bot, premium, bytes)
}
pub(crate) fn pacer(&self, dc_id: i32, direction: Direction, plan: Plan) -> Option<Arc<Pacer>> {
Some(self.0.transfers.pacer(dc_id, direction, plan.rate?))
}
pub(crate) fn dc(&self, dc_id: i32) -> Result<Dc> {
if let Some(addr) = self.0.pinned {
return Ok(Dc { id: dc_id, addr, test: self.0.test_mode, media: false });
}
data_center::find(&self.0.dcs.read().unwrap(), dc_id, self.0.test_mode, self.0.ipv6)
.ok_or(Error::InvalidDc(dc_id))
}
pub(crate) fn media_dc(&self, dc_id: i32) -> Result<Dc> {
let media = self.0.media_dcs.read().unwrap().iter().find(|(id, _)| *id == dc_id).map(|&(_, addr)| addr);
match media.filter(|_| self.0.pinned.is_none() && !self.0.options.uses_websocket()) {
Some(addr) => Ok(Dc { id: dc_id, addr, test: self.0.test_mode, media: true }),
None => self.dc(dc_id),
}
}
pub(crate) async fn switch_dc(&self, dc_id: i32) -> Result<()> {
let (inner, events, pfs) = (&self.0, self.0.events.clone(), self.session().pfs());
let (session, updates, dc_options) =
connect(self.dc(dc_id)?, None, inner.api_id, &inner.options, events, pfs).await?;
*self.0.dcs.write().unwrap() = data_center::table(&dc_options, self.0.ipv6, false);
*self.0.media_dcs.write().unwrap() = data_center::table(&dc_options, self.0.ipv6, true);
*self.0.session.write().unwrap() = session;
*self.0.updates.lock().await = updates;
{
let mut me = self.0.me.lock().unwrap();
(me.id, me.premium) = (0, None);
}
self.0.transfers.clear();
self.save().await
}
pub(crate) fn forget_account(&self) {
let mut state = self.0.state.lock().unwrap();
self.0.account.fetch_add(1, Ordering::Relaxed);
*state = None;
drop(state);
*self.0.me.lock().unwrap() = Me::default();
self.0.peers.lock().unwrap().clear();
self.0.transfers.clear();
}
pub(crate) async fn transfer_sessions(&self, dc: Dc, count: usize) -> Result<Lease> {
let home = self.session();
let main = if dc.media { self.dc(dc.id)? } else { dc };
let (auth, options, events) = (Auth::Home(&home, self.0.api_id), &self.0.options, &self.0.events);
self.0.transfers.lease_keyed_at(main, dc, count, auth, options, events).await
}
pub(crate) async fn cdn_sessions(&self, dc: Dc, count: usize) -> Result<Lease> {
let key = self.cdn_key(dc.id).await?;
self.0.transfers.lease(dc, count, Auth::Cdn(&key), &self.0.options, &self.0.events).await
}
pub(crate) fn forget_cdn(&self, dc: Dc) {
self.0.transfers.forget(dc);
}
async fn cdn_key(&self, dc_id: i32) -> Result<PublicKey> {
let find = |keys: &[(i32, PublicKey)]| keys.iter().find(|(id, _)| *id == dc_id).map(|(_, key)| key.clone());
if let Some(key) = find(&self.0.cdn_keys.lock().unwrap()) {
return Ok(key);
}
let base::CdnConfig::CdnConfig(config) = self.invoke(&functions::help::GetCdnConfig {}).await?;
let keys: Vec<_> = config
.public_keys
.iter()
.filter_map(|base::CdnPublicKey::CdnPublicKey(k)| Some((k.dc_id, PublicKey::from_pem(&k.public_key)?)))
.collect();
let key = find(&keys);
*self.0.cdn_keys.lock().unwrap() = keys;
key.ok_or(Error::InvalidDc(dc_id))
}
pub(crate) fn watch_link(&self) {
let client = Arc::downgrade(&self.0);
self.0.events.on_link(Arc::new(move |up| {
let Some(inner) = client.upgrade() else { return };
let kind = if up { UpdateKind::Connect } else { UpdateKind::Disconnect };
let hook = inner.handlers.current().hooks.get(kind);
if let Some(hook) = hook {
tokio::spawn(run_hook(Client(inner, None), kind, hook));
}
}));
}
pub(crate) async fn invoke_inline<R: RemoteCall>(&self, dc_id: i32, request: R) -> Result<R::Return> {
self.invoke_in_dc(dc_id, &request).await
}
pub(crate) async fn invoke_on_file_connection<R: RemoteCall>(
&self,
dc: Dc,
name: &'static str,
request: &R,
) -> Result<R::Return> {
let lease = self.transfer_sessions(dc, 1).await?;
let request = init_connection(self.0.api_id, &self.0.options, Borrowed(request));
invoke_sleeping_floods(&lease.sessions[0], name, &request, self.0.options.request_timeout).await
}
pub(crate) fn session_data(&self) -> SessionData {
let session = self.session();
let me = self.0.me.lock().unwrap();
SessionData {
dc_id: session.dc_id(),
test_mode: self.0.test_mode,
addr: self.dc(session.dc_id()).ok().map(|dc| dc.addr),
api_id: self.0.api_id,
auth_key: *session.auth_key(),
user_id: me.id,
is_bot: me.is_bot,
}
}
pub(crate) async fn save(&self) -> Result<()> {
Ok(self.0.store.save_session(self.session_data()).await?)
}
}
async fn connect(
dc: Dc,
auth_key: Option<([u8; 256], Salt)>,
api_id: i32,
options: &Options,
events: Arc<Events>,
pfs: bool,
) -> Result<(Session, UpdatesRx, Vec<base::DcOption>)> {
let rebind = pfs.then(|| match options.no_updates {
true => init_connection(api_id, options, quiet(functions::help::GetNearestDc {})).to_bytes(),
false => init_connection(api_id, options, functions::help::GetNearestDc {}).to_bytes(),
});
let (session, updates) = Session::connect(dc, auth_key, options, events, rebind).await?;
let base::Config::Config(config) = match options.no_updates {
true => session.invoke(&init_connection(api_id, options, quiet(functions::help::GetConfig {}))).await?,
false => session.invoke(&init_connection(api_id, options, functions::help::GetConfig {})).await?,
};
Ok((session, updates, config.dc_options))
}
pub(crate) fn quiet<X>(query: X) -> functions::InvokeWithoutUpdates<X> {
functions::InvokeWithoutUpdates { query }
}
pub(crate) struct Borrowed<'a, R>(pub(crate) &'a R);
impl<R: Serializable> Serializable for Borrowed<'_, R> {
fn serialize(&self, buf: &mut Vec<u8>) {
self.0.serialize(buf);
}
}
impl<R: RemoteCall> RemoteCall for Borrowed<'_, R> {
const NAME: &'static str = R::NAME;
type Return = R::Return;
}
#[cfg(test)]
pub(crate) async fn sent<F: IntoFuture>(rx: &mut tokio::sync::mpsc::UnboundedReceiver<Vec<u8>>, call: F) -> u32 {
let _ = call.await;
let body = rx.try_recv().expect("no request sent");
u32::from_le_bytes(body[..4].try_into().unwrap())
}
#[cfg(test)]
mod tests {
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::time::Duration;
use super::{Client, Me};
use crate::errors::Error;
use crate::raw::{base, types};
use crate::session::pacer::{Direction, LARGE};
use crate::session::test_dc::TestDc;
use crate::session::{AutoSleep, RateCategory, RateLimits};
use crate::storage::{FileStorage, MemoryStorage, PeerRecord, Recording, SessionData, Storage, UpdateState};
use crate::types::{Json, PeerRef};
fn temp_dir(name: &str) -> PathBuf {
let dir = std::env::temp_dir().join(format!("vaegram-client-{name}-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
dir
}
#[test]
fn builder_defaults_match_todays_behaviour() {
let builder = Client::builder("defaults", 1, "hash");
let options = &builder.options;
assert_eq!(options.updates_capacity, 1024);
assert_eq!(builder.auto_sleep, AutoSleep::new().threshold(Duration::from_secs(60)).tries(5));
assert!(builder.catch_up);
assert_eq!(builder.client_platform, "unknown");
assert_eq!(builder.listener_timeout, Some(Duration::from_secs(300)));
assert_eq!(builder.unallowed_click_alert.as_deref(), Some("You are not expected to click this button."));
let device = &options.device;
assert_eq!((device.lang_pack.as_str(), device.system_lang_code.as_deref(), device.tz_offset), ("", None, None));
let set = Client::builder("set", 1, "hash").lang_pack("android").system_lang_code("fr").tz_offset(60);
let device = &set.options.device;
assert_eq!((device.lang_pack.as_str(), device.system_lang_code.as_deref()), ("android", Some("fr")));
assert_eq!(device.tz_offset, Some(60));
}
#[test]
fn a_zero_update_queue_is_stored_as_one() {
assert_eq!(Client::builder("zero", 1, "hash").updates_capacity(0).options.updates_capacity, 1);
}
#[tokio::test]
async fn non_object_params_with_tz_offset_are_refused() {
let refused =
Client::builder("refused", 1, "hash").in_memory().tz_offset(60).init_connection_params(Json::Null);
assert!(matches!(refused.connect().await, Err(Error::InvalidArgument(_))));
let array = Client::builder("refused", 1, "hash").in_memory().init_connection_params(Json::Array(Vec::new()));
let array = array.tz_offset(1).connect().await;
assert!(matches!(array, Err(Error::InvalidArgument(_))));
}
#[tokio::test]
async fn bad_transfer_options_are_refused() {
let builder = || Client::builder("refused", 1, "hash").in_memory();
let refused = [
builder().download_connections(0),
builder().upload_connections(9),
builder().max_download_bytes_per_sec(Some(0)),
builder().max_upload_bytes_per_sec(Some(0)),
];
for builder in refused {
assert!(matches!(builder.connect().await, Err(Error::InvalidArgument(_))));
}
}
#[test]
fn transfer_options_reach_the_settings() {
let builder = Client::builder("set", 1, "hash").download_connections(3).max_upload_bytes_per_sec(None);
let settings = builder.transfer_settings;
let large = Some(LARGE);
assert_eq!(settings.plan(Direction::Download, true, false, large).shape.connections, 3);
assert_eq!(settings.plan(Direction::Upload, true, false, large).rate, None);
let set = Client::builder("set", 1, "hash").max_download_bytes_per_sec(Some(1 << 20)).transfer_settings;
let rate = |bot| set.plan(Direction::Download, bot, false, large).rate;
assert_eq!((rate(true), rate(false)), (Some(1 << 20), Some(1 << 20)));
}
#[test]
fn zero_listeners_and_transmissions_are_stored_as_one() {
let builder = Client::builder("zero", 1, "hash").max_listeners(0).max_concurrent_transmissions(0);
assert_eq!((builder.max_listeners, builder.max_concurrent_transmissions), (Some(1), Some(1)));
}
#[tokio::test]
async fn rate_limits_are_checked_when_connecting() {
let limit = |rate, burst| RateLimits::default().limit(RateCategory::Query, rate, burst);
for limits in
[limit(0.0, 5.0), limit(-1.0, 5.0), limit(f64::NAN, 5.0), limit(f64::INFINITY, 5.0), limit(1.0, 0.5)]
{
let refused = Client::builder("limits", 1, "hash").in_memory().rate_limits(limits).connect().await;
assert!(matches!(refused, Err(Error::InvalidArgument(_))));
}
}
#[cfg(feature = "dns-config")]
async fn open_via_dns(expires: i32, factory: bool) -> (Result<Client, Error>, Vec<std::net::SocketAddr>) {
use std::net::SocketAddr;
use crate::connection::{AccessPointRule, DnsConfig, IpPort};
let dc = TestDc::start([5; 256], false).await;
let SocketAddr::V4(real) = dc.dc(99).addr else { panic!("the test DC isn't on IPv4") };
let saved = SessionData {
dc_id: 99,
test_mode: false,
addr: Some("0.0.0.0:1".parse().unwrap()),
api_id: 1,
auth_key: [5; 256],
user_id: 0,
is_bot: false,
};
let session = crate::storage::session_string::export(&saved);
let mut builder = Client::builder("dns", 1, "hash").session_string(session).dns_fallback();
let dialed = Arc::new(std::sync::Mutex::new(Vec::new()));
if factory {
let seen = dialed.clone();
builder = builder.connection_factory(move |addr: SocketAddr| {
seen.lock().unwrap().push(addr);
async { Err::<tokio::net::TcpStream, _>(std::io::Error::from(std::io::ErrorKind::ConnectionRefused)) }
});
}
let rule = AccessPointRule {
phone_prefix_rules: String::new(),
dc_id: 99,
ips: vec![IpPort { addr: real, secret: None }],
};
builder.dns_config = Some(DnsConfig { date: 0, expires, rules: vec![rule] });
let client = builder.connect().await;
let dialed = dialed.lock().unwrap().clone();
(client, dialed)
}
#[cfg(feature = "dns-config")]
#[tokio::test]
async fn fallback_tries_dns_addresses_after_both_fail() {
let (client, _) = open_via_dns(i32::MAX, false).await;
assert_eq!(client.unwrap().session().dc_id(), 99);
}
#[cfg(feature = "dns-config")]
#[tokio::test]
async fn an_expired_dns_config_is_ignored() {
let (client, _) = open_via_dns(1, false).await;
assert!(client.is_err());
}
#[cfg(feature = "dns-config")]
#[tokio::test]
async fn a_connection_factory_turns_the_fallback_off() {
let (client, dialed) = open_via_dns(i32::MAX, true).await;
assert!(client.is_err());
assert_eq!(dialed, ["0.0.0.0:1".parse::<std::net::SocketAddr>().unwrap()]);
}
#[tokio::test]
async fn no_updates_wraps_user_calls_and_init() {
use crate::raw::functions::Ping;
use crate::session::test_dc::{INIT_CONNECTION, INVOKE_WITH_LAYER, INVOKE_WITHOUT_UPDATES, PING};
let dc = TestDc::start([5; 256], false).await;
let quiet = Client::builder("quiet", 1, "hash").session_string(dc.session_string([5; 256])).no_updates();
let client = quiet.connect().await.unwrap();
client.invoke(&Ping { ping_id: 3 }).await.unwrap();
let seen: Vec<Vec<u32>> = dc.seen().into_iter().map(|s| s.ids).collect();
let opening = seen.iter().find(|ids| ids[0] == INVOKE_WITH_LAYER).expect("no initConnection");
assert_eq!((opening.len(), opening[1], opening[2]), (4, INIT_CONNECTION, INVOKE_WITHOUT_UPDATES));
assert!(seen.contains(&vec![INVOKE_WITHOUT_UPDATES, PING]), "{seen:?}");
let plain = Client::builder("plain", 1, "hash").session_string(dc.session_string([5; 256]));
let plain = plain.connect().await.unwrap();
plain.invoke(&Ping { ping_id: 4 }).await.unwrap();
let after: Vec<Vec<u32>> = dc.seen().into_iter().skip(seen.len()).map(|s| s.ids).collect();
assert!(after.iter().all(|ids| !ids.contains(&INVOKE_WITHOUT_UPDATES)), "{after:?}");
}
#[test]
fn the_link_listener_does_not_keep_the_client_alive() {
let client = Client::offline();
client.on_connect(|_| async { Ok(()) });
let (weak, events) = (std::sync::Arc::downgrade(&client.0), client.0.events.clone());
drop(client);
assert!(weak.upgrade().is_none());
events.link(true);
}
#[tokio::test]
async fn the_default_file_keeps_the_login_the_state_and_known_peers() {
let dir = temp_dir("files");
let (mut client, _) = Client::scripted(Vec::new());
Arc::get_mut(&mut client.0).unwrap().set_store(Arc::new(FileStorage::new(dir.join("bot"))));
*client.0.me.lock().unwrap() = Me { id: 1001, is_bot: true, ..Me::default() };
let peer = types::InputPeerUser { user_id: 777, access_hash: 5 };
client.0.peers.lock().unwrap().insert(777, base::InputPeer::InputPeerUser(Box::new(peer)));
let update_state = UpdateState { pts: 50, date: 1, ..Default::default() };
client.save().await.unwrap();
client.0.save_state(&update_state).await;
drop(client);
let file = FileStorage::new(dir.join("bot"));
let session = file.load_session().await.unwrap().map(|s| (s.user_id, s.is_bot));
let state = file.load_state().await.unwrap();
let peers = file.export_peers(None).await.unwrap();
let mut names: Vec<_> = std::fs::read_dir(&dir).unwrap().map(|e| e.unwrap().file_name()).collect();
names.sort();
let _ = std::fs::remove_dir_all(&dir);
assert_eq!(session, Some((1001, true)));
assert_eq!(state.map(|s| (s.owner, s.update)), Some((1001, Some(update_state))));
assert_eq!(peers.iter().map(|p| (p.id, p.access_hash)).collect::<Vec<_>>(), [(777, 5)]);
assert_eq!(names, ["bot.session", "bot.session.lock"], "the login and its lock, no .state");
}
#[tokio::test]
async fn a_session_file_from_an_older_vaegram_is_refused_untouched() {
let dir = temp_dir("old-files");
let old = "VAE_BAQAADA5AQABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uLzAx";
std::fs::write(dir.join("bot.session"), old).unwrap();
let client = Client::builder(dir.join("bot").to_str().unwrap(), 1, "hash").connect().await;
let left = std::fs::read_to_string(dir.join("bot.session")).unwrap();
let _ = std::fs::remove_dir_all(&dir);
let Err(Error::Io(e)) = client else { panic!("an old file opened") };
assert!(e.to_string().contains("log in again"), "{e}");
assert_eq!(left, old);
}
#[tokio::test]
async fn a_storage_engine_is_read_on_connect_and_given_the_login() {
let dc = TestDc::start([5; 256], false).await;
let login = storage_session(&dc);
let engine = Arc::new(Recording::default());
engine.save_session(&login).await.unwrap();
let client = Client::builder("custom-store", 1, "hash").storage_engine(engine.clone()).connect().await;
drop(client.unwrap());
let calls = engine.calls();
assert_eq!(calls[..6], ["save_session", "open", "load_session", "load_state", "export_peers", "save_session"]);
assert_eq!(calls.last(), Some(&"close"));
assert!(!Path::new("custom-store.session").exists());
}
fn storage_session(dc: &TestDc) -> SessionData {
crate::storage::session_string::parse(&dc.session_string([5; 256])).unwrap()
}
#[test]
fn the_last_of_storage_engine_session_string_and_in_memory_wins() {
let string = Client::builder("a", 1, "hash").in_memory().session_string("x");
assert!(string.engine.is_none() && string.session_string.is_some());
let engine = Client::builder("a", 1, "hash").session_string("x").storage_engine(MemoryStorage::new());
assert!(engine.engine.is_some() && engine.session_string.is_none());
}
#[test]
fn workdir_joins_the_name() {
let dir = std::env::temp_dir().join("bots");
let builder = Client::builder("echo", 1, "hash").workdir(&dir);
assert_eq!(builder.default_engine().path(), dir.join("echo.session"));
assert_eq!(Client::builder("a/echo", 1, "hash").default_engine().path(), Path::new("a/echo.session"));
}
#[tokio::test]
async fn a_cold_peer_comes_from_the_store_without_a_request() {
let engine = Arc::new(MemoryStorage::new());
engine.update_peers(&[PeerRecord::new(777, 5)]).await.unwrap();
let (mut client, mut sent) = Client::scripted(Vec::new());
Arc::get_mut(&mut client.0).unwrap().set_store(engine);
let peer = client.resolve_peer(777).await.unwrap();
let expected = base::InputPeer::InputPeerUser(Box::new(types::InputPeerUser { user_id: 777, access_hash: 5 }));
assert_eq!(peer, expected);
assert!(sent.try_recv().is_err(), "a request went out");
assert!(client.0.peers.lock().unwrap().contains_key(&777), "and it stays cached");
}
#[tokio::test]
async fn a_stored_username_survives_a_restart() {
let dir = temp_dir("usernames");
let (mut client, _) = Client::scripted(Vec::new());
Arc::get_mut(&mut client.0).unwrap().set_store(Arc::new(FileStorage::new(dir.join("bot"))));
*client.0.me.lock().unwrap() = Me { id: 1001, is_bot: true, ..Me::default() };
client.save().await.unwrap();
client.0.peers.lock().unwrap().remember(777, 5, &["Alice"], None);
drop(client);
let (mut client, mut sent) = Client::scripted(Vec::new());
Arc::get_mut(&mut client.0).unwrap().set_store(Arc::new(FileStorage::new(dir.join("bot"))));
let found = client.resolve(&PeerRef::Username("@alice".into())).await;
let _ = std::fs::remove_dir_all(&dir);
assert_eq!(found.unwrap().0, 777);
assert!(sent.try_recv().is_err(), "a request went out");
}
#[tokio::test]
async fn an_in_memory_client_writes_no_files() {
assert!(Client::builder("memory", 1, "hash").in_memory().engine.is_some());
let dc = TestDc::start([5; 256], false).await;
let dir = temp_dir("memory");
let builder = Client::builder(dir.join("bot").to_str().unwrap(), 1, "hash").in_memory();
let client = builder.session_string(dc.session_string([5; 256])).connect().await.unwrap();
client.0.save_state(&UpdateState { pts: 1, date: 1, ..Default::default() }).await;
client.save().await.unwrap();
drop(client);
let files = std::fs::read_dir(&dir).unwrap().count();
let _ = std::fs::remove_dir_all(&dir);
assert_eq!(files, 0);
}
#[tokio::test]
async fn builder_listener_settings_reach_the_client() {
let dc = TestDc::start([5; 256], false).await;
let builder = Client::builder("listener-settings", 1, "hash").session_string(dc.session_string([5; 256]));
let builder = builder.listener_timeout(Duration::from_secs(7)).unallowed_click_alert("not yours");
let client = builder.client_platform("android").connect().await.unwrap();
assert_eq!(client.0.listener_timeout, Some(Duration::from_secs(7)));
assert_eq!(client.0.unallowed_click_alert.as_deref(), Some("not yours"));
assert_eq!(client.0.client_platform, "android");
let builder = Client::builder("no-listener-settings", 1, "hash").session_string(dc.session_string([5; 256]));
let client = builder.no_listener_timeout().no_unallowed_click_alert().connect().await.unwrap();
assert_eq!((client.0.listener_timeout, client.0.unallowed_click_alert.clone()), (None, None));
}
#[tokio::test]
async fn a_session_string_client_writes_no_files() {
let dc = TestDc::start([5; 256], false).await;
let dir = temp_dir("string");
let builder = Client::builder(dir.join("bot").to_str().unwrap(), 1, "hash");
let client = builder.session_string(dc.session_string([5; 256])).connect().await.unwrap();
client.0.save_state(&UpdateState { pts: 1, date: 1, ..Default::default() }).await;
drop(client);
let files = std::fs::read_dir(&dir).unwrap().count();
let _ = std::fs::remove_dir_all(&dir);
assert_eq!(files, 0);
}
#[tokio::test]
async fn a_failing_store_fails_connect_instead_of_panicking() {
let result = Client::builder("failing-store", 1, "hash").storage_engine(Recording::failing()).connect().await;
assert!(matches!(result, Err(Error::Io(_))), "{result:?}");
}
fn imported_string(dc: &TestDc) -> String {
let std::net::SocketAddr::V4(addr) = dc.dc(2).addr else { unreachable!("TestDc listens on IPv4") };
let b = [&[2][..], &addr.ip().octets(), &addr.port().to_be_bytes(), &[5; 256]].concat();
format!("1{}", crate::utils::base64url_encode(&b))
}
fn user_lookups(dc: &TestDc) -> usize {
dc.seen().iter().filter(|s| s.ids.last() == Some(&crate::session::test_dc::GET_USERS)).count()
}
#[tokio::test]
async fn an_imported_string_learns_who_it_is() {
let dc = TestDc::start([5; 256], false).await;
dc.sign_in(4242);
let builder = Client::builder("imported-user", 1, "hash").session_string(imported_string(&dc));
let client = builder.connect().await.unwrap();
assert_eq!(client.0.me.lock().unwrap().id, 4242);
let saved = client.0.store.load_session().await.unwrap().map(|s| s.user_id);
assert_eq!(saved, Some(4242), "the store gets the account");
assert_eq!(user_lookups(&dc), 1);
drop(dc.client([5; 256]).await);
assert_eq!(user_lookups(&dc), 1);
}
#[tokio::test]
async fn a_revoked_import_stays_logged_out() {
let dc = TestDc::start([5; 256], false).await;
let builder = Client::builder("revoked-import", 1, "hash").session_string(imported_string(&dc));
let client = builder.connect().await.unwrap();
assert_eq!((client.0.me.lock().unwrap().id, user_lookups(&dc)), (0, 1));
}
#[tokio::test]
async fn only_a_picked_media_address_makes_a_media_dc() {
let media: std::net::SocketAddr = "149.154.167.151:443".parse().unwrap();
let with_media = || {
let client = Client::offline();
*client.0.media_dcs.write().unwrap() = vec![(2, media)];
client
};
let mut client = with_media();
let picked = client.media_dc(2).unwrap();
assert_eq!((picked.addr, picked.media, picked.wire_id()), (media, true, -2));
assert!(!client.dc(2).unwrap().media, "the main address is never the media one");
assert!(!client.media_dc(4).unwrap().media, "DC 4 has no media address");
Arc::get_mut(&mut client.0).unwrap().pinned = Some("127.0.0.1:1".parse().unwrap());
assert!(!client.media_dc(2).unwrap().media && !client.dc(2).unwrap().media);
#[cfg(feature = "websocket")]
{
let mut client = with_media();
Arc::get_mut(&mut client.0).unwrap().options.websocket = true;
assert!(!client.media_dc(2).unwrap().media);
}
}
#[tokio::test]
async fn a_media_download_makes_its_key_on_the_main_address() {
use crate::raw::Serializable;
let dc = TestDc::start([5; 256], false).await;
let export = types::auth::ExportedAuthorization { id: 1, bytes: vec![1] };
let export = base::auth::ExportedAuthorization::ExportedAuthorization(Box::new(export)).to_bytes();
let (client, _sent) = Client::scripted(vec![Ok(export)]);
*client.0.dcs.write().unwrap() = vec![(4, dc.dc(4).addr)];
*client.0.media_dcs.write().unwrap() = vec![(4, dc.dc(4).addr)];
let lease = client.transfer_sessions(client.media_dc(4).unwrap(), 2).await.unwrap();
for session in &lease.sessions {
session.invoke(&crate::raw::functions::Ping { ping_id: 1 }).await.unwrap();
}
assert_eq!(dc.handshakes(), [(1, 4, false)], "the permanent key is made on the main address only");
}
}