ppc/ppc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fixed some stuff

Browse Source
This commit is contained in:
Sebastian Moser
2026-05-18 18:22:32 +02:00
parent d1ddb405c8
commit 19573502d2
10 changed files with 172 additions and 301 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
md
View File

@@ -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 {

3
packages/ac_mize_macros/src/lib.rs
View File

@@ -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<dyn MizePart + Send + Sync>, mut mize: Mize) {
#struct_name::create_this_sucks(&mut mize);
}

6
packages/marts/auth/client.rs
View File

@@ -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())?;
}

5
packages/marts/c2vi/mod.rs
View File

@@ -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)
{

2
packages/mize/src/core/instance/mod.rs
View File

@@ -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()?;

10
packages/mize/src/core/item.rs
View File

@@ -79,13 +79,9 @@ impl Item<'_> {
.skip(2)
.map(|v| v.to_owned())
.collect::<Vec<String>>()
.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())?);
}
_ => {}
}

3
packages/mize/src/platform/os/fsstore.rs
View File

@@ -173,7 +173,10 @@ impl Store for FileStore {
let mut path_iter = tmp.into_iter();
path_iter.next();
let new_path: Vec<String> = 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);
}

421
packages/mize/src/platform/os/logging.rs
View File

@@ -1,91 +1,135 @@
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::<String>("log-level") {
@@ -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<LevelFilter>, Vec<(Level, String)>) {
fn level_from_env(
var_name: &str,
log_level: LevelFilter,
) -> (Option<LevelFilter>, 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<LevelFilter
log_level
}
};
return (Some(level), log_messages)
},
Err(env::VarError::NotPresent) => {},
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::<Vec<String>>()
.join("");
let os_string_as_hex: String = os_string
.clone()
.into_encoded_bytes()
.iter()
.map(|b| format!("{:02x}", b).to_string())
.collect::<Vec<String>>()
.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<LevelFilter
, var_name
, os_string.to_string_lossy(), os_string_as_hex
)));
},
}
};
return (None, log_messages);
}
struct MyFormatter;
impl<S, N> FormatEvent<S, N> 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<Level>,
}
pub struct MinimalTracer {
enabled: bool,
filters: Vec<LogFilter>,
level: Arc<Mutex<Level>>,
spans: Arc<Mutex<Vec<Id>>>,
span_levels: Arc<Mutex<HashMap<Id, Level>>>,
span_names: Arc<Mutex<HashMap<Id, String>>>,
span_names_to_enable: Arc<Mutex<Vec<String>>>,
level_no_span: Level,
}
fn string_to_level(string: &str) -> Option<Level> {
match string.to_lowercase().as_str() {
"info" => Some(Level::INFO),
@@ -310,191 +361,3 @@ fn string_to_level(string: &str) -> Option<Level> {
_ => 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<LogFilter> = 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::<Vec<String>>()
.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();
}
}

2
packages/mize/src/platform/os/mod.rs
View File

@@ -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

2
packages/mize/src/platform/os/unix_socket.rs
View File

@@ -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()?;