Git-Mirrors/veilid
1
0
Fork 0
mirror of https://gitlab.com/veilid/veilid.git synced 2025-03-22 22:06:34 -04:00
Code Issues Packages Projects Releases Wiki Activity

refactor checkpoint

Browse Source
This commit is contained in:
John Smith 2022-06-07 21:31:05 -04:00
parent 182af30b97
commit 1d8c63786a
28 changed files with 822 additions and 626 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

288
Cargo.lock generated
View File

@ -131,14 +131,20 @@ dependencies = [
"log", "log",
] ]
[[package]]
name = "ansi_term"
version = "0.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2"
dependencies = [
"winapi",
]
[[package]] [[package]]
name = "anyhow" name = "anyhow"
version = "1.0.56" version = "1.0.56"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4361135be9122e0870de935d7c439aef945b9f9ddd4199a553b5270b49c82a27" checksum = "4361135be9122e0870de935d7c439aef945b9f9ddd4199a553b5270b49c82a27"
dependencies = [
"backtrace",
]
[[package]] [[package]]
name = "arraydeque" name = "arraydeque"
@ -738,7 +744,7 @@ dependencies = [
"libc", "libc",
"num-integer", "num-integer",
"num-traits 0.2.14", "num-traits 0.2.14",
"time", "time 0.1.43",
"winapi", "winapi",
] ]
@ -795,6 +801,33 @@ dependencies = [
"bitflags", "bitflags",
] ]
[[package]]
name = "color-eyre"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8ebf286c900a6d5867aeff75cfee3192857bb7f24b547d4f0df2ed6baa812c90"
dependencies = [
"backtrace",
"color-spantrace",
"eyre",
"indenter",
"once_cell",
"owo-colors",
"tracing-error",
]
[[package]]
name = "color-spantrace"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1ba75b3d9449ecdccb27ecbc479fdc0b87fa2dd43d2f8298f9bf0e59aacc8dce"
dependencies = [
"once_cell",
"owo-colors",
"tracing-core",
"tracing-error",
]
[[package]] [[package]]
name = "combine" name = "combine"
version = "4.6.3" version = "4.6.3"
@ -1274,7 +1307,6 @@ checksum = "f2fb860ca6fafa5552fb6d0e816a69c8e49f0908bf524e30a90d97c85892d506"
dependencies = [ dependencies = [
"block-buffer 0.10.2", "block-buffer 0.10.2",
"crypto-common", "crypto-common",
"subtle",
] ]
[[package]] [[package]]
@ -1324,7 +1356,7 @@ dependencies = [
"curve25519-dalek", "curve25519-dalek",
"ed25519", "ed25519",
"rand 0.7.3", "rand 0.7.3",
"sha2 0.9.9", "sha2",
"zeroize", "zeroize",
] ]
@ -1466,6 +1498,16 @@ version = "2.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77f3309417938f28bf8228fcff79a4a37103981e3e186d2ccd19c74b38f4eb71" checksum = "77f3309417938f28bf8228fcff79a4a37103981e3e186d2ccd19c74b38f4eb71"
[[package]]
name = "eyre"
version = "0.6.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4c2b6b5a29c02cdc822728b7d7b8ae1bab3e3b05d44522770ddd49722eeac7eb"
dependencies = [
"indenter",
"once_cell",
]
[[package]] [[package]]
name = "failure" name = "failure"
version = "0.1.8" version = "0.1.8"
@ -1847,7 +1889,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "51ab2f639c231793c5f6114bdb9bbe50a7dbbfcd7c7c6bd8475dec2d991e964f" checksum = "51ab2f639c231793c5f6114bdb9bbe50a7dbbfcd7c7c6bd8475dec2d991e964f"
dependencies = [ dependencies = [
"digest 0.9.0", "digest 0.9.0",
"hmac 0.10.1", "hmac",
] ]
[[package]] [[package]]
@ -1860,15 +1902,6 @@ dependencies = [
"digest 0.9.0", "digest 0.9.0",
] ]
[[package]]
name = "hmac"
version = "0.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
dependencies = [
"digest 0.10.3",
]
[[package]] [[package]]
name = "hostname" name = "hostname"
version = "0.3.1" version = "0.3.1"
@ -1962,6 +1995,12 @@ dependencies = [
"syn", "syn",
] ]
[[package]]
name = "indenter"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ce23b50ad8242c51a442f3ff322d56b02f08852c77e4c0b4d3fd684abc89c683"
[[package]] [[package]]
name = "indexmap" name = "indexmap"
version = "1.8.0" version = "1.8.0"
@ -2239,24 +2278,6 @@ dependencies = [
"vcpkg", "vcpkg",
] ]
[[package]]
name = "libsystemd"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8144587c71c16756b1055d3dcb0c75cb605a10ecd6523cc33702d5f90902bf6d"
dependencies = [
"hmac 0.12.1",
"libc",
"log",
"nix 0.23.1",
"nom 7.1.0",
"once_cell",
"serde 1.0.136",
"sha2 0.10.2",
"thiserror",
"uuid",
]
[[package]] [[package]]
name = "linked-hash-map" name = "linked-hash-map"
version = "0.3.0" version = "0.3.0"
@ -2331,6 +2352,15 @@ version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ffbee8634e0d45d258acb448e7eaab3fce7a0a467395d4d9f228e3c1f01fb2e4" checksum = "ffbee8634e0d45d258acb448e7eaab3fce7a0a467395d4d9f228e3c1f01fb2e4"
[[package]]
name = "matchers"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558"
dependencies = [
"regex-automata",
]
[[package]] [[package]]
name = "matches" name = "matches"
version = "0.1.9" version = "0.1.9"
@ -2754,6 +2784,15 @@ dependencies = [
"syn", "syn",
] ]
[[package]]
name = "num_threads"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2819ce041d2ee131036f4fc9d6ae7ae125a3a40e97ba64d04fe799ad9dabbb44"
dependencies = [
"libc",
]
[[package]] [[package]]
name = "object" name = "object"
version = "0.27.1" version = "0.27.1"
@ -3335,6 +3374,9 @@ name = "regex-automata"
version = "0.1.10" version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132" checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
dependencies = [
"regex-syntax",
]
[[package]] [[package]]
name = "regex-syntax" name = "regex-syntax"
@ -3590,7 +3632,7 @@ dependencies = [
"num 0.3.1", "num 0.3.1",
"rand 0.8.5", "rand 0.8.5",
"serde 1.0.136", "serde 1.0.136",
"sha2 0.9.9", "sha2",
"zbus", "zbus",
"zbus_macros", "zbus_macros",
"zvariant", "zvariant",
@ -3839,14 +3881,12 @@ dependencies = [
] ]
[[package]] [[package]]
name = "sha2" name = "sharded-slab"
version = "0.10.2" version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "55deaec60f81eefe3cce0dc50bda92d6d8e88f2a27df7c5033b42afeb1ed2676" checksum = "900fba806f70c630b0a382d0d825e17a0f19fcd059a2ade1ff237bcddf446b31"
dependencies = [ dependencies = [
"cfg-if 1.0.0", "lazy_static",
"cpufeatures 0.2.1",
"digest 0.10.3",
] ]
[[package]] [[package]]
@ -4023,16 +4063,6 @@ dependencies = [
"winapi", "winapi",
] ]
[[package]]
name = "systemd-journal-logger"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c2b2b2ff370208ad472629786a66dc252933843755a1d620a54a8fdd0fccb31f"
dependencies = [
"libsystemd",
"log",
]
[[package]] [[package]]
name = "tap" name = "tap"
version = "1.0.1" version = "1.0.1"
@ -4097,6 +4127,15 @@ dependencies = [
"syn", "syn",
] ]
[[package]]
name = "thread_local"
version = "1.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5516c27b78311c50bf42c071425c560ac799b11c30b31f87e3081965fe5e0180"
dependencies = [
"once_cell",
]
[[package]] [[package]]
name = "time" name = "time"
version = "0.1.43" version = "0.1.43"
@ -4107,6 +4146,17 @@ dependencies = [
"winapi", "winapi",
] ]
[[package]]
name = "time"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c2702e08a7a860f005826c6815dcac101b19b5eb330c27fe4a5928fec1d20ddd"
dependencies = [
"itoa 1.0.1",
"libc",
"num_threads",
]
[[package]] [[package]]
name = "tiny-keccak" name = "tiny-keccak"
version = "2.0.2" version = "2.0.2"
@ -4161,6 +4211,112 @@ dependencies = [
"serde 1.0.136", "serde 1.0.136",
] ]
[[package]]
name = "tracing"
version = "0.1.34"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5d0ecdcb44a79f0fe9844f0c4f33a342cbcbb5117de8001e6ba0dc2351327d09"
dependencies = [
"cfg-if 1.0.0",
"log",
"pin-project-lite",
"tracing-attributes",
"tracing-core",
]
[[package]]
name = "tracing-appender"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "09d48f71a791638519505cefafe162606f706c25592e4bde4d97600c0195312e"
dependencies = [
"crossbeam-channel",
"time 0.3.9",
"tracing-subscriber",
]
[[package]]
name = "tracing-attributes"
version = "0.1.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cc6b8ad3567499f98a1db7a752b07a7c8c7c7c34c332ec00effb2b0027974b7c"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "tracing-core"
version = "0.1.26"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f54c8ca710e81886d498c2fd3331b56c93aa248d49de2222ad2742247c60072f"
dependencies = [
"lazy_static",
"valuable",
]
[[package]]
name = "tracing-error"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d686ec1c0f384b1277f097b2f279a2ecc11afe8c133c1aabf036a27cb4cd206e"
dependencies = [
"tracing",
"tracing-subscriber",
]
[[package]]
name = "tracing-journald"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ba316a74e8fc3c3896a850dba2375928a9fa171b085ecddfc7c054d39970f3fd"
dependencies = [
"libc",
"tracing-core",
"tracing-subscriber",
]
[[package]]
name = "tracing-log"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "78ddad33d2d10b1ed7eb9d1f518a5674713876e97e5bb9b7345a7984fbb4f922"
dependencies = [
"lazy_static",
"log",
"tracing-core",
]
[[package]]
name = "tracing-subscriber"
version = "0.3.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4bc28f93baff38037f64e6f43d34cfa1605f27a49c34e8a04c5e78b0babf2596"
dependencies = [
"ansi_term",
"lazy_static",
"matchers",
"regex",
"sharded-slab",
"smallvec",
"thread_local",
"tracing",
"tracing-core",
"tracing-log",
]
[[package]]
name = "tracing-wasm"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4575c663a174420fa2d78f4108ff68f65bf2fbb7dd89f33749b6e826b3626e07"
dependencies = [
"tracing",
"tracing-subscriber",
"wasm-bindgen",
]
[[package]] [[package]]
name = "trust-dns-proto" name = "trust-dns-proto"
version = "0.21.2" version = "0.21.2"
@ -4340,13 +4496,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9" checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
[[package]] [[package]]
name = "uuid" name = "valuable"
version = "0.8.2" version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bc5cf98d8186244414c848017f0e2676b3fcb46807f6668a97dfe67359a3c4b7" checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
dependencies = [
"serde 1.0.136",
]
[[package]] [[package]]
name = "value-bag" name = "value-bag"
@ -4399,7 +4552,6 @@ name = "veilid-core"
version = "0.1.0" version = "0.1.0"
dependencies = [ dependencies = [
"android_logger", "android_logger",
"anyhow",
"async-io", "async-io",
"async-lock", "async-lock",
"async-std", "async-std",
@ -4416,6 +4568,7 @@ dependencies = [
"chacha20", "chacha20",
"chacha20poly1305", "chacha20poly1305",
"chrono", "chrono",
"color-eyre",
"config 0.12.0", "config 0.12.0",
"console_error_panic_hook", "console_error_panic_hook",
"curve25519-dalek-ng", "curve25519-dalek-ng",
@ -4441,7 +4594,6 @@ dependencies = [
"keyvaluedb-web", "keyvaluedb-web",
"lazy_static", "lazy_static",
"libc", "libc",
"log",
"lru", "lru",
"maplit", "maplit",
"ndk", "ndk",
@ -4468,6 +4620,9 @@ dependencies = [
"socket2", "socket2",
"static_assertions", "static_assertions",
"thiserror", "thiserror",
"tracing",
"tracing-error",
"tracing-subscriber",
"wasm-bindgen", "wasm-bindgen",
"wasm-bindgen-futures", "wasm-bindgen-futures",
"wasm-bindgen-test", "wasm-bindgen-test",
@ -4487,17 +4642,17 @@ name = "veilid-flutter"
version = "0.1.0" version = "0.1.0"
dependencies = [ dependencies = [
"allo-isolate", "allo-isolate",
"anyhow",
"async-std", "async-std",
"backtrace", "backtrace",
"ffi-support", "ffi-support",
"futures", "futures",
"jni", "jni",
"lazy_static", "lazy_static",
"log",
"parking_lot 0.12.0", "parking_lot 0.12.0",
"serde 1.0.136", "serde 1.0.136",
"serde_json", "serde_json",
"tracing",
"tracing-subscriber",
"veilid-core", "veilid-core",
] ]
@ -4505,6 +4660,7 @@ dependencies = [
name = "veilid-server" name = "veilid-server"
version = "0.1.0" version = "0.1.0"
dependencies = [ dependencies = [
"ansi_term",
"async-std", "async-std",
"async-tungstenite 0.17.1", "async-tungstenite 0.17.1",
"bugsalot", "bugsalot",
@ -4521,7 +4677,6 @@ dependencies = [
"flume", "flume",
"futures", "futures",
"lazy_static", "lazy_static",
"log",
"nix 0.23.1", "nix 0.23.1",
"parking_lot 0.12.0", "parking_lot 0.12.0",
"rpassword 6.0.1", "rpassword 6.0.1",
@ -4531,8 +4686,10 @@ dependencies = [
"serial_test 0.6.0", "serial_test 0.6.0",
"signal-hook", "signal-hook",
"signal-hook-async-std", "signal-hook-async-std",
"simplelog", "tracing",
"systemd-journal-logger", "tracing-appender",
"tracing-journald",
"tracing-subscriber",
"url", "url",
"veilid-core", "veilid-core",
"windows-service", "windows-service",
@ -4547,10 +4704,11 @@ dependencies = [
"futures-util", "futures-util",
"js-sys", "js-sys",
"lazy_static", "lazy_static",
"log",
"send_wrapper", "send_wrapper",
"serde 1.0.136", "serde 1.0.136",
"serde_json", "serde_json",
"tracing-subscriber",
"tracing-wasm",
"veilid-core", "veilid-core",
"wasm-bindgen", "wasm-bindgen",
"wasm-bindgen-futures", "wasm-bindgen-futures",

6
veilid-core/Cargo.toml
View File

@ -15,12 +15,14 @@ ios_tests = [ "simplelog", "backtrace" ]
tracking = [ "backtrace" ] tracking = [ "backtrace" ]
[dependencies] [dependencies]
tracing = { version = "^0", features = ["log", "attributes"] }
tracing-subscriber = "^0"
tracing-error = "^0"
color-eyre = "^0"
capnp = { version = "^0", default_features = false } capnp = { version = "^0", default_features = false }
rust-fsm = "^0" rust-fsm = "^0"
static_assertions = "^1" static_assertions = "^1"
log = "^0"
cfg-if = "^1" cfg-if = "^1"
anyhow = "^1"
thiserror = "^1" thiserror = "^1"
hex = "^0" hex = "^0"
generic-array = "^0" generic-array = "^0"

150
veilid-core/src/api_logger.rs
View File

@ -1,150 +0,0 @@
use crate::core_context::*;
use crate::veilid_api::*;
use crate::xx::*;
use log::{set_boxed_logger, set_max_level, Level, LevelFilter, Log, Metadata, Record};
use once_cell::sync::OnceCell;
cfg_if! {
if #[cfg(target_arch = "wasm32")] {
use send_wrapper::*;
struct ApiLoggerInner {
level: LevelFilter,
filter_ignore: Cow<'static, [Cow<'static, str>]>,
update_callback: SendWrapper<UpdateCallback>,
}
} else {
struct ApiLoggerInner {
level: LevelFilter,
filter_ignore: Cow<'static, [Cow<'static, str>]>,
update_callback: UpdateCallback,
}
}
}
#[derive(Clone)]
pub struct ApiLogger {
inner: Arc<Mutex<Option<ApiLoggerInner>>>,
}
static API_LOGGER: OnceCell<ApiLogger> = OnceCell::new();
impl ApiLogger {
fn new_inner(level: LevelFilter, update_callback: UpdateCallback) -> ApiLoggerInner {
cfg_if! {
if #[cfg(target_arch = "wasm32")] {
ApiLoggerInner {
level,
filter_ignore: Default::default(),
update_callback: SendWrapper::new(update_callback),
}
} else {
ApiLoggerInner {
level,
filter_ignore: Default::default(),
update_callback,
}
}
}
}
pub async fn init(log_level: LevelFilter, update_callback: UpdateCallback) {
set_max_level(log_level);
let api_logger = API_LOGGER.get_or_init(|| {
let api_logger = ApiLogger {
inner: Arc::new(Mutex::new(None)),
};
set_boxed_logger(Box::new(api_logger.clone())).expect("failed to set api logger");
api_logger
});
let apilogger_inner = Some(Self::new_inner(log_level, update_callback));
*api_logger.inner.lock() = apilogger_inner;
}
pub async fn terminate() {
if let Some(api_logger) = API_LOGGER.get() {
let mut inner = api_logger.inner.lock();
*inner = None;
// Clear everything and we're done
set_max_level(LevelFilter::Off);
}
}
pub fn change_log_level(log_level: LevelFilter) {
if let Some(api_logger) = API_LOGGER.get() {
if let Some(inner) = &mut *api_logger.inner.lock() {
set_max_level(log_level);
inner.level = log_level;
}
}
}
pub fn add_filter_ignore_str(filter_ignore: &'static str) {
if let Some(api_logger) = API_LOGGER.get() {
if let Some(inner) = &mut *api_logger.inner.lock() {
let mut list = Vec::from(&*inner.filter_ignore);
list.push(Cow::Borrowed(filter_ignore));
inner.filter_ignore = Cow::Owned(list);
}
}
}
}
impl Log for ApiLogger {
fn enabled(&self, metadata: &Metadata<'_>) -> bool {
if let Some(inner) = &mut *self.inner.lock() {
return metadata.level() <= inner.level;
}
false
}
fn log(&self, record: &Record<'_>) {
if let Some(inner) = &mut *self.inner.lock() {
// Skip filtered targets
let skip = match (record.target(), &*inner.filter_ignore) {
(path, ignore) if !ignore.is_empty() => {
// Check that the module path does not match any ignore filters
ignore.iter().any(|v| path.starts_with(&**v))
}
_ => false,
};
if skip {
return;
}
let metadata = record.metadata();
let level = metadata.level();
if level <= inner.level {
let ll = VeilidLogLevel::from_log_level(level);
let file = record.file().unwrap_or("<unknown>");
let loc = if level >= Level::Debug {
if let Some(line) = record.line() {
format!("[{}:{}] ", file, line)
} else {
format!("[{}:<unknown>] ", file)
}
} else {
"".to_owned()
};
let tgt = if record.target().is_empty() {
"".to_owned()
} else {
format!("{}: ", record.target())
};
let s = format!("{}{}{}", tgt, loc, record.args());
(inner.update_callback)(VeilidUpdate::Log(VeilidStateLog {
log_level: ll,
message: s,
}))
}
}
}
fn flush(&self) {
// always flushes
}
}

310
veilid-core/src/api_tracing_layer.rs Normal file
View File

@ -0,0 +1,310 @@
use crate::core_context::*;
use crate::veilid_api::*;
use crate::xx::*;
use core::fmt::Write;
use once_cell::sync::OnceCell;
use tracing_subscriber::*;
cfg_if! {
if #[cfg(target_arch = "wasm32")] {
use send_wrapper::*;
struct ApiLoggerInner {
max_level: Option<VeilidLogLevel>,
filter_ignore: Cow<'static, [Cow<'static, str>]>,
update_callback: SendWrapper<UpdateCallback>,
}
} else {
struct ApiLoggerInner {
max_level: Option<VeilidLogLevel>,
filter_ignore: Cow<'static, [Cow<'static, str>]>,
update_callback: UpdateCallback,
}
}
}
#[derive(Clone)]
pub struct ApiTracingLayer {
inner: Arc<Mutex<Option<ApiLoggerInner>>>,
}
static API_LOGGER: OnceCell<ApiTracingLayer> = OnceCell::new();
impl ApiTracingLayer {
fn new_inner(
max_level: Option<VeilidLogLevel>,
update_callback: UpdateCallback,
) -> ApiLoggerInner {
cfg_if! {
if #[cfg(target_arch = "wasm32")] {
ApiLoggerInner {
max_level,
filter_ignore: Default::default(),
update_callback: SendWrapper::new(update_callback),
}
} else {
ApiLoggerInner {
max_level,
filter_ignore: Default::default(),
update_callback,
}
}
}
}
pub async fn init(max_level: Option<VeilidLogLevel>, update_callback: UpdateCallback) {
let api_logger = API_LOGGER.get_or_init(|| ApiTracingLayer {
inner: Arc::new(Mutex::new(None)),
});
let apilogger_inner = Some(Self::new_inner(max_level, update_callback));
*api_logger.inner.lock() = apilogger_inner;
}
pub async fn terminate() {
if let Some(api_logger) = API_LOGGER.get() {
let mut inner = api_logger.inner.lock();
*inner = None;
}
}
pub fn get() -> ApiTracingLayer {
API_LOGGER
.get_or_init(|| ApiTracingLayer {
inner: Arc::new(Mutex::new(None)),
})
.clone()
}
pub fn change_api_log_level(max_level: Option<VeilidLogLevel>) {
if let Some(api_logger) = API_LOGGER.get() {
if let Some(inner) = &mut *api_logger.inner.lock() {
*inner = Self::new_inner(max_level, inner.update_callback.clone());
}
}
}
pub fn add_filter_ignore_str(filter_ignore: &'static str) {
if let Some(api_logger) = API_LOGGER.get() {
if let Some(inner) = &mut *api_logger.inner.lock() {
let mut list = Vec::from(&*inner.filter_ignore);
list.push(Cow::Borrowed(filter_ignore));
inner.filter_ignore = Cow::Owned(list);
}
}
}
}
fn display_current_thread_id() -> String {
cfg_if! {
if #[cfg(target_arch = "wasm32")] {
"".to_owned()
} else {
format!("({}:{:?})",
if let Some(n) = async_std::task::current().name() {
n.to_string()
}
else {
async_std::task::current().id().to_string()
},
std::thread::current().id()
)
}
}
}
impl<S: Subscriber + for<'a> registry::LookupSpan<'a>> Layer<S> for ApiTracingLayer {
fn enabled(&self, metadata: &tracing::Metadata<'_>, _: layer::Context<'_, S>) -> bool {
if let Some(inner) = &mut *self.inner.lock() {
// Skip things that are out of our level
if let Some(max_level) = inner.max_level {
if VeilidLogLevel::from_tracing_level(*metadata.level()) > max_level {
return false;
}
} else {
return false;
}
// Skip filtered targets
let skip = match (metadata.target(), &*inner.filter_ignore) {
(path, ignore) if !ignore.is_empty() => {
// Check that the module path does not match any ignore filters
ignore.iter().any(|v| path.starts_with(&**v))
}
_ => false,
};
!skip
} else {
false
}
}
fn on_new_span(
&self,
attrs: &tracing::span::Attributes<'_>,
id: &tracing::Id,
ctx: layer::Context<'_, S>,
) {
if let Some(_inner) = &mut *self.inner.lock() {
let mut new_debug_record = StringRecorder::new();
attrs.record(&mut new_debug_record);
if let Some(span_ref) = ctx.span(id) {
span_ref
.extensions_mut()
.insert::<StringRecorder>(new_debug_record);
}
}
}
fn on_record(
&self,
id: &tracing::Id,
values: &tracing::span::Record<'_>,
ctx: layer::Context<'_, S>,
) {
if let Some(_inner) = &mut *self.inner.lock() {
if let Some(span_ref) = ctx.span(id) {
if let Some(debug_record) = span_ref.extensions_mut().get_mut::<StringRecorder>() {
values.record(debug_record);
}
}
}
}
fn on_event(&self, event: &tracing::Event<'_>, _ctx: layer::Context<'_, S>) {
if let Some(inner) = &mut *self.inner.lock() {
let mut recorder = StringRecorder::new();
event.record(&mut recorder);
let meta = event.metadata();
let level = meta.level();
if let Some(max_level) = inner.max_level {
if VeilidLogLevel::from_tracing_level(*level) <= max_level {
let log_level = VeilidLogLevel::from_tracing_level(*level);
let origin = meta
.file()
.and_then(|file| meta.line().map(|ln| format!("{}:{}", file, ln)))
.unwrap_or_default();
let message = format!("{}{} {}", origin, display_current_thread_id(), recorder);
(inner.update_callback)(VeilidUpdate::Log(VeilidStateLog {
log_level,
message,
}))
}
}
}
}
}
struct StringRecorder {
display: String,
is_following_args: bool,
}
impl StringRecorder {
fn new() -> Self {
StringRecorder {
display: String::new(),
is_following_args: false,
}
}
}
impl tracing::field::Visit for StringRecorder {
fn record_debug(&mut self, field: &tracing::field::Field, value: &dyn core::fmt::Debug) {
if field.name() == "message" {
if !self.display.is_empty() {
self.display = format!("{:?}\n{}", value, self.display)
} else {
self.display = format!("{:?}", value)
}
} else {
if self.is_following_args {
// following args
writeln!(self.display).unwrap();
} else {
// first arg
write!(self.display, " ").unwrap();
self.is_following_args = true;
}
write!(self.display, "{} = {:?};", field.name(), value).unwrap();
}
}
}
impl core::fmt::Display for StringRecorder {
fn fmt(&self, mut f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
if !self.display.is_empty() {
write!(&mut f, " {}", self.display)
} else {
Ok(())
}
}
}
impl core::default::Default for StringRecorder {
fn default() -> Self {
StringRecorder::new()
}
}
impl log::Log for ApiTracingLayer {
fn enabled(&self, metadata: &log::Metadata<'_>) -> bool {
if let Some(inner) = &mut *self.inner.lock() {
if let Some(max_level) = inner.max_level {
return VeilidLogLevel::from_log_level(metadata.level()) <= max_level;
}
}
false
}
fn log(&self, record: &log::Record<'_>) {
if let Some(inner) = &mut *self.inner.lock() {
// Skip filtered targets
let skip = match (record.target(), &*inner.filter_ignore) {
(path, ignore) if !ignore.is_empty() => {
// Check that the module path does not match any ignore filters
ignore.iter().any(|v| path.starts_with(&**v))
}
_ => false,
};
if skip {
return;
}
let metadata = record.metadata();
let level = metadata.level();
let log_level = VeilidLogLevel::from_log_level(level);
if let Some(max_level) = inner.max_level {
if log_level <= max_level {
let file = record.file().unwrap_or("<unknown>");
let loc = if level >= log::Level::Debug {
if let Some(line) = record.line() {
format!("[{}:{}] ", file, line)
} else {
format!("[{}:<unknown>] ", file)
}
} else {
"".to_owned()
};
let tgt = if record.target().is_empty() {
"".to_owned()
} else {
format!("{}: ", record.target())
};
let message = format!("{}{}{}", tgt, loc, record.args());
(inner.update_callback)(VeilidUpdate::Log(VeilidStateLog {
log_level,
message,
}))
}
}
}
}
fn flush(&self) {
// always flushes
}
}

16
veilid-core/src/core_context.rs
View File

@ -1,4 +1,4 @@
use crate::api_logger::*; use crate::api_tracing_layer::*;
use crate::attachment_manager::*; use crate::attachment_manager::*;
use crate::dht::Crypto; use crate::dht::Crypto;
use crate::intf::*; use crate::intf::*;
@ -60,11 +60,15 @@ impl ServicesContext {
} }
pub async fn startup(&mut self) -> Result<(), VeilidAPIError> { pub async fn startup(&mut self) -> Result<(), VeilidAPIError> {
let log_level: VeilidConfigLogLevel = self.config.get().log_level; let api_log_level: VeilidConfigLogLevel = self.config.get().api_log_level;
if log_level != VeilidConfigLogLevel::Off { if api_log_level != VeilidConfigLogLevel::Off {
ApiLogger::init(log_level.to_level_filter(), self.update_callback.clone()).await; ApiTracingLayer::init(
api_log_level.to_veilid_log_level(),
self.update_callback.clone(),
)
.await;
for ig in crate::DEFAULT_LOG_IGNORE_LIST { for ig in crate::DEFAULT_LOG_IGNORE_LIST {
ApiLogger::add_filter_ignore_str(ig); ApiTracingLayer::add_filter_ignore_str(ig);
} }
info!("Veilid logging initialized"); info!("Veilid logging initialized");
} }
@ -154,7 +158,7 @@ impl ServicesContext {
info!("Veilid API shutdown complete"); info!("Veilid API shutdown complete");
// api logger terminate is idempotent // api logger terminate is idempotent
ApiLogger::terminate().await; ApiTracingLayer::terminate().await;
// send final shutdown update // send final shutdown update
(self.update_callback)(VeilidUpdate::Shutdown); (self.update_callback)(VeilidUpdate::Shutdown);

3
veilid-core/src/lib.rs
View File

@ -4,7 +4,7 @@
#[macro_use] #[macro_use]
extern crate alloc; extern crate alloc;
mod api_logger; mod api_tracing_layer;
mod attachment_manager; mod attachment_manager;
mod callback_state_machine; mod callback_state_machine;
mod core_context; mod core_context;
@ -21,6 +21,7 @@ mod veilid_rng;
#[macro_use] #[macro_use]
pub mod xx; pub mod xx;
pub use self::api_tracing_layer::ApiTracingLayer;
pub use self::attachment_manager::AttachmentState; pub use self::attachment_manager::AttachmentState;
pub use self::core_context::{api_startup, api_startup_json, UpdateCallback}; pub use self::core_context::{api_startup, api_startup_json, UpdateCallback};
pub use self::veilid_api::*; pub use self::veilid_api::*;

4
veilid-core/src/tests/common/test_veilid_config.rs
View File

@ -169,7 +169,7 @@ fn config_callback(key: String) -> ConfigCallbackReturn {
match key.as_str() { match key.as_str() {
"program_name" => Ok(Box::new(String::from("Veilid"))), "program_name" => Ok(Box::new(String::from("Veilid"))),
"namespace" => Ok(Box::new(String::from(""))), "namespace" => Ok(Box::new(String::from(""))),
"log_level" => Ok(Box::new(VeilidConfigLogLevel::Off)), "api_log_level" => Ok(Box::new(VeilidConfigLogLevel::Off)),
"capabilities.protocol_udp" => Ok(Box::new(true)), "capabilities.protocol_udp" => Ok(Box::new(true)),
"capabilities.protocol_connect_tcp" => Ok(Box::new(true)), "capabilities.protocol_connect_tcp" => Ok(Box::new(true)),
"capabilities.protocol_accept_tcp" => Ok(Box::new(true)), "capabilities.protocol_accept_tcp" => Ok(Box::new(true)),
@ -291,7 +291,7 @@ pub async fn test_config() {
let inner = vc.get(); let inner = vc.get();
assert_eq!(inner.program_name, String::from("Veilid")); assert_eq!(inner.program_name, String::from("Veilid"));
assert_eq!(inner.namespace, String::from("")); assert_eq!(inner.namespace, String::from(""));
assert_eq!(inner.log_level, VeilidConfigLogLevel::Off); assert_eq!(inner.api_log_level, VeilidConfigLogLevel::Off);
assert_eq!(inner.capabilities.protocol_udp, true); assert_eq!(inner.capabilities.protocol_udp, true);
assert_eq!(inner.capabilities.protocol_connect_tcp, true); assert_eq!(inner.capabilities.protocol_connect_tcp, true);
assert_eq!(inner.capabilities.protocol_accept_tcp, true); assert_eq!(inner.capabilities.protocol_accept_tcp, true);

35
veilid-core/src/veilid_api/mod.rs
View File

@ -1,7 +1,9 @@
#![allow(dead_code)] #![allow(dead_code)]
mod debug; mod debug;
mod serialize_helpers;
pub use debug::*; pub use debug::*;
pub use serialize_helpers::*;
use crate::*; use crate::*;
@ -21,6 +23,7 @@ pub use network_manager::NetworkManager;
pub use routing_table::RoutingTable; pub use routing_table::RoutingTable;
pub use rpc_processor::StatusAnswer; pub use rpc_processor::StatusAnswer;
use api_tracing_layer::*;
use core::fmt; use core::fmt;
use core_context::{api_shutdown, VeilidCoreContext}; use core_context::{api_shutdown, VeilidCoreContext};
use enumset::*; use enumset::*;
@ -146,7 +149,7 @@ macro_rules! parse_error {
///////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////
#[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Copy, Serialize, Deserialize)]
pub enum VeilidLogLevel { pub enum VeilidLogLevel {
Error = 1, Error = 1,
Warn, Warn,
@ -156,13 +159,22 @@ pub enum VeilidLogLevel {
} }
impl VeilidLogLevel { impl VeilidLogLevel {
pub fn from_tracing_level(level: tracing::Level) -> VeilidLogLevel {
match level {
tracing::Level::ERROR => VeilidLogLevel::Error,
tracing::Level::WARN => VeilidLogLevel::Warn,
tracing::Level::INFO => VeilidLogLevel::Info,
tracing::Level::DEBUG => VeilidLogLevel::Debug,
tracing::Level::TRACE => VeilidLogLevel::Trace,
}
}
pub fn from_log_level(level: log::Level) -> VeilidLogLevel { pub fn from_log_level(level: log::Level) -> VeilidLogLevel {
match level { match level {
Level::Error => VeilidLogLevel::Error, log::Level::Error => VeilidLogLevel::Error,
Level::Warn => VeilidLogLevel::Warn, log::Level::Warn => VeilidLogLevel::Warn,
Level::Info => VeilidLogLevel::Info, log::Level::Info => VeilidLogLevel::Info,
Level::Debug => VeilidLogLevel::Debug, log::Level::Debug => VeilidLogLevel::Debug,
Level::Trace => VeilidLogLevel::Trace, log::Level::Trace => VeilidLogLevel::Trace,
} }
} }
} }
@ -1804,15 +1816,8 @@ impl VeilidAPI {
} }
// Change api logging level if it is enabled // Change api logging level if it is enabled
pub async fn change_log_level(&self, log_level: VeilidConfigLogLevel) { pub async fn change_api_log_level(&self, log_level: VeilidConfigLogLevel) {
cfg_if! { ApiTracingLayer::change_api_log_level(log_level.to_veilid_log_level());
if #[cfg(target_arch = "wasm32")] {
set_max_level(log_level.to_level_filter());
} else {
use api_logger::ApiLogger;
ApiLogger::change_log_level(log_level.to_level_filter());
}
}
} }
//////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////

12
veilid-flutter/rust/src/dart_serialize.rs → veilid-core/src/veilid_api/serialize_helpers.rs
View File

@ -1,9 +1,9 @@
use serde::*; use super::*;
pub fn deserialize_json<'a, T: de::Deserialize<'a>>( pub fn deserialize_json<'a, T: de::Deserialize<'a>>(
arg: &'a str, arg: &'a str,
) -> Result<T, veilid_core::VeilidAPIError> { ) -> Result<T, super::VeilidAPIError> {
serde_json::from_str(arg).map_err(|e| veilid_core::VeilidAPIError::ParseError { serde_json::from_str(arg).map_err(|e| VeilidAPIError::ParseError {
message: e.to_string(), message: e.to_string(),
value: String::new(), value: String::new(),
}) })
@ -11,9 +11,9 @@ pub fn deserialize_json<'a, T: de::Deserialize<'a>>(
pub fn deserialize_opt_json<T: de::DeserializeOwned>( pub fn deserialize_opt_json<T: de::DeserializeOwned>(
arg: Option<String>, arg: Option<String>,
) -> Result<T, veilid_core::VeilidAPIError> { ) -> Result<T, VeilidAPIError> {
let arg = arg.ok_or_else(|| veilid_core::VeilidAPIError::ParseError { let arg = arg.ok_or_else(|| VeilidAPIError::ParseError {
message: "invalid null string passed to rust".to_owned(), message: "invalid null string".to_owned(),
value: String::new(), value: String::new(),
})?; })?;
deserialize_json(&arg) deserialize_json(&arg)

34
veilid-core/src/veilid_config.rs
View File

@ -1,7 +1,5 @@
use crate::dht::*;
use crate::intf;
use crate::xx::*; use crate::xx::*;
use crate::*;
use serde::*; use serde::*;
//////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////
@ -195,14 +193,24 @@ pub enum VeilidConfigLogLevel {
} }
impl VeilidConfigLogLevel { impl VeilidConfigLogLevel {
pub fn to_level_filter(&self) -> LevelFilter { pub fn to_veilid_log_level(&self) -> Option<VeilidLogLevel> {
match self { match self {
Self::Off => LevelFilter::Off, Self::Off => None,
Self::Error => LevelFilter::Error, Self::Error => Some(VeilidLogLevel::Error),
Self::Warn => LevelFilter::Warn, Self::Warn => Some(VeilidLogLevel::Warn),
Self::Info => LevelFilter::Info, Self::Info => Some(VeilidLogLevel::Info),
Self::Debug => LevelFilter::Debug, Self::Debug => Some(VeilidLogLevel::Debug),
Self::Trace => LevelFilter::Trace, Self::Trace => Some(VeilidLogLevel::Trace),
}
}
pub fn from_veilid_log_level(level: Option<VeilidLogLevel>) -> Self {
match level {
None => Self::Off,
Some(VeilidLogLevel::Error) => Self::Error,
Some(VeilidLogLevel::Warn) => Self::Warn,
Some(VeilidLogLevel::Info) => Self::Info,
Some(VeilidLogLevel::Debug) => Self::Debug,
Some(VeilidLogLevel::Trace) => Self::Trace,
} }
} }
} }
@ -216,7 +224,7 @@ impl Default for VeilidConfigLogLevel {
pub struct VeilidConfigInner { pub struct VeilidConfigInner {
pub program_name: String, pub program_name: String,
pub namespace: String, pub namespace: String,
pub log_level: VeilidConfigLogLevel, pub api_log_level: VeilidConfigLogLevel,
pub capabilities: VeilidConfigCapabilities, pub capabilities: VeilidConfigCapabilities,
pub protected_store: VeilidConfigProtectedStore, pub protected_store: VeilidConfigProtectedStore,
pub table_store: VeilidConfigTableStore, pub table_store: VeilidConfigTableStore,
@ -272,7 +280,7 @@ impl VeilidConfig {
let mut inner = self.inner.write(); let mut inner = self.inner.write();
get_config!(inner.program_name); get_config!(inner.program_name);
get_config!(inner.namespace); get_config!(inner.namespace);
get_config!(inner.log_level); get_config!(inner.api_log_level);
get_config!(inner.capabilities.protocol_udp); get_config!(inner.capabilities.protocol_udp);
get_config!(inner.capabilities.protocol_connect_tcp); get_config!(inner.capabilities.protocol_connect_tcp);
get_config!(inner.capabilities.protocol_accept_tcp); get_config!(inner.capabilities.protocol_accept_tcp);
@ -552,7 +560,7 @@ impl VeilidConfig {
// If we have a node id from storage, check it // If we have a node id from storage, check it
if node_id.valid && node_id_secret.valid { if node_id.valid && node_id_secret.valid {
// Validate node id // Validate node id
if !validate_key(&node_id, &node_id_secret) { if !dht::validate_key(&node_id, &node_id_secret) {
return Err("node id secret and node id key don't match".to_owned()); return Err("node id secret and node id key don't match".to_owned());
} }
} }

2
veilid-core/src/xx/mod.rs
View File

@ -20,12 +20,12 @@ pub use futures_util::future::{select, Either};
pub use futures_util::select; pub use futures_util::select;
pub use futures_util::stream::FuturesUnordered; pub use futures_util::stream::FuturesUnordered;
pub use futures_util::{AsyncRead, AsyncWrite}; pub use futures_util::{AsyncRead, AsyncWrite};
pub use log::*;
pub use log_thru::*; pub use log_thru::*;
pub use owo_colors::OwoColorize; pub use owo_colors::OwoColorize;
pub use parking_lot::*; pub use parking_lot::*;
pub use split_url::*; pub use split_url::*;
pub use static_assertions::*; pub use static_assertions::*;
pub use tracing::*;
pub type PinBox<T> = Pin<Box<T>>; pub type PinBox<T> = Pin<Box<T>>;
pub type PinBoxFuture<T> = PinBox<dyn Future<Output = T> + 'static>; pub type PinBoxFuture<T> = PinBox<dyn Future<Output = T> + 'static>;

12
veilid-flutter/lib/veilid.dart
View File

@ -745,7 +745,7 @@ class VeilidConfigCapabilities {
class VeilidConfig { class VeilidConfig {
String programName; String programName;
String namespace; String namespace;
VeilidConfigLogLevel logLevel; VeilidConfigLogLevel apiLogLevel;
VeilidConfigCapabilities capabilities; VeilidConfigCapabilities capabilities;
VeilidConfigProtectedStore protectedStore; VeilidConfigProtectedStore protectedStore;
VeilidConfigTableStore tableStore; VeilidConfigTableStore tableStore;
@ -755,7 +755,7 @@ class VeilidConfig {
VeilidConfig({ VeilidConfig({
required this.programName, required this.programName,
required this.namespace, required this.namespace,
required this.logLevel, required this.apiLogLevel,
required this.capabilities, required this.capabilities,
required this.protectedStore, required this.protectedStore,
required this.tableStore, required this.tableStore,
@ -767,7 +767,7 @@ class VeilidConfig {
return { return {
'program_name': programName, 'program_name': programName,
'namespace': namespace, 'namespace': namespace,
'log_level': logLevel.json, 'api_log_level': apiLogLevel.json,
'capabilities': capabilities.json, 'capabilities': capabilities.json,
'protected_store': protectedStore.json, 'protected_store': protectedStore.json,
'table_store': tableStore.json, 'table_store': tableStore.json,
@ -779,7 +779,7 @@ class VeilidConfig {
VeilidConfig.fromJson(Map<String, dynamic> json) VeilidConfig.fromJson(Map<String, dynamic> json)
: programName = json['program_name'], : programName = json['program_name'],
namespace = json['namespace'], namespace = json['namespace'],
logLevel = json['log_level'], apiLogLevel = json['api_log_level'],
capabilities = VeilidConfigCapabilities.fromJson(json['capabilities']), capabilities = VeilidConfigCapabilities.fromJson(json['capabilities']),
protectedStore = protectedStore =
VeilidConfigProtectedStore.fromJson(json['protected_store']), VeilidConfigProtectedStore.fromJson(json['protected_store']),
@ -797,7 +797,7 @@ abstract class VeilidUpdate {
case "Log": case "Log":
{ {
return VeilidUpdateLog( return VeilidUpdateLog(
veilidLogLevelFromJson(json["log_level"]), json["message"]); veilidLogLevelFromJson(json["api_log_level"]), json["message"]);
} }
case "Attachment": case "Attachment":
{ {
@ -1072,7 +1072,7 @@ abstract class Veilid {
Stream<VeilidUpdate> startupVeilidCore(VeilidConfig config); Stream<VeilidUpdate> startupVeilidCore(VeilidConfig config);
Future<VeilidState> getVeilidState(); Future<VeilidState> getVeilidState();
Future<void> changeLogLevel(VeilidConfigLogLevel logLevel); Future<void> changeApiLogLevel(VeilidConfigLogLevel logLevel);
Future<void> shutdownVeilidCore(); Future<void> shutdownVeilidCore();
Future<String> debug(String command); Future<String> debug(String command);
String veilidVersionString(); String veilidVersionString();

20
veilid-flutter/lib/veilid_ffi.dart
View File

@ -35,9 +35,9 @@ typedef _StartupVeilidCoreDart = void Function(int, Pointer<Utf8>);
// fn get_veilid_state(port: i64) // fn get_veilid_state(port: i64)
typedef _GetVeilidStateC = Void Function(Int64); typedef _GetVeilidStateC = Void Function(Int64);
typedef _GetVeilidStateDart = void Function(int); typedef _GetVeilidStateDart = void Function(int);
// fn change_log_level(port: i64, log_level: FfiStr) // fn change_api_log_level(port: i64, log_level: FfiStr)
typedef _ChangeLogLevelC = Void Function(Int64, Pointer<Utf8>); typedef _ChangeApiLogLevelC = Void Function(Int64, Pointer<Utf8>);
typedef _ChangeLogLevelDart = void Function(int, Pointer<Utf8>); typedef _ChangeApiLogLevelDart = void Function(int, Pointer<Utf8>);
// fn debug(port: i64, log_level: FfiStr) // fn debug(port: i64, log_level: FfiStr)
typedef _DebugC = Void Function(Int64, Pointer<Utf8>); typedef _DebugC = Void Function(Int64, Pointer<Utf8>);
typedef _DebugDart = void Function(int, Pointer<Utf8>); typedef _DebugDart = void Function(int, Pointer<Utf8>);
@ -243,7 +243,7 @@ class VeilidFFI implements Veilid {
final _FreeStringDart _freeString; final _FreeStringDart _freeString;
final _StartupVeilidCoreDart _startupVeilidCore; final _StartupVeilidCoreDart _startupVeilidCore;
final _GetVeilidStateDart _getVeilidState; final _GetVeilidStateDart _getVeilidState;
final _ChangeLogLevelDart _changeLogLevel; final _ChangeApiLogLevelDart _changeApiLogLevel;
final _ShutdownVeilidCoreDart _shutdownVeilidCore; final _ShutdownVeilidCoreDart _shutdownVeilidCore;
final _DebugDart _debug; final _DebugDart _debug;
final _VeilidVersionStringDart _veilidVersionString; final _VeilidVersionStringDart _veilidVersionString;
@ -259,9 +259,9 @@ class VeilidFFI implements Veilid {
_getVeilidState = _getVeilidState =
dylib.lookupFunction<_GetVeilidStateC, _GetVeilidStateDart>( dylib.lookupFunction<_GetVeilidStateC, _GetVeilidStateDart>(
'get_veilid_state'), 'get_veilid_state'),
_changeLogLevel = _changeApiLogLevel =
dylib.lookupFunction<_ChangeLogLevelC, _ChangeLogLevelDart>( dylib.lookupFunction<_ChangeApiLogLevelC, _ChangeApiLogLevelDart>(
'change_log_level'), 'change_api_log_level'),
_shutdownVeilidCore = _shutdownVeilidCore =
dylib.lookupFunction<_ShutdownVeilidCoreC, _ShutdownVeilidCoreDart>( dylib.lookupFunction<_ShutdownVeilidCoreC, _ShutdownVeilidCoreDart>(
'shutdown_veilid_core'), 'shutdown_veilid_core'),
@ -299,11 +299,11 @@ class VeilidFFI implements Veilid {
} }
@override @override
Future<void> changeLogLevel(VeilidConfigLogLevel logLevel) async { Future<void> changeApiLogLevel(VeilidConfigLogLevel logLevel) async {
var nativeLogLevel = logLevel.json.toNativeUtf8(); var nativeLogLevel = logLevel.json.toNativeUtf8();
final recvPort = ReceivePort("change_log_level"); final recvPort = ReceivePort("change_api_log_level");
final sendPort = recvPort.sendPort; final sendPort = recvPort.sendPort;
_changeLogLevel(sendPort.nativePort, nativeLogLevel); _changeApiLogLevel(sendPort.nativePort, nativeLogLevel);
malloc.free(nativeLogLevel); malloc.free(nativeLogLevel);
return processFutureVoid(recvPort.first); return processFutureVoid(recvPort.first);
} }

4
veilid-flutter/lib/veilid_js.dart
View File

@ -46,8 +46,8 @@ class VeilidJS implements Veilid {
} }
@override @override
Future<void> changeLogLevel(VeilidConfigLogLevel logLevel) { Future<void> changeApiLogLevel(VeilidConfigLogLevel logLevel) {
return _wrapApiPromise(js_util.callMethod(wasm, "change_log_level", return _wrapApiPromise(js_util.callMethod(wasm, "change_api_log_level",
[jsonEncode(logLevel.json, toEncodable: veilidApiToEncodable)])); [jsonEncode(logLevel.json, toEncodable: veilidApiToEncodable)]));
} }

7
veilid-flutter/rust/Cargo.toml
View File

@ -8,8 +8,9 @@ crate-type = ["cdylib", "staticlib", "rlib"]
[dependencies] [dependencies]
veilid-core = { path="../../veilid-core" } veilid-core = { path="../../veilid-core" }
tracing = { version = "^0", features = ["log", "attributes"] }
tracing-subscriber = "^0"
parking_lot = "^0" parking_lot = "^0"
log = "^0"
backtrace = "^0" backtrace = "^0"
serde_json = "^1" serde_json = "^1"
serde = "^1" serde = "^1"
@ -19,11 +20,13 @@ futures = "^0"
# Linux, Windows, Mac, iOS, Android # Linux, Windows, Mac, iOS, Android
[target.'cfg(not(target_arch = "wasm32"))'.dependencies] [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
async-std = { version = "^1", features = ["unstable"] } async-std = { version = "^1", features = ["unstable"] }
anyhow = { version = "^1", features = ["backtrace"] }
allo-isolate = "^0" allo-isolate = "^0"
ffi-support = "^0" ffi-support = "^0"
lazy_static = "^1" lazy_static = "^1"
# Dependencies for WASM builds only
# [target.'cfg(target_arch = "wasm32")'.dependencies]
# Dependencies for Android builds only # Dependencies for Android builds only
[target.'cfg(target_os = "android")'.dependencies] [target.'cfg(target_os = "android")'.dependencies]
jni = "^0" jni = "^0"

15
veilid-flutter/rust/src/dart_ffi.rs
View File

@ -1,13 +1,11 @@
use crate::dart_isolate_wrapper::*; use crate::dart_isolate_wrapper::*;
use crate::dart_serialize::*;
use allo_isolate::*; use allo_isolate::*;
use async_std::sync::Mutex as AsyncMutex; use async_std::sync::Mutex as AsyncMutex;
use ffi_support::*; use ffi_support::*;
use lazy_static::*; use lazy_static::*;
use log::*;
use std::os::raw::c_char; use std::os::raw::c_char;
use std::sync::Arc; use std::sync::Arc;
use tracing::*;
// Globals // Globals
@ -71,7 +69,7 @@ pub extern "C" fn initialize_veilid_flutter(dart_post_c_object_ptr: ffi::DartPos
} else { } else {
("<unknown>", 0) ("<unknown>", 0)
}; };
log::error!("### Rust `panic!` hit at file '{}', line {}", file, line); error!("### Rust `panic!` hit at file '{}', line {}", file, line);
if let Some(s) = panic_info.payload().downcast_ref::<&str>() { if let Some(s) = panic_info.payload().downcast_ref::<&str>() {
error!("panic payload: {:?}", s); error!("panic payload: {:?}", s);
} else if let Some(s) = panic_info.payload().downcast_ref::<String>() { } else if let Some(s) = panic_info.payload().downcast_ref::<String>() {
@ -81,7 +79,7 @@ pub extern "C" fn initialize_veilid_flutter(dart_post_c_object_ptr: ffi::DartPos
} else { } else {
error!("no panic payload"); error!("no panic payload");
} }
log::error!(" Complete stack trace:\n{:?}", backtrace::Backtrace::new()); error!(" Complete stack trace:\n{:?}", backtrace::Backtrace::new());
// And stop the process, no recovery is going to be possible here // And stop the process, no recovery is going to be possible here
std::process::abort(); std::process::abort();
@ -143,12 +141,13 @@ pub extern "C" fn get_veilid_state(port: i64) {
} }
#[no_mangle] #[no_mangle]
pub extern "C" fn change_log_level(port: i64, log_level: FfiStr) { pub extern "C" fn change_api_log_level(port: i64, log_level: FfiStr) {
let log_level = log_level.into_opt_string(); let log_level = log_level.into_opt_string();
DartIsolateWrapper::new(port).spawn_result_json(async move { DartIsolateWrapper::new(port).spawn_result_json(async move {
let log_level: veilid_core::VeilidConfigLogLevel = deserialize_opt_json(log_level)?; let log_level: veilid_core::VeilidConfigLogLevel =
veilid_core::deserialize_opt_json(log_level)?;
let veilid_api = get_veilid_api().await?; let veilid_api = get_veilid_api().await?;
veilid_api.change_log_level(log_level).await; veilid_api.change_api_log_level(log_level).await;
APIRESULT_VOID APIRESULT_VOID
}); });
} }

9
veilid-flutter/rust/src/dart_isolate_wrapper.rs
View File

@ -1,4 +1,3 @@
use crate::dart_serialize::*;
pub use allo_isolate::ffi::DartCObject; pub use allo_isolate::ffi::DartCObject;
pub use allo_isolate::IntoDart; pub use allo_isolate::IntoDart;
use allo_isolate::Isolate; use allo_isolate::Isolate;
@ -71,7 +70,7 @@ impl DartIsolateWrapper {
pub fn ok_json<T: Serialize>(self, value: T) -> bool { pub fn ok_json<T: Serialize>(self, value: T) -> bool {
self.isolate.post(vec![ self.isolate.post(vec![
MESSAGE_OK_JSON.into_dart(), MESSAGE_OK_JSON.into_dart(),
serialize_json(value).into_dart(), veilid_core::serialize_json(value).into_dart(),
]) ])
} }
@ -83,7 +82,7 @@ impl DartIsolateWrapper {
pub fn err_json<E: Serialize>(self, error: E) -> bool { pub fn err_json<E: Serialize>(self, error: E) -> bool {
self.isolate.post(vec![ self.isolate.post(vec![
MESSAGE_ERR_JSON.into_dart(), MESSAGE_ERR_JSON.into_dart(),
serialize_json(error).into_dart(), veilid_core::serialize_json(error).into_dart(),
]) ])
} }
} }
@ -128,7 +127,7 @@ impl DartIsolateStream {
if let Some(isolate) = &inner.isolate { if let Some(isolate) = &inner.isolate {
isolate.post(vec![ isolate.post(vec![
MESSAGE_STREAM_ITEM_JSON.into_dart(), MESSAGE_STREAM_ITEM_JSON.into_dart(),
serialize_json(value).into_dart(), veilid_core::serialize_json(value).into_dart(),
]) ])
} else { } else {
false false
@ -149,7 +148,7 @@ impl DartIsolateStream {
if let Some(isolate) = inner.isolate.take() { if let Some(isolate) = inner.isolate.take() {
isolate.post(vec![ isolate.post(vec![
MESSAGE_STREAM_ABORT_JSON.into_dart(), MESSAGE_STREAM_ABORT_JSON.into_dart(),
serialize_json(error).into_dart(), veilid_core::serialize_json(error).into_dart(),
]) ])
} else { } else {
false false

1
veilid-flutter/rust/src/lib.rs
View File

@ -1,6 +1,5 @@
mod dart_ffi; mod dart_ffi;
mod dart_isolate_wrapper; mod dart_isolate_wrapper;
mod dart_serialize;
#[cfg(target_os = "android")] #[cfg(target_os = "android")]
use jni::{objects::JClass, objects::JObject, JNIEnv}; use jni::{objects::JClass, objects::JObject, JNIEnv};

8
veilid-server/Cargo.toml
View File

@ -11,8 +11,9 @@ name = "veilid-server"
path = "src/main.rs" path = "src/main.rs"
[dependencies] [dependencies]
log = "^0" tracing = { version = "^0", features = ["log", "attributes"] }
simplelog = { version = "^0", features = ["test"] } tracing-subscriber = { version = "^0", features = ["env-filter"] }
tracing-appender = "^0"
clap = "^3" clap = "^3"
async-std = { version = "^1", features = ["unstable"] } async-std = { version = "^1", features = ["unstable"] }
async-tungstenite = { version = "^0", features = ["async-std-runtime", "async-tls"] } async-tungstenite = { version = "^0", features = ["async-std-runtime", "async-tls"] }
@ -37,6 +38,7 @@ rpassword = "^6"
[target.'cfg(windows)'.dependencies] [target.'cfg(windows)'.dependencies]
windows-service = "^0" windows-service = "^0"
ansi_term = "^0"
[target.'cfg(unix)'.dependencies] [target.'cfg(unix)'.dependencies]
daemonize = "^0" daemonize = "^0"
@ -45,7 +47,7 @@ signal-hook-async-std = "^0"
nix = "^0" nix = "^0"
[target.'cfg(target_os = "linux")'.dependencies] [target.'cfg(target_os = "linux")'.dependencies]
systemd-journal-logger = "^0" tracing-journald = "^0"
[dev-dependencies] [dev-dependencies]
serial_test = "^0" serial_test = "^0"

41
veilid-server/proto/veilid-client.capnp
View File

@ -1,55 +1,20 @@
@0xd29582d26b2fb073; @0xd29582d26b2fb073;
enum AttachmentState {
detached @0;
attaching @1;
attachedWeak @2;
attachedGood @3;
attachedStrong @4;
fullyAttached @5;
overAttached @6;
detaching @7;
}
struct VeilidStateAttachment {
state @0 :AttachmentState;
}
struct VeilidStateNetwork {
started @0 :Bool;
bpsDown @1 :UInt64;
bpsUp @2 :UInt64;
}
struct VeilidUpdate {
union {
attachment @0 :VeilidStateAttachment;
network @1 :VeilidStateNetwork;
shutdown @2 :Void;
}
}
struct VeilidState {
attachment @0 :VeilidStateAttachment;
network @1 :VeilidStateNetwork;
}
interface Registration {} interface Registration {}
interface VeilidServer { interface VeilidServer {
register @0 (veilidClient: VeilidClient) -> (registration: Registration, state: VeilidState); register @0 (veilidClient: VeilidClient) -> (registration: Registration, state: Text);
debug @1 (what: Text) -> (output: Text); debug @1 (what: Text) -> (output: Text);
attach @2 (); attach @2 ();
detach @3 (); detach @3 ();
shutdown @4 (); shutdown @4 ();
getState @5 () -> (state: VeilidState); getState @5 () -> (state: Text);
} }
interface VeilidClient { interface VeilidClient {
update @0 (veilidUpdate: VeilidUpdate); update @0 (veilidUpdate: Text);
logMessage @1 (message: Text);
} }

142
veilid-server/src/client_api.rs
View File

@ -7,74 +7,18 @@ use failure::*;
use futures::io::AsyncReadExt; use futures::io::AsyncReadExt;
use futures::FutureExt as FuturesFutureExt; use futures::FutureExt as FuturesFutureExt;
use futures::StreamExt; use futures::StreamExt;
use log::*;
use std::cell::RefCell; use std::cell::RefCell;
use std::collections::HashMap; use std::collections::HashMap;
use std::net::SocketAddr; use std::net::SocketAddr;
use std::rc::Rc; use std::rc::Rc;
use tracing::*;
use veilid_core::xx::Eventual; use veilid_core::xx::Eventual;
use veilid_core::*;
#[derive(Fail, Debug)] #[derive(Fail, Debug)]
#[fail(display = "Client API error: {}", _0)] #[fail(display = "Client API error: {}", _0)]
pub struct ClientAPIError(String); pub struct ClientAPIError(String);
fn convert_attachment_state(state: &veilid_core::AttachmentState) -> AttachmentState {
match state {
veilid_core::AttachmentState::Detached => AttachmentState::Detached,
veilid_core::AttachmentState::Attaching => AttachmentState::Attaching,
veilid_core::AttachmentState::AttachedWeak => AttachmentState::AttachedWeak,
veilid_core::AttachmentState::AttachedGood => AttachmentState::AttachedGood,
veilid_core::AttachmentState::AttachedStrong => AttachmentState::AttachedStrong,
veilid_core::AttachmentState::FullyAttached => AttachmentState::FullyAttached,
veilid_core::AttachmentState::OverAttached => AttachmentState::OverAttached,
veilid_core::AttachmentState::Detaching => AttachmentState::Detaching,
}
}
fn convert_update(
update: &veilid_core::VeilidUpdate,
mut rpc_update: crate::veilid_client_capnp::veilid_update::Builder,
) {
match update {
veilid_core::VeilidUpdate::Log(veilid_core::VeilidStateLog {
log_level: _,
message: _,
}) => {
panic!("Should not be logging to api in server!");
}
veilid_core::VeilidUpdate::Attachment(veilid_core::VeilidStateAttachment { state }) => {
let mut att = rpc_update.init_attachment();
att.set_state(convert_attachment_state(state));
}
veilid_core::VeilidUpdate::Network(veilid_core::VeilidStateNetwork {
started,
bps_down,
bps_up,
}) => {
let mut nb = rpc_update.init_network();
nb.set_started(*started);
nb.set_bps_down(*bps_down);
nb.set_bps_up(*bps_up);
}
veilid_core::VeilidUpdate::Shutdown => {
rpc_update.set_shutdown(());
}
}
}
fn convert_state(
state: &veilid_core::VeilidState,
mut rpc_state: crate::veilid_client_capnp::veilid_state::Builder,
) {
let mut ab = rpc_state.reborrow().init_attachment();
ab.set_state(convert_attachment_state(&state.attachment.state));
let mut nb = rpc_state.reborrow().init_network();
nb.set_started(state.network.started);
nb.set_bps_down(state.network.bps_down);
nb.set_bps_up(state.network.bps_up);
}
// --- interface Registration --------------------------------- // --- interface Registration ---------------------------------
struct RegistrationHandle { struct RegistrationHandle {
@ -166,11 +110,17 @@ impl veilid_server::Server for VeilidServerImpl {
.get_state() .get_state()
.await .await
.map_err(|e| ::capnp::Error::failed(format!("{:?}", e)))?; .map_err(|e| ::capnp::Error::failed(format!("{:?}", e)))?;
let state = serialize_json(state);
let mut res = results.get(); let mut res = results.get();
res.set_registration(registration); res.set_registration(registration);
let rpc_state = res.init_state(); let mut rpc_state = res.init_state(
convert_state(&state, rpc_state); state
.len()
.try_into()
.map_err(|e| ::capnp::Error::failed(format!("{:?}", e)))?,
);
rpc_state.push_str(&state);
Ok(()) Ok(())
}) })
@ -256,9 +206,17 @@ impl veilid_server::Server for VeilidServerImpl {
.get_state() .get_state()
.await .await
.map_err(|e| ::capnp::Error::failed(format!("{:?}", e)))?; .map_err(|e| ::capnp::Error::failed(format!("{:?}", e)))?;
let state = serialize_json(state);
let res = results.get();
let mut rpc_state = res.init_state(
state
.len()
.try_into()
.map_err(|e| ::capnp::Error::failed(format!("{:?}", e)))?,
);
rpc_state.push_str(&state);
let rpc_state = results.get().init_state();
convert_state(&state, rpc_state);
Ok(()) Ok(())
}) })
} }
@ -345,7 +303,7 @@ impl ClientApi {
fn send_request_to_all_clients<F, T>(self: Rc<Self>, request: F) fn send_request_to_all_clients<F, T>(self: Rc<Self>, request: F)
where where
F: Fn(u64, &mut RegistrationHandle) -> ::capnp::capability::RemotePromise<T>, F: Fn(u64, &mut RegistrationHandle) -> Option<::capnp::capability::RemotePromise<T>>,
T: capnp::traits::Pipelined + for<'a> capnp::traits::Owned<'a> + 'static + Unpin, T: capnp::traits::Pipelined + for<'a> capnp::traits::Owned<'a> + 'static + Unpin,
{ {
// Send status update to each registered client // Send status update to each registered client
@ -361,40 +319,44 @@ impl ClientApi {
} }
registration.requests_in_flight += 1; registration.requests_in_flight += 1;
let request_promise = request(id, registration); if let Some(request_promise) = request(id, registration) {
let registration_map2 = registration_map1.clone();
let registration_map2 = registration_map1.clone(); async_std::task::spawn_local(request_promise.promise.map(move |r| match r {
async_std::task::spawn_local(request_promise.promise.map(move |r| match r { Ok(_) => {
Ok(_) => { if let Some(ref mut s) =
if let Some(ref mut s) = registration_map2.borrow_mut().registrations.get_mut(&id)
registration_map2.borrow_mut().registrations.get_mut(&id) {
{ s.requests_in_flight -= 1;
s.requests_in_flight -= 1; }
} }
} Err(e) => {
Err(e) => { println!("Got error: {:?}. Dropping registation.", e);
println!("Got error: {:?}. Dropping registation.", e); registration_map2.borrow_mut().registrations.remove(&id);
registration_map2.borrow_mut().registrations.remove(&id); }
} }));
})); }
} }
} }
pub fn handle_update(self: Rc<Self>, veilid_update: veilid_core::VeilidUpdate) { pub fn handle_update(self: Rc<Self>, veilid_update: veilid_core::VeilidUpdate) {
// serialize update
let veilid_update = serialize_json(veilid_update);
// Pass other updates to clients // Pass other updates to clients
self.send_request_to_all_clients(|_id, registration| { self.send_request_to_all_clients(|_id, registration| {
let mut request = registration.client.update_request(); match veilid_update
let rpc_veilid_update = request.get().init_veilid_update(); .len()
convert_update(&veilid_update, rpc_veilid_update); .try_into()
request.send() .map_err(|e| ::capnp::Error::failed(format!("{:?}", e)))
}); {
} Ok(len) => {
let mut request = registration.client.update_request();
pub fn handle_client_log(self: Rc<Self>, message: String) { let mut rpc_veilid_update = request.get().init_veilid_update(len);
self.send_request_to_all_clients(|_id, registration| { rpc_veilid_update.push_str(&veilid_update);
let mut request = registration.client.log_message_request(); Some(request.send())
request.get().set_message(&message); }
request.send() Err(_) => None,
}
}); });
} }

7
veilid-server/src/main.rs
View File

@ -24,6 +24,9 @@ pub mod veilid_client_capnp {
} }
fn main() -> Result<(), String> { fn main() -> Result<(), String> {
#[cfg(windows)]
let _ = ansi_term::enable_ansi_support();
let (settings, matches) = cmdline::process_command_line()?; let (settings, matches) = cmdline::process_command_line()?;
// --- Dump Config --- // --- Dump Config ---
@ -55,7 +58,7 @@ fn main() -> Result<(), String> {
// Handle non-normal server modes // Handle non-normal server modes
if !matches!(server_mode, ServerMode::Normal) { if !matches!(server_mode, ServerMode::Normal) {
// Init combined console/file logger // Init combined console/file logger
let logs = VeilidLogs::setup_normal_logs(settings.clone())?; let logs = VeilidLogs::setup(settings.clone())?;
// run the server to set the node id and quit // run the server to set the node id and quit
return task::block_on(async { run_veilid_server(settings, logs, server_mode).await }) return task::block_on(async { run_veilid_server(settings, logs, server_mode).await })
.map(|v| { .map(|v| {
@ -80,7 +83,7 @@ fn main() -> Result<(), String> {
} }
// Init combined console/file logger // Init combined console/file logger
let logs = VeilidLogs::setup_normal_logs(settings.clone())?; let logs = VeilidLogs::setup(settings.clone())?;
// --- Normal Startup --- // --- Normal Startup ---
ctrlc::set_handler(move || { ctrlc::set_handler(move || {

47
veilid-server/src/server.rs
View File

@ -3,10 +3,10 @@ use crate::settings::*;
use crate::veilid_logs::*; use crate::veilid_logs::*;
use flume::{bounded, Receiver, Sender}; use flume::{bounded, Receiver, Sender};
use lazy_static::*; use lazy_static::*;
use log::*;
use parking_lot::Mutex; use parking_lot::Mutex;
use std::sync::Arc; use std::sync::Arc;
use std::time::{Duration, Instant}; use std::time::{Duration, Instant};
use tracing::*;
use veilid_core::xx::SingleShotEventual; use veilid_core::xx::SingleShotEventual;
#[derive(Copy, Clone, PartialEq, Eq)] #[derive(Copy, Clone, PartialEq, Eq)]
@ -91,41 +91,6 @@ pub async fn run_veilid_server_internal(
} }
} }
}); });
// Handle log messages on main thread for capnproto rpc
let client_log_receiver_jh = capi.clone().and_then(|capi| {
logs.client_log_channel
.clone()
.map(|mut client_log_channel| {
async_std::task::spawn_local(async move {
// Batch messages to either 16384 chars at once or every second to minimize packets
let rate = Duration::from_secs(1);
let mut start = Instant::now();
let mut messages = String::new();
loop {
let timeout_dur =
rate.checked_sub(start.elapsed()).unwrap_or(Duration::ZERO);
match async_std::future::timeout(timeout_dur, client_log_channel.recv())
.await
{
Ok(Ok(message)) => {
messages += &message;
if messages.len() > 16384 {
capi.clone()
.handle_client_log(core::mem::take(&mut messages));
start = Instant::now();
}
}
Ok(Err(_)) => break,
Err(_) => {
capi.clone()
.handle_client_log(core::mem::take(&mut messages));
start = Instant::now();
}
}
}
})
})
});
// Auto-attach if desired // Auto-attach if desired
let mut out = Ok(()); let mut out = Ok(());
@ -193,18 +158,8 @@ pub async fn run_veilid_server_internal(
// Shut down Veilid API to release state change sender // Shut down Veilid API to release state change sender
veilid_api.shutdown().await; veilid_api.shutdown().await;
// Close the client api log channel if it is open to release client log sender
if let Some(client_log_channel_closer) = logs.client_log_channel_closer {
client_log_channel_closer.close();
}
// Wait for update receiver to exit // Wait for update receiver to exit
update_receiver_jh.await; update_receiver_jh.await;
// Wait for client api log receiver to exit
if let Some(client_log_receiver_jh) = client_log_receiver_jh {
client_log_receiver_jh.await;
}
out out
} }

31
veilid-server/src/settings.rs
View File

@ -1,7 +1,6 @@
#![allow(clippy::bool_assert_comparison)] #![allow(clippy::bool_assert_comparison)]
use directories::*; use directories::*;
use log::*;
use parking_lot::*; use parking_lot::*;
use serde_derive::*; use serde_derive::*;
@ -34,7 +33,7 @@ logging:
path: '' path: ''
append: true append: true
level: 'info' level: 'info'
client: api:
enabled: false enabled: false
level: 'info' level: 'info'
testing: testing:
@ -226,13 +225,13 @@ impl serde::Serialize for LogLevel {
} }
} }
pub fn convert_loglevel(log_level: LogLevel) -> LevelFilter { pub fn convert_loglevel(log_level: LogLevel) -> veilid_core::VeilidLogLevel {
match log_level { match log_level {
LogLevel::Error => LevelFilter::Error, LogLevel::Error => veilid_core::VeilidLogLevel::Error,
LogLevel::Warn => LevelFilter::Warn, LogLevel::Warn => veilid_core::VeilidLogLevel::Warn,
LogLevel::Info => LevelFilter::Info, LogLevel::Info => veilid_core::VeilidLogLevel::Info,
LogLevel::Debug => LevelFilter::Debug, LogLevel::Debug => veilid_core::VeilidLogLevel::Debug,
LogLevel::Trace => LevelFilter::Trace, LogLevel::Trace => veilid_core::VeilidLogLevel::Trace,
} }
} }
@ -419,7 +418,7 @@ pub struct System {
} }
#[derive(Debug, Deserialize, Serialize)] #[derive(Debug, Deserialize, Serialize)]
pub struct Client { pub struct Api {
pub enabled: bool, pub enabled: bool,
pub level: LogLevel, pub level: LogLevel,
} }
@ -435,7 +434,7 @@ pub struct Logging {
pub system: System, pub system: System,
pub terminal: Terminal, pub terminal: Terminal,
pub file: File, pub file: File,
pub client: Client, pub api: Api,
} }
#[derive(Debug, Deserialize, Serialize)] #[derive(Debug, Deserialize, Serialize)]
@ -862,7 +861,13 @@ impl Settings {
} else { } else {
format!("subnode{}", inner.testing.subnode_index) format!("subnode{}", inner.testing.subnode_index)
})), })),
"log_level" => Ok(Box::new(veilid_core::VeilidConfigLogLevel::Off)), "api_log_level" => Ok(Box::new(if inner.logging.api.enabled {
veilid_core::VeilidConfigLogLevel::from_veilid_log_level(Some(
convert_loglevel(inner.logging.api.level),
))
} else {
veilid_core::VeilidConfigLogLevel::Off
})),
"capabilities.protocol_udp" => Ok(Box::new(true)), "capabilities.protocol_udp" => Ok(Box::new(true)),
"capabilities.protocol_connect_tcp" => Ok(Box::new(true)), "capabilities.protocol_connect_tcp" => Ok(Box::new(true)),
"capabilities.protocol_accept_tcp" => Ok(Box::new(true)), "capabilities.protocol_accept_tcp" => Ok(Box::new(true)),
@ -1257,8 +1262,8 @@ mod tests {
assert_eq!(s.logging.file.path, ""); assert_eq!(s.logging.file.path, "");
assert_eq!(s.logging.file.append, true); assert_eq!(s.logging.file.append, true);
assert_eq!(s.logging.file.level, LogLevel::Info); assert_eq!(s.logging.file.level, LogLevel::Info);
assert_eq!(s.logging.client.enabled, false); assert_eq!(s.logging.api.enabled, false);
assert_eq!(s.logging.client.level, LogLevel::Info); assert_eq!(s.logging.api.level, LogLevel::Info);
assert_eq!(s.testing.subnode_index, 0); assert_eq!(s.testing.subnode_index, 0);
assert_eq!( assert_eq!(

2
veilid-server/src/unix.rs
View File

@ -93,7 +93,7 @@ pub fn run_daemon(settings: Settings, _matches: ArgMatches) -> Result<(), String
}; };
// Init combined console/file logger // Init combined console/file logger
let logs = VeilidLogs::setup_normal_logs(settings.clone())?; let logs = VeilidLogs::setup(settings.clone())?;
// Daemonize // Daemonize
daemon daemon

235
veilid-server/src/veilid_logs.rs
View File

@ -1,162 +1,127 @@
use crate::log_safe_channel::*;
use crate::settings::*; use crate::settings::*;
use cfg_if::*; use cfg_if::*;
use log::*; use std::path::*;
use simplelog::*; use tracing::*;
use std::fs::OpenOptions; use tracing_appender::*;
use std::path::Path; use tracing_subscriber::prelude::*;
use tracing_subscriber::*;
pub struct VeilidLogs { pub struct VeilidLogs {
pub client_log_channel: Option<LogSafeChannel>, pub guard: Option<non_blocking::WorkerGuard>,
pub client_log_channel_closer: Option<LogSafeChannelCloser>,
} }
cfg_if! { fn logfilter<T: AsRef<str>, V: AsRef<[T]>>(
if #[cfg(target_os = "linux")] { metadata: &Metadata,
use systemd_journal_logger::JournalLog; max_level: veilid_core::VeilidLogLevel,
pub struct SystemLogger { ignore_list: V,
level_filter: LevelFilter, ) -> bool {
config: Config, // Skip filtered targets
journal_log: JournalLog<String,String>, !match (metadata.target(), ignore_list.as_ref()) {
} (path, ignore) if !ignore.is_empty() => {
// Check that the module path does not match any ignore filters
impl SystemLogger { ignore.iter().any(|v| path.starts_with(v.as_ref()))
pub fn new(level_filter: LevelFilter, config: Config) -> Box<Self> {
Box::new(Self {
level_filter,
config,
journal_log: JournalLog::with_extra_fields(Vec::new())
})
}
pub fn should_skip(record: &Record<'_>) -> bool {
// // If a module path and allowed list are available
// match (record.target(), &*config.filter_allow) {
// (path, allowed) if !allowed.is_empty() => {
// // Check that the module path matches at least one allow filter
// if !allowed.iter().any(|v| path.starts_with(&**v)) {
// // If not, skip any further writing
// return true;
// }
// }
// _ => {}
// }
// If a module path and ignore list are available
match (record.target(), &veilid_core::DEFAULT_LOG_IGNORE_LIST) {
(path, ignore) if !ignore.is_empty() => {
// Check that the module path does not match any ignore filters
if ignore.iter().any(|v| path.starts_with(&**v)) {
// If not, skip any further writing
return true;
}
}
_ => {}
}
false
}
}
impl Log for SystemLogger {
fn enabled(&self, metadata: &Metadata<'_>) -> bool {
metadata.level() <= self.level_filter
}
fn log(&self, record: &Record<'_>) {
if self.enabled(record.metadata()) && ! Self::should_skip(record) {
self.journal_log.log(record);
}
}
fn flush(&self) {
self.journal_log.flush();
}
}
impl SharedLogger for SystemLogger {
fn level(&self) -> LevelFilter {
self.level_filter
}
fn config(&self) -> Option<&Config> {
Some(&self.config)
}
fn as_log(self: Box<Self>) -> Box<dyn Log> {
Box::new(*self)
}
} }
_ => false,
} }
} }
impl VeilidLogs { impl VeilidLogs {
pub fn setup_normal_logs(settings: Settings) -> Result<VeilidLogs, String> { pub fn setup(settings: Settings) -> Result<VeilidLogs, String> {
let settingsr = settings.read(); let settingsr = settings.read();
// Set up loggers // Set up subscriber and layers
let mut logs: Vec<Box<dyn SharedLogger>> = Vec::new();
let mut client_log_channel: Option<LogSafeChannel> = None; let mut ignore_list = Vec::<String>::new();
let mut client_log_channel_closer: Option<LogSafeChannelCloser> = None;
let mut cb = ConfigBuilder::new();
for ig in veilid_core::DEFAULT_LOG_IGNORE_LIST { for ig in veilid_core::DEFAULT_LOG_IGNORE_LIST {
cb.add_filter_ignore_str(ig); ignore_list.push(ig.to_owned());
} }
if settingsr.logging.terminal.enabled { let subscriber = Registry::default();
logs.push(TermLogger::new(
convert_loglevel(settingsr.logging.terminal.level), let subscriber = subscriber.with(
cb.build(), EnvFilter::builder()
TerminalMode::Mixed, .with_default_directive(level_filters::LevelFilter::INFO.into())
ColorChoice::Auto, .from_env_lossy(),
)) );
}
if settingsr.logging.file.enabled { let subscriber = subscriber.with(if settingsr.logging.terminal.enabled {
let terminal_max_log_level = convert_loglevel(settingsr.logging.terminal.level);
Some(
fmt::Layer::new()
.compact()
.with_writer(std::io::stdout)
.with_filter(filter::FilterFn::new(move |metadata| {
logfilter(metadata, terminal_max_log_level, &ignore_list)
})),
)
} else {
None
});
let mut guard = None;
let subscriber = subscriber.with(if settingsr.logging.file.enabled {
let file_max_log_level = convert_loglevel(settingsr.logging.file.level);
let log_path = Path::new(&settingsr.logging.file.path); let log_path = Path::new(&settingsr.logging.file.path);
let full_path = std::env::current_dir()
.unwrap_or(PathBuf::from(MAIN_SEPARATOR.to_string()))
.join(log_path);
let log_parent = full_path
.parent()
.unwrap_or(Path::new(&MAIN_SEPARATOR.to_string()))
.canonicalize()
.map_err(|e| {
format!(
"File log path parent does not exist: {} ({})",
settingsr.logging.file.path, e
)
})?;
let log_filename = full_path.file_name().ok_or(format!(
"File log filename not specified in path: {}",
settingsr.logging.file.path
))?;
let logfile = if settingsr.logging.file.append { let appender = tracing_appender::rolling::never(log_parent, Path::new(log_filename));
OpenOptions::new() let (non_blocking_appender, non_blocking_guard) =
.create(true) tracing_appender::non_blocking(appender);
.append(true) guard = Some(non_blocking_guard);
.open(log_path)
.map_err(|e| format!("failed to open log file: {}", e))? Some(
} else { fmt::Layer::new()
OpenOptions::new() .compact()
.create(true) .with_writer(non_blocking_appender)
.truncate(true) .with_filter(filter::FilterFn::new(|metadata| {
.write(true) logfilter(metadata, file_max_log_level, &ignore_list)
.open(log_path) })),
.map_err(|e| format!("failed to open log file: {}", e))? )
}; } else {
logs.push(WriteLogger::new( None
convert_loglevel(settingsr.logging.file.level), });
cb.build(),
logfile, let subscriber = subscriber.with(if settingsr.logging.api.enabled {
)) // Get layer from veilid core, filtering is done by ApiTracingLayer automatically
} Some(veilid_core::ApiTracingLayer::get())
if settingsr.logging.client.enabled { } else {
let (clog, clogwriter, clogcloser) = LogSafeChannel::new(); None
client_log_channel = Some(clog); });
client_log_channel_closer = Some(clogcloser);
logs.push(WriteLogger::new(
convert_loglevel(settingsr.logging.client.level),
cb.build(),
clogwriter,
))
}
cfg_if! { cfg_if! {
if #[cfg(target_os = "linux")] { if #[cfg(target_os = "linux")] {
if settingsr.logging.system.enabled { let subscriber = subscriber.with(if settingsr.logging.system.enabled {
logs.push(SystemLogger::new(convert_loglevel(settingsr.logging.system.level), cb.build())) let system_max_log_level = convert_loglevel(settingsr.logging.system.level);
} Some(tracing_journald::layer().map_err(|e| format!("failed to set up journald logging: {}", e))?.with_filter(filter::FilterFn::new(|metadata| {
logfilter(metadata, system_max_log_level, &ignore_list)
})))
} else {
None
});
} }
} }
CombinedLogger::init(logs).map_err(|e| format!("failed to init logs: {}", e))?; subscriber
.try_init()
.map_err(|e| format!("failed to initialize logging: {}", e))?;
Ok(VeilidLogs { Ok(VeilidLogs { guard })
client_log_channel,
client_log_channel_closer,
})
} }
} }

3
veilid-wasm/Cargo.toml
View File

@ -12,7 +12,8 @@ crate-type = ["cdylib", "rlib"]
wasm-bindgen = { version = "^0", features = ["serde-serialize"] } wasm-bindgen = { version = "^0", features = ["serde-serialize"] }
console_error_panic_hook = "^0" console_error_panic_hook = "^0"
wee_alloc = "^0" wee_alloc = "^0"
log = "^0" tracing-wasm = "^0"
tracing-subscriber = "^0"
veilid-core = { path = "../veilid-core" } veilid-core = { path = "../veilid-core" }
cfg-if = "^1" cfg-if = "^1"
wasm-bindgen-futures = "^0" wasm-bindgen-futures = "^0"

4
veilid-wasm/src/lib.rs
View File

@ -139,11 +139,11 @@ pub fn get_veilid_state() -> Promise {
} }
#[wasm_bindgen()] #[wasm_bindgen()]
pub fn change_log_level(log_level: String) -> Promise { pub fn change_api_log_level(log_level: String) -> Promise {
wrap_api_future(async move { wrap_api_future(async move {
let veilid_api = get_veilid_api()?; let veilid_api = get_veilid_api()?;
let log_level: veilid_core::VeilidConfigLogLevel = deserialize_json(&log_level)?; let log_level: veilid_core::VeilidConfigLogLevel = deserialize_json(&log_level)?;
veilid_api.change_log_level(log_level).await; veilid_api.change_api_log_level(log_level).await;
APIRESULT_UNDEFINED APIRESULT_UNDEFINED
}) })
} }