perf: Improve error handling for run-time errors

Author: dormant-user

src/api.rs

@@ -193,7 +193,13 @@ async fn get_existing(client: &Client, config: &settings::Config) -> Vec<HashMap
 fn resolve_payload(body: &[settings::PutItem]) -> Vec<settings::PutItem> {
     let mut ret: Vec<settings::PutItem> = Vec::new();
     for item in body.iter() {
-        let url = Url::parse(&item.url).expect("Invalid URL");
+        let url = match Url::parse(&item.url) {
+            Ok(url) => url,
+            Err(e) => {
+                log::error!("Invalid URL '{}': {}", item.url, e);
+                return Vec::new();
+            }
+        };
         let query_pairs: Vec<(String, String)> = url
             .query_pairs()
             .map(|(key, value)| (key.into_owned(), value.into_owned()))

src/database.rs

@@ -45,7 +45,7 @@ pub fn open() -> Connection {
 /// * `entry` - The `RsyncTrack` data to persist.
 pub fn upsert(conn: &Connection, hash: &str, entry: &RsyncTrack) {
     let (status, progress) = encode_status(&entry.status);
-    conn.execute(
+    match conn.execute(
         "INSERT OR REPLACE INTO state
             (hash, name, status, progress, url, save_path, remote_host, remote_user, remote_path, delete_after_copy)
          VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)",
@@ -61,8 +61,12 @@ pub fn upsert(conn: &Connection, hash: &str, entry: &RsyncTrack) {
             entry.put_item.remote_path,
             entry.put_item.delete_after_copy as i32,
         ],
-    )
-        .expect("Failed to upsert state");
+    ) {
+        Ok(_) => (),
+        Err(e) => {
+            log::error!("Failed to upsert state for {}: {}", hash, e);
+        }
+    }
 }
 
 /// Inserts or replaces a pending transfer entry in the `pending` table.
@@ -73,7 +77,7 @@ pub fn upsert(conn: &Connection, hash: &str, entry: &RsyncTrack) {
 /// * `tag` - Unique identifier for the pending item.
 /// * `item` - The `PutItem` data to store as pending.
 pub fn upsert_pending(conn: &Connection, tag: &str, item: &PutItem) {
-    conn.execute(
+    match conn.execute(
         "INSERT OR REPLACE INTO pending
             (tag, url, save_path, remote_host, remote_user, remote_path, delete_after_copy)
          VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)",
@@ -86,8 +90,12 @@ pub fn upsert_pending(conn: &Connection, tag: &str, item: &PutItem) {
             item.remote_path,
             item.delete_after_copy as i32,
         ],
-    )
-    .expect("Failed to upsert pending");
+    ) {
+        Ok(_) => (),
+        Err(e) => {
+            log::error!("Failed to upsert pending for {:?}: {}", item.hash, e);
+        }
+    }
 }
 
 /// Removes a pending transfer entry by its tag.
@@ -97,8 +105,12 @@ pub fn upsert_pending(conn: &Connection, tag: &str, item: &PutItem) {
 /// * `conn` - Active SQLite database connection.
 /// * `tag` - Identifier of the pending entry to remove.
 pub fn remove_pending(conn: &Connection, tag: &str) {
-    conn.execute("DELETE FROM pending WHERE tag = ?1", params![tag])
-        .expect("Failed to remove pending");
+    match conn.execute("DELETE FROM pending WHERE tag = ?1", params![tag]) {
+        Ok(_) => (),
+        Err(e) => {
+            log::error!("Failed to remove pending for {}: {}", tag, e);
+        }
+    }
 }
 
 /// Loads all pending transfer entries from the database into memory.
@@ -142,8 +154,12 @@ pub fn load_pending(conn: &Connection) -> HashMap<String, PutItem> {
 /// * `conn` - Active SQLite database connection.
 /// * `hash` - Unique torrent hash identifier.
 pub fn remove(conn: &Connection, hash: &str) {
-    conn.execute("DELETE FROM state WHERE hash = ?1", params![hash])
-        .expect("Failed to remove state");
+    match conn.execute("DELETE FROM state WHERE hash = ?1", params![hash]) {
+        Ok(_) => (),
+        Err(e) => {
+            log::error!("Failed to remove for {}: {}", hash, e);
+        }
+    }
 }
 
 /// Loads all pending transfer entries from the database into memory.

src/rsync.rs

@@ -60,7 +60,7 @@ pub async fn run(
         put_item.remote_username, put_item.remote_host, put_item.remote_path
     );
 
-    let mut child = Command::new("rsync")
+    let child_result = Command::new("rsync")
         .args([
             "-az",
             "--progress",
@@ -70,8 +70,20 @@ pub async fn run(
             &remote,
         ])
         .stdout(std::process::Stdio::piped())
-        .spawn()
-        .expect("rsync failed");
+        .stderr(std::process::Stdio::piped())
+        .spawn();
+
+    let mut child = match child_result {
+        Ok(c) => c,
+        Err(e) => {
+            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;
+            }
+            return;
+        }
+    };
 
     let stdout = child.stdout.take().unwrap();
     let mut lines = BufReader::new(stdout).lines();
@@ -87,7 +99,17 @@ pub async fn run(
         }
     }
 
-    let status = child.wait().await.expect("failed to wait on rsync");
+    let status = match child.wait().await {
+        Ok(status) => status,
+        Err(e) => {
+            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;
+            }
+            return;
+        }
+    };
 
     if status.success() {
         log::info!("rsync complete: {}", name);

src/settings.rs

@@ -1,10 +1,10 @@
 use crate::squire;
 use std::collections::HashMap;
 use std::num::NonZeroUsize;
+use std::str::FromStr;
 use std::sync::Arc;
 use tokio::sync::RwLock;
 use utoipa::ToSchema;
-use std::str::FromStr;
 
 /// ### SharedState
 /// Shared application state for tracking active rsync operations.