tmp

Author: Nathan Monfils

core-dump-agent/src/main.rs

@@ -91,7 +91,12 @@ async fn main() -> Result<(), anyhow::Error> {
             };
             let p = Path::new(&file);
             info!("Uploading {}", file);
-            process_file(p, &bucket).await;
+            match process_file(p, &bucket).await {
+                Ok(()) => (),
+                Err(e) => {
+                    error!("File processing failed: {e}");
+                }
+            };
         } else {
             info!("Uploading all content in {}", core_dir_command);
             run_polling_agent(false).await;
@@ -320,53 +325,37 @@ async fn process_file(zip_path: &Path, bucket: &Bucket) -> Result<(), String> {
             } else {
                 error!("File locked on INotify shouldn't happen as we are waiting for file close events.\nPlease recycling pod to perform sweep\n{}", e);
             }
-            return;
+            return Err("File locked".into());
         }
     }
 
-    let metadata = fs::metadata(zip_path).expect("unable to read metadata");
+    let metadata = fs::metadata(zip_path).map_err(|e| format!("unable to read metadata: {e}"))?;
     info!("zip size is {}", metadata.len());
-    let path_str = match zip_path.to_str() {
-        Some(v) => v,
-        None => {
-            error!("Failed to extract path");
-            return;
-        }
-    };
-    let upload_file_name: &str = match zip_path.file_name().unwrap().to_str() {
-        Some(v) => v,
-        None => {
-            error!("Failed to get file name for upload");
-            return;
-        }
-    };
+    let path_str = zip_path.to_str().ok_or("Failed to extract path")?;
+    let upload_file_name: &str = zip_path
+        .file_name()
+        .ok_or("Failed to get file name for upload")?
+        .to_str()
+        .ok_or("Invalid encoding of file name for upload")?;
 
     let mut fasync = tokio::fs::File::open(zip_path)
         .await
-        .expect("file was removed");
+        .map_err(|e| format!("file became unavailable while processing: {e}"))?;
 
-    let code = match bucket
+    let code = bucket
         .put_object_stream(&mut fasync, upload_file_name)
         .await
-    {
-        Ok(v) => v,
-        Err(e) => {
-            error!("Upload Failed {}", e);
-            return;
-        }
-    };
-    match fs::remove_file(path_str) {
-        Ok(v) => v,
-        Err(e) => {
-            error!("File delete failed: {}", e);
-            return;
-        }
-    };
+        .map_err(|e| format!("Upload Failed: {e:?}"))?;
+
+    fs::remove_file(path_str).map_err(|e| format!("File delete failed: {}", e))?;
+
     info!(
         "S3 Returned: status_code: {} uploaded_bytes: {}",
         code.status_code(),
         code.uploaded_bytes()
     );
+
+    Ok(())
 }
 
 fn get_bucket() -> Result<Box<Bucket>, anyhow::Error> {