image_store_plugin: delete all files related to an image

Author: richcar58

Cargo.lock

@@ -11,6 +11,7 @@ chrono = "0.4.22"
 #event-engine = { path = "../event-engine/event-engine/"}
 event-engine = "0.2.0"
 flatbuffers = "2.1.2"
+glob = "0.3.1"
 lazy_static = "1.4.0"
 log = "0.4.17"
 log4rs = "1.1.1"

Cargo.toml

@@ -78,10 +78,13 @@ pub enum Errors {
     #[error("Expected event type {}, but received event {} instead.", .0, .1)]
     EventUnexpectedError(String, String),
 
+    #[error("Deleted file {0}")]
+    FileDeleted(String),
+
     #[error("Failed to delete file {0}: {1}")]
     FileDeleteError(String, String),
 
-    #[error("File IO error: {}", .0)]
+     #[error("File IO error: {}", .0)]
     FileIOError(String),
 
     /// Input parameter logging.

src/config/errors.rs

@@ -9,8 +9,9 @@ use event_engine::{plugins::Plugin};
 use anyhow::{Result, anyhow};
 use std::fs;
 use serde_json;
+use glob::glob;
 
-use log::{info, error};
+use log::{info, error, warn, debug};
 
 // The search string prefix for this plugin.
 const PREFIX: &str  = "image_store_";
@@ -170,6 +171,7 @@ fn get_action_for_score(store_parms_ref: &StoreParms, score: f32) -> StoreAction
  * the empty string.  Both of these values are part of the application configuration.
  * The image uuid and format are returned in the NewImageEvent. 
  */
+#[allow(dead_code)]
 fn make_image_filepath(plugin: &ImageStorePlugin, event: &ImageScoredEvent) -> Option<String> {
     // Get the uuid string for use in the file name.
     let uuid_str = match event.image_uuid() {
@@ -240,28 +242,71 @@ fn make_score_filepath(plugin: &ImageStorePlugin, event: &ImageScoredEvent) -> O
 // ---------------------------------------------------------------------------
 // action_delete:
 // ---------------------------------------------------------------------------
-/** Delete the image file and don't save the scores.
+/** Delete all image related files and don't save the scores.  Image related
+ * files are all file that match this format:
+ * 
+ *      <image_directory_path>/<image_file_prefix><image_uuid>*
+ * 
  */
 fn action_delete(plugin: &ImageStorePlugin, event: &ImageScoredEvent) -> StoreAction{
-    // Create absolute file path for the image.  Errors have alread been logged.
-    let filepath = match make_image_filepath(plugin, event) {
-        Some(p) => p,
-        None => return StoreAction::ErrorOut,
+        // Get the uuid string for use in the file name.
+    let uuid_str = match event.image_uuid() {
+        Some(s) => s,
+        None => {
+            // Log the error and just return.
+            let msg = format!("{}", Errors::PluginEventAccessUuidError(
+                                      plugin.get_name(), "NewImageEvent".to_string()));
+            error!("{}", msg);
+            return StoreAction::ErrorOut
+        }
     };
 
-    // Delete the file.
-    match fs::remove_file(filepath.clone()){
-        Ok(_) => {},
+    // Get the path iterator that matches the wildcard path.
+    let wildcard_path = 
+        traps_utils::create_image_wildcard_path(&plugin.get_runctx().abs_image_dir, 
+                                                &plugin.get_runctx().parms.config.image_file_prefix, 
+                                                uuid_str);
+
+    // Get path iterator and process its entries.
+    match glob(&wildcard_path) {
+        // Get an iterator to paths that match the filter.
         Err(e) => {
             // Log error.
             let msg = format!("{}", Errors::FileDeleteError(
-                                      filepath, e.to_string()));
+                                      wildcard_path.clone(), e.to_string()));
             error!("{}", msg);
             return StoreAction::ErrorOut
+        },
+        Ok(path_iter) => {
+            // Process each matching filepath.
+            for entry in path_iter {
+                match entry {
+                    // Record the error and continue.
+                    Err(e) => {
+                        let msg = format!("{}", Errors::FileDeleteError(
+                            wildcard_path.clone(), e.to_string()));
+                        warn!("{}", msg);
+                    },
+                    Ok(path) => {
+                        let filepath = path.as_os_str().to_str().unwrap();
+                        match fs::remove_file(filepath){
+                            Ok(_) => {
+                                debug!("{}", format!("{}", Errors::FileDeleted(filepath.to_string())));
+                            },
+                            Err(e) => {
+                                // Log error.
+                                let msg = format!("{}", Errors::FileDeleteError(
+                                                          filepath.to_string(), e.to_string()));
+                                warn!("{}", msg);
+                            }
+                        }
+                    }
+                }
+            }
         }
-    };
+    }
 
-    // Success.
+    // Success though warnings may have been logged.
     StoreAction::Delete
 }
 

src/plugins/actions/image_store_actions.rs

@@ -105,6 +105,40 @@ pub fn create_image_filepath(abs_dir: &str, image_file_prefix: &Option<String>,
     filepath
 }
 
+// ---------------------------------------------------------------------------
+// create_image_wildcard_path:
+// ---------------------------------------------------------------------------
+/** Create a file path using the glob wildcard characters that would that 
+ * capture all files related to an image.  The result is string that can be 
+ * used to search for all files in a directory that are related to or stem from
+ * an image file, including the image file itself.  The format of the result
+ * string is:
+ * 
+ *    <image_directory_path>/<image_file_prefix><image_uuid>*
+ *  
+ * Using above constructed strings with the glob search crate allows all 
+ * imaged related files to be discovered.
+ *
+ */
+#[allow(dead_code)]
+pub fn create_image_wildcard_path(abs_dir: &str, image_file_prefix: &Option<String>, 
+                             uuid_str: &str) -> String {
+    // Get absolute path of the image directory with a trailing slash.
+    let slash = if abs_dir.ends_with('/') {""} else {"/"};
+    let mut filepath = abs_dir.to_owned();
+    filepath.push_str(slash);
+
+    // Prepend the file prefix if one is specified.
+    match image_file_prefix {
+        Some(s) => filepath.push_str(s),
+        None => {}
+    }
+
+    // Append the image uuid as the file name and the wildcare.
+    filepath.push_str(uuid_str);
+    filepath.push('*');
+    filepath
+}
 
 // ---------------------------------------------------------------------------
 // validate_image_dir: