SkuldNorniern · SkuldNorniern · Mar 13, 2024 · Feb 5, 2024 · Feb 5, 2024 · Feb 5, 2024
diff --git a/Cargo.toml b/Cargo.toml
@@ -18,7 +18,9 @@ pnet_macros_support = "0.34.0"
 pnet_macros = "0.34.0"
 
 # using custom forked version of pcap-rs for fixing audits
-pcap = { version = "1.1.0", git = "https://github.com/SkuldNorniern/pcap", rev = "40f1163" }
+# pcap = { version = "1.1.0", git = "https://github.com/SkuldNorniern/pcap", rev = "40f1163" }
+
+pcap = "1.2.0"
 
 chrono = { version = "0.4.29", default-features = false, features = ["clock"] }
 libc = "0.2"
@@ -28,15 +30,14 @@ snafu = "0.8.0"
 serde = { version = "1.0.193", features = ["derive"] }
 toml = "0.8.8"
 
-fluere_plugin = { version = "0.1.1", path = "./fluere-plugin" }
-fluere-config = { version = "0.1.3", path = "./fluere-config" }
+fluere_plugin = { version = "0.2.0", path = "./fluere-plugin", features = ["log"] }
+fluere-config = { version = "0.2.0", path = "./fluere-config", features = ["log"] }
 fluereflow = { version = "0.3.2", path = "./fluereflow" }
 
 ratatui = { version = "0.25.0", features = ["all-widgets"] }
 crossterm = "0.27"
 dirs = "5.0.1"
-logs = "0.7.1"
-env_logger = "0.10.0"
+log = { version = "0.4.21", features = ["std"]}
 
 [workspace]
 members = [

diff --git a/fluere-config/Cargo.toml b/fluere-config/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "fluere-config"
-version = "0.1.3"
+version = "0.2.0"
 edition = "2021"
 readme = "README.md"
 description = "Configuration manager for Fluere."
@@ -13,7 +13,11 @@ repository = "https://github.com/SkuldNorniern/fluere"
 dirs = "5.0.1"
 serde = { version = "1.0.193", features = ["derive"]}
 toml = "0.8.8"
+log = { version = "0.4.21", features = ["std"], optional = true }
 
 [lib]
 name = "fluere_config"
 
+
+[features]
+log = ["dep:log"]
diff --git a/fluere-config/src/init.rs b/fluere-config/src/init.rs
@@ -1,20 +1,35 @@
-use dirs::config_dir;
+use std::{default::Default, env, fs, path::Path, path::PathBuf};
 
 use crate::Config;
 
-use std::{default::Default, env, fs, path::Path, path::PathBuf};
+use dirs::config_dir;
+
+#[cfg(feature = "log")]
+use log::{debug, error, warn};
 
 impl Config {
     pub fn new() -> Self {
         let path_base = home_config_path();
 
         let path_file = path_base.join(Path::new("fluere.toml"));
-        println!("path_file: {:?}", path_file);
+
+        #[cfg(feature = "log")]
+        debug!("Using config file from: {:?}", path_file);
+        #[cfg(not(feature = "log"))]
+        println!("Using config file from: {:?}", path_file);
         if !path_base.exists() {
             match fs::create_dir_all(&path_base) {
-                Ok(_) => (),
+                Ok(_) => {
+                    #[cfg(feature = "log")]
+                    debug!("Created directory at {:?}", path_base);
+                    ()
+                }
                 Err(e) => {
+                    #[cfg(feature = "log")]
+                    error!("Failed to create directory at {:?}: {}", path_base, e);
+                    #[cfg(not(feature = "log"))]
                     eprintln!("Failed to create directory at {:?}: {}", path_base, e);
+
                     return Config::default();
                 }
             }
@@ -25,8 +40,16 @@
         }
 
         match Self::load(path_file.to_str().unwrap().to_string()) {
-            Ok(config) => config,
+            Ok(config) => {
+                #[cfg(feature = "log")]
+                debug!("Loaded configuration from: {:?}", path_file);
+
+                config
+            }
             Err(_) => {
+                #[cfg(feature = "log")]
+                warn!("failed to load configuration, using default config");
+                #[cfg(not(feature = "log"))]
                 println!("failed to load configuration, using default config");
                 Config::default()
             }
@@ -72,5 +95,5 @@
        }
    };
    let path_config = path_base.join("fluere");
    path_config
 }
diff --git a/fluere-plugin/Cargo.toml b/fluere-plugin/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "fluere_plugin"
-version = "0.1.1"
+version = "0.2.0"
 authors = ["Skuld Norniern <[email protected]>"]
 edition = "2021"
 description = "Plugin API for Fluere."
@@ -16,12 +16,18 @@ repository = "https://github.com/SkuldNorniern/fluere"
 [dependencies]
 git2 = "0.18.1"
 tokio = { version = "1.32", features = ["full","macros", "rt-multi-thread"] }
-fluere-config = { version = "0.1.2", path = "../fluere-config" }
+fluere-config = { version = "0.2.0", path = "../fluere-config" }
 #fluere-plugin-trait = { path = "../fluere-plugin-trait" }
 fluereflow = { version = "0.3.2", path = "../fluereflow" }
 dirs = "5.0.1"
 mlua = { version = "0.9.2", features = ["lua54", "vendored","async","send"] }
 inksac = "0.4.0"
 
+log = { version = "0.4.21", features = ["std"], optional = true }
+
 [lib]
 name = "fluere_plugin"
+
+
+[features]
+log = ["dep:log"]
diff --git a/fluere-plugin/src/downloader.rs b/fluere-plugin/src/downloader.rs
@@ -12,6 +12,9 @@ use std::time::Duration;
 
 use crate::util::home_cache_path;
 
+#[cfg(feature = "log")]
+use log::{debug, info};
+
 #[derive(Debug)]
 pub enum DownloadError {
     Io(std::io::Error),
@@ -81,7 +84,11 @@ pub fn download_plugin_from_github(repo_name: &str) -> Result<(), DownloadError>
             if has_local_changes(&repo)? {
                 println!("{}: You have uncommitted changes. Updating will overwrite these changes. Continue? [y/N] (auto skip in 5 seconds)","Warning".styled(warn_style));
                 if !user_confirms()? {
+                    #[cfg(feature = "log")]
+                    info!("Update skipped for {}", repo_name.styled(highlight_style));
+                    #[cfg(not(feature = "log"))]
                     println!("Update skipped for {}", repo_name.styled(highlight_style));
+
                     return Ok(());
                 }
             }
@@ -96,14 +103,26 @@ pub fn download_plugin_from_github(repo_name: &str) -> Result<(), DownloadError>
             repo.checkout_tree(fetch_commit_obj.as_object(), Some(&mut checkout_builder))?;
             repo.set_head_detached(fetch_commit)?;
 
+            #[cfg(feature = "log")]
+            info!(
+                "Successfully updated to the latest version for {}",
+                repo_name.styled(highlight_style)
+            );
+            #[cfg(not(feature = "log"))]
             println!(
                 "Successfully updated to the latest version for {}",
                 repo_name.styled(highlight_style)
             );
         } else {
+            #[cfg(feature = "log")]
+            info!("Update skipped for {}", repo_name.styled(highlight_style));
+            #[cfg(not(feature = "log"))]
             println!("Update skipped for {}", repo_name.styled(highlight_style));
         }
     } else {
+        #[cfg(feature = "log")]
+        info!("{} is up to date.", repo_name.styled(highlight_style));
+        #[cfg(not(feature = "log"))]
         println!("{} is up to date.", repo_name.styled(highlight_style));
     }
 
@@ -129,7 +148,9 @@ fn user_confirms() -> Result<bool, DownloadError> {
     match receiver.recv_timeout(Duration::from_secs(5)) {
         Ok(result) => Ok(result),
         Err(_) => {
-            print!("Timeout. ");
+            #[cfg(feature = "log")]
+            debug!("Timeout. ");
+
             Ok(false)
         }
     }

diff --git a/fluere-plugin/src/lib.rs b/fluere-plugin/src/lib.rs
@@ -1,22 +1,27 @@
-use fluere_config::Config;
-use fluereflow::FluereRecord;
-use mlua::{Lua, Result};
-use tokio::sync::{mpsc, Mutex};
-
 use std::collections::HashSet;
 use std::sync::Arc;
 
 mod downloader;
 mod util;
 
+use std::borrow::Cow;
+
 use downloader::download_plugin_from_github;
 use util::home_cache_path;
 
+use fluere_config::Config;
+use fluereflow::FluereRecord;
+use mlua::{Lua, Result};
+use tokio::sync::{mpsc, Mutex};
+
+#[cfg(feature = "log")]
+use log::{debug, error, info, warn};
+
 pub struct PluginManager {
     lua: Arc<Mutex<Lua>>,
     sender: mpsc::Sender<FluereRecord>,
     receiver: Arc<Mutex<mpsc::Receiver<FluereRecord>>>,
-    plugins: Arc<Mutex<HashSet<String>>>,
+    plugins: Arc<Mutex<HashSet<Cow<'static, str>>>>,
 }
 
 impl PluginManager {
@@ -34,6 +39,9 @@ impl PluginManager {
     }
 
     pub async fn load_plugins(&self, config: &Config) -> Result<()> {
+        #[cfg(feature = "log")]
+        debug!("Loading plugins");
+
         let plugins_clone = self.plugins.clone();
         let mut plugins_guard = plugins_clone.lock().await;
         for (name, plugin_config) in &config.plugins {
@@ -50,7 +58,10 @@ impl PluginManager {
                                 let lua_clone = self.lua.clone();
                                 let lua_guard = lua_clone.lock().await;
                                 let lua = &*lua_guard;
-                                // println!("lua path: {}", path);
+
+                                #[cfg(feature = "log")]
+                                debug!("Lua path: {}", path);
+
                                 let lua_plugin_path =
                                     format!("package.path = package.path .. \";{}/?.lua\"", path);
                                 let _ = lua.load(lua_plugin_path).exec();
@@ -61,7 +72,9 @@ impl PluginManager {
 
                                 let argument_table = lua.create_table()?;
 
-                                // println!("extra argument details{:?}", plugin_config.extra_arguments);
+                                #[cfg(feature = "log")]
+                                debug!("extra argument details{:?}", plugin_config.extra_arguments);
+
                                 for (key, value) in
                                     plugin_config.extra_arguments.clone().unwrap().iter()
                                 {
@@ -87,13 +100,23 @@ impl PluginManager {
                                 Ok(())
                                 }).expect(format!("Error on plugin: {}", name).as_str(()));*/
                                 //lua_guard.load(&code).exec().expect(format!("Error on plugin: {}", name).as_str());
-
-                                plugins_guard.insert(name.clone());
+                                let _ = plugins_guard.insert(std::borrow::Cow::Owned(name.clone()));
+                                #[cfg(feature = "log")]
+                                info!("Loaded plugin {}", name);
+                                #[cfg(not(feature = "log"))]
                                 println!("Loaded plugin {}", name);
                             }
                             Err(err) => {
-                                println!("Failed to read plugin: {}", name);
-                                println!("Error: {}", err);
+                                #[cfg(feature = "log")]
+                                {
+                                    warn!("Failed to read plugin: {}", name);
+                                    error!("Error: {}", err);
+                                }
+                                #[cfg(not(feature = "log"))]
+                                {
+                                    println!("Failed to read plugin: {}", name);
+                                    println!("Error: {}", err);
+                                }
                                 continue;
                             }
                         };
@@ -146,19 +169,38 @@ impl PluginManager {
 
                                         Ok(())
                                         }).expect(format!("Error on plugin: {}", name).as_str());*/
-                                        plugins_guard.insert(name.clone());
+                                        let _ = plugins_guard.insert(std::borrow::Cow::Owned(name.clone()));
+                                        #[cfg(feature = "log")]
+                                        info!("Loaded plugin {}", name);
+                                        #[cfg(not(feature = "log"))]
                                         println!("Loaded plugin {}", name);
                                     }
                                     Err(eri) => {
-                                        println!("Failed to read plugin: {}", name);
-                                        println!("Error: {}", eri);
+                                        #[cfg(feature = "log")]
+                                        {
+                                            warn!("Failed to read plugin: {}", name);
+                                            error!("Error: {}", eri);
+                                        }
+                                        #[cfg(not(feature = "log"))]
+                                        {
+                                            println!("Failed to read plugin: {}", name);
+                                            println!("Error: {}", eri);
+                                        }
                                         continue;
                                     }
                                 }
                             }
                             Err(eri) => {
-                                println!("Unable to download plugin: {}", name);
-                                println!("Error: {}", eri);
+                                #[cfg(feature = "log")]
+                                {
+                                    warn!("Unable to download plugin: {}", name);
+                                    error!("Error: {}", eri);
+                                }
+                                #[cfg(not(feature = "log"))]
+                                {
+                                    println!("Unable to download plugin: {}", name);
+                                    println!("Error: {}", eri);
+                                }
                             }
                         }
                     }
@@ -226,13 +268,20 @@ impl PluginManager {
                     for plugin_name in plugins.iter() {
                         let plugin_table: mlua::Table = lua
                             .globals()
-                            .get(plugin_name.as_str())
+                            .get(plugin_name.as_ref())
                             .expect("Plugin table not found");
 
                         if let Ok(func) = plugin_table.get::<_, mlua::Function>("process_data") {
                             func.call::<mlua::Table<'_>, ()>(lua_table.clone())
                                 .unwrap_or_else(|_| panic!("Error on plugin: {}", plugin_name));
                         } else {
+                            #[cfg(feature = "log")]
+                            error!(
+                                "'process_data' function not found in plugin: {}",
+                                plugin_name
+                            );
+
+                            #[cfg(not(feature = "log"))]
                             println!(
                                 "'process_data' function not found in plugin: {}",
                                 plugin_name
@@ -253,7 +302,7 @@ impl PluginManager {
 
     pub async fn await_completion(&self, target_worker: Arc<Mutex<tokio::task::JoinHandle<()>>>) {
         let worker_clone = target_worker.clone();
-        let _ = worker_clone.lock().await;
+        let worker = worker_clone.lock().await;
 
         // Cleanup each plugin before exiting
         let lua_clone = self.lua.clone();
@@ -265,15 +314,29 @@ impl PluginManager {
         for plugin_name in plugins.iter() {
             let plugin_table: mlua::Table = lua
                 .globals()
-                .get(plugin_name.as_str())
+                .get(plugin_name.as_ref())
                 .expect("Plugin table not found");
 
             if let Ok(func) = plugin_table.get::<_, mlua::Function>("cleanup") {
                 func.call::<(), ()>(())
                     .unwrap_or_else(|_| panic!("Error on plugin: {}", plugin_name));
             } else {
+                #[cfg(feature = "log")]
+                warn!("cleanup function not found in plugin: {}", plugin_name);
+                #[cfg(not(feature = "log"))]
                 println!("cleanup function not found in plugin: {}", plugin_name);
             }
         }
+
+        drop(lua);
+        drop(plugins);
+        drop(worker);
     }
 }
+
+impl Drop for PluginManager {
+    fn drop(&mut self) {
+        drop(self.plugins.lock());
+        drop(self.lua.lock());
+    }
+}