//! Root folders (`DESIGN.md` §5.1): kind, audience, path and the one policy //! attached. Reads serve the add flow (§9.2); writes are the settings view's. use axum::extract::rejection::JsonRejection; use axum::extract::{Path, State}; use axum::http::StatusCode; use axum::Json; use serde::{Deserialize, Serialize}; use utoipa::ToSchema; use crate::movies::{pool, ApiError, ErrorBody}; use crate::policies::parsed; use crate::state::AppState; /// A root folder joined with its policy, enough for the add flow to pre-fill /// root and policy (DESIGN.md §9.2) without a second request. #[derive(Debug, Clone, Serialize, ToSchema)] pub struct Root { pub id: i64, pub kind: String, pub audience: String, pub path: String, pub policy_id: i64, pub policy_name: String, } /// The payload for creating or replacing a root. #[derive(Debug, Clone, Deserialize, ToSchema)] pub struct RootInput { /// `movie` or `tv` — the Transmission label and layout prefix (§7.1, §7.4). pub kind: String, /// `main` or `kids`. pub audience: String, pub path: String, pub policy_id: i64, } impl RootInput { fn validate(&self) -> Result<(), String> { if self.kind != "movie" && self.kind != "tv" { return Err(format!("kind: '{}' is neither movie nor tv", self.kind)); } if self.audience != "main" && self.audience != "kids" { return Err(format!( "audience: '{}' is neither main nor kids", self.audience )); } if self.path.trim().is_empty() { return Err("path: must not be empty".into()); } Ok(()) } async fn policy_exists(&self, state: &AppState) -> Result<(), ApiError> { let exists: Option = sqlx::query_scalar!("SELECT id FROM policies WHERE id = ?", self.policy_id) .fetch_optional(pool(state)?) .await?; if exists.is_none() { return Err(ApiError::Invalid(format!( "policy_id: no policy {}", self.policy_id ))); } Ok(()) } } /// Strips a trailing separator so `/mnt/media` and `/mnt/media/` name the /// same root — otherwise a `PUT` that only adds or drops a trailing slash /// takes the relocation branch and every planned destination conflicts with /// its own source. Leaves a bare `/` alone. fn normalize_path(path: &str) -> String { let trimmed = path.trim(); let stripped = trimmed.trim_end_matches('/'); if stripped.is_empty() { "/".to_owned() } else { stripped.to_owned() } } async fn load_root(state: &AppState, id: i64) -> Result { sqlx::query_as!( Root, r#"SELECT r.id AS "id!: i64", r.kind AS "kind!: String", r.audience AS "audience!: String", r.path AS "path!: String", p.id AS "policy_id!: i64", p.name AS "policy_name!: String" FROM roots r JOIN policies p ON p.id = r.policy_id WHERE r.id = ?"#, id ) .fetch_optional(pool(state)?) .await? .ok_or(ApiError::RootNotFound) } #[utoipa::path( get, path = "/api/roots", tag = "roots", responses( (status = 200, body = [Root]), (status = 500, body = ErrorBody), (status = 503, body = ErrorBody) ) )] pub async fn list(State(state): State) -> Result>, ApiError> { let roots = sqlx::query_as!( Root, r#"SELECT r.id AS "id!: i64", r.kind AS "kind!: String", r.audience AS "audience!: String", r.path AS "path!: String", p.id AS "policy_id!: i64", p.name AS "policy_name!: String" FROM roots r JOIN policies p ON p.id = r.policy_id ORDER BY r.id"# ) .fetch_all(pool(&state)?) .await?; Ok(Json(roots)) } #[utoipa::path( get, path = "/api/roots/{root_id}", tag = "roots", params(("root_id" = i64, Path, description = "Root row id")), responses( (status = 200, body = Root), (status = 404, body = ErrorBody), (status = 500, body = ErrorBody), (status = 503, body = ErrorBody) ) )] pub async fn get( State(state): State, Path(id): Path, ) -> Result, ApiError> { Ok(Json(load_root(&state, id).await?)) } #[utoipa::path( post, path = "/api/roots", tag = "roots", request_body = RootInput, responses( (status = 201, body = Root), (status = 409, body = ErrorBody), (status = 422, body = ErrorBody), (status = 500, body = ErrorBody), (status = 503, body = ErrorBody) ) )] pub async fn create( State(state): State, body: Result, JsonRejection>, ) -> Result<(StatusCode, Json), ApiError> { let input = parsed(body)?; input.validate().map_err(ApiError::Invalid)?; input.policy_exists(&state).await?; let path = normalize_path(&input.path); path_is_free(&state, None, &path).await?; let result = sqlx::query!( "INSERT INTO roots (kind, audience, path, policy_id) VALUES (?, ?, ?, ?)", input.kind, input.audience, path, input.policy_id, ) .execute(pool(&state)?) .await .map_err(root_conflict)?; let root = load_root(&state, result.last_insert_rowid()).await?; Ok((StatusCode::CREATED, Json(root))) } #[utoipa::path( put, path = "/api/roots/{root_id}", tag = "roots", request_body = RootInput, params(("root_id" = i64, Path, description = "Root row id")), responses( (status = 200, body = Root), (status = 404, body = ErrorBody), (status = 409, body = ErrorBody), (status = 422, body = ErrorBody), (status = 500, body = ErrorBody), (status = 503, body = ErrorBody) ) )] pub async fn update( State(state): State, Path(id): Path, body: Result, JsonRejection>, ) -> Result, ApiError> { let input = parsed(body)?; input.validate().map_err(ApiError::Invalid)?; input.policy_exists(&state).await?; let current = load_root(&state, id).await?; let path = normalize_path(&input.path); // #244: rows written before #243 can hold a trailing separator, so the // stored value is normalised too. Comparing a normalised payload against // a raw stored value means the row can never compare equal: every edit, // policy changes included, takes the relocation branch, and there each // planned destination is its own source. The normalised value is what // `relocate_root` gets as well, so no planned path carries a doubled // separator. let current_path = normalize_path(¤t.path); // A path change moves every §7.4 title folder under this root with the // row (issue #236), the same way changing a title's root moves one // (#228). Disk first, row second: a failed rename leaves the root row // alone, so the operator sees the library where its files actually are // and can retry. A path already taken is refused before any of it, since // the write would fail afterwards anyway. let relocation = if path == current_path { None } else { path_is_free(&state, Some(id), &path).await?; Some(crate::relocate::relocate_root(&state, id, ¤t_path, &path).await?) }; let mut transaction = pool(&state)?.begin().await?; let written: Result<(), sqlx::Error> = async { sqlx::query!( r#"UPDATE roots SET kind = ?, audience = ?, path = ?, policy_id = ?, updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now') WHERE id = ?"#, input.kind, input.audience, path, input.policy_id, id, ) .execute(&mut *transaction) .await?; if let Some(relocation) = &relocation { relocation.rewrite_rows(&mut transaction).await?; } Ok(()) } .await; let committed = match written { Ok(()) => transaction.commit().await.map_err(root_conflict), Err(error) => Err(root_conflict(error)), }; if let Err(error) = committed { if let Some(relocation) = &relocation { relocation.undo().await; } return Err(error); } if relocation .as_ref() .is_some_and(crate::relocate::Relocation::moved_files) { crate::relocate::refresh_jellyfin(&state).await; } // Verdicts already stored under this root were reached under the old // policy; §9.3's deck and the grab gate both read them (`reclassify`). if input.policy_id != current.policy_id { crate::reclassify::root(&state, id).await?; } Ok(Json(load_root(&state, id).await?)) } /// The unique index on `path` would catch this after the move; catching it /// first keeps a doomed write from touching the disk at all. `except` is the /// row being updated, or `None` when creating. /// /// The stored side is normalised in SQL, mirroring [`normalize_path`], so /// `/mnt/media/x` and `/mnt/media/x/` cannot be two roots for one directory /// (#244). The unique index cannot see that — it compares the raw strings — /// and migration 0031 leaves any pair that already collides alone rather /// than failing to apply, so such a row can still be on disk. async fn path_is_free(state: &AppState, except: Option, path: &str) -> Result<(), ApiError> { let taken: Option = sqlx::query_scalar!( r#"SELECT id AS "id!: i64" FROM roots WHERE CASE WHEN rtrim(path, '/') = '' THEN '/' ELSE rtrim(path, '/') END = ? AND (? IS NULL OR id <> ?)"#, path, except, except ) .fetch_optional(pool(state)?) .await?; if taken.is_some() { return Err(ApiError::Conflict( "a root with this path already exists".into(), )); } Ok(()) } /// A duplicate path or a duplicate (kind, audience) pair is a settings /// mistake the operator can fix, not a server fault. fn root_conflict(error: sqlx::Error) -> ApiError { if error .as_database_error() .is_some_and(sqlx::error::DatabaseError::is_unique_violation) { return ApiError::Conflict( "a root with this path or this kind and audience already exists".into(), ); } ApiError::from(error) } #[utoipa::path( delete, path = "/api/roots/{root_id}", tag = "roots", params(("root_id" = i64, Path, description = "Root row id")), responses( (status = 204), (status = 404, body = ErrorBody), (status = 409, body = ErrorBody), (status = 500, body = ErrorBody), (status = 503, body = ErrorBody) ) )] pub async fn delete( State(state): State, Path(id): Path, ) -> Result { let movies: i64 = sqlx::query_scalar!( r#"SELECT count(*) AS "count!: i64" FROM movies WHERE root_id = ?"#, id ) .fetch_one(pool(&state)?) .await?; if movies > 0 { return Err(ApiError::Conflict(format!( "this root still owns {movies} movie{} — move them first", if movies == 1 { "" } else { "s" } ))); } let series: i64 = sqlx::query_scalar!( r#"SELECT count(*) AS "count!: i64" FROM series WHERE root_id = ?"#, id ) .fetch_one(pool(&state)?) .await?; if series > 0 { return Err(ApiError::Conflict(format!( "this root still owns {series} series — move them first" ))); } let result = sqlx::query!("DELETE FROM roots WHERE id = ?", id) .execute(pool(&state)?) .await?; if result.rows_affected() == 0 { return Err(ApiError::RootNotFound); } Ok(StatusCode::NO_CONTENT) } #[cfg(test)] mod tests { use crate::{router, AppState, Upstreams}; use axum::http::StatusCode; async fn application() -> (tempfile::TempDir, AppState, String) { let dir = tempfile::tempdir().expect("tempdir"); let database = arr_db::Db::connect(dir.path().join("arr.db")) .await .expect("database"); database.migrate().await.expect("migrate"); let state = AppState::new(Upstreams::new( "http://127.0.0.1:1".into(), "http://127.0.0.1:1".into(), )) .expect("state") .with_database(database); let listener = tokio::net::TcpListener::bind("127.0.0.1:0") .await .expect("bind"); let address = listener.local_addr().expect("address"); let app = router(state.clone()); tokio::spawn(async move { axum::serve(listener, app).await.expect("serve") }); (dir, state, format!("http://{address}")) } #[tokio::test] async fn roots_carry_their_policy_name() { let (_dir, _state, base) = application().await; let roots: Vec = reqwest::get(format!("{base}/api/roots")) .await .expect("roots") .json() .await .expect("json"); assert_eq!(roots.len(), 4, "the seeded movie and TV roots: {roots:?}"); assert_eq!(roots[0]["audience"], "main"); assert_eq!(roots[0]["policy_name"], "Movies — main"); assert_eq!(roots[1]["audience"], "kids"); assert!(roots[1]["path"] .as_str() .is_some_and(|p| p.contains("kids"))); assert_eq!(roots[2]["kind"], "tv"); assert_eq!(roots[2]["policy_name"], "TV — main"); assert_eq!(roots[3]["kind"], "tv"); assert_eq!(roots[3]["policy_name"], "TV — kids"); } fn root_input(policy_id: i64) -> serde_json::Value { serde_json::json!({ "kind": "movie", "audience": "archive", "path": "/mnt/media/movies/archive", "policy_id": policy_id, }) } async fn first_policy_ids(base: &str) -> Vec { let policies: Vec = reqwest::get(format!("{base}/api/policies")) .await .expect("policies") .json() .await .expect("policies json"); policies .into_iter() .map(|policy| policy["id"].as_i64().expect("policy id")) .collect() } async fn policy_id_named(base: &str, name: &str) -> i64 { let policies: Vec = reqwest::get(format!("{base}/api/policies")) .await .expect("policies") .json() .await .expect("policies json"); policies .iter() .find(|policy| policy["name"] == name) .and_then(|policy| policy["id"].as_i64()) .expect("policy id") } async fn stamped_eligible_release(state: &AppState, name: &str, size: i64) -> i64 { let parsed = arr_parse::parse(name); sqlx::query_scalar::<_, i64>( "INSERT INTO releases (indexer_id, guid, name, size, seeders, download_url, parsed, score, verdict) VALUES (7, ?, ?, ?, 40, 'url', ?, 0, 'eligible') RETURNING id", ) .bind(name) .bind(name) .bind(size) .bind(serde_json::to_string(&parsed).expect("parsed json")) .fetch_one(state.database().expect("database").pool()) .await .expect("release") } /// A movie under the movie main root, its release stamped eligible. async fn movie_with_eligible_release(state: &AppState, base: &str) -> i64 { let movie: serde_json::Value = reqwest::Client::new() .post(format!("{base}/api/movies")) .json(&serde_json::json!({ "tmdb_id": 693_134, "title": "Dune Part Two", "year": 2024, "original_language": "en", "root_id": 1, "overrides": {} })) .send() .await .expect("create movie") .json() .await .expect("movie json"); let movie_id = movie["id"].as_i64().expect("movie id"); let release_id = stamped_eligible_release( state, "Dune Part Two 2024 1080p WEB-DL ENGLISH x264-GROUP", 6_i64 * (1 << 30), ) .await; sqlx::query("INSERT INTO movie_releases (movie_id, release_id) VALUES (?, ?)") .bind(movie_id) .bind(release_id) .execute(state.database().expect("database").pool()) .await .expect("movie association"); movie_id } /// A series under the given TV root, with a season 9 pack stamped /// eligible. Ten episodes in 15 GiB: 1.5 GiB each, inside the 1080p band. async fn series_with_eligible_pack(state: &AppState, base: &str, root_id: i64) -> i64 { let client = reqwest::Client::new(); let series: serde_json::Value = client .post(format!("{base}/api/series")) .json(&serde_json::json!({ "tmdb_id": 82_728, "title": "Bluey", "year": 2018, "original_language": "en", "root_id": root_id, "auto_track": false })) .send() .await .expect("create series") .json() .await .expect("series json"); let series_id = series["id"].as_i64().expect("series id"); let episodes: Vec = (1..=10) .map(|number| { serde_json::json!({ "number": number, "title": format!("Episode {number}"), "air_date": "2025-01-01" }) }) .collect(); let season: serde_json::Value = client .post(format!("{base}/api/series/{series_id}/seasons")) .json(&serde_json::json!({"number": 9, "episodes": episodes})) .send() .await .expect("create season") .json() .await .expect("season json"); let season_id = season["id"].as_i64().expect("season id"); let release_id = stamped_eligible_release( state, "Bluey S09 1080p WEB-DL ENGLISH x264-GROUP", 15_i64 * (1 << 30), ) .await; sqlx::query("INSERT INTO season_releases (season_id, release_id) VALUES (?, ?)") .bind(season_id) .bind(release_id) .execute(state.database().expect("database").pool()) .await .expect("season association"); series_id } async fn verdict_of(url: String) -> serde_json::Value { let releases: Vec = reqwest::get(url) .await .expect("releases") .json() .await .expect("releases json"); releases[0]["verdict"].clone() } /// #241: `PUT /api/roots/{id}` writing a different `policy_id` /// re-derives the stored verdicts of every title under the root (§5.1) /// — and of nothing outside it. #[tokio::test] async fn repointing_a_root_at_another_policy_rederives_its_library() { let (_dir, state, base) = application().await; let pool = state.database().expect("database").pool(); let client = reqwest::Client::new(); let movie_id = movie_with_eligible_release(&state, &base).await; let tv_main: i64 = sqlx::query_scalar("SELECT id FROM roots WHERE kind = 'tv' AND audience = 'main'") .fetch_one(pool) .await .expect("tv root"); let series_id = series_with_eligible_pack(&state, &base, tv_main).await; // Point the movie main root at the kids policy; the path stays, so // nothing on disk is touched. let kids_policy = policy_id_named(&base, "Movies — kids").await; let response = client .put(format!("{base}/api/roots/1")) .json(&serde_json::json!({ "kind": "movie", "audience": "main", "path": "/mnt/media/movies/main", "policy_id": kids_policy })) .send() .await .expect("repoint movie root"); assert_eq!(response.status(), StatusCode::OK); assert_eq!( verdict_of(format!("{base}/api/movies/{movie_id}/releases")).await, "waived", "kids requires pt-PT, English is a soft fail" ); // The TV root was not repointed, so its library is untouched. assert_eq!( verdict_of(format!("{base}/api/series/{series_id}/seasons/9/releases")).await, "eligible" ); // Now the TV root; the series' pack re-derives too. let tv_kids_policy = policy_id_named(&base, "TV — kids").await; let response = client .put(format!("{base}/api/roots/{tv_main}")) .json(&serde_json::json!({ "kind": "tv", "audience": "main", "path": "/mnt/media/tv/main", "policy_id": tv_kids_policy })) .send() .await .expect("repoint tv root"); assert_eq!( response.status(), StatusCode::OK, "{:?}", response.text().await ); assert_eq!( verdict_of(format!("{base}/api/series/{series_id}/seasons/9/releases")).await, "waived", "kids requires pt-PT, English is a soft fail" ); } #[tokio::test] async fn a_root_round_trips_through_create_and_update() { let (_dir, _state, base) = application().await; let policy_ids = first_policy_ids(&base).await; let roots: Vec = reqwest::get(format!("{base}/api/roots")) .await .expect("roots") .json() .await .expect("roots json"); // the schema only knows movie and tv, main and kids let rejected = reqwest::Client::new() .post(format!("{base}/api/roots")) .json(&root_input(policy_ids[0])) .send() .await .expect("create root"); assert_eq!(rejected.status(), StatusCode::UNPROCESSABLE_ENTITY); // (movie, kids) is taken by a seeded root, so free the pair first let kids_root = roots[1]["id"].as_i64().expect("movie kids root id"); let freed = reqwest::Client::new() .delete(format!("{base}/api/roots/{kids_root}")) .send() .await .expect("free the seeded movie kids root"); assert_eq!(freed.status(), StatusCode::NO_CONTENT); let mut payload = root_input(policy_ids[0]); payload["audience"] = serde_json::json!("kids"); payload["path"] = serde_json::json!("/mnt/media/movies/archive"); let created: serde_json::Value = reqwest::Client::new() .post(format!("{base}/api/roots")) .json(&payload) .send() .await .expect("create root") .json() .await .expect("created json"); assert_eq!(created["audience"], "kids"); assert_eq!(created["policy_name"], "Movies — main"); let id = created["id"].as_i64().expect("id"); payload["path"] = serde_json::json!("/mnt/media/movies/archive-4k"); payload["policy_id"] = policy_ids[1].into(); let updated: serde_json::Value = reqwest::Client::new() .put(format!("{base}/api/roots/{id}")) .json(&payload) .send() .await .expect("update root") .json() .await .expect("updated json"); assert_eq!(updated["path"], "/mnt/media/movies/archive-4k"); assert_eq!(updated["policy_name"], "Movies — kids"); let deleted = reqwest::Client::new() .delete(format!("{base}/api/roots/{id}")) .send() .await .expect("delete root"); assert_eq!(deleted.status(), StatusCode::NO_CONTENT); assert_eq!( reqwest::get(format!("{base}/api/roots/{id}")) .await .expect("get deleted") .status(), StatusCode::NOT_FOUND ); } #[tokio::test] async fn an_unknown_kind_or_policy_is_a_422_naming_the_field() { let (_dir, _state, base) = application().await; let policy_ids = first_policy_ids(&base).await; for (mut payload, field) in [ (root_input(999), "policy_id"), (root_input(policy_ids[0]), "kind"), ] { payload["audience"] = serde_json::json!("main"); if field == "kind" { payload["kind"] = serde_json::json!("book"); payload["path"] = serde_json::json!("/mnt/media/movies/elsewhere"); } let response = reqwest::Client::new() .post(format!("{base}/api/roots")) .json(&payload) .send() .await .expect("create root"); assert_eq!(response.status(), StatusCode::UNPROCESSABLE_ENTITY); let body: serde_json::Value = response.json().await.expect("error body"); assert!( body["error"].as_str().expect("text").starts_with(field), "{field}: {body}" ); } } #[tokio::test] async fn a_duplicate_path_or_pair_conflicts() { let (_dir, _state, base) = application().await; let mut path = root_input(1); path["audience"] = serde_json::json!("kids"); path["path"] = serde_json::json!("/mnt/media/movies/kids"); let response = reqwest::Client::new() .post(format!("{base}/api/roots")) .json(&path) .send() .await .expect("duplicate path create"); assert_eq!(response.status(), StatusCode::CONFLICT); let mut pair = root_input(1); pair["audience"] = serde_json::json!("main"); pair["path"] = serde_json::json!("/mnt/media/movies/somewhere-new"); let response = reqwest::Client::new() .post(format!("{base}/api/roots")) .json(&pair) .send() .await .expect("duplicate pair create"); assert_eq!(response.status(), StatusCode::CONFLICT); } #[tokio::test] async fn a_root_with_titles_refuses_to_die() { let (_dir, _state, base) = application().await; let roots: Vec = reqwest::get(format!("{base}/api/roots")) .await .expect("roots") .json() .await .expect("roots json"); let main_root = roots[0]["id"].as_i64().expect("root id"); let created = reqwest::Client::new() .post(format!("{base}/api/movies")) .json(&serde_json::json!({ "tmdb_id": 693_134, "title": "Dune Part Two", "year": 2024, "original_language": "en", "root_id": main_root, })) .send() .await .expect("create movie"); assert_eq!(created.status(), StatusCode::CREATED); let response = reqwest::Client::new() .delete(format!("{base}/api/roots/{main_root}")) .send() .await .expect("delete occupied root"); assert_eq!(response.status(), StatusCode::CONFLICT); let body: serde_json::Value = response.json().await.expect("error body"); assert!( body["error"].as_str().expect("text").contains("movie"), "{body}" ); // an empty root deletes fine let empty_root = roots[3]["id"].as_i64().expect("tv kids root id"); let response = reqwest::Client::new() .delete(format!("{base}/api/roots/{empty_root}")) .send() .await .expect("delete empty root"); assert_eq!(response.status(), StatusCode::NO_CONTENT); } /// A path written straight into the row, no normalisation — how a root /// created before #243 could end up holding a trailing separator. async fn point_root_at_raw(state: &AppState, root_id: i64, path: &str) { sqlx::query("UPDATE roots SET path = ? WHERE id = ?") .bind(path) .bind(root_id) .execute(state.database().expect("database").pool()) .await .expect("store the raw path"); } async fn point_root_at(state: &AppState, root_id: i64, path: &std::path::Path) { sqlx::query("UPDATE roots SET path = ? WHERE id = ?") .bind(path.to_str().expect("utf-8 root")) .bind(root_id) .execute(state.database().expect("database").pool()) .await .expect("point the root at the tempdir"); } async fn add_movie(base: &str, tmdb_id: i64, title: &str, root_id: i64) -> i64 { let created: serde_json::Value = reqwest::Client::new() .post(format!("{base}/api/movies")) .json(&serde_json::json!({ "tmdb_id": tmdb_id, "title": title, "year": 2024, "original_language": "en", "root_id": root_id, })) .send() .await .expect("create movie") .json() .await .expect("movie json"); created["id"].as_i64().expect("movie id") } /// One movie's §7.4 folder on disk with a feature in it, and the /// `media_files` row that points at the feature. async fn library_folder( state: &AppState, movie_id: i64, root: &std::path::Path, folder: &str, ) -> std::path::PathBuf { let folder = root.join(folder); tokio::fs::create_dir_all(&folder) .await .expect("create title folder"); let feature = folder.join("feature.mkv"); tokio::fs::write(&feature, b"feature").await.expect("write"); sqlx::query( "INSERT INTO media_files (owner_kind, owner_id, path, size) VALUES ('movie', ?, ?, 7)", ) .bind(movie_id) .bind(feature.to_str().expect("utf-8 path")) .execute(state.database().expect("database").pool()) .await .expect("media file"); folder } async fn root_payload(base: &str, id: i64, path: &str) -> serde_json::Value { let root: serde_json::Value = reqwest::get(format!("{base}/api/roots/{id}")) .await .expect("root") .json() .await .expect("root json"); serde_json::json!({ "kind": root["kind"], "audience": root["audience"], "path": path, "policy_id": root["policy_id"], }) } async fn file_paths(state: &AppState) -> Vec { sqlx::query_scalar("SELECT path FROM media_files ORDER BY id") .fetch_all(state.database().expect("database").pool()) .await .expect("media files") } async fn stored_path(base: &str, id: i64) -> String { let root: serde_json::Value = reqwest::get(format!("{base}/api/roots/{id}")) .await .expect("root") .json() .await .expect("root json"); root["path"].as_str().expect("path").to_owned() } /// Issue #236: changing a root's path renames every §7.4 title folder /// under it into the new path and rewrites the `media_files` rows in the /// same write. Titles under other roots are not this root's business. #[tokio::test] async fn changing_a_root_path_moves_every_title_under_it() { let (_dir, state, base) = application().await; let old = tempfile::tempdir().expect("old root"); let other = tempfile::tempdir().expect("other root"); point_root_at(&state, 1, old.path()).await; point_root_at(&state, 2, other.path()).await; let mut folders = Vec::new(); for (tmdb_id, title) in [(100, "Dune"), (101, "Arrival"), (102, "Sicario")] { let id = add_movie(&base, tmdb_id, title, 1).await; folders.push(library_folder(&state, id, old.path(), title).await); } let elsewhere = add_movie(&base, 200, "Prisoners", 2).await; let untouched = library_folder(&state, elsewhere, other.path(), "Prisoners").await; // The new path need not exist yet — pointing a root somewhere fresh // is the ordinary case. let new = old.path().parent().expect("parent").join("relocated-main"); let response = reqwest::Client::new() .put(format!("{base}/api/roots/1")) .json(&root_payload(&base, 1, new.to_str().expect("utf-8")).await) .send() .await .expect("move the root"); assert_eq!(response.status(), StatusCode::OK); for folder in &folders { assert!(!folder.exists(), "{} left the old path", folder.display()); } for title in ["Dune", "Arrival", "Sicario"] { assert!( new.join(title).join("feature.mkv").exists(), "{title} arrived under the new path" ); } assert!( untouched.join("feature.mkv").exists(), "a title under another root is untouched" ); let paths = file_paths(&state).await; for path in paths.iter().take(3) { assert!( std::path::Path::new(path).starts_with(&new), "the row follows the file: {path}" ); assert!( std::path::Path::new(path).exists(), "the rewritten path describes the disk: {path}" ); } assert!( std::path::Path::new(&paths[3]).starts_with(other.path()), "the other root's row is untouched: {}", paths[3] ); assert_eq!(stored_path(&base, 1).await, new.to_str().expect("utf-8")); tokio::fs::remove_dir_all(&new).await.expect("clean up"); } /// Issue #236: a root with nothing under it changes path with no /// filesystem work at all — the new path is not even created. #[tokio::test] async fn an_empty_root_changes_path_with_no_filesystem_work() { let (_dir, state, base) = application().await; let home = tempfile::tempdir().expect("home"); let new = home.path().join("nothing-here"); let response = reqwest::Client::new() .put(format!("{base}/api/roots/1")) .json(&root_payload(&base, 1, new.to_str().expect("utf-8")).await) .send() .await .expect("move the root"); assert_eq!(response.status(), StatusCode::OK); assert_eq!(stored_path(&base, 1).await, new.to_str().expect("utf-8")); assert!(!new.exists(), "nothing was created on disk"); assert!(file_paths(&state).await.is_empty()); } /// Issue #236: a destination already holding a folder of that name is a /// conflict, not an overwrite, and it is caught before anything moves. #[tokio::test] async fn a_squatted_destination_refuses_the_whole_move() { let (_dir, state, base) = application().await; let old = tempfile::tempdir().expect("old root"); let new = tempfile::tempdir().expect("new root"); point_root_at(&state, 1, old.path()).await; let first = add_movie(&base, 100, "Dune", 1).await; let second = add_movie(&base, 101, "Arrival", 1).await; let dune = library_folder(&state, first, old.path(), "Dune").await; let arrival = library_folder(&state, second, old.path(), "Arrival").await; tokio::fs::create_dir_all(new.path().join("Arrival")) .await .expect("squatter"); let before = file_paths(&state).await; let response = reqwest::Client::new() .put(format!("{base}/api/roots/1")) .json(&root_payload(&base, 1, new.path().to_str().expect("utf-8")).await) .send() .await .expect("move the root"); assert_eq!(response.status(), StatusCode::CONFLICT); assert!(dune.exists(), "not even the first folder moved"); assert!(arrival.exists()); assert_eq!(file_paths(&state).await, before, "the rows are untouched"); assert_eq!( stored_path(&base, 1).await, old.path().to_str().expect("utf-8"), "the root still points where the files are" ); } /// Integration review of the Feedback pass 2 blitz: the retry the module /// documents has to actually converge. An undo is best-effort, so a move /// can fail and leave one folder at the destination with its row still /// naming the source. Every later attempt used to 409 against the /// operator's own half-moved library, and the only way out was moving the /// folder back by hand. #[tokio::test] async fn a_folder_left_at_the_destination_by_a_failed_undo_does_not_block_the_retry() { let (_dir, state, base) = application().await; let old = tempfile::tempdir().expect("old root"); let new = tempfile::tempdir().expect("new root"); point_root_at(&state, 1, old.path()).await; let first = add_movie(&base, 100, "Dune", 1).await; let second = add_movie(&base, 101, "Arrival", 1).await; let dune = library_folder(&state, first, old.path(), "Dune").await; let arrival = library_folder(&state, second, old.path(), "Arrival").await; // What a failed undo leaves behind: Arrival is already at the new // path, its row still points at the old one, and the root row was // never changed. tokio::fs::create_dir_all(new.path()) .await .expect("the new root"); tokio::fs::rename(&arrival, new.path().join("Arrival")) .await .expect("strand the folder"); assert!(!arrival.exists()); let response = reqwest::Client::new() .put(format!("{base}/api/roots/1")) .json(&root_payload(&base, 1, new.path().to_str().expect("utf-8")).await) .send() .await .expect("retry the move"); assert_eq!( response.status(), StatusCode::OK, "the stranded folder is the state we wanted, not a conflict" ); assert!(!dune.exists(), "the folder still on disk moved"); assert!(new.path().join("Dune").exists()); assert!(new.path().join("Arrival").exists(), "left where it was"); let paths = file_paths(&state).await; let root = new.path().to_str().expect("utf-8"); assert!( paths.iter().all(|path| path.starts_with(root)), "every row follows the root, the stranded one included: {paths:?}" ); assert_eq!(stored_path(&base, 1).await, root); } /// Issue #236: the move is all or nothing. A folder that cannot be /// renamed part-way through takes the whole change down: what had already /// moved is moved back, the root row keeps the old path, and the rows /// still describe the disk, so the operator can fix the folder and send /// the same request again. #[cfg(unix)] #[tokio::test] async fn one_folder_that_cannot_move_puts_the_others_back() { use std::os::unix::fs::PermissionsExt; if !crate::privilege::mode_bits_bind().await { crate::privilege::skipped_because_privileged( "one_folder_that_cannot_move_puts_the_others_back", ); return; } let (_dir, state, base) = application().await; let old = tempfile::tempdir().expect("old root"); let home = tempfile::tempdir().expect("home of the new path"); let new = home.path().join("relocated-main"); point_root_at(&state, 1, old.path()).await; let mut folders = Vec::new(); for (tmdb_id, title) in [(100, "Dune"), (101, "Arrival"), (102, "Sicario")] { let id = add_movie(&base, tmdb_id, title, 1).await; folders.push(library_folder(&state, id, old.path(), title).await); } // Moving a directory to another parent rewrites its `..`, which needs // write permission on the directory itself: the second title cannot // move, the first already has. let stuck = folders[1].clone(); tokio::fs::set_permissions(&stuck, std::fs::Permissions::from_mode(0o555)) .await .expect("freeze the second title folder"); let before = file_paths(&state).await; let response = reqwest::Client::new() .put(format!("{base}/api/roots/1")) .json(&root_payload(&base, 1, new.to_str().expect("utf-8")).await) .send() .await .expect("move the root"); assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR); let body: serde_json::Value = response.json().await.expect("error body"); assert!( body["error"] .as_str() .expect("text") .contains(stuck.to_str().expect("utf-8")), "the error names the folder that stopped the move: {body}" ); tokio::fs::set_permissions(&stuck, std::fs::Permissions::from_mode(0o755)) .await .expect("thaw the second title folder"); for folder in &folders { assert!( folder.join("feature.mkv").exists(), "{} is back where the row says it is", folder.display() ); } assert!( !new.exists(), "the directory created for the failed move was removed, since it never held anything" ); assert_eq!(file_paths(&state).await, before, "the rows are untouched"); assert_eq!( stored_path(&base, 1).await, old.path().to_str().expect("utf-8"), "the root still points where the files are" ); // The same request again, with the folder fixed, is the retry path. let response = reqwest::Client::new() .put(format!("{base}/api/roots/1")) .json(&root_payload(&base, 1, new.to_str().expect("utf-8")).await) .send() .await .expect("retry the move"); assert_eq!(response.status(), StatusCode::OK); for title in ["Dune", "Arrival", "Sicario"] { assert!(new.join(title).join("feature.mkv").exists()); } } /// Issue #243: a directory a failed move did not create is not this /// request's to remove, even though it sits at the same new root path. #[cfg(unix)] #[tokio::test] async fn a_new_root_that_already_existed_survives_a_failed_move() { use std::os::unix::fs::PermissionsExt; if !crate::privilege::mode_bits_bind().await { crate::privilege::skipped_because_privileged( "a_new_root_that_already_existed_survives_a_failed_move", ); return; } let (_dir, state, base) = application().await; let old = tempfile::tempdir().expect("old root"); let new = tempfile::tempdir().expect("new root, already there"); point_root_at(&state, 1, old.path()).await; let id = add_movie(&base, 100, "Dune", 1).await; let stuck = library_folder(&state, id, old.path(), "Dune").await; tokio::fs::set_permissions(&stuck, std::fs::Permissions::from_mode(0o555)) .await .expect("freeze the title folder"); let response = reqwest::Client::new() .put(format!("{base}/api/roots/1")) .json(&root_payload(&base, 1, new.path().to_str().expect("utf-8")).await) .send() .await .expect("move the root"); assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR); tokio::fs::set_permissions(&stuck, std::fs::Permissions::from_mode(0o755)) .await .expect("thaw the title folder"); assert!( new.path().exists(), "a directory this request did not create is left alone" ); } /// Issue #243: a path differing only by a trailing separator is the same /// root, not a self-conflict — `PUT` with it is a no-op. #[tokio::test] async fn a_trailing_separator_is_not_a_path_change() { let (_dir, state, base) = application().await; let old = tempfile::tempdir().expect("old root"); point_root_at(&state, 1, old.path()).await; let id = add_movie(&base, 100, "Dune", 1).await; let folder = library_folder(&state, id, old.path(), "Dune").await; let mut trailing = old.path().to_str().expect("utf-8").to_owned(); trailing.push('/'); let response = reqwest::Client::new() .put(format!("{base}/api/roots/1")) .json(&root_payload(&base, 1, &trailing).await) .send() .await .expect("update root with a trailing separator"); assert_eq!(response.status(), StatusCode::OK); assert!(folder.exists(), "nothing on disk moved"); assert_eq!( stored_path(&base, 1).await, old.path().to_str().expect("utf-8"), "the stored path keeps no trailing separator" ); } /// Issue #243: `create` normalises the same way, so a trailing separator /// cannot dodge the duplicate-path check. #[tokio::test] async fn create_normalises_a_trailing_separator_before_checking_for_conflicts() { let (_dir, _state, base) = application().await; let policy_ids = first_policy_ids(&base).await; let roots: Vec = reqwest::get(format!("{base}/api/roots")) .await .expect("roots") .json() .await .expect("roots json"); let existing_path = roots[0]["path"].as_str().expect("path").to_owned(); // Free the (movie, kids) pair so the conflict below is the path // check alone, not the (kind, audience) uniqueness check. let kids_root = roots[1]["id"].as_i64().expect("movie kids root id"); let freed = reqwest::Client::new() .delete(format!("{base}/api/roots/{kids_root}")) .send() .await .expect("free the seeded movie kids root"); assert_eq!(freed.status(), StatusCode::NO_CONTENT); let mut payload = root_input(policy_ids[0]); payload["audience"] = serde_json::json!("kids"); payload["path"] = serde_json::json!(format!("{existing_path}/")); let response = reqwest::Client::new() .post(format!("{base}/api/roots")) .json(&payload) .send() .await .expect("create root with a trailing separator"); assert_eq!( response.status(), StatusCode::CONFLICT, "a trailing separator does not dodge the duplicate-path check" ); } /// Issue #236: a TV root carries series folders, whose files hang off /// episodes rather than off the title row. They move with the root too. #[tokio::test] async fn a_tv_root_moves_its_series_folders() { let (_dir, state, base) = application().await; let old = tempfile::tempdir().expect("old root"); let home = tempfile::tempdir().expect("home of the new path"); let new = home.path().join("relocated-tv"); point_root_at(&state, 3, old.path()).await; let pool = state.database().expect("database").pool(); sqlx::query( "INSERT INTO series (id, tmdb_id, title, year, original_language, root_id) VALUES (1, 82728, 'Bluey', 2018, 'en', 3)", ) .execute(pool) .await .expect("series"); sqlx::query("INSERT INTO seasons (id, series_id, number) VALUES (1, 1, 1)") .execute(pool) .await .expect("season"); sqlx::query( "INSERT INTO episodes (id, season_id, number, title) VALUES (1, 1, 2, 'Hospital')", ) .execute(pool) .await .expect("episode"); let season = old .path() .join("Bluey (2018) [tmdbid-82728]") .join("Season 01"); tokio::fs::create_dir_all(&season) .await .expect("create season folder"); let episode = season.join("Bluey - S01E02.mkv"); tokio::fs::write(&episode, b"episode").await.expect("write"); sqlx::query( "INSERT INTO media_files (owner_kind, owner_id, path, size) VALUES ('episode', 1, ?, 9)", ) .bind(episode.to_str().expect("utf-8 path")) .execute(pool) .await .expect("media file"); let response = reqwest::Client::new() .put(format!("{base}/api/roots/3")) .json(&root_payload(&base, 3, new.to_str().expect("utf-8")).await) .send() .await .expect("move the root"); assert_eq!(response.status(), StatusCode::OK); assert!( new.join("Bluey (2018) [tmdbid-82728]") .join("Season 01") .join("Bluey - S01E02.mkv") .exists(), "the whole series folder moved, season layout intact" ); let paths = file_paths(&state).await; assert!( std::path::Path::new(&paths[0]).starts_with(&new) && std::path::Path::new(&paths[0]).exists(), "the episode row follows the file: {}", paths[0] ); } /// Issue #244: a root *stored* with a trailing separator — creatable /// through the API at any point before #243 — could not be edited at /// all. The payload was normalised and the stored value was not, so no /// payload compared equal: every edit took the relocation branch, where /// every planned destination is its own source and the pre-check 409s. #[tokio::test] async fn a_root_stored_with_a_trailing_separator_can_still_be_edited() { let (_dir, state, base) = application().await; let old = tempfile::tempdir().expect("old root"); let unslashed = old.path().to_str().expect("utf-8").to_owned(); point_root_at_raw(&state, 1, &format!("{unslashed}/")).await; let id = add_movie(&base, 100, "Dune", 1).await; let folder = library_folder(&state, id, old.path(), "Dune").await; // What the settings view sends back: the path exactly as stored, // separator included, with only the policy changed. let kids_policy = policy_id_named(&base, "Movies — kids").await; let mut payload = root_payload(&base, 1, &format!("{unslashed}/")).await; payload["policy_id"] = kids_policy.into(); let response = reqwest::Client::new() .put(format!("{base}/api/roots/1")) .json(&payload) .send() .await .expect("edit the root"); assert_eq!( response.status(), StatusCode::OK, "{:?}", response.text().await ); assert!(folder.join("feature.mkv").exists(), "nothing on disk moved"); assert_eq!( stored_path(&base, 1).await, unslashed, "the row is left normalised, so the next edit compares equal too" ); // And the same payload without the separator is not a relocation // either. let response = reqwest::Client::new() .put(format!("{base}/api/roots/1")) .json(&root_payload(&base, 1, &unslashed).await) .send() .await .expect("edit the root again"); assert_eq!(response.status(), StatusCode::OK); assert!(folder.join("feature.mkv").exists(), "still nothing moved"); } /// Issue #244: a real path change from a root stored with a trailing /// separator plans from the normalised value, so neither a destination /// nor a rewritten row carries a doubled separator. #[tokio::test] async fn relocating_a_slash_stored_root_plans_no_doubled_separator() { let (_dir, state, base) = application().await; let old = tempfile::tempdir().expect("old root"); let home = tempfile::tempdir().expect("home of the new path"); let new = home.path().join("relocated-main"); let unslashed = old.path().to_str().expect("utf-8").to_owned(); point_root_at_raw(&state, 1, &format!("{unslashed}/")).await; let id = add_movie(&base, 100, "Dune", 1).await; let folder = library_folder(&state, id, old.path(), "Dune").await; let response = reqwest::Client::new() .put(format!("{base}/api/roots/1")) .json(&root_payload(&base, 1, new.to_str().expect("utf-8")).await) .send() .await .expect("move the root"); assert_eq!( response.status(), StatusCode::OK, "{:?}", response.text().await ); assert!(!folder.exists(), "the folder left the old path"); assert!(new.join("Dune").join("feature.mkv").exists()); let paths = file_paths(&state).await; assert!( !paths[0].contains("//"), "no doubled separator in the rewritten row: {}", paths[0] ); assert!( std::path::Path::new(&paths[0]).exists(), "the rewritten path describes the disk: {}", paths[0] ); assert_eq!(stored_path(&base, 1).await, new.to_str().expect("utf-8")); } /// Issue #244: `create_dir_all` can materialise more than one level for /// a root path pointed somewhere fresh. A failed move removes every /// level it created, not only the leaf — and still nothing that was /// already on disk. #[cfg(unix)] #[tokio::test] async fn a_failed_move_removes_every_level_it_created() { use std::os::unix::fs::PermissionsExt; if !crate::privilege::mode_bits_bind().await { crate::privilege::skipped_because_privileged( "a_failed_move_removes_every_level_it_created", ); return; } let (_dir, state, base) = application().await; let old = tempfile::tempdir().expect("old root"); let home = tempfile::tempdir().expect("home of the new path"); // Three levels below a directory that is already there. let top = home.path().join("media-v2"); let new = top.join("tv").join("kids"); point_root_at(&state, 1, old.path()).await; let id = add_movie(&base, 100, "Dune", 1).await; let stuck = library_folder(&state, id, old.path(), "Dune").await; // Moving a directory to another parent rewrites its `..`, which // needs write permission on the directory itself. tokio::fs::set_permissions(&stuck, std::fs::Permissions::from_mode(0o555)) .await .expect("freeze the title folder"); let response = reqwest::Client::new() .put(format!("{base}/api/roots/1")) .json(&root_payload(&base, 1, new.to_str().expect("utf-8")).await) .send() .await .expect("move the root"); assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR); tokio::fs::set_permissions(&stuck, std::fs::Permissions::from_mode(0o755)) .await .expect("thaw the title folder"); assert!( !top.exists(), "every level the failed move created is gone, not only the leaf" ); assert!( home.path().exists(), "the level that was already there is left alone" ); assert!( stuck.join("feature.mkv").exists(), "the folder is still where the row says it is" ); assert_eq!( stored_path(&base, 1).await, old.path().to_str().expect("utf-8") ); } /// Issue #244: two roots naming one directory, differing only by a /// trailing separator, are not two roots. The unique index compares raw /// strings and cannot see it, so the check normalises both sides. #[tokio::test] async fn a_slash_stored_path_is_not_free_for_another_root() { let (_dir, state, base) = application().await; point_root_at_raw(&state, 2, "/mnt/media/movies/archive/").await; // An update onto the stripped form of a path another root holds. let response = reqwest::Client::new() .put(format!("{base}/api/roots/1")) .json(&root_payload(&base, 1, "/mnt/media/movies/archive").await) .send() .await .expect("update onto the other root's path"); assert_eq!(response.status(), StatusCode::CONFLICT); // And a create, which the unique index would have let through. let policy_ids = first_policy_ids(&base).await; let mut payload = root_input(policy_ids[0]); payload["kind"] = serde_json::json!("tv"); payload["audience"] = serde_json::json!("main"); payload["path"] = serde_json::json!("/mnt/media/movies/archive"); let deleted = reqwest::Client::new() .delete(format!("{base}/api/roots/3")) .send() .await .expect("free the (tv, main) pair"); assert_eq!(deleted.status(), StatusCode::NO_CONTENT); let response = reqwest::Client::new() .post(format!("{base}/api/roots")) .json(&payload) .send() .await .expect("create onto the other root's path"); assert_eq!(response.status(), StatusCode::CONFLICT); } /// Issue #236: a path another root already holds is refused before the /// disk is touched at all. #[tokio::test] async fn a_path_another_root_holds_is_refused_before_any_move() { let (_dir, state, base) = application().await; let old = tempfile::tempdir().expect("old root"); let taken = tempfile::tempdir().expect("taken root"); point_root_at(&state, 1, old.path()).await; point_root_at(&state, 2, taken.path()).await; let id = add_movie(&base, 100, "Dune", 1).await; let folder = library_folder(&state, id, old.path(), "Dune").await; let response = reqwest::Client::new() .put(format!("{base}/api/roots/1")) .json(&root_payload(&base, 1, taken.path().to_str().expect("utf-8")).await) .send() .await .expect("move the root"); assert_eq!(response.status(), StatusCode::CONFLICT); assert!(folder.exists(), "nothing moved"); assert!(!taken.path().join("Dune").exists()); } }