refactor: remove system directory from meta_plugin

src/meta_plugin/keep_pid.rs

@@ -0,0 +1,149 @@
+use std::process;
+use crate::meta_plugin::MetaPlugin;
+
+#[derive(Debug, Clone, Default)]
+pub struct KeepPidMetaPlugin {
+    meta_name: String,
+    is_finalized: bool,
+    outputs: std::collections::HashMap<String, serde_yaml::Value>,
+    options: std::collections::HashMap<String, serde_yaml::Value>,
+}
+
+impl KeepPidMetaPlugin {
+    pub fn new(
+        _options: Option<std::collections::HashMap<String, serde_yaml::Value>>,
+        outputs: Option<std::collections::HashMap<String, serde_yaml::Value>>,
+    ) -> KeepPidMetaPlugin {
+        // Start with default options
+        let mut final_options = std::collections::HashMap::new();
+        if let Some(opts) = _options {
+            for (key, value) in opts {
+                final_options.insert(key, value);
+            }
+        }
+        
+        // Start with default outputs
+        let mut final_outputs = std::collections::HashMap::new();
+        let default_outputs = Self::default().default_outputs();
+        for output_name in default_outputs {
+            final_outputs.insert(output_name.clone(), serde_yaml::Value::String(output_name));
+        }
+        if let Some(outs) = outputs {
+            for (key, value) in outs {
+                final_outputs.insert(key, value);
+            }
+        }
+        
+        KeepPidMetaPlugin {
+            meta_name: "keep_pid".to_string(),
+            is_finalized: false,
+            outputs: final_outputs,
+            options: final_options,
+        }
+    }
+    
+    pub fn new_simple() -> KeepPidMetaPlugin {
+        Self::new(None, None)
+    }
+}
+
+impl MetaPlugin for KeepPidMetaPlugin {
+    fn is_finalized(&self) -> bool {
+        self.is_finalized
+    }
+    
+    fn set_finalized(&mut self, finalized: bool) {
+        self.is_finalized = finalized;
+    }
+    
+    fn finalize(&mut self) -> crate::meta_plugin::MetaPluginResponse {
+        // If already finalized, don't process again
+        if self.is_finalized {
+            return crate::meta_plugin::MetaPluginResponse {
+                metadata: Vec::new(),
+                is_finalized: true,
+            };
+        }
+        
+        // Mark as finalized
+        self.is_finalized = true;
+        
+        crate::meta_plugin::MetaPluginResponse {
+            metadata: Vec::new(),
+            is_finalized: true,
+        }
+    }
+
+    fn update(&mut self, _data: &[u8]) -> crate::meta_plugin::MetaPluginResponse {
+        // If already finalized, don't process more data
+        if self.is_finalized {
+            return crate::meta_plugin::MetaPluginResponse {
+                metadata: Vec::new(),
+                is_finalized: true,
+            };
+        }
+        
+        crate::meta_plugin::MetaPluginResponse {
+            metadata: Vec::new(),
+            is_finalized: false,
+        }
+    }
+
+    fn meta_name(&self) -> String {
+        self.meta_name.clone()
+    }
+    
+    fn initialize(&mut self) -> crate::meta_plugin::MetaPluginResponse {
+        // If already finalized, don't process again
+        if self.is_finalized {
+            return crate::meta_plugin::MetaPluginResponse {
+                metadata: Vec::new(),
+                is_finalized: true,
+            };
+        }
+        
+        let mut metadata = Vec::new();
+        let pid = process::id().to_string();
+        
+        // Use process_metadata_outputs to handle output mapping
+        if let Some(meta_data) = crate::meta_plugin::process_metadata_outputs(
+            "keep_pid", 
+            pid, 
+            &self.outputs
+        ) {
+            metadata.push(meta_data);
+        }
+        
+        // Mark as finalized since this plugin only needs to run once
+        self.is_finalized = true;
+        
+        crate::meta_plugin::MetaPluginResponse {
+            metadata,
+            is_finalized: true,
+        }
+    }
+    
+    fn outputs(&self) -> &std::collections::HashMap<String, serde_yaml::Value> {
+        &self.outputs
+    }
+    
+    fn outputs_mut(&mut self) -> &mut std::collections::HashMap<String, serde_yaml::Value> {
+        &mut self.outputs
+    }
+    
+    fn default_outputs(&self) -> Vec<String> {
+        vec!["keep_pid".to_string()]
+    }
+    
+    fn default_options(&self) -> std::collections::HashMap<String, serde_yaml::Value> {
+        std::collections::HashMap::new()
+    }
+    
+    fn options(&self) -> &std::collections::HashMap<String, serde_yaml::Value> {
+        &self.options
+    }
+    
+    fn options_mut(&mut self) -> &mut std::collections::HashMap<String, serde_yaml::Value> {
+        &mut self.options
+    }
+}