From 19573502d2ed3c9de58a52291a6303117051e910 Mon Sep 17 00:00:00 2001 From: Sebastian Moser Date: Mon, 18 May 2026 18:22:32 +0200 Subject: [PATCH] fixed some stuff --- md | 17 +- packages/ac_mize_macros/src/lib.rs | 3 +- packages/marts/auth/client.rs | 6 +- packages/marts/c2vi/mod.rs | 5 +- packages/mize/src/core/instance/mod.rs | 2 +- packages/mize/src/core/item.rs | 10 +- packages/mize/src/platform/os/fsstore.rs | 3 + packages/mize/src/platform/os/logging.rs | 423 +++++++------------ packages/mize/src/platform/os/mod.rs | 2 +- packages/mize/src/platform/os/unix_socket.rs | 2 +- 10 files changed, 172 insertions(+), 301 deletions(-) diff --git a/md b/md index b801083..aafc119 100755 --- a/md +++ b/md @@ -1,7 +1,7 @@ #!/bin/sh set -e -MIZE_SRC="/home/me/work/mize" # hardcoded for now +MIZE_SRC="/home/me/work/config/mize" # hardcoded for now RSYNC_EXCLUDES="--exclude=node_modules --exclude=target --exclude=mize_config.toml --exclude=rust_dist --exclude=deno_dist --exclude=dist --exclude=result --exclude=pkg" function main { @@ -63,15 +63,18 @@ EOF } function deploy_main { - cargo build --manifest-path $MIZE_SRC/packages/mize/Cargo.toml --release - cargo build --manifest-path $MIZE_SRC/packages/ppc/Cargo.toml --release --features desktop + mkdir -p ~/here/mize/lib + cargo build --manifest-path $MIZE_SRC/packages/mize/Cargo.toml + cargo build --manifest-path $MIZE_SRC/packages/ppc/Cargo.toml --features desktop - cp $MIZE_SRC/target/release/mize ~/here/mize/ - cp $MIZE_SRC/target/release/libppc_part.so ~/here/mize/ + systemctl --user stop mize + + cp $MIZE_SRC/target/debug/mize ~/here/mize/ + cp $MIZE_SRC/target/debug/libppc.so ~/here/mize/lib/libppc_part.so cp $MIZE_SRC/md ~/here/mize/ - cp $MIZE_SRC/target/release/ppc ~/here/mize/ + cp $MIZE_SRC/target/debug/ppc ~/here/mize/ - systemctl --user restart mize + systemctl --user start mize } function deploy_mac { diff --git a/packages/ac_mize_macros/src/lib.rs b/packages/ac_mize_macros/src/lib.rs index 72be2c5..02859fc 100644 --- a/packages/ac_mize_macros/src/lib.rs +++ b/packages/ac_mize_macros/src/lib.rs @@ -33,7 +33,7 @@ pub fn mize_part(attr: TokenStream, item: TokenStream) -> TokenStream { .into(); } - let part_getter_fn_name_str = format!("get_mize_part_{}", part_name); + let part_getter_fn_name_str = format!("make_mize_part_{}", part_name); let part_getter_fn_name = syn::Ident::new(&part_getter_fn_name_str, struct_name.span()); let expanded = quote! { @@ -72,6 +72,7 @@ pub fn mize_part(attr: TokenStream, item: TokenStream) -> TokenStream { impl MizePartCreateThisSucks for #struct_name {} // the function to get the part from a .so file + #[unsafe(no_mangle)] extern "C" fn #part_getter_fn_name(part: &mut Box, mut mize: Mize) { #struct_name::create_this_sucks(&mut mize); } diff --git a/packages/marts/auth/client.rs b/packages/marts/auth/client.rs index 42e7f93..65b9aa6 100644 --- a/packages/marts/auth/client.rs +++ b/packages/marts/auth/client.rs @@ -186,8 +186,10 @@ fn write_secrets(mize: &mut Mize, secrets: &ClientSecrets) -> MizeResult<()> { // update the spacetimedb_token in XDG_CONFIG_HOME/spacetime/cli.toml config file if configured to do so if mize - .get_config("auth.client.update_spacetime_token")? - .value_bool()? + .get_config("auth.client.update_spacetime_token") + .unwrap_or(ItemData::empty()) + .as_bool() + .unwrap_or(false) { update_spacetimedb_token(&secrets.id_token.as_str())?; } diff --git a/packages/marts/c2vi/mod.rs b/packages/marts/c2vi/mod.rs index 1882855..730445d 100644 --- a/packages/marts/c2vi/mod.rs +++ b/packages/marts/c2vi/mod.rs @@ -2,6 +2,8 @@ use std::sync::Mutex; use chrono::{Timelike, Utc}; use clap::{Arg, Command}; +#[cfg(feature = "desktop")] +use mize::item::ItemData; use rusqlite::{params, Connection}; use serde_json::{json, Value}; @@ -56,7 +58,8 @@ impl C2vi { pub fn c2vi(mize: &mut Mize) -> MizeResult<()> { #[cfg(feature = "desktop")] if mize - .get_config("c2vi.dash.enable")? + .get_config("c2vi.dash.enable") + .unwrap_or(ItemData::empty()) .as_bool() .unwrap_or(false) { diff --git a/packages/mize/src/core/instance/mod.rs b/packages/mize/src/core/instance/mod.rs index a755318..18fcd3c 100644 --- a/packages/mize/src/core/instance/mod.rs +++ b/packages/mize/src/core/instance/mod.rs @@ -613,7 +613,7 @@ impl Mize { let ns_of_peer_str = self .get(format!( - "inst/con_by_id/{}/peer/0/config/namespace", + "inst/con_by_id/{}/peer/self/config/namespace", conn_id ))? .value_string()?; diff --git a/packages/mize/src/core/item.rs b/packages/mize/src/core/item.rs index 86f2697..a8a5c09 100644 --- a/packages/mize/src/core/item.rs +++ b/packages/mize/src/core/item.rs @@ -79,13 +79,9 @@ impl Item<'_> { .skip(2) .map(|v| v.to_owned()) .collect::>() - .join("/"); - let id_for_store = self - .instance - .new_id("0/config".to_owned() + "/" + rest_path.as_str())?; - let store = self.instance.store.lock()?; - let data = store.get_value_data_full(id_for_store)?; - return Ok(data); + .join("."); + let mut mize = self.instance.to_owned(); + return Ok(mize.get_config(rest_path.as_str())?); } _ => {} } diff --git a/packages/mize/src/platform/os/fsstore.rs b/packages/mize/src/platform/os/fsstore.rs index 465a2b2..17f6cc1 100644 --- a/packages/mize/src/platform/os/fsstore.rs +++ b/packages/mize/src/platform/os/fsstore.rs @@ -173,7 +173,10 @@ impl Store for FileStore { let mut path_iter = tmp.into_iter(); path_iter.next(); let new_path: Vec = path_iter.map(|v| v.to_owned()).collect(); + //println!("data: {}", data); + //println!("new_path: {:?}", new_path); let ret_data = data.get_path(new_path)?; + //println!("ret_data: {}", ret_data); return Ok(ret_data); } diff --git a/packages/mize/src/platform/os/logging.rs b/packages/mize/src/platform/os/logging.rs index e315ef4..025ec61 100644 --- a/packages/mize/src/platform/os/logging.rs +++ b/packages/mize/src/platform/os/logging.rs @@ -1,92 +1,136 @@ +use clap::{crate_version, Arg, Command}; +use clap::{ArgAction, ArgMatches}; use std::collections::HashMap; use std::path::PathBuf; -use clap::{ArgAction, ArgMatches}; -use clap::{Arg, crate_version, Command}; -use tokio::sync::mpsc; -use std::sync::Mutex; -use std::sync::Arc; use colored::Colorize; -use std::env; -use tracing::{span_enabled, Instrument, Level}; -use tracing::level_filters::LevelFilter; -use tracing_subscriber::filter::EnvFilter; -use tracing_subscriber::fmt::FormatEvent; -use tracing_subscriber::registry::LookupSpan; -use tracing_subscriber::fmt::FormatFields; -use tracing_subscriber::fmt::FmtContext; -use tracing_subscriber::fmt::format; -use tracing::Event; use core::fmt; -use tracing_subscriber::fmt::FormattedFields; -use tracing::{trace, debug, info, warn, error}; -use std::sync::atomic::AtomicUsize; -use tracing::{field::Visit, Id, Subscriber}; -use tracing_core::Field; +use std::env; use std::fmt::Write; +use std::sync::atomic::AtomicUsize; +use std::sync::Arc; +use std::sync::Mutex; +use tokio::sync::mpsc; +use tracing::level_filters::LevelFilter; +use tracing::Event; +use tracing::{debug, error, info, trace, warn}; +use tracing::{field::Visit, Id, Subscriber}; +use tracing::{span_enabled, Instrument, Level}; +use tracing_core::Field; +use tracing_subscriber::filter::EnvFilter; +use tracing_subscriber::fmt::format; +use tracing_subscriber::fmt::FmtContext; +use tracing_subscriber::fmt::FormatEvent; +use tracing_subscriber::fmt::FormatFields; +use tracing_subscriber::fmt::FormattedFields; +use tracing_subscriber::registry::LookupSpan; -use crate::MizeError; -use crate::MizeResult; use crate::id::MizeId; use crate::item::ItemData; +use crate::MizeError; +use crate::MizeResult; static DEFAULT_LOG_LEVEL: LevelFilter = LevelFilter::WARN; pub fn init_logger(cli_matches: &ArgMatches) { - + println!("init_logger called"); // to save log messages, before the logger is setup let mut log_messages: Vec<(Level, String)> = Vec::new(); log_messages.push((Level::INFO, "Starting Mize".to_owned())); // builder with DEFAULT_LOG_LEVEL - //let mut builder = tracing_subscriber::fmt::Subscriber::builder(); + let mut builder = tracing_subscriber::fmt::Subscriber::builder(); // set loglevel let mut log_level = DEFAULT_LOG_LEVEL; - log_messages.push((Level::TRACE, format!("set log level from DEFAULT_LOG_LEVEL to {}", DEFAULT_LOG_LEVEL))); + log_messages.push(( + Level::TRACE, + format!( + "set log level from DEFAULT_LOG_LEVEL to {}", + DEFAULT_LOG_LEVEL + ), + )); // check env RUST_LOG let mut val_rust_log = level_from_env("RUST_LOG", log_level); if let Some(level_rust_log) = val_rust_log.0 { log_level = level_rust_log; - log_messages.push((Level::TRACE, format!("set log level from the Variable RUST_LOG to {}", level_rust_log))); + log_messages.push(( + Level::TRACE, + format!( + "set log level from the Variable RUST_LOG to {}", + level_rust_log + ), + )); } log_messages.append(&mut val_rust_log.1); + // check env LOG + let mut val_mize_log = level_from_env("LOG", log_level); + if let Some(level_mize_log) = val_mize_log.0 { + println!("set log level from the Variable LOG to {}", level_mize_log); + log_level = level_mize_log; + log_messages.push(( + Level::TRACE, + format!( + "set log level from the Variable MIZE_LOG to {}", + level_mize_log + ), + )); + } + log_messages.append(&mut val_mize_log.1); + // check env MIZE_LOG let mut val_mize_log = level_from_env("MIZE_LOG", log_level); if let Some(level_mize_log) = val_mize_log.0 { log_level = level_mize_log; - log_messages.push((Level::TRACE, format!("set log level from the Variable MIZE_LOG to {}", level_mize_log))); + log_messages.push(( + Level::TRACE, + format!( + "set log level from the Variable MIZE_LOG to {}", + level_mize_log + ), + )); } log_messages.append(&mut val_mize_log.1); // check -vvvvv flags let v_flag_count = cli_matches.get_count("verbose"); - let default_log_level_as_num = match DEFAULT_LOG_LEVEL { - LevelFilter::OFF => 0, - LevelFilter::ERROR => 1, - LevelFilter::WARN => 2, - LevelFilter::INFO => 3, - LevelFilter::DEBUG => 4, - LevelFilter::TRACE => 5, - }; - let new_log_level_num = default_log_level_as_num + v_flag_count; - log_level = match new_log_level_num { - 0 => LevelFilter::OFF, - 1 => LevelFilter::ERROR, - 2 => LevelFilter::WARN, - 3 => LevelFilter::INFO, - 4 => LevelFilter::DEBUG, - 5 => LevelFilter::TRACE, - _ => { - log_messages.push((Level::TRACE, format!("the number of verbose (-v) flags passed ({}) exeeds the maximumg log_level", v_flag_count))); - LevelFilter::TRACE - }, - }; - log_messages.push((Level::TRACE, format!("set log level from the verbose flags to {}", log_level))); - + if v_flag_count > 0 { + let default_log_level_as_num = match DEFAULT_LOG_LEVEL { + LevelFilter::OFF => 0, + LevelFilter::ERROR => 1, + LevelFilter::WARN => 2, + LevelFilter::INFO => 3, + LevelFilter::DEBUG => 4, + LevelFilter::TRACE => 5, + }; + let new_log_level_num = default_log_level_as_num + v_flag_count; + log_level = match new_log_level_num { + 0 => LevelFilter::OFF, + 1 => LevelFilter::ERROR, + 2 => LevelFilter::WARN, + 3 => LevelFilter::INFO, + 4 => LevelFilter::DEBUG, + 5 => LevelFilter::TRACE, + _ => { + log_messages.push(( + Level::TRACE, + format!( + "the number of verbose (-v) flags passed ({}) exeeds the maximumg log_level", + v_flag_count + ), + )); + LevelFilter::TRACE + } + }; + log_messages.push(( + Level::TRACE, + format!("set log level from the verbose flags to {}", log_level), + )); + } + // check --log-level arg if let Some(log_level_arg_string) = cli_matches.get_one::("log-level") { let log_level_from_arg = match log_level_arg_string.to_owned().to_lowercase().as_str() { @@ -106,7 +150,13 @@ pub fn init_logger(cli_matches: &ArgMatches) { } }; log_level = log_level_from_arg; - log_messages.push((Level::TRACE, format!("set log level from the --log-level arg to {}", log_level_from_arg))); + log_messages.push(( + Level::TRACE, + format!( + "set log level from the --log-level arg to {}", + log_level_from_arg + ), + )); } // check --silent flag @@ -124,21 +174,30 @@ pub fn init_logger(cli_matches: &ArgMatches) { // filter loging //let mut my_env_filter = tracing_subscriber::filter::EnvFilter::new("") - //.add_directive("[get_raw_from_cbor]=debug".parse().expect("error parsing log directive")) - //.add_directive("[MemStore::get_value_raw]=trace".parse().expect("error parsing log directive")) - //.add_directive("trace".parse().unwrap()) - //.add_directive("[get_raw_from_cbor]=debug".parse().expect("error parsing log directive")) + //.add_directive("[get_raw_from_cbor]=debug".parse().expect("error parsing log directive")) + //.add_directive("[MemStore::get_value_raw]=trace".parse().expect("error parsing log directive")) + //.add_directive("trace".parse().unwrap()) + //.add_directive("[get_raw_from_cbor]=debug".parse().expect("error parsing log directive")) //; - MinimalTracer::register(); + //MinimalTracer::register(); - //builder + println!("log_level: {}", log_level); + let field_formatter = tracing_subscriber::fmt::format::debug_fn(|writer, field, value| { + if field.name() == "message" { + write!(writer, "{:?}", value)?; + } else { + write!(writer, "{}={:?}", field, value)?; + } + Ok(()) + }); + builder //.with_env_filter(my_env_filter) - //.without_time() - //.event_format(MyFormatter) - //.with_max_level(log_level) - //.init(); - + .without_time() + .event_format(MyFormatter) + .fmt_fields(field_formatter) + .with_max_level(log_level) + .init(); // write out all log messages from log_messages for (level, msg) in log_messages { @@ -152,9 +211,14 @@ pub fn init_logger(cli_matches: &ArgMatches) { } } -fn level_from_env(var_name: &str, log_level: LevelFilter) -> (Option, Vec<(Level, String)>) { +fn level_from_env( + var_name: &str, + log_level: LevelFilter, +) -> (Option, Vec<(Level, String)>) { let mut log_messages: Vec<(Level, String)> = Vec::new(); let var_value = env::var(var_name); + println!("checking env var: {}={:?}", var_name, var_value); + match var_value { Ok(val) => { // set loglevel acording to RUST_LOG @@ -175,15 +239,17 @@ fn level_from_env(var_name: &str, log_level: LevelFilter) -> (Option {}, + return (Some(level), log_messages); + } + Err(env::VarError::NotPresent) => {} Err(env::VarError::NotUnicode(os_string)) => { - - let os_string_as_hex : String = os_string.clone().into_encoded_bytes().iter() - .map(|b| format!("{:02x}", b).to_string()) - .collect::>() - .join(""); + let os_string_as_hex: String = os_string + .clone() + .into_encoded_bytes() + .iter() + .map(|b| format!("{:02x}", b).to_string()) + .collect::>() + .join(""); log_messages.push((Level::DEBUG, format!( "value of Environment Variable {} was not a unicode valid string. Therefore ignoring it. \n value with replacement char U+FFFD: {} @@ -191,12 +257,11 @@ fn level_from_env(var_name: &str, log_level: LevelFilter) -> (Option FormatEvent for MyFormatter @@ -214,13 +279,9 @@ where let metadata = event.metadata(); - // set format - /* - builder.format(|buf, record| { - match record.level() { - } - }); - */ + // set format + //builder.format(|buf, record| match record.level() {}); + let level_str = match metadata.level() { &Level::TRACE => format!("[ {} ]", "TRACE".yellow()), &Level::DEBUG => format!("[ {} ]", "DEBUG".green()), @@ -260,7 +321,8 @@ where // Write fields on the event ctx.field_format().format_fields(writer.by_ref(), event)?; - writeln!(writer) + writeln!(writer); + Ok(()) } } @@ -289,17 +351,6 @@ struct LogFilter { level: Option, } -pub struct MinimalTracer { - enabled: bool, - filters: Vec, - level: Arc>, - spans: Arc>>, - span_levels: Arc>>, - span_names: Arc>>, - span_names_to_enable: Arc>>, - level_no_span: Level, -} - fn string_to_level(string: &str) -> Option { match string.to_lowercase().as_str() { "info" => Some(Level::INFO), @@ -310,191 +361,3 @@ fn string_to_level(string: &str) -> Option { _ => None, } } - -impl MinimalTracer { - pub fn register() -> Result<(), tracing::subscriber::SetGlobalDefaultError> { - let mut enabled = true; - let mut span_names_to_enable = Vec::new(); - let mut my_level = Level::ERROR; - - let mut filters: Vec = Vec::with_capacity(10); - if let Ok(env_value) = env::var("RUST_LOG") { - for filter in env_value.split(',') { - let mut target = Some(filter); - let mut level = None; - if let Some(equals_index) = target.unwrap().find('=') { - let (first, second) = filter.split_at(equals_index); - target = Some(first); - level = string_to_level(&second[1..]) - } else { - my_level = string_to_level(target.unwrap()).unwrap(); - } - let target_level = string_to_level(target.unwrap()); - - //if let Some(target_level) = target_level { - //level = Some(target_level); - //target = None; - //} - - // in case target is a span name, add id to span_names_to_enable - // for now every target is also a span_name..... - // i would think everything, that contains a "." would be a span, and not a module - // targeet - if let Some(name) = target { - span_names_to_enable.push(name.to_owned()); - } - - filters.push(LogFilter { - target: target.map(|v| v.to_string()), - level, - }); - } - } else { - enabled = false; - } - - tracing::subscriber::set_global_default(MinimalTracer { - enabled, filters, - spans: Arc::new(Mutex::new(Vec::new())), - level: Arc::new(Mutex::new(my_level)), - span_names: Arc::new(Mutex::new(HashMap::new())), - span_names_to_enable: Arc::new(Mutex::new(span_names_to_enable)), - span_levels: Arc::new(Mutex::new(HashMap::new())), - level_no_span: my_level, - }) - } -} - -static AUTO_ID: AtomicUsize = AtomicUsize::new(1); - -impl Subscriber for MinimalTracer { - fn enabled(&self, metadata: &tracing::Metadata<'_>) -> bool { - return true; - - if metadata.is_span() { - return true; - let mut span_names_to_enable = self.span_names_to_enable.lock().unwrap(); - if span_names_to_enable.contains(&metadata.name().to_owned()) { - return true; - } - } - - if self.enabled { - if self.filters.is_empty() { - return true; - } - - let mut matches: bool; - for filter in &self.filters { - matches = true; - if let Some(level) = filter.level { - if metadata.level() != &level { - matches = false; - } - } - if let Some(target) = &filter.target { - if !metadata.target().starts_with(target) { - matches = false; - } - } - if matches { - return true; - } - } - return false; - } - false - } - - fn new_span(&self, _span: &tracing_core::span::Attributes<'_>) -> tracing_core::span::Id { - let mut span_names = self.span_names.lock().unwrap(); - let mut span_levels = self.span_levels.lock().unwrap(); - let mut span_names_to_enable = self.span_names_to_enable.lock().unwrap(); - - let id = Id::from_u64(AUTO_ID.fetch_add(1, std::sync::atomic::Ordering::Relaxed) as u64); - let span_name = _span.metadata().name().to_string(); - - span_names.insert(id.clone(), span_name.clone()); - if span_names_to_enable.contains(&span_name) { - span_levels.insert(id.clone(), Level::TRACE); - } else { - span_levels.insert(id.clone(), Level::ERROR); - } - - id - } - - fn record(&self, _span: &tracing_core::span::Id, _values: &tracing_core::span::Record<'_>) { - } - - fn record_follows_from( - &self, - _span: &tracing_core::span::Id, - _follows: &tracing_core::span::Id, - ) { - } - - fn event(&self, event: &tracing::Event<'_>) { - let metadata = event.metadata(); - - let level = metadata.level(); - let my_level = self.level.lock().unwrap(); - - //println!("uuuuuuuuuuuu event name: {}", metadata.name()); - //println!("uuuuuuuuuuuu my_level: {}", my_level); - //println!("uuuuuuuuuuuu event level: {}", level); - - if *level > *my_level { - //println!("uuuuuuuuuuuu comparison"); - //println!("BLOCKED EVENT") - return; - } - - let target = metadata.target(); - - let mut text = String::new(); - - let mut visitor = StringVisitor::new(&mut text); - event.record(&mut visitor); - - let level_str = match metadata.level() { - &Level::TRACE => format!("[ {} ]", "TRACE".yellow()), - &Level::DEBUG => format!("[ {} ]", "DEBUG".green()), - &Level::INFO => format!("[ {} ]", "INFO".blue()), - &Level::WARN => format!("[ {} ]", "WARN".truecolor(245, 164, 66)), - &Level::ERROR => format!("[ {} ]", "ERROR".red()), - }; - - //println!("{} {:?}", "META:".red(), metadata.in_current_span()); - let mut spans = self.spans.lock().unwrap(); - let mut span_names = self.span_names.lock().unwrap(); - let span_text = spans.iter() - .map(|id| span_names.get(id).unwrap().to_owned()) - .collect::>() - .join("::"); - println!("{level_str} {span_text} {text}"); - } - - fn enter(&self, _span: &tracing_core::span::Id) { - //println!("eeeeeeeeeeeeeeeee enter"); - let mut spans = self.spans.lock().unwrap(); - let mut level = self.level.lock().unwrap(); - let mut span_levels = self.span_levels.lock().unwrap(); - let mut span_names = self.span_names.lock().unwrap(); - - let name = span_names.get(_span).unwrap().to_owned(); - *level = span_levels.get(_span).unwrap().to_owned(); - spans.push(_span.clone()); - //println!("my_level is now: {}", level); - } - - fn exit(&self, _span: &tracing_core::span::Id) { - //println!("eeeeeeeeeeeeeeeee exit"); - - let mut level = self.level.lock().unwrap(); - *level = self.level_no_span; - - let mut spans = self.spans.lock().unwrap(); - spans.pop(); - } -} diff --git a/packages/mize/src/platform/os/mod.rs b/packages/mize/src/platform/os/mod.rs index bfd54df..868fea0 100644 --- a/packages/mize/src/platform/os/mod.rs +++ b/packages/mize/src/platform/os/mod.rs @@ -64,7 +64,7 @@ pub fn os_instance_init(mize: &mut Mize) -> MizeResult<()> { ////// if a config.store_path is set, upgrade to the filestore there let mut test = mize.get("0")?.as_data_full()?; - let mut store_path = match mize.get("self/config/store_path")?.value_string() { + let mut store_path = match mize.get("self/config/store")?.value_string() { Ok(path) => path, Err(e) => { // the default store_path: $HOME/.mize diff --git a/packages/mize/src/platform/os/unix_socket.rs b/packages/mize/src/platform/os/unix_socket.rs index 9040abd..0df4fef 100644 --- a/packages/mize/src/platform/os/unix_socket.rs +++ b/packages/mize/src/platform/os/unix_socket.rs @@ -32,7 +32,7 @@ pub fn connect(instance: &mut Mize, store_path: PathBuf) -> MizeResult<()> { let ns_of_peer_str = instance .get(format!( - "inst/con_by_id/{}/peer/0/config/namespace", + "inst/con_by_id/{}/peer/self/config/namespace", conn_id ))? .value_string()?;