diff --git a/Cargo.lock b/Cargo.lock index d14d6a0..fea0fb3 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3822,7 +3822,7 @@ dependencies = [ [[package]] name = "tglock" -version = "2.0.0-beta.19" +version = "2.0.0-beta.20" dependencies = [ "aes", "cipher", diff --git a/Cargo.toml b/Cargo.toml index 743a9e9..79d4e6f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "tglock" -version = "2.0.0-beta.19" +version = "2.0.0-beta.20" edition = "2021" rust-version = "1.88" description = "Telegram unblock via local WebSocket tunnel" diff --git a/docs/ARCHITECTURE_V2.md b/docs/ARCHITECTURE_V2.md index f74ec16..eb0991b 100644 --- a/docs/ARCHITECTURE_V2.md +++ b/docs/ARCHITECTURE_V2.md @@ -243,8 +243,13 @@ Telegram Desktop на этот код выключает прокси как н Успешный маршрут становится первым для следующего соединения того же DC и типа трафика. Попытки запускаются с интервалом 250 мс, не больше трёх одновременно на соединение; остальные отменяются после первого успеха. -Если все маршруты на паузе, возвращается причина и время до повторной -попытки. Новое подключение клиента не обходит cooldown. Маршрут тоже теряет +Новое подключение клиента не обходит cooldown, с одним исключением: если на +паузе все маршруты DC, набирается один — тот, чья пауза кончается раньше всех. +Иначе одно потерянное соединение до единственного живого фронта оставляло DC без +связи на всю паузу, а Telegram за это время набирал тысячи мгновенных отказов +(#76). TCP к адресу маршрута открывается до трёх раз внахлёст с шагом 500 мс: +провайдер может отбрасывать часть соединений целиком, и повторы SYN их не +спасают, а новое соединение проходит. Маршрут тоже теряет предпочтение и получает cooldown, если Telegram закрыл соединение с кодом ошибки, туннель оборвался, не проработав 15 секунд, или клиент спросил, не дождался ответа за 5 секунд и ушёл сам. Обрыв туннеля, который работал дольше и получал ответы, diff --git a/package-lock.json b/package-lock.json index 742b332..6a4cd3e 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "tglock-ui", - "version": "2.0.0-beta.19", + "version": "2.0.0-beta.20", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "tglock-ui", - "version": "2.0.0-beta.19", + "version": "2.0.0-beta.20", "dependencies": { "@tauri-apps/api": "^2.8.0" }, diff --git a/package.json b/package.json index df61298..9cfb6e7 100644 --- a/package.json +++ b/package.json @@ -1,7 +1,7 @@ { "name": "tglock-ui", "private": true, - "version": "2.0.0-beta.19", + "version": "2.0.0-beta.20", "type": "module", "scripts": { "test:worker": "node --experimental-vm-modules --test worker/tglock-worker.test.js", diff --git a/src/proxy.rs b/src/proxy.rs index 174f25a..1e60e7b 100644 --- a/src/proxy.rs +++ b/src/proxy.rs @@ -730,6 +730,13 @@ impl Drop for EstablishedTunnel<'_> { } } +/// Что делать, если провайдер не пускает к адресам Telegram совсем. В +/// by-sonic/tglock#76 у Ростелекома отвечал только фронт DC2 и DC4, а до DC1, +/// DC3 и DC5 не доходил ни один TCP-пакет; без Cloudflare туда дороги нет. +const CLOUDFLARE_HINT: &str = "Если туннели не поднимаются постоянно, провайдер режет \ + адреса Telegram. Обойти это можно через Cloudflare: свой домен (Настройки → Свой \ + домен на Cloudflare, docs/CF_PROXY.md) или Cloudflare Worker (docs/CLOUDFLARE_WORKER.md)"; + async fn ws_tunnel( tcp: TcpStream, dc: u16, @@ -748,6 +755,10 @@ async fn ws_tunnel( // причины, и отличить «провайдер режет адреса» от «воркер отвечает // отказом» было нечем (by-sonic/tglock#50). stats.note(error.clone()); + if !stats.transport.has_cloudflare_routes() { + // Одна и та же строка попадает в журнал один раз. + stats.note(CLOUDFLARE_HINT); + } return Err(error.into()); } }; diff --git a/src/transport.rs b/src/transport.rs index 5e042f2..4174063 100644 --- a/src/transport.rs +++ b/src/transport.rs @@ -1,4 +1,5 @@ use std::collections::HashMap; +use std::net::SocketAddr; use std::sync::atomic::{AtomicU32, Ordering}; use std::sync::{Arc, Mutex, OnceLock}; use std::time::Duration; @@ -16,6 +17,14 @@ const FALLBACK_DELAY: Duration = Duration::from_millis(250); const MAX_CONNECTING: usize = 3; const FAILURE_BACKOFF_INITIAL: Duration = Duration::from_secs(30); const FAILURE_BACKOFF_MAX: Duration = Duration::from_secs(30 * 60); +// Провайдер может молча отбрасывать часть соединений до адреса целиком: в +// by-sonic/tglock#76 так терялось около трети соединений до единственного +// доступного фронта Telegram. Повторы SYN такое соединение не спасают, а новое +// соединение с другого порта проходит. Живое открывается за десятки +// миллисекунд, поэтому следующая попытка начинается, если за полсекунды ответа +// не было, и все они укладываются в CONNECT_TIMEOUT. +const TCP_ATTEMPTS: usize = 3; +const TCP_ATTEMPT_DELAY: Duration = Duration::from_millis(500); const HTTPS_PORT: u16 = 443; const HTTP_PORT: u16 = 80; const CDN203_IP: &str = "91.105.192.100"; @@ -286,23 +295,31 @@ impl TransportEngine { } } + // Все маршруты на паузе, и ни один не набирался. Пауза нужна, чтобы + // мёртвый адрес не задерживал живые; когда живых нет, она лишь + // гарантирует отказ. Telegram тут же переподключается, и в + // by-sonic/tglock#76 за четыре минуты набралось 17836 отказов при 160 + // сбоях маршрутов: единственный рабочий фронт отдыхал после одного + // потерянного соединения. Поэтому один маршрут, чья пауза кончается + // раньше всех, пробуем всё равно. Остальные ждут своей паузы. if errors.is_empty() { - let routes = self.routes_for_key(key); - let health = self.health.lock().unwrap(); - let retry = routes - .iter() - .filter_map(|route| health.routes.get(route)) - .map(|entry| entry.retry_at.saturating_duration_since(Instant::now())) - .min(); - errors.push(match retry { - Some(delay) => format!( - "маршруты на паузе после ошибок; повтор через {} с", - delay - .as_secs() - .saturating_add(u64::from(delay.subsec_nanos() != 0)) - ), - None => "для этого дата-центра нет маршрутов".to_owned(), - }); + if let Some(route) = self.soonest_paused_route(key) { + match connect(route.clone()).await { + Ok(connection) => { + self.record_success(key, &route); + return Ok((connection, ConnectedRoute { route })); + } + Err(error) => { + self.record_failure(&route); + errors.push(format!("{} — {error}", describe_endpoint(&route))); + } + } + } + } + + if errors.is_empty() { + // Хоть один маршрут был бы набран выше, значит, их нет вовсе. + errors.push("для этого дата-центра нет маршрутов".to_owned()); } Err(format!( "Не поднялся туннель до DC{}{}: {}", @@ -353,19 +370,7 @@ impl TransportEngine { } Err(error) => { self.record_failure(&route); - let endpoint = match route.kind { - RouteKind::TelegramTcp => { - format!("{}:{} (MTProto TCP)", route.connect_host, route.port) - } - RouteKind::TelegramPlainWs => { - format!("{}:{} (WebSocket)", route.connect_host, route.port) - } - _ => format!( - "{} (TLS {})", - route.connect_host, route.websocket_host - ), - }; - errors.push(format!("{endpoint} — {error}")); + errors.push(format!("{} — {error}", describe_endpoint(&route))); } } } @@ -376,6 +381,25 @@ impl TransportEngine { None } + /// Маршрут, чья пауза кончается раньше всех; последние средства — только + /// если ничего другого нет. + fn soonest_paused_route(&self, key: DcKey) -> Option { + let routes = self.routes_for_key(key); + let health = self.health.lock().unwrap(); + routes.into_iter().min_by_key(|route| { + ( + is_last_resort(route), + health.routes.get(route).map(|entry| entry.retry_at), + ) + }) + } + + /// Задан ли хоть один маршрут через Cloudflare: Worker или свой домен. + pub fn has_cloudflare_routes(&self) -> bool { + !self.worker_domains.lock().unwrap().is_empty() + || !self.cf_proxy_domains.lock().unwrap().is_empty() + } + fn route_available(&self, route: &Route) -> bool { self.health .lock() @@ -498,6 +522,15 @@ impl TransportEngine { } } +/// Куда шёл маршрут — для журнала отказов. +fn describe_endpoint(route: &Route) -> String { + match route.kind { + RouteKind::TelegramTcp => format!("{}:{} (MTProto TCP)", route.connect_host, route.port), + RouteKind::TelegramPlainWs => format!("{}:{} (WebSocket)", route.connect_host, route.port), + _ => format!("{} (TLS {})", route.connect_host, route.websocket_host), + } +} + /// Path a user's Cloudflare Worker must serve for the given data centre. /// /// This is the contract documented in `docs/CLOUDFLARE_WORKER.md`; both the @@ -754,7 +787,7 @@ async fn connect_route_with_config( } let tcp = tokio::time::timeout( CONNECT_TIMEOUT, - TcpStream::connect((route.connect_host.as_str(), route.port)), + connect_tcp(route.connect_host.as_str(), route.port), ) .await .map_err(|_| "не отвечает (таймаут TCP)".to_owned())? @@ -807,6 +840,51 @@ async fn connect_route_with_config( .map_err(|error| format!("TLS/WebSocket handshake: {}", error)) } +async fn connect_tcp(host: &str, port: u16) -> std::io::Result { + let addresses: Vec = tokio::net::lookup_host((host, port)).await?.collect(); + hedged_connect(&addresses, TcpStream::connect).await +} + +/// Открыть TCP, не полагаясь на одно соединение: см. `TCP_ATTEMPTS`. +/// +/// Попытки идут внахлёст с шагом `TCP_ATTEMPT_DELAY` по адресам из DNS по +/// кругу; побеждает первая открывшаяся, остальные закрываются. Отказ сразу +/// (например, «соединение отвергнуто») запускает следующую попытку без ожидания. +/// Время ограничивает вызывающий. +async fn hedged_connect(addresses: &[SocketAddr], mut connect: F) -> std::io::Result +where + F: FnMut(SocketAddr) -> Fut, + Fut: std::future::Future>, +{ + if addresses.is_empty() { + return Err(std::io::Error::new( + std::io::ErrorKind::NotFound, + "имя не разрешилось ни в один адрес", + )); + } + let mut pending = FuturesUnordered::new(); + let mut started = 0; + let mut next_start = Instant::now(); + let mut last_error = None; + + while started < TCP_ATTEMPTS || !pending.is_empty() { + if started < TCP_ATTEMPTS && (pending.is_empty() || Instant::now() >= next_start) { + pending.push(connect(addresses[started % addresses.len()])); + started += 1; + next_start = Instant::now() + TCP_ATTEMPT_DELAY; + continue; + } + tokio::select! { + Some(result) = pending.next(), if !pending.is_empty() => match result { + Ok(stream) => return Ok(stream), + Err(error) => last_error = Some(error), + }, + _ = tokio::time::sleep_until(next_start), if started < TCP_ATTEMPTS => {} + } + } + Err(last_error.expect("at least one attempt was started and failed")) +} + fn allowed_plain_ws_route(route: &Route) -> bool { #[cfg(test)] if route.connect_host == "127.0.0.1" { @@ -1518,18 +1596,130 @@ mod tests { assert!(error.contains("test handshake failure")); assert_eq!(peak.load(Ordering::SeqCst), MAX_CONNECTING); assert_eq!(engine.route_failures(), 8); + // Every route is in cooldown now. Only one of them may be dialed per + // client: the cooldown still keeps the rest from being redialed. + let dialed = Arc::new(std::sync::atomic::AtomicUsize::new(0)); let error = engine .race_connections(key, |_| { - panic!("a route in cooldown must never be dialed"); - #[allow(unreachable_code)] - std::future::ready(Ok::<(), String>(())) + dialed.fetch_add(1, Ordering::SeqCst); + std::future::ready(Err::<(), _>("still down".to_owned())) }) .await .unwrap_err(); - assert!(error.contains("повтор через")); - assert_eq!(engine.route_failures(), 8); + assert!(error.contains("still down")); + assert_eq!(dialed.load(Ordering::SeqCst), 1); + assert_eq!(engine.route_failures(), 9); tokio::time::advance(FAILURE_BACKOFF_INITIAL).await; - assert_eq!(engine.ordered_candidates(key).len(), 8); + assert_eq!(engine.ordered_candidates(key).len(), 7); + } + + /// by-sonic/tglock#76: the provider dropped about a third of the TCP + /// connections to the only reachable frontend. One dropped connection put + /// that route in cooldown, and from then on every client failed at once + /// without dialing anything: 17836 failures against 160 route failures in + /// four minutes. With every route paused, the one whose pause ends first + /// must still be tried, and its success must lift the pause. + #[tokio::test(start_paused = true)] + async fn a_paused_only_route_is_still_tried_and_recovers() { + let engine = TransportEngine::new(); + *engine.forced_routes.lock().unwrap() = local_routes(2); + let key = DcKey { + dc: 2, + media: false, + }; + engine.record_failure(&local_routes(2)[1]); + engine.record_failure(&local_routes(2)[1]); + engine.record_failure(&local_routes(2)[0]); + assert!(engine.ordered_candidates(key).is_empty()); + + let (_, winner) = engine + .race_connections(key, |route| { + assert_eq!( + route.path, "/0", + "the route paused for the shortest time goes first" + ); + std::future::ready(Ok::<(), String>(())) + }) + .await + .unwrap(); + assert_eq!(winner.route.path, "/0"); + assert_eq!( + engine.ordered_candidates(key), + vec![local_routes(2)[0].clone()] + ); + } + + #[tokio::test(start_paused = true)] + async fn a_dropped_tcp_connection_is_overtaken_by_the_next_attempt() { + let address: SocketAddr = "192.0.2.1:443".parse().unwrap(); + let attempts = Arc::new(std::sync::atomic::AtomicUsize::new(0)); + let started = Instant::now(); + let winner = tokio::time::timeout( + CONNECT_TIMEOUT, + hedged_connect(&[address], |dialed| { + assert_eq!(dialed, address); + let attempt = attempts.fetch_add(1, Ordering::SeqCst); + async move { + if attempt == 0 { + // The provider dropped this one: no answer, ever. + std::future::pending::>().await + } else { + tokio::time::sleep(Duration::from_millis(50)).await; + Ok(attempt) + } + } + }), + ) + .await + .expect("a second connection must overtake the dropped one") + .unwrap(); + assert_eq!(winner, 1); + assert_eq!( + started.elapsed(), + TCP_ATTEMPT_DELAY + Duration::from_millis(50) + ); + assert_eq!(attempts.load(Ordering::SeqCst), 2); + } + + #[tokio::test(start_paused = true)] + async fn tcp_attempts_are_bounded_and_spread_over_addresses() { + let addresses: Vec = vec![ + "192.0.2.1:443".parse().unwrap(), + "[2001:db8::1]:443".parse().unwrap(), + ]; + let dialed = Arc::new(Mutex::new(Vec::new())); + let result = tokio::time::timeout( + CONNECT_TIMEOUT, + hedged_connect(&addresses, |address| { + dialed.lock().unwrap().push(address); + std::future::pending::>() + }), + ) + .await; + assert!( + result.is_err(), + "nothing answered, so the caller's timeout ends it" + ); + assert_eq!( + *dialed.lock().unwrap(), + vec![addresses[0], addresses[1], addresses[0]] + ); + } + + #[tokio::test(start_paused = true)] + async fn refused_tcp_attempts_report_the_last_error() { + let address: SocketAddr = "192.0.2.1:443".parse().unwrap(); + let attempts = Arc::new(std::sync::atomic::AtomicUsize::new(0)); + let error = hedged_connect(&[address], |_| { + attempts.fetch_add(1, Ordering::SeqCst); + std::future::ready(Err::<(), _>(std::io::Error::from( + std::io::ErrorKind::ConnectionRefused, + ))) + }) + .await + .unwrap_err(); + assert_eq!(error.kind(), std::io::ErrorKind::ConnectionRefused); + assert_eq!(attempts.load(Ordering::SeqCst), TCP_ATTEMPTS); } #[test] diff --git a/tauri.conf.json b/tauri.conf.json index 3cefebc..92305e4 100644 --- a/tauri.conf.json +++ b/tauri.conf.json @@ -1,7 +1,7 @@ { "$schema": "https://schema.tauri.app/config/2", "productName": "TGLock", - "version": "2.0.0-beta.19", + "version": "2.0.0-beta.20", "identifier": "com.bysonic.tglock", "mainBinaryName": "tglock", "build": { diff --git a/ui/main.ts b/ui/main.ts index 3c36b05..fa24134 100644 --- a/ui/main.ts +++ b/ui/main.ts @@ -523,9 +523,8 @@ function publicLogLine(message: string): string { function failureLog(): string[] { const failure = /^(Не поднялся туннель|Сбой туннеля|Обрыв туннеля)/; - const paused = /на паузе после ошибок/; return status.logs - .filter(({ message }) => failure.test(message) && !paused.test(message)) + .filter(({ message }) => failure.test(message)) .slice(-20) .map(({ timestamp, message }) => `${timestamp} ${publicLogLine(message)}`); } @@ -535,7 +534,7 @@ async function copyDiagnostics(): Promise { // Public reports exclude proxy links and secrets. const report = { application: "TGLock", - version: "2.0.0-beta.19", + version: "2.0.0-beta.20", running: status.running, activeConnections: status.activeConnections, tunnels: status.tunnels,