feat(daemon): grab pipeline for wanted movies (#77)

crates/arr-daemon/Cargo.toml

@@ -13,13 +13,19 @@ path = "src/main.rs"
 [dependencies]
 arr-api = { workspace = true }
 arr-compat = { workspace = true }
+arr-core = { workspace = true }
 arr-db = { workspace = true }
+arr-dl = { workspace = true }
+arr-indexer = { workspace = true }
 arr-meta = { workspace = true }
+arr-parse = { workspace = true }
 axum = { workspace = true }
+chrono = { workspace = true }
 include_dir = { workspace = true }
 mime_guess = { workspace = true }
 reqwest = { workspace = true }
 serde = { workspace = true }
+serde_json = { workspace = true }
 sqlx = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true }
@@ -30,6 +36,7 @@ tracing-subscriber = { workspace = true }
 
 [dev-dependencies]
 tempfile = { workspace = true }
+wiremock = { workspace = true }
 
 [lints]
 workspace = true

crates/arr-daemon/src/config.rs

@@ -20,6 +20,9 @@ pub const ENV_MEDIA_ROOT: &str = "ARR_MEDIA_ROOT";
 pub const ENV_PROWLARR_URL: &str = "ARR_PROWLARR_URL";
 pub const ENV_PROWLARR_API_KEY: &str = "ARR_PROWLARR_API_KEY";
 pub const ENV_TRANSMISSION_URL: &str = "ARR_TRANSMISSION_URL";
+pub const ENV_DOWNLOAD_DIR: &str = "ARR_DOWNLOAD_DIR";
+pub const ENV_SEED_RATIO_LIMIT: &str = "ARR_SEED_RATIO_LIMIT";
+pub const ENV_SEED_IDLE_LIMIT_MINUTES: &str = "ARR_SEED_IDLE_LIMIT_MINUTES";
 pub const ENV_TMDB_API_KEY: &str = "ARR_TMDB_API_KEY";
 pub const ENV_TMDB_URL: &str = "ARR_TMDB_URL";
 pub const ENV_JELLYFIN_URL: &str = "ARR_JELLYFIN_URL";
@@ -31,6 +34,13 @@ pub const DEFAULT_DATABASE_PATH: &str = "arr.db";
 pub const DEFAULT_MEDIA_ROOT: &str = "/mnt/media";
 pub const DEFAULT_PROWLARR_URL: &str = "http://localhost:9696";
 pub const DEFAULT_TRANSMISSION_URL: &str = "http://localhost:9091/transmission/rpc";
+/// Transmission's own view of the download directory (DESIGN.md §3). It
+/// shares the media dataset with the library so hardlinks work (§7.2).
+pub const DEFAULT_DOWNLOAD_DIR: &str = "/mnt/media/transmission/complete";
+/// Seeding obligation defaults (§7.3), applied to every torrent at add time
+/// and enforced by Transmission. Per-tracker rules are issue #25.
+pub const DEFAULT_SEED_RATIO_LIMIT: f64 = 1.0;
+pub const DEFAULT_SEED_IDLE_LIMIT_MINUTES: u64 = 4320;
 pub const DEFAULT_JELLYFIN_URL: &str = "http://localhost:8096";
 pub const DEFAULT_NTFY_URL: &str = "http://localhost";
 
@@ -46,6 +56,8 @@ pub enum ConfigError {
         input: String,
         source: std::net::AddrParseError,
     },
+    #[error("invalid {env} ({input:?}): expected a number")]
+    InvalidNumber { env: &'static str, input: String },
 }
 
 /// On-disk representation. Non-secret fields only — see the module docs.
@@ -63,6 +75,12 @@ struct ConfigFile {
     #[serde(default)]
     transmission_url: Option<String>,
     #[serde(default)]
+    download_dir: Option<PathBuf>,
+    #[serde(default)]
+    seed_ratio_limit: Option<f64>,
+    #[serde(default)]
+    seed_idle_limit_minutes: Option<u64>,
+    #[serde(default)]
     jellyfin_url: Option<String>,
     #[serde(default)]
     ntfy_url: Option<String>,
@@ -89,6 +107,9 @@ pub struct EnvOverrides {
     pub prowlarr_url: Option<String>,
     pub prowlarr_api_key: Option<String>,
     pub transmission_url: Option<String>,
+    pub download_dir: Option<String>,
+    pub seed_ratio_limit: Option<String>,
+    pub seed_idle_limit_minutes: Option<String>,
     pub tmdb_api_key: Option<String>,
     pub tmdb_url: Option<String>,
     pub jellyfin_url: Option<String>,
@@ -106,6 +127,9 @@ impl EnvOverrides {
             prowlarr_url: std::env::var(ENV_PROWLARR_URL).ok(),
             prowlarr_api_key: std::env::var(ENV_PROWLARR_API_KEY).ok(),
             transmission_url: std::env::var(ENV_TRANSMISSION_URL).ok(),
+            download_dir: std::env::var(ENV_DOWNLOAD_DIR).ok(),
+            seed_ratio_limit: std::env::var(ENV_SEED_RATIO_LIMIT).ok(),
+            seed_idle_limit_minutes: std::env::var(ENV_SEED_IDLE_LIMIT_MINUTES).ok(),
             tmdb_api_key: std::env::var(ENV_TMDB_API_KEY).ok(),
             tmdb_url: std::env::var(ENV_TMDB_URL).ok(),
             jellyfin_url: std::env::var(ENV_JELLYFIN_URL).ok(),
@@ -116,7 +140,7 @@ impl EnvOverrides {
 }
 
 /// Resolved bootstrap configuration. See DESIGN.md §10.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Config {
     pub bind_addr: SocketAddr,
     pub database_path: PathBuf,
@@ -124,6 +148,11 @@ pub struct Config {
     pub prowlarr_url: String,
     pub prowlarr_api_key: Option<String>,
     pub transmission_url: String,
+    /// Where Transmission puts completed downloads, in Transmission's own
+    /// namespace (§7.1).
+    pub download_dir: PathBuf,
+    pub seed_ratio_limit: f64,
+    pub seed_idle_limit_minutes: u64,
     pub tmdb_api_key: Option<String>,
     /// E2E seam only, env-only. `None` means the client's built-in TMDB
     /// address; DESIGN.md §10 keeps the real URL out of configuration.
@@ -175,6 +204,21 @@ impl Config {
                 .transmission_url
                 .or(file.transmission_url)
                 .unwrap_or_else(|| DEFAULT_TRANSMISSION_URL.to_string()),
+            download_dir: env
+                .download_dir
+                .map(PathBuf::from)
+                .or(file.download_dir)
+                .unwrap_or_else(|| PathBuf::from(DEFAULT_DOWNLOAD_DIR)),
+            seed_ratio_limit: match &env.seed_ratio_limit {
+                Some(raw) => parse_number(raw, ENV_SEED_RATIO_LIMIT)?,
+                None => file.seed_ratio_limit.unwrap_or(DEFAULT_SEED_RATIO_LIMIT),
+            },
+            seed_idle_limit_minutes: match &env.seed_idle_limit_minutes {
+                Some(raw) => parse_number(raw, ENV_SEED_IDLE_LIMIT_MINUTES)?,
+                None => file
+                    .seed_idle_limit_minutes
+                    .unwrap_or(DEFAULT_SEED_IDLE_LIMIT_MINUTES),
+            },
             tmdb_api_key: env.tmdb_api_key,
             tmdb_url: env.tmdb_url,
             jellyfin_url: env
@@ -190,6 +234,13 @@ impl Config {
     }
 }
 
+fn parse_number<T: std::str::FromStr>(raw: &str, env: &'static str) -> Result<T, ConfigError> {
+    raw.parse().map_err(|_| ConfigError::InvalidNumber {
+        env,
+        input: raw.to_string(),
+    })
+}
+
 fn parse_bind_addr(raw: &str, env: &'static str) -> Result<SocketAddr, ConfigError> {
     raw.parse().map_err(|source| ConfigError::InvalidBindAddr {
         env,
@@ -211,6 +262,12 @@ mod tests {
         assert_eq!(config.media_root, PathBuf::from(DEFAULT_MEDIA_ROOT));
         assert_eq!(config.prowlarr_url, DEFAULT_PROWLARR_URL);
         assert_eq!(config.transmission_url, DEFAULT_TRANSMISSION_URL);
+        assert_eq!(config.download_dir, PathBuf::from(DEFAULT_DOWNLOAD_DIR));
+        assert!((config.seed_ratio_limit - DEFAULT_SEED_RATIO_LIMIT).abs() < f64::EPSILON);
+        assert_eq!(
+            config.seed_idle_limit_minutes,
+            DEFAULT_SEED_IDLE_LIMIT_MINUTES
+        );
         assert_eq!(config.jellyfin_url, DEFAULT_JELLYFIN_URL);
         assert_eq!(config.ntfy_url, DEFAULT_NTFY_URL);
         assert_eq!(config.prowlarr_api_key, None);
@@ -324,6 +381,43 @@ prowlarr_url = "http://prowlarr.internal:9696"
         ));
     }
 
+    /// §7.3: both seeding limits are set at add time, so both have to be
+    /// configurable without a rebuild.
+    #[test]
+    fn seeding_limits_come_from_file_or_env() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("arr.toml");
+        std::fs::write(
+            &path,
+            "seed_ratio_limit = 2.5\nseed_idle_limit_minutes = 120\n",
+        )
+        .unwrap();
+        let env = EnvOverrides {
+            config_file: Some(path.to_string_lossy().into_owned()),
+            ..EnvOverrides::default()
+        };
+        let config = Config::resolve(env.clone()).unwrap();
+        assert!((config.seed_ratio_limit - 2.5).abs() < f64::EPSILON);
+        assert_eq!(config.seed_idle_limit_minutes, 120);
+
+        let config = Config::resolve(EnvOverrides {
+            seed_ratio_limit: Some("0.5".into()),
+            ..env.clone()
+        })
+        .unwrap();
+        assert!((config.seed_ratio_limit - 0.5).abs() < f64::EPSILON);
+
+        let error = Config::resolve(EnvOverrides {
+            seed_idle_limit_minutes: Some("soon".into()),
+            ..env
+        })
+        .unwrap_err();
+        assert!(matches!(
+            error,
+            ConfigError::InvalidNumber { env, .. } if env == ENV_SEED_IDLE_LIMIT_MINUTES
+        ));
+    }
+
     #[test]
     fn invalid_env_bind_addr_returns_diagnostic() {
         let env = EnvOverrides {

crates/arr-daemon/src/main.rs

@@ -1,6 +1,7 @@
 //! arr — reconcile loop and process entry point. See DESIGN.md §8.
 
 mod config;
+mod grab;
 pub mod reconcile;
 mod web;
 
@@ -12,7 +13,8 @@ use arr_compat::CompatState;
 use arr_db::Db;
 use arr_meta::TmdbClient;
 use config::Config;
-use reconcile::ReconcileLoop;
+use grab::{GrabAction, SeedingLimits};
+use reconcile::{ReconcileLoop, Tick};
 use tower_http::trace::TraceLayer;
 
 /// Dump the `OpenAPI` document and exit, instead of serving. `just gen-client`
@@ -67,6 +69,10 @@ enum Error {
     Migration(#[from] sqlx::migrate::MigrateError),
     #[error("tmdb client: {0}")]
     Tmdb(#[from] arr_meta::Error),
+    #[error("prowlarr client: {0}")]
+    Prowlarr(#[from] arr_indexer::Error),
+    #[error("transmission client: {0}")]
+    Transmission(#[from] arr_dl::Error),
     #[error("bind {addr}: {source}")]
     Bind {
         addr: std::net::SocketAddr,
@@ -82,7 +88,28 @@ async fn run() -> Result<(), Error> {
     let config = Config::load()?;
     let database = Db::connect(&config.database_path).await?;
     database.migrate().await?;
-    let reconcile = ReconcileLoop::new(database.clone());
+
+    let mut reconcile = ReconcileLoop::new(database.clone());
+    // Without a Prowlarr key nothing can be searched, so the grab lane stays
+    // unregistered rather than failing a tick every 30 seconds.
+    if let Some(key) = config.prowlarr_api_key.clone() {
+        let prowlarr = arr_indexer::ProwlarrClient::new(config.prowlarr_url.clone(), key)?;
+        let transmission = arr_dl::TransmissionClient::new(&config.transmission_url)?;
+        reconcile = reconcile.register(
+            Tick::Reconcile,
+            GrabAction::new(
+                prowlarr,
+                transmission,
+                config.download_dir.clone(),
+                SeedingLimits {
+                    ratio: config.seed_ratio_limit,
+                    idle_minutes: config.seed_idle_limit_minutes,
+                },
+            ),
+        );
+    } else {
+        tracing::warn!("no Prowlarr API key: nothing will be grabbed");
+    }
 
     // Jellyseerr's Radarr shim (DESIGN.md §9.4) reads the same database and
     // needs its own TMDB client for `movie/lookup`.