fetching modules should now work

src/core/error.rs

@@ -7,13 +7,14 @@ use std::io;
 use colored::Colorize;
 use tracing::{trace, debug, info, warn, error};
 
+use crate::proto::MizeMessage;
+
+
 #[macro_export]
 macro_rules! mize_err {
     ($($arg:tt)*) => { MizeError::new().msg(format!( $($arg)*)) };
 }
 
-use crate::proto::MizeMessage;
-
 pub type MizeResult<T> = Result<T, MizeError>;
 
 pub trait MizeResultTrait<T> {
@@ -32,6 +33,7 @@ pub struct MizeError {
     pub messages: Vec<String>,
     pub caused_by_msg: Option<CausedByMessage>,
     pub code_location: Option<MizeCodeLocation>,
+    pub backtrace: String,
 }
 
 #[derive(Debug, Clone)]
@@ -85,6 +87,7 @@ impl MizeError {
             messages: Vec::new(),
             caused_by_msg: None,
             code_location: Some(caller_location.into()),
+            backtrace: format!("{}", std::backtrace::Backtrace::capture()),
         }
     }
 
@@ -110,12 +113,17 @@ impl MizeError {
 
     pub fn log(self) -> MizeError {
         error!("MizeError envountered!");
+
         if let Some(ref location) = self.code_location {
             error!("[ {} ] {}", "LOCATION".yellow(), location);
         };
+
+        error!("[ {} ] {}", "BACKTRACE".yellow(), self.backtrace);
+
         for msg in &self.messages {
             error!("[ {} ] {}", "MSG".yellow(), msg);
         }
+
         self
     }
 
@@ -258,6 +266,7 @@ fn get_error_by_code(code: u32, caller_location: &std::panic::Location) -> MizeE
         messages: Vec::new(),
         caused_by_msg: None,
         code_location: Some(caller_location.into()),
+        backtrace: format!("{}", std::backtrace::Backtrace::capture()),
     };
 
     match code {

src/core/instance/mod.rs

@@ -129,6 +129,11 @@ impl Instance {
         //instance.spawn("msg_thread", closure)?;
 
 
+        // load the config from build time
+        let config = ItemData::from_toml(BUILD_TIME_CONFIG)?;
+        instance.set_blocking("0", config);
+
+
         return Ok(instance);
     }
 
@@ -146,12 +151,8 @@ impl Instance {
 
     fn init(&mut self) -> MizeResult<()> {
 
-        // load the config from build time
-        let config = ItemData::from_toml(BUILD_TIME_CONFIG)?;
-        self.set_blocking("0", config);
-
         // platform specific init code
-        crate::platform::any::instance_init(self);
+        crate::platform::any::instance_init(self)?;
 
         // end of platform specific init code
 

src/core/instance/tests.rs

@@ -5,6 +5,47 @@ use crate::item::IntoItemData;
 
 use super::*;
 
+#[test]
+fn test_get_module_hash() -> MizeResult<()> {
+    let mut instance = Instance::empty()?;
+
+    use crate::platform::os::get_module_hash;
+    let selector_toml = r#"
+        mize_version = "0.0.0"
+        system = "x86_64-unknown-linux-gnu"
+        toolchain_version = "rustc 1.78.0 (9b00956e5 2024-04-29)"
+    "#;
+
+    instance.set_blocking("0/config/selector", ItemData::from_toml(&selector_toml)?)?;
+
+    let hash = get_module_hash(&mut instance, "String", ItemData::new())?;
+
+    test_println!("hash: {}", hash);
+
+    assert_eq!(hash, "e96edf60216688314efc263c1aa8d6ce".to_owned());
+
+    Ok(())
+}
+
+#[test]
+fn test_set_store_path() -> MizeResult<()> {
+    let instance = Instance::empty()?;
+
+    let store_path = "/home/me/.mize".to_owned();
+
+    let config = instance.get("0/config")?.as_data_full()?;
+
+    test_println!("data at 0/config: {}", config);
+
+    instance.set_blocking("0/config/store_path", store_path.clone().into_item_data())?;
+
+    let store_path_new = instance.get("0/config/store_path")?.value_string()?;
+
+    assert_eq!(store_path_new, store_path);
+
+    Ok(())
+}
+
 #[test]
 fn test_set_sub_path() -> MizeResult<()> {
     let instance = Instance::empty()?;

src/core/item.rs

@@ -15,6 +15,7 @@ use crate::error::{MizeError, MizeResult, IntoMizeResult};
 use crate::instance::{connection, Instance};
 use crate::instance::store::Store;
 use crate::id::MizeId;
+use crate::mize_err;
 use crate::proto::MizeMessage;
 use ciborium::Value as CborValue;
 use crate::instance::connection::value_raw_con_by_id;
@@ -65,12 +66,13 @@ impl Item<'_> {
                     let namespace_inner = self.instance.namespace.lock()?;
                     return Ok(ItemData::from_string(namespace_inner.as_real_string()));
                 },
-                "self_namespace" => { 
+                "self_namespace" => {
                     let namespace_inner = self.instance.self_namespace.lock()?;
                     return Ok(ItemData::from_string(namespace_inner.as_real_string()));
                 },
                 _ => {},
             }
+            return Err(mize_err!("a /self path, but the next element in the path '{:?}' is not valid", id.nth_part(1)));
         }
 
         let self_namespace_inner = self.instance.self_namespace.lock()?;
@@ -258,7 +260,7 @@ pub fn item_data_set_path(data: &mut CborValue, path: Vec<String>, data_to_set:
     //trace!("[ {} ] path: {:?}", "ARG".yellow(), path);
     //trace!("[ {} ] data_to_set: {}", "ARG".yellow(), data_to_set.clone().into_item_data());
 
-    test_println!("###########################");
+    test_println!("item_data_set_path ###########################");
     test_println!("data: {}", ItemData::from_cbor(data.clone()));
     test_println!("path: {:?}", path);
     test_println!("data_to_set: {}", ItemData::from_cbor(data_to_set.clone()));
@@ -275,7 +277,7 @@ pub fn item_data_set_path(data: &mut CborValue, path: Vec<String>, data_to_set:
     };
     match data {
         CborValue::Map(ref mut map) => {
-            for (key, val) in map {
+            for (key, val) in &mut * map {
                 if let CborValue::Text(key_str) = key {
                     if key_str == &path_el {
                         //path_iter.next();
@@ -283,6 +285,12 @@ pub fn item_data_set_path(data: &mut CborValue, path: Vec<String>, data_to_set:
                     }
                 }
             }
+
+            // if we get here, that means, the key (which is the variable path_el) does not exist
+            // in the map
+            // so add it
+            map.push((CborValue::Text(path_el.clone()), data_to_set.to_owned()));
+            return Ok(());
         },
         CborValue::Null => {
             let mut inner_value = CborValue::Null;