use std::path::{Path, PathBuf}; use std::sync::{Arc, Mutex, RwLock}; // 会话字段专用 tokio 异步互斥(与 std 互斥区分开): // 创建 Session 是 async 操作,必须持锁跨 await,否则"双重检查"在 await 期间失效, // 并发首次添加 BT 任务可能各建一个全局会话,产生孤儿会话与跨会话无效句柄。 use tokio::sync::Mutex as AsyncMutex; use librqbit::api::TorrentIdOrHash; use librqbit::{AddTorrent, AddTorrentOptions, AddTorrentResponse, ManagedTorrent, Session}; use super::task::BtFileInfo; /// 磁力元数据解析超时(秒):依赖 DHT/tracker 拉取,过短易误报,过长体验差 pub(crate) const INSPECT_TIMEOUT_SECS: u64 = 60; /// 每日 tracker 同步源(XIU2/TrackersListCollection,官方新域名 cf.trackerslist.com)。 /// 注意:GitHub 仓库 raw 路径(raw.githubusercontent.com/...trackers_best.txt)已随项目 /// 迁移失效(404),不要再用 GitHub 代理镜像。以下为官方 Cloudflare 分发地址, /// 国内直连通常可达,按顺序尝试、首个成功即用。 const TRACKER_SYNC_SOURCES: &[&str] = &[ "https://cf.trackerslist.com/best.txt", "https://trackerslist.com/best.txt", "https://cf.trackerslist.com/all.txt", ]; /// 动态 tracker 持久化文件与同步元数据 const TRACKERS_FILE: &str = "bt_trackers.txt"; const TRACKERS_META_FILE: &str = "bt_trackers_meta.json"; /// 常用公共 tracker:磁力链接本身可能只带很少 tracker,追加这些可提升解析成功率。 /// 混合 UDP/HTTP(S)/WebSocket,覆盖 UDP 被屏蔽但 HTTP 可用的网络环境。 pub const PUBLIC_TRACKERS: &[&str] = &[ // UDP "udp://tracker.opentrackr.org:1337/announce", "udp://open.tracker.cl:1337/announce", "udp://tracker.openbittorrent.com:6969/announce", "udp://tracker.torrent.eu.org:451/announce", "udp://open.stealth.si:80/announce", "udp://exodus.desync.com:6969/announce", "udp://tracker.tiny-vps.com:6969/announce", "udp://open.demonii.com:1337/announce", "udp://tracker.moeking.me:6969/announce", "udp://ipv4.tracker.harry.lu:80/announce", "udp://explodie.org:6969/announce", "udp://tracker.birkenfeld.ru:7496/announce", "udp://tracker.pomf.se:80/announce", "udp://tracker.tamersunion.org:6969/announce", "udp://retracker.lanta-net.ru:2710/announce", // HTTP(S) "http://tracker.opentrackr.org:1337/announce", "http://tracker.openbittorrent.com:80/announce", "http://tracker1.itzmx.com:8080/announce", "http://tracker4.itzmx.com:2710/announce", "https://tracker.gbitt.info:443/announce", "https://tracker.nanoha.org:443/announce", "http://tracker.bt4g.com:2095/announce", "http://tracker.gbitt.info:80/announce", ]; /// 种子信息(inspect 解析结果,供命令返回给前端做文件勾选) #[derive(Debug, Clone, serde::Serialize, specta::Type)] #[serde(rename_all = "camelCase")] pub struct TorrentInfo { /// 种子名称 pub name: String, /// infohash(hex 小写字符串) pub info_hash: String, /// 种子内全部文件总大小(字节) pub total_size: u64, /// 种子内文件列表 pub files: Vec, } /// BitTorrent 下载器:封装 librqbit 全局会话(多任务共享 DHT / 监听端口 / tracker 缓存)。 /// 会话懒创建:只有真正添加 BT 任务时才初始化,避免引擎启动即拉起 BT 内核。 #[derive(Clone)] pub struct TorrentDownloader { /// 全局会话(懒创建;tokio 异步互斥保证并发首次添加只创建一个会话) session: Arc>>>, /// 会话默认输出目录(每个任务用 AddTorrentOptions.output_folder 覆盖) base_dir: PathBuf, /// 上传限速 bytes/s(0=不限),per-torrent 应用 upload_limit_bps: Arc, /// 监听端口(0=自动) listen_port: Arc, /// SOCKS5 代理地址(None=直连;来自代理模块,不可用时降级直连) proxy_addr: Arc>>, /// 动态公共 tracker(每日从外部列表同步,叠加到内置列表) dynamic_trackers: Arc>>, } impl TorrentDownloader { pub fn new(base_dir: PathBuf) -> Self { Self { session: Arc::new(AsyncMutex::new(None)), base_dir, upload_limit_bps: Arc::new(std::sync::atomic::AtomicU64::new(0)), listen_port: Arc::new(std::sync::atomic::AtomicU16::new(0)), proxy_addr: Arc::new(Mutex::new(None)), dynamic_trackers: Arc::new(RwLock::new(Vec::new())), } } /// 更新 BT 专属设置(上传限速 KB/s、监听端口、SOCKS5 代理地址)— 会话创建时生效 pub fn set_settings(&self, upload_limit_kb: u64, listen_port: u16, proxy_addr: Option) { self.upload_limit_bps .store(upload_limit_kb.saturating_mul(1024), std::sync::atomic::Ordering::SeqCst); self.listen_port .store(listen_port, std::sync::atomic::Ordering::SeqCst); *self.proxy_addr.lock().unwrap_or_else(|e| e.into_inner()) = proxy_addr; } /// 设置动态 tracker(合并去重) pub fn add_dynamic_trackers(&self, list: Vec) { if list.is_empty() { return; } let mut g = self.dynamic_trackers.write().unwrap_or_else(|e| e.into_inner()); for t in list { let t = t.trim().to_string(); if !t.is_empty() && !g.contains(&t) { g.push(t); } } } /// 当前动态 tracker 数量 pub fn dynamic_count(&self) -> usize { self.dynamic_trackers.read().unwrap_or_else(|e| e.into_inner()).len() } /// 合并内置 + 动态 tracker(去重),供 inspect / add_async 共用 fn build_trackers(&self) -> Vec { let dyn_trackers = self.dynamic_trackers.read().unwrap_or_else(|e| e.into_inner()).clone(); let mut trackers: Vec = PUBLIC_TRACKERS.iter().map(|s| s.to_string()).collect(); for t in dyn_trackers { if !trackers.contains(&t) { trackers.push(t); } } trackers } /// 每日同步动态 tracker:读取本地缓存 → 判断今天是否已同步 → 未同步则拉取更新。 /// 失败静默降级:保留上次成功的列表。 pub async fn sync_dynamic_trackers(&self, data_dir: &Path) { fn parse_list(text: &str) -> Vec { text.lines() .map(|l| l.trim()) .filter(|l| l.starts_with("http://") || l.starts_with("https://") || l.starts_with("udp://") || l.starts_with("ws://") || l.starts_with("wss://")) .map(|l| l.to_string()) .collect() } let trackers_path = data_dir.join(TRACKERS_FILE); let meta_path = data_dir.join(TRACKERS_META_FILE); let today = chrono::Local::now().format("%Y-%m-%d").to_string(); // 1. 先加载上次成功保存的列表到内存(覆盖"重启后内存被清空") if let Ok(s) = std::fs::read_to_string(&trackers_path) { self.add_dynamic_trackers(parse_list(&s)); } // 2. 今天已同步过则不再下载 if let Ok(meta) = std::fs::read_to_string(&meta_path) { if let Ok(v) = serde_json::from_str::(&meta) { if v.get("date").and_then(|d| d.as_str()) == Some(&today) { return; } } } // 3. 依次尝试各镜像源(记录每个源的失败原因,便于判断是 DNS 还是连接超时) let client = reqwest::Client::builder() .timeout(std::time::Duration::from_secs(10)) .build() .ok(); for url in TRACKER_SYNC_SOURCES { let Some(c) = &client else { break }; match c.get(*url).send().await { Err(e) => { crate::logger::log_line("download", crate::logger::LogLevel::Debug, &format!("动态 tracker 源不可达 {}: {}", url, e)); continue; } Ok(resp) => { let text = match resp.text().await { Ok(t) => t, Err(e) => { crate::logger::log_line("download", crate::logger::LogLevel::Debug, &format!("动态 tracker 源读取失败 {}: {}", url, e)); continue; } }; let list = parse_list(&text); if list.is_empty() { crate::logger::log_line("download", crate::logger::LogLevel::Debug, &format!("动态 tracker 源返回空列表 {}", url)); continue; } // 保存列表与同步元数据 let _ = std::fs::write(&trackers_path, format!("{}\n", list.join("\n"))); let _ = std::fs::write(&meta_path, serde_json::json!({ "date": today }).to_string()); self.add_dynamic_trackers(list); crate::logger::log_info("download", &format!("已同步动态 tracker(共 {} 条)", self.dynamic_count())); return; } } } crate::logger::log_warn("download", "动态 tracker 全部同步源不可达,使用上次成功列表或内置列表(不影响磁力解析,公共 tracker 仍会生效)"); } /// 会话级公共 tracker(HashSet,供 SessionOptions.trackers 使用)。 /// 注意:librqbit 对磁力链接只采用 magnet URL 自带的 tr= 参数,完全忽略 /// AddTorrentOptions.trackers(见 librqbit session.rs 的 magnet 分支),导致 /// 纯磁力(无自带 tr)解析元数据时 "trackers list is empty"。而会话级 /// SessionOptions.trackers 会在 make_peer_rx 中合并进每个种子(含磁力), /// 因此必须放到这里才能让磁力链接真正带上公共 tracker。 fn session_trackers(&self) -> std::collections::HashSet { self.build_trackers() .into_iter() .filter_map(|t| url::Url::parse(&t).ok()) .collect() } /// 获取或创建全局会话。 /// 持 tokio 互斥锁覆盖整个构造过程:并发调用在此串行化, /// 先进入者创建并写入,后续者锁内二次检查直接复用(避免多会话竞态)。 /// 开启代理时先尝试用代理初始化;失败则降级为直连(记录下来供 add 重试判断)。 async fn get_session(&self) -> Result, String> { let mut guard = self.session.lock().await; if let Some(s) = guard.as_ref() { return Ok(s.clone()); } let _ = std::fs::create_dir_all(&self.base_dir); let port = self.listen_port.load(std::sync::atomic::Ordering::SeqCst); let proxy = self.proxy_addr.lock().unwrap_or_else(|e| e.into_inner()).clone(); let connect_opt = proxy.as_ref().map(|p| librqbit::ConnectionOptions { proxy_url: Some(p.clone()), ..Default::default() }); let had_proxy = connect_opt.is_some(); // 构造带代理(若启用)+ 监听端口 + 会话级公共 tracker 的会话选项 let mut opts = lib_session_options(); opts.trackers = self.session_trackers(); if connect_opt.is_some() { opts.connect = connect_opt; } if port > 0 { if let Ok(addr) = format!("0.0.0.0:{}", port).parse::() { opts.listen = Some(librqbit::ListenerOptions { listen_addr: addr, ..Default::default() }); } else { crate::logger::log_error("download", &format!("BT 监听端口 {} 无效,使用自动端口", port)); } } // 尝试创建会话:先按配置(可能带代理),失败且有代理则降级直连重试 let s = match Session::new_with_opts(self.base_dir.clone(), opts).await { Ok(s) => s, Err(e) => { if had_proxy { crate::logger::log_error("download", &format!("BT 代理会话初始化失败({}),降级为直连", e)); let mut m = lib_session_options(); m.trackers = self.session_trackers(); if port > 0 { if let Ok(addr) = format!("0.0.0.0:{}", port).parse::() { m.listen = Some(librqbit::ListenerOptions { listen_addr: addr, ..Default::default() }); } } Session::new_with_opts(self.base_dir.clone(), m).await.map_err(|e2| format!("初始化 BitTorrent 会话失败: {}", e2))? } else { return Err(format!("初始化 BitTorrent 会话失败: {}", e)); } } }; *guard = Some(s.clone()); Ok(s) } /// 解析磁力链 / 本地 .torrent 文件,返回种子信息(不开始下载)。 /// list_only 模式:仅获取元数据,不加入会话,因此不影响后续真正添加。 /// 磁力元数据依赖 DHT/tracker 拉取,无超时会永久等待,故加超时。 pub async fn inspect(&self, input: &str) -> Result { let session = self.get_session().await?; let trackers = self.build_trackers(); // 磁力:需从网络拉取元数据,可能较慢(取决于种子热度与网络连通性); // 本地 .torrent / http(s) .torrent URL:元数据在文件内,from_cli_argument 会读取/下载并解析 let add = AddTorrent::from_cli_argument(input).map_err(|e| format!("无效的种子输入: {}", e))?; let add_fut = session.add_torrent( add, Some(AddTorrentOptions { list_only: true, trackers: Some(trackers), ..Default::default() }), ); let resp = tokio::time::timeout(std::time::Duration::from_secs(INSPECT_TIMEOUT_SECS), add_fut) .await .map_err(|_| "解析磁力元数据超时:未能从 DHT/Tracker 获取种子信息,请确认种子有做种源或网络可直连 BT".to_string())? .map_err(|e| format!("解析种子失败: {}", e))?; let AddTorrentResponse::ListOnly(lo) = resp else { return Err("该链接未返回有效的种子元数据".to_string()); }; let info = lo.info.info(); let name = info .name .as_ref() .map(|b| String::from_utf8_lossy(b.as_ref()).into_owned()) .or_else(|| lo.info.name().map(|c| c.to_string())) .unwrap_or_else(|| "未命名种子".to_string()); let mut files = Vec::new(); let mut total_size = 0u64; if let Some(fs) = &info.files { for (i, f) in fs.iter().enumerate() { let path = f .path .iter() .map(|p| String::from_utf8_lossy(p.as_ref()).into_owned()) .collect::>() .join("/"); files.push(BtFileInfo { index: i as u32, path, size: f.length, }); total_size += f.length; } } else if let Some(len) = info.length { // 单文件种子 files.push(BtFileInfo { index: 0, path: name.clone(), size: len, }); total_size = len; } Ok(TorrentInfo { name, info_hash: hex_encode(&lo.info_hash.0), total_size, files, }) } /// 异步添加种子:立即返回句柄(不等待元数据),由调用方后台解析。 /// 附加公共 tracker 提升磁力元数据解析成功率;上传限速 per-torrent 应用。 pub async fn add_async( &self, input: &str, output_dir: &str, ) -> Result<(usize, Arc), String> { let session = self.get_session().await?; std::fs::create_dir_all(output_dir).map_err(|e| format!("创建下载目录失败: {}", e))?; let up = self.upload_limit_bps.load(std::sync::atomic::Ordering::SeqCst); let upload_bps = std::num::NonZeroU32::new(up.min(u32::MAX as u64) as u32); let trackers = self.build_trackers(); let opts = AddTorrentOptions { paused: true, output_folder: Some(output_dir.to_string()), overwrite: true, trackers: Some(trackers), ratelimits: librqbit::limits::LimitsConfig { upload_bps, download_bps: None, }, ..Default::default() }; let add = AddTorrent::from_cli_argument(input).map_err(|e| format!("无效的种子输入: {}", e))?; let resp = session .add_torrent(add, Some(opts)) .await .map_err(|e| format!("添加种子失败: {}", e))?; match resp { AddTorrentResponse::Added(id, handle) => Ok((id, handle)), AddTorrentResponse::AlreadyManaged(id, handle) => Ok((id, handle)), _ => Err("种子已存在或元数据无效".to_string()), } } /// 等待种子元数据初始化就绪(磁力需要从网络拉取,带超时) pub async fn wait_initialized(&self, handle: &Arc) -> Result<(), String> { tokio::time::timeout( std::time::Duration::from_secs(INSPECT_TIMEOUT_SECS), handle.wait_until_initialized(), ) .await .map_err(|_| "解析磁力元数据超时:未能从 DHT/Tracker 获取种子信息,请确认种子有做种源或网络可直连 BT".to_string())? .map_err(|e| format!("获取种子元数据失败: {}", e)) } /// 设置要下载的种子文件子集(用户文件勾选;传全部索引则全选) pub async fn set_only_files(&self, handle: &Arc, files: &[u32]) -> Result<(), String> { let session = self.get_session().await?; let set: std::collections::HashSet = files.iter().map(|&i| i as usize).collect(); session .update_only_files(handle, &set) .await .map_err(|e| format!("设置下载文件失败: {}", e)) } /// 读取句柄当前进度:返回 (已下载字节, 总字节, 每文件已下载字节) /// `file_progress` 与种子文件一一对应,供前端详情页展示单文件进度。 pub fn progress_full(handle: &Arc) -> (u64, u64, Vec) { let s = handle.stats(); (s.progress_bytes, s.total_bytes, s.file_progress.clone()) } /// 暂停种子(下载中的连接会停止,已下载片段保留,可继续) pub async fn pause(&self, handle: &Arc) -> Result<(), String> { let session = self.get_session().await?; session .pause(handle) .await .map_err(|e| format!("暂停种子失败: {}", e)) } /// 继续种子(幂等):恢复已暂停的种子。 /// 若种子本已处于 Live(例如 select_bt_files 的 set_only_files 内部已恢复过、 /// 或暂停期间被其他逻辑恢复),直接视为成功,避免 librqbit 报 "torrent is already live" /// 而导致 pause→resume 链路被误判为失败。 pub async fn unpause(&self, handle: &Arc) -> Result<(), String> { let session = self.get_session().await?; match handle.stats().state { librqbit::TorrentStatsState::Live => Ok(()), librqbit::TorrentStatsState::Error => Err("种子处于错误状态,无法继续".to_string()), librqbit::TorrentStatsState::Paused | librqbit::TorrentStatsState::Initializing { .. } => session .unpause(handle) .await .map_err(|e| format!("继续种子失败: {}", e)), } } /// 删除种子(info_hash 为 hex 字符串;delete_files 是否同时删除已下载文件) pub async fn delete(&self, info_hash: &str, delete_files: bool) -> Result<(), String> { let session = self.get_session().await?; let id = TorrentIdOrHash::parse(info_hash) .map_err(|_| format!("无效的 infohash: {}", info_hash))?; session .delete(id, delete_files) .await .map_err(|e| format!("删除种子失败: {}", e)) } /// 读取句柄当前下载进度 (已下载字节, 总字节) pub fn progress(handle: &Arc) -> (u64, u64) { let s = handle.stats(); (s.progress_bytes, s.total_bytes) } /// 停止全局会话(应用退出时调用) pub async fn stop(&self) { let session = { let mut guard = self.session.lock().await; guard.take() }; if let Some(s) = session { let _ = s.stop().await; } } } /// 字节数组转小写十六进制字符串(librqbit 的 Id 未实现 Display) pub(crate) fn hex_encode(bytes: &[u8]) -> String { const HEX: &[u8; 16] = b"0123456789abcdef"; let mut out = String::with_capacity(bytes.len() * 2); for &b in bytes { out.push(HEX[(b >> 4) as usize] as char); out.push(HEX[(b & 0x0f) as usize] as char); } out } /// 默认会话选项(后续如需新增 DHT/缓存等可在此统一配置) fn lib_session_options() -> librqbit::SessionOptions { librqbit::SessionOptions::default() }