feat: Add a new feature to retry failed rsync

Author: dormant-user

Cargo.toml

@@ -43,3 +43,4 @@ regex = "1.12"
 rusqlite = { version = "0.39", features = ["bundled"] }
 dirs = "6.0.0"
 base64 = "0.22.1"
+urlencoding = "2.1.3"

src/api.rs

@@ -125,6 +125,7 @@ pub async fn get_torrents(
                 settings::Status::Copying => "Copying".to_string(),
                 settings::Status::Completed => "Completed".to_string(),
                 settings::Status::Failed => "Failed".to_string(),
+                settings::Status::CopyError  => "CopyError".to_string(),
                 settings::Status::Downloading(_) => {
                     format!("Downloading: {:.0}%", progress * 100.0)
                 }
@@ -489,3 +490,87 @@ pub async fn delete_torrent(
     log::info!("Successfully deleted {}", identifier);
     HttpResponse::Ok().json("Deleted")
 }
+
+/// API endpoint to retry a failed rsync transfer.
+///
+/// # Arguments
+///
+/// * `request` - Reference to the `HttpRequest` object.
+/// * `state` - Reference to the `SharedState` object.
+/// * `config` - Reference to the `Config` object.
+/// * `query` - Query parameters: `name` (required).
+///
+/// #### Sample Request
+/// ```shell
+/// curl -X POST "http://localhost:3000/retry?name=Foo+Bar+1080p"
+/// ```
+///
+/// #### Status
+/// * `200`: Retry queued.
+/// * `400`: Torrent is not in `CopyError` state.
+/// * `404`: Torrent not found in state.
+///
+/// # Returns
+///
+/// Returns a JSON string indicating the result.
+#[utoipa::path(
+    post,
+    path = "/retry",
+    params(
+        ("name" = String, Query, description = "Torrent name")
+    ),
+    responses(
+        (status = 200, description = "Retry queued", body = String),
+        (status = 400, description = "Not in CopyError state", body = String),
+        (status = 404, description = "Not found", body = String),
+    )
+)]
+pub async fn retry_torrent(
+    request: HttpRequest,
+    state: web::Data<settings::SharedState>,
+    config: web::Data<settings::Config>,
+    query: web::Query<HashMap<String, String>>,
+) -> impl Responder {
+    if !authenticator(request, &config) {
+        return HttpResponse::Unauthorized().json("Unauthorized");
+    }
+
+    let name = match query.get("name") {
+        Some(i) => i,
+        None => return HttpResponse::BadRequest().body("Missing name"),
+    };
+
+    // Find the hash for the given name in state
+    // TODO: Allow to override certain/all of put item
+    let (hash, put_item) = {
+        let db = state.read().await;
+        let found = db.iter().find(|(_, entry)| entry.name == *name);
+        match found {
+            None => return HttpResponse::NotFound().body("Torrent not found in state"),
+            Some((hash, entry)) => {
+                match entry.status {
+                    settings::Status::CopyError => (hash.clone(), entry.put_item.clone()),
+                    _ => return HttpResponse::BadRequest().body("Torrent is not in CopyError state"),
+                }
+            }
+        }
+    };
+
+    // Transition back to Copying and re-spawn rsync
+    {
+        let mut db = state.write().await;
+        if let Some(entry) = db.get_mut(&hash) {
+            entry.status = settings::Status::Copying;
+        }
+    }
+
+    let state_clone = state.as_ref().clone();
+    let hash_clone  = hash.clone();
+    let name_clone  = name.clone();
+    tokio::spawn(async move {
+        crate::rsync::run(state_clone, hash_clone, name_clone, put_item).await;
+    });
+
+    log::info!("Retry queued for: {}", name);
+    HttpResponse::Ok().json("Retry queued")
+}

src/background.rs

@@ -204,7 +204,7 @@ pub fn spawn_worker(
                 };
 
                 match entry.status {
-                    settings::Status::Copying => continue,
+                    settings::Status::Copying | settings::Status::CopyError => continue,
 
                     settings::Status::Failed => {
                         let config_cloned = config.clone();

src/database.rs

@@ -230,6 +230,7 @@ fn encode_status(status: &Status) -> (&'static str, f64) {
         Status::Copying => ("Copying", 0.0),
         Status::Completed => ("Completed", 1.0),
         Status::Failed => ("Failed", 0.0),
+        Status::CopyError => ("CopyError", 0.0),
     }
 }
 
@@ -248,6 +249,7 @@ fn decode_status(status: &str, progress: f64) -> Status {
         "Copying" => Status::Copying,
         "Completed" => Status::Completed,
         "Failed" => Status::Failed,
+        "CopyError" => Status::CopyError,
         _ => Status::Downloading(progress),
     }
 }

src/display.rs

@@ -80,7 +80,7 @@ impl Ansi {
 #[macro_export]
 macro_rules! warning {
     ($($arg:tt)*) => {{
-        use crate::display::Ansi;
+        use $crate::display::Ansi;
 
         eprintln!();
         let head = "=".repeat(81);
@@ -149,7 +149,7 @@ macro_rules! warning {
 #[macro_export]
 macro_rules! error {
     ($($arg:tt)*) => {{
-        use crate::display::Ansi;
+        use $crate::display::Ansi;
 
         eprintln!();
         let head = "=".repeat(81);

src/lib.rs

@@ -95,6 +95,7 @@ pub async fn start() -> std::io::Result<()> {
             .route("/torrent", web::get().to(api::get_torrents))
             .route("/torrent", web::put().to(api::put_torrent))
             .route("/torrent", web::delete().to(api::delete_torrent))
+            .route("/retry",   web::post().to(api::retry_torrent))
             .route("/swagger", web::get().to(swagger::redirector))
             .route("/ui", web::get().to(swagger::redirector))
             .route("/authenticator", web::post().to(ui::authenticator))

src/rsync.rs

@@ -45,7 +45,7 @@ pub async fn run(
             log::error!("Failed to start rsync for {}: {}", name, e);
             let mut db = state.write().await;
             if let Some(entry) = db.get_mut(&hash) {
-                entry.status = settings::Status::Failed;
+                entry.status = settings::Status::CopyError;
             }
             return;
         }
@@ -63,7 +63,7 @@ pub async fn run(
             log::error!("Failed waiting for rsync process for {}: {}", name, e);
             let mut db = state.write().await;
             if let Some(entry) = db.get_mut(&hash) {
-                entry.status = settings::Status::Failed;
+                entry.status = settings::Status::CopyError;
             }
             return;
         }
@@ -90,7 +90,7 @@ pub async fn run(
         e.status = if status.success() {
             settings::Status::Completed
         } else {
-            settings::Status::Failed
+            settings::Status::CopyError
         };
     }
 }

src/settings.rs

@@ -244,6 +244,7 @@ pub enum Status {
     Copying,
     Completed,
     Failed,
+    CopyError,
 }
 
 /// ### RsyncTrack

src/swagger.rs

@@ -11,7 +11,8 @@ use utoipa_swagger_ui::SwaggerUi;
         api::version,
         api::get_torrents,
         api::put_torrent,
-        api::delete_torrent
+        api::delete_torrent,
+        api::retry_torrent
     ),
     components(schemas(settings::PutItem)),
     security(