//! Offline downloads: resumable HTTP transfers of Plex media parts with a small //! JSON catalog, so downloaded titles stay browsable and playable offline. //! //! URLs carrying Plex tokens are only held in memory. The catalog stores the //! server-relative source path; resuming after a restart asks the interface for //! a freshly signed URL. use std::collections::{HashMap, HashSet}; use std::path::{Path, PathBuf}; use std::sync::atomic::{AtomicU64, Ordering}; use std::sync::Arc; use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH}; use futures_util::StreamExt; use parking_lot::Mutex; use serde::{Deserialize, Serialize}; use serde_json::Value; use tauri::{AppHandle, Emitter, Manager, Runtime}; use tokio::io::AsyncWriteExt; use tokio::sync::{watch, Semaphore}; const MAX_ACTIVE: usize = 2; #[derive(Clone, Serialize, Deserialize, PartialEq, Debug)] #[serde(rename_all = "lowercase")] pub enum Status { Queued, Downloading, Paused, Completed, Failed, } #[derive(Clone, Serialize, Deserialize, Debug)] #[serde(rename_all = "camelCase")] pub struct Item { pub id: String, pub file_path: String, pub total: u64, pub received: u64, pub status: Status, #[serde(default)] pub error: Option, #[serde(default)] pub meta: Value, pub created_at: u64, #[serde(default)] pub speed: u64, } /// The transfer task that currently owns a download (and its `.part` file). struct Worker { generation: u64, cancel: watch::Sender, /// Closes once the task has exited and let go of the file. done: watch::Receiver<()>, } pub struct Downloads { items: Mutex>, dir: Mutex>, workers: Mutex>, generation: AtomicU64, permits: Arc, client: reqwest::Client, } impl Default for Downloads { fn default() -> Self { Downloads { items: Mutex::new(Vec::new()), dir: Mutex::new(None), workers: Mutex::new(HashMap::new()), generation: AtomicU64::new(0), permits: Arc::new(Semaphore::new(MAX_ACTIVE)), client: reqwest::Client::builder() .connect_timeout(Duration::from_secs(20)) .user_agent("Kaleido") .build() .expect("http client"), } } } fn now() -> u64 { SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_secs()).unwrap_or(0) } fn catalog_path(app: &AppHandle) -> PathBuf { crate::system::data_dir(app).join("downloads.json") } fn save(app: &AppHandle) { let state = app.state::(); let items = state.items.lock().clone(); let path = catalog_path(app); if let Some(parent) = path.parent() { let _ = std::fs::create_dir_all(parent); } if let Ok(text) = serde_json::to_string_pretty(&items) { let tmp = path.with_extension("json.tmp"); if std::fs::write(&tmp, text).is_ok() { let _ = std::fs::rename(tmp, path); } } } /// Loads the catalog at startup. Interrupted transfers become paused: their /// signed URLs were never persisted. pub fn restore(app: &AppHandle) { let Ok(text) = std::fs::read_to_string(catalog_path(app)) else { return }; let Ok(mut items) = serde_json::from_str::>(&text) else { return }; for item in items.iter_mut() { if matches!(item.status, Status::Downloading | Status::Queued) { // Marked so the interface resumes it once it has a signed URL again. item.status = Status::Paused; item.error = Some("interrupted".into()); } if item.status == Status::Completed && !Path::new(&item.file_path).exists() { item.status = Status::Failed; item.error = Some("The downloaded file is missing.".into()); } item.speed = 0; } *app.state::().items.lock() = items; } fn update(app: &AppHandle, id: &str, f: impl FnOnce(&mut Item)) -> Option { let state = app.state::(); let mut items = state.items.lock(); let item = items.iter_mut().find(|i| i.id == id)?; f(item); let snapshot = item.clone(); drop(items); let _ = app.emit("download", &snapshot); Some(snapshot) } fn sanitize(name: &str) -> String { let cleaned: String = name .chars() .map(|c| if "<>:\"/\\|?*".contains(c) || c.is_control() { '_' } else { c }) .collect(); let trimmed = cleaned.trim().trim_end_matches('.').to_string(); if trimmed.is_empty() { "Untitled".into() } else { trimmed.chars().take(120).collect() } } #[derive(Deserialize)] #[serde(rename_all = "camelCase")] pub struct StartRequest { id: String, url: String, folder: String, file_name: String, #[serde(default)] meta: Value, /// Artwork to keep with the download: name → signed URL. #[serde(default)] assets: HashMap, } #[tauri::command] pub async fn download_start(app: AppHandle, request: StartRequest) -> Result { let state = app.state::(); let dir = state.dir.lock().clone().ok_or("Choose a download folder first.")?; // The folder may be nested ("Show/Season 1"); sanitize each component. let folder = request .folder .split(['/', '\\']) .filter(|c| !c.trim().is_empty() && *c != "." && *c != "..") .fold(dir.clone(), |p, c| p.join(sanitize(c))); tokio::fs::create_dir_all(&folder).await.map_err(|e| format!("Cannot create the download folder: {e}"))?; let file_path = folder.join(sanitize(&request.file_name)); let mut meta = request.meta.clone(); if let Value::Object(map) = &mut meta { let mut local = serde_json::Map::new(); // Episodes share their season's folder, so artwork is named after the file it // belongs to: one episode's still never replaces another's. let stem = file_path.file_stem().and_then(|s| s.to_str()).map(sanitize).unwrap_or_else(|| sanitize(&request.id)); for (name, url) in &request.assets { let target = folder.join(format!(".{stem}.{}.jpg", sanitize(name))); if fetch_to(&state.client, url, &target).await.is_ok() { local.insert(name.clone(), Value::String(target.display().to_string())); } } map.insert("localAssets".into(), Value::Object(local)); } let item = Item { id: request.id.clone(), file_path: file_path.display().to_string(), total: 0, received: 0, status: Status::Queued, error: None, meta, created_at: now(), speed: 0, }; { let mut items = state.items.lock(); items.retain(|i| i.id != item.id); items.insert(0, item.clone()); } save(&app); let _ = app.emit("download", &item); spawn(app.clone(), request.id, request.url); Ok(item) } async fn fetch_to(client: &reqwest::Client, url: &str, target: &Path) -> Result<(), String> { let bytes = client.get(url).send().await.map_err(|e| e.to_string())?.error_for_status().map_err(|e| e.to_string())?.bytes().await.map_err(|e| e.to_string())?; tokio::fs::write(target, bytes).await.map_err(|e| e.to_string()) } /// Starts a transfer task for `id`, taking over from any task still running for it: /// that one is cancelled and the new one waits for it to exit before touching the file. fn spawn(app: AppHandle, id: String, url: String) { let state = app.state::(); let generation = state.generation.fetch_add(1, Ordering::Relaxed); let (tx, rx) = watch::channel(false); let (done_tx, done_rx) = watch::channel(()); let previous = state.workers.lock().insert(id.clone(), Worker { generation, cancel: tx, done: done_rx }); let previous = previous.map(|w| { let _ = w.cancel.send(true); w.done }); tauri::async_runtime::spawn(async move { // Held until this task ends: whoever waits on `done` then knows the file is free. let _done = done_tx; let took_over = previous.is_some(); if let Some(done) = previous { exited(done).await; } let stopped = rx.clone(); if *stopped.borrow() { release(&app, &id, generation); return; } let permits = app.state::().permits.clone(); let _permit = tokio::select! { p = permits.acquire_owned() => p, _ = cancelled(rx.clone()) => { release(&app, &id, generation); return; } }; // The task it replaced may have finished the file just as it was stopped. let result = if took_over && finished_file(&app, &id) { Ok(true) } else { transfer(&app, &id, &url, rx).await }; release(&app, &id, generation); // Once paused, removed or replaced, the outcome is no longer this task's to // report, except a finished file, which is complete whatever happened since. if *stopped.borrow() && !matches!(result, Ok(true)) { return; } match result { Ok(true) => { update(&app, &id, |i| { i.status = Status::Completed; i.error = None; i.speed = 0; i.received = i.total.max(i.received); }); } Ok(false) => {} Err(e) => { update(&app, &id, |i| { i.status = Status::Failed; i.error = Some(e); i.speed = 0; }); } } save(&app); }); } /// Drops the worker entry, unless a newer task has taken it over. fn release(app: &AppHandle, id: &str, generation: u64) { let state = app.state::(); let mut workers = state.workers.lock(); if workers.get(id).map(|w| w.generation) == Some(generation) { workers.remove(id); } } /// The download's file is in place and nothing is left to transfer. fn finished_file(app: &AppHandle, id: &str) -> bool { let Some(path) = app.state::().items.lock().iter().find(|i| i.id == id).map(|i| PathBuf::from(&i.file_path)) else { return false }; path.exists() && !part_path(&path).exists() } fn part_path(path: &Path) -> PathBuf { path.with_extension(format!("{}.part", path.extension().and_then(|e| e.to_str()).unwrap_or("bin"))) } /// Resolves once a worker task has exited. async fn exited(mut done: watch::Receiver<()>) { while done.changed().await.is_ok() {} } async fn cancelled(mut rx: watch::Receiver) { while !*rx.borrow() { if rx.changed().await.is_err() { std::future::pending::<()>().await; } } } /// Returns Ok(true) when complete, Ok(false) when paused/removed. async fn transfer(app: &AppHandle, id: &str, url: &str, rx: watch::Receiver) -> Result { let Some(item) = app.state::().items.lock().iter().find(|i| i.id == id).cloned() else { return Ok(false) }; let final_path = PathBuf::from(&item.file_path); let part_path = part_path(&final_path); let existing = tokio::fs::metadata(&part_path).await.map(|m| m.len()).unwrap_or(0); let client = app.state::().client.clone(); let mut request = client.get(url); if existing > 0 { request = request.header("Range", format!("bytes={existing}-")); } let response = tokio::select! { r = request.send() => r.map_err(|e| format!("Could not reach the server: {e}"))?, _ = cancelled(rx.clone()) => return Ok(false), }; let status = response.status(); if status.as_u16() == 401 || status.as_u16() == 403 { return Err("The server does not allow downloads for this account.".into()); } if !status.is_success() { return Err(format!("The server could not provide this file ({status}).")); } let resumed = status.as_u16() == 206; let start = if resumed { existing } else { 0 }; let total = response.content_length().map(|l| l + start).unwrap_or(0); let mut file = tokio::fs::OpenOptions::new() .create(true) .write(true) .append(resumed) .truncate(!resumed) .open(&part_path) .await .map_err(|e| format!("Cannot write the download: {e}"))?; update(app, id, |i| { i.status = Status::Downloading; i.total = total; i.received = start; i.error = None; }); save(app); let mut stream = response.bytes_stream(); let mut received = start; let mut last_emit = Instant::now(); let mut last_save = Instant::now(); let mut window_bytes = 0u64; let mut window_start = Instant::now(); let mut speed = 0u64; loop { if *rx.borrow() { file.flush().await.ok(); return Ok(false); } let chunk = tokio::select! { c = stream.next() => c, _ = cancelled(rx.clone()) => { file.flush().await.ok(); return Ok(false); } }; let Some(chunk) = chunk else { break }; let chunk = chunk.map_err(|e| format!("The transfer was interrupted: {e}"))?; file.write_all(&chunk).await.map_err(|e| format!("Cannot write the download: {e}"))?; received += chunk.len() as u64; window_bytes += chunk.len() as u64; let elapsed = window_start.elapsed(); if elapsed >= Duration::from_secs(1) { speed = (window_bytes as f64 / elapsed.as_secs_f64()) as u64; window_bytes = 0; window_start = Instant::now(); } if last_emit.elapsed() >= Duration::from_millis(250) { last_emit = Instant::now(); update(app, id, |i| { i.received = received; i.speed = speed; }); } if last_save.elapsed() >= Duration::from_secs(5) { last_save = Instant::now(); save(app); } } file.flush().await.map_err(|e| e.to_string())?; drop(file); if total > 0 && received < total { return Err("The transfer ended early. Resume to continue.".into()); } tokio::fs::rename(&part_path, &final_path).await.map_err(|e| format!("Cannot finish the download: {e}"))?; update(app, id, |i| i.received = received); Ok(true) } /// Stops the transfer for `id`, if one is running; the receiver closes once it has exited. /// The entry stays until then, so a task started meanwhile knows to wait for it. fn cancel(app: &AppHandle, id: &str) -> Option> { let state = app.state::(); let workers = state.workers.lock(); let worker = workers.get(id)?; let _ = worker.cancel.send(true); Some(worker.done.clone()) } #[tauri::command] pub fn download_pause(app: AppHandle, id: String) { cancel(&app, &id); update(&app, &id, |i| { if i.status != Status::Completed { i.status = Status::Paused; i.speed = 0; } }); save(&app); } #[tauri::command] pub fn download_resume(app: AppHandle, id: String, url: String) { // `spawn` takes over from a transfer still winding down. update(&app, &id, |i| { i.status = Status::Queued; i.error = None; }); spawn(app, id, url); } #[tauri::command] pub async fn download_remove(app: AppHandle, id: String, delete_files: bool) -> Result<(), String> { let running = cancel(&app, &id); let removed = { let state = app.state::(); let mut items = state.items.lock(); let pos = items.iter().position(|i| i.id == id); pos.map(|p| items.remove(p)) }; if let (Some(item), true) = (removed, delete_files) { let path = PathBuf::from(&item.file_path); // Let the cancelled transfer release its file handle first. if let Some(done) = running { let _ = tokio::time::timeout(Duration::from_secs(10), exited(done)).await; } let _ = tokio::fs::remove_file(&path).await; let _ = tokio::fs::remove_file(part_path(&path)).await; // Older downloads shared artwork between a season's episodes: keep what others still use. let in_use: HashSet = app .state::() .items .lock() .iter() .filter_map(|i| i.meta.get("localAssets").and_then(Value::as_object)) .flat_map(|a| a.values().filter_map(Value::as_str).map(str::to_owned)) .collect(); if let Value::Object(assets) = &item.meta["localAssets"] { for v in assets.values() { if let Some(p) = v.as_str().filter(|p| !in_use.contains(*p)) { let _ = tokio::fs::remove_file(p).await; } } } // Remove now-empty folders (season, then show), never the download root. let root = app.state::().dir.lock().clone(); let mut folder = path.parent().map(|p| p.to_path_buf()); while let Some(f) = folder { if Some(&f) == root.as_ref() || tokio::fs::remove_dir(&f).await.is_err() { break; } folder = f.parent().map(|p| p.to_path_buf()); } } save(&app); let _ = app.emit("download-removed", &id); Ok(()) } #[tauri::command] pub fn download_list(app: AppHandle) -> Vec { app.state::().items.lock().clone() } #[tauri::command] pub fn download_set_dir(app: AppHandle, dir: String) -> Result<(), String> { let path = PathBuf::from(dir); std::fs::create_dir_all(&path).map_err(|e| format!("Cannot use this folder: {e}"))?; *app.state::().dir.lock() = Some(path); Ok(()) } #[tauri::command] pub fn download_write_meta(app: AppHandle, id: String, meta: Value) { update(&app, &id, |i| { let assets = i.meta.get("localAssets").cloned(); i.meta = meta; if let (Some(a), Value::Object(m)) = (assets, &mut i.meta) { m.insert("localAssets".into(), a); } }); save(&app); }