initial image_store_file_action

Author: richcar58

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "camera-traps"
-version = "0.2.1"
+version = "0.2.2"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -18,8 +18,9 @@ path-absolutize = "3.0.13"
 rand = "0.8.5"
 serde = "1.0.144"
 serde_derive = "1.0.144"
+serde_json = "1.0.92"
 shellexpand = "2.1.2"
 thiserror = "1.0.32"
 toml = "0.5.9"
-uuid = { version = "1.1", features = ["v4"] }
+uuid = { version = "1.1", features = ["v4", "serde"] }
 zmq = "0.9.2"

Cargo.toml

@@ -29,7 +29,8 @@ internal = [
 # take when new work is received.  If no action is specified for a plugin, its no-op action 
 # is used by default. 
 internal_actions = [
-    "image_recv_write_file_action"
+    "image_recv_write_file_action",
+    "image_store_file_action"
 ]
 
 # External plugins require more configuration information than internal plugins.

resources/traps.toml

@@ -69,9 +69,15 @@ pub enum Errors {
     #[error("Plugin {} is unable to convert a {} event to vector of bytes: {}", .0, .1, .2)]
     EventToBytesError(String, String, String),
 
+    #[error("Plugin {} is unable to convert a {} event to vector to JSON: {}", .0, .1, .2)]
+    EventToJsonError(String, String, String),
+
     #[error("Expected event type {}, but received event {} instead.", .0, .1)]
     EventUnexpectedError(String, String),
 
+    #[error("Failed to delete file {0}: {1}")]
+    FileDeleteError(String, String),
+
     #[error("File IO error: {}", .0)]
     FileIOError(String),
 

src/config/errors.rs

@@ -3,6 +3,7 @@ use event_engine::events::{Event, EventType};
 use flatbuffers::{FlatBufferBuilder, InvalidFlatbuffer};
 use std::error::Error;
 use uuid::Uuid;
+use serde::Serialize;
 
 // Logging imports.
 use anyhow::Result;
@@ -379,6 +380,7 @@ impl ImageReceivedEvent {
 // ------------------------------
 // ------ ImageLabelScore
 // ------------------------------
+#[derive(Serialize)]
 pub struct ImageLabelScore {
     image_uuid: Uuid,
     label: String,
@@ -432,6 +434,7 @@ impl ImageLabelScore {
 // ------------------------------
 // ------ ImageScoredEvent
 // ------------------------------
+#[derive(Serialize)]
 pub struct ImageScoredEvent {
     created: String,
     image_uuid: Uuid,
@@ -544,10 +547,26 @@ impl Event for ImageScoredEvent {
 // ------ Associated Functions
 // ------------------------------
 impl ImageScoredEvent {
+    // ----------------------------------------------------------------------
+    // accessors:
+    // ----------------------------------------------------------------------
+    pub fn get_created(&self) -> &String {
+        return &self.created;
+    }
+    pub fn get_image_uuid(&self) -> &Uuid {
+        return &self.image_uuid;
+    }
+    pub fn get_image_format(&self) -> &String {
+        return &self.image_format;
+    }
+    pub fn get_scores(&self) -> &Vec<ImageLabelScore> {
+        return &self.scores;
+    }
+
     // ----------------------------------------------------------------------
     // new:
     // ----------------------------------------------------------------------
-    #![allow(unused)]
+    #[allow(unused)]
     pub fn new(image_uuid: Uuid, image_format: String, scores: Vec<ImageLabelScore>) -> Self {
         ImageScoredEvent {
             created: timestamp_str(),

src/events.rs

@@ -3,15 +3,21 @@
 use crate::{Config, traps_utils};
 use crate::plugins::image_store_plugin::{ImageStorePlugin, StoreAction, StoreParms};
 use crate::events_generated::gen_events::ImageScoredEvent;
-use crate::{config::errors::Errors};
-use anyhow::{Result, anyhow};
+use crate::{events, config::errors::Errors};
+use event_engine::{plugins::Plugin};
 
+use anyhow::{Result, anyhow};
+use std::fs;
+use serde_json;
 
 use log::{info, error};
 
 // The search string prefix for this plugin.
 const PREFIX: &str  = "image_store_";
 
+// The score file suffix.
+const SCORE_SUFFIX: &str = "score";
+
 // ***************************************************************************
 //                            PUBLIC FUNCTIONS
 // ***************************************************************************
@@ -96,10 +102,10 @@ pub fn image_store_file_action(plugin: &ImageStorePlugin, event: &ImageScoredEve
 
     // Perform the action.
     match store_action {
-        StoreAction::Delete => action_delete(event),
-        StoreAction::Noop   => action_noop(event),
-        StoreAction::ReduceSave => action_reduce_save(event),
-        StoreAction::Save       => action_save(event),
+        StoreAction::Delete     => action_delete(plugin, event),
+        StoreAction::Noop       => {},
+        StoreAction::ReduceSave => action_reduce_save(plugin, event),
+        StoreAction::Save       => action_save(plugin, event),
     }
 
     // Return the action taken.
@@ -150,39 +156,149 @@ fn get_action_for_score(store_parms_ref: &StoreParms, score: f32) -> StoreAction
 }
 
 // ---------------------------------------------------------------------------
-// create_image_filepath:
+// make_image_filepath:
 // ---------------------------------------------------------------------------
 /** Create absolute file path for the image. */
-fn create_image_filepath(plugin: &ImageStorePlugin, uuid_str: &str, suffix: &str) -> String {
-    return traps_utils::create_image_filepath(&plugin.get_runctx().abs_image_dir, 
-                                              &plugin.get_runctx().parms.config.image_file_prefix, 
-                                              uuid_str, 
-                                              suffix);
+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() {
+        Some(s) => s,
+        None => {
+            // Log the error and just return.
+            let msg = format!("{}", Errors::PluginEventAccessUuidError(
+                                      plugin.get_name(), "NewImageEvent".to_string()));
+            error!("{}", msg);
+            return None;
+        }
+    };
+
+    // Standardize image type suffixes to lowercase.
+    let suffix = match event.image_format() {
+        Some(s) => s.to_string().to_lowercase(),
+        None => {
+            // Log the error and just return.
+            let msg = format!("{}", Errors::ActionImageFormatTypeError(
+                                      plugin.get_name(), "NewImageEvent".to_string()));
+            error!("{}", msg);
+            return None;
+        } 
+    };
+
+    // Get the path.
+    let path = traps_utils::create_image_filepath(&plugin.get_runctx().abs_image_dir, 
+                                                          &plugin.get_runctx().parms.config.image_file_prefix, 
+                                                          uuid_str, 
+                                                          suffix.as_str());
+
+    Option::Some(path)
 }
 
 // ---------------------------------------------------------------------------
-// action_delete:
+// make_score_filepath:
 // ---------------------------------------------------------------------------
-fn action_delete(event: &ImageScoredEvent) {
-    let uuid = event.image_uuid();
+/** Create absolute file path for the image. */
+fn make_score_filepath(plugin: &ImageStorePlugin, event: &ImageScoredEvent) -> Option<String> {
+    // 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 None;
+        }
+    };
+
+    // Get the path.
+    let path = traps_utils::create_image_filepath(&plugin.get_runctx().abs_image_dir, 
+                                                          &plugin.get_runctx().parms.config.image_file_prefix, 
+                                                          uuid_str, 
+                                                          SCORE_SUFFIX);
+
+    Option::Some(path)
 }
 
 // ---------------------------------------------------------------------------
-// action_noop:
+// action_delete:
 // ---------------------------------------------------------------------------
-fn action_noop(event: &ImageScoredEvent) {
+/** Delete the image file and don't save the scores.
+ */
+fn action_delete(plugin: &ImageStorePlugin, event: &ImageScoredEvent) {
+    // 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,
+    };
 
+    // Delete the file.
+    match fs::remove_file(filepath.clone()){
+        Ok(_) => {},
+        Err(e) => {
+            // Log error.
+            let msg = format!("{}", Errors::FileDeleteError(
+                                      filepath, e.to_string()));
+            error!("{}", msg);
+        }
+    };
 }
 
 // ---------------------------------------------------------------------------
 // action_reduce_save:
 // ---------------------------------------------------------------------------
-fn action_reduce_save(event: &ImageScoredEvent) {
+/** Reduce the image resolution and then save it and it's scores.
+ */
+fn action_reduce_save(plugin: &ImageStorePlugin, event: &ImageScoredEvent) {
+    // TODO: reduce image size
 
+    action_save(plugin, event)
 }
+
 // ---------------------------------------------------------------------------
 // action_save:
 // ---------------------------------------------------------------------------
-fn action_save(event: &ImageScoredEvent) {
+/** Leave the image file as-is and save its scores.  On error, just log and return.
+ */
+fn action_save(plugin: &ImageStorePlugin, event: &ImageScoredEvent) {
+    // Extract the image uuid from the new image event.
+    let image_scored_event = match events::ImageScoredEvent::new_from_gen(*event) {
+        Ok(ev) => ev,
+        Err(e) => {
+            let msg = format!("{}", Errors::PluginEventDeserializationError(
+                                      plugin.get_name(), "ImageScoredEvent".to_string()));           
+            error!("{}: {}", msg, e.to_string());
+            return
+        }
+    };
 
+    // Convert the event scores to json.
+    let json_str = match serde_json::to_string(&image_scored_event) {
+        Ok(s) => s,
+        Err(e) => {
+            let msg = format!("{}", Errors::EventToJsonError(
+                                      plugin.get_name(), "ImageScoredEvent".to_string(), e.to_string()));           
+            error!("{}", msg);
+            return;
+        }
+    };
+
+    // Construct the score output path name.
+    let filepath = match make_score_filepath(plugin, event) {
+        Some(fp)=> fp,
+        None => {
+            // Error already logged.
+            return;
+        }
+    };
+
+    // Write the json to the score output file.
+    match traps_utils::create_or_replace_file(&filepath, json_str.as_bytes()) {
+        Ok(_) => (),
+        Err(e) => {
+            let msg = format!("{}", Errors::ActionWriteFileError(plugin.get_name(),
+                                      "action_save".to_string(), filepath, e.to_string()));
+            error!("{}", msg);
+            return;
+        }
+    };
 }

src/plugins/actions/image_store_actions.rs

@@ -370,6 +370,9 @@ impl ImageStorePlugin {
 #[cfg(test)]
 mod tests {
     use crate::plugins::image_store_plugin::StoreAction;
+    use crate::events::{ImageLabelScore, ImageScoredEvent};
+    use uuid::Uuid;
+    use serde_json;
 
     #[test]
     fn here_i_am() {
@@ -417,6 +420,24 @@ mod tests {
         assert_eq!(&list[4], &(15u8,  StoreAction::Noop));
         assert_eq!(&list[5], &(5u8,   StoreAction::Save));
         assert_eq!(&list[6], &(0u8,   StoreAction::Delete));
+    }
+
+    #[test]
+    fn sertest() {
+        // Image uuid.
+        let uuid = Uuid::new_v4();
+        
+        // Create label vector.
+        let label1 = ImageLabelScore::new(uuid.clone(), "cow".to_string(), 0.8); 
+        let label2 = ImageLabelScore::new(uuid.clone(), "dog".to_string(), 0.3); 
+        let labels:Vec<ImageLabelScore> = vec!(label1, label2);
+
+        // Create the event.
+        let ev = ImageScoredEvent::new(uuid.clone(), "png".to_string(), labels);
 
+        // Serialize event to json.
+        let json_str = serde_json::to_string(&ev).unwrap();
+        println!("{}", json_str); // assert is difficult because of timestamp.
     }
+
 }