Work on runtime system

unshell-lib/src/module/manager.rs

@@ -5,37 +5,35 @@ use std::{
     time::Duration,
 };
 
-use unshell_obfuscate::symbol;
-
 use crate::{
     config::{NamedComponent, PayloadConfig, RuntimeConfig},
     *,
 };
 use module::Module;
+use unshell_obfuscate::symbol;
 
 // #[derive(Debug)]
-pub struct Manager<'a> {
+pub struct Manager {
     id: &'static str,
 
-    modules: Vec<Module>,
+    pub modules: Vec<Module>,
 
-    active_runtimes: Vec<&'a dyn ModuleRuntime>,
+    active_runtimes: Vec<Box<dyn ModuleRuntime>>,
     // runtime_config: Vec<RuntimeConfig>,
-    components: HashMap<String, &'a NamedComponent>,
+    components: HashMap<String, NamedComponent>,
 }
 
 // static mut MANAGER_RUNTIME: Option<Arc<Mutex<Manager>>> = None;
 
-impl<'a> Manager<'a> {
-    fn new(id: &'static str, config: &'a Vec<NamedComponent>, modules: Vec<Module>) -> Self {
+impl Manager {
+    fn new(id: &'static str, config: Vec<NamedComponent>, modules: Vec<Module>) -> Self {
         Self {
             id,
-
-            // config,
             modules,
-
-            components: config.iter().map(|c| (c.name.to_string(), c)).collect(),
-
+            components: config
+                .into_iter()
+                .map(|c| (c.name.to_string(), c))
+                .collect(),
             active_runtimes: Vec::new(),
         }
     }
@@ -44,54 +42,49 @@ impl<'a> Manager<'a> {
     #[allow(static_mut_refs)]
     pub fn run(config: &'static PayloadConfig, modules: Vec<Module>) {
         // Construct self
-        let this = Self::new(&config.id, &config.components, modules);
+        let mut this = Self::new(&config.id, config.components.clone(), modules);
 
         // Load each of the pre-prepared modules
-        // this.load_components();
+        this.load_components();
 
         let this = Arc::new(Mutex::new(this));
 
         Self::start_runtimes(this.clone(), &config.runtime_config);
 
-        // let components = this.components.clone();
-
-        // let mut runtimes: Vec<Box<dyn ModuleRuntime>> = Vec::new();
-
-        // for (_name, component) in components {
-        //     let module_runtime = component.start_runtime(this.clone());
-        //     if let Some(module_runtime) = module_runtime {
-        //         runtimes.push(module_runtime);
-        //     }
-        // }
+        // drop(config);
 
         Self::join(this);
     }
 
-    // fn load_components(&mut self) {
-    //     for i in 0..self.modules.len() {
-    //         debug!("Importing module {}", i);
-    //         // let this_lock = .unwrap();
-    //         let component_func = if let Ok(component_func) = self.modules[i]
-    //             .get_symbol::<fn() -> HashMap<&'static str, Box<dyn Component>>>(
-    //                 symbol!("get_components").as_bytes(),
-    //             ) {
-    //             component_func
-    //         } else {
-    //             warn!("get_components function not found");
-    //             continue;
-    //         };
+    fn load_components(&mut self) {
+        for module in &self.modules {
+            // Load get_components function from shared object library
+            let component_func = match module
+                .get_symbol::<fn() -> Vec<NamedComponent>>(symbol!(b"get_components"))
+            {
+                Ok(func) => func,
+                Err(_) => {
+                    warn!("get_components function not found");
+                    continue;
+                }
+            };
 
-    //         let components = component_func();
+            let components = component_func();
+            let component_name = "TODO";
 
-    //         let len = components.len();
-    //         debug!("[{}] Loaded {} components", i, len);
+            debug!("{} - Retrieved payload metadata", component_name);
 
-    //         self.components.extend(components);
-    //     }
-    // }
+            // Add each component into self
+            for c in components {
+                debug!("{} - Found component '{}'", "TODO", c.name);
+                self.components.insert(c.name.to_owned(), c);
+            }
+        }
+    }
 
     /// Start each runtime
     fn start_runtimes(this: Arc<Mutex<Self>>, runtimes: &'static Vec<RuntimeConfig>) {
+        debug!("Starting runtimes...");
         for runtime in runtimes {
             let mut this_lock = this.lock().unwrap();
 
@@ -106,6 +99,8 @@ impl<'a> Manager<'a> {
                 }
             };
 
+            debug!("Starting runtime: {}", runtime.name);
+
             let runtime = match (*component.start_runtime)(runtime) {
                 Ok(runtime) => runtime,
                 Err(e) => {

unshell-lib/src/module/mod.rs

@@ -7,10 +7,6 @@ mod module;
 pub use manager::Manager;
 pub use module::Module;
 
-pub trait Interface {
-    fn as_any(self: Box<Self>) -> Box<dyn std::any::Any>;
-}
-
 /// "Module Interface" helper macro that creates a struct with function pointers
 /// Useful for defining and requiring modules' functions accross FFI boundry.
 #[macro_export]
@@ -58,10 +54,10 @@ macro_rules! module_interface {
             }
         }
 
-        impl crate::module::Interface for $interface_name {
-            fn as_any(self: Box<Self>) -> Box<dyn std::any::Any> {
-                self
-            }
-        }
+        // impl crate::module::Interface for $interface_name {
+        //     fn as_any(self: Box<Self>) -> Box<dyn std::any::Any> {
+        //         self
+        //     }
+        // }
     };
 }

unshell-lib/src/module/module.rs

@@ -5,7 +5,6 @@ use crate::{ModuleError, logger::SetupLogger, logger::logger};
 use crate::*;
 
 pub struct Module {
-    // name: String,
     lib: Library,
 }
 
@@ -29,6 +28,9 @@ impl Module {
 
         Ok(symbol)
     }
+    // pub fn get_id(&self) -> &str {
+    //     self.id
+    // }
     // pub fn get_interface<T>(&self) -> Result<T, ModuleError> {
     //     if let Ok(interface_function) = self.get_symbol::<fn() -> T>(b"interface") {
     //         Ok(interface_function())