Git-Mirrors/veilid
1
0
Fork 0
mirror of https://gitlab.com/veilid/veilid.git synced 2025-02-08 18:58:32 -05:00
Code Issues Packages Projects Releases Wiki Activity

logging improvements

Browse Source
This commit is contained in:
Christien Rioux 2024-03-01 11:38:03 -05:00
parent 292664f3fe
commit ef6ecdab79
19 changed files with 1920 additions and 1500 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
veilid-core/src/api_tracing_layer.rs
View File

@ -47,6 +47,19 @@ impl ApiTracingLayer {
} }
} }
fn simplify_file(file: &str) -> String {
let path = std::path::Path::new(file);
let path_component_count = path.iter().count();
if path.ends_with("mod.rs") && path_component_count >= 2 {
let outpath: std::path::PathBuf = path.iter().skip(path_component_count - 2).collect();
outpath.to_string_lossy().to_string()
} else if let Some(filename) = path.file_name() {
filename.to_string_lossy().to_string()
} else {
file.to_string()
}
}
impl<S: Subscriber + for<'a> registry::LookupSpan<'a>> Layer<S> for ApiTracingLayer { impl<S: Subscriber + for<'a> registry::LookupSpan<'a>> Layer<S> for ApiTracingLayer {
fn on_new_span( fn on_new_span(
&self, &self,
@ -86,15 +99,39 @@ impl<S: Subscriber + for<'a> registry::LookupSpan<'a>> Layer<S> for ApiTracingLa
let mut recorder = StringRecorder::new(); let mut recorder = StringRecorder::new();
event.record(&mut recorder); event.record(&mut recorder);
let meta = event.metadata(); let meta = event.metadata();
let level = meta.level(); let level = *meta.level();
let log_level = VeilidLogLevel::from_tracing_level(*level); let target = meta.target();
let log_level = VeilidLogLevel::from_tracing_level(level);
let origin = meta let origin = match level {
.file() Level::ERROR | Level::WARN => meta
.and_then(|file| meta.line().map(|ln| format!("{}:{}", file, ln))) .file()
.unwrap_or_default(); .and_then(|file| {
meta.line()
.map(|ln| format!("{}:{}", simplify_file(file), ln))
})
.unwrap_or_default(),
Level::INFO => "".to_owned(),
Level::DEBUG | Level::TRACE => meta
.file()
.and_then(|file| {
meta.line().map(|ln| {
format!(
"{}{}:{}",
if target.is_empty() {
"".to_owned()
} else {
format!("[{}]", target)
},
simplify_file(file),
ln
)
})
})
.unwrap_or_default(),
};
let message = format!("{} {}", origin, recorder); let message = format!("{}{}", origin, recorder).trim().to_owned();
let backtrace = if log_level <= VeilidLogLevel::Error { let backtrace = if log_level <= VeilidLogLevel::Error {
let bt = backtrace::Backtrace::new(); let bt = backtrace::Backtrace::new();

12
veilid-core/src/rpc_processor/mod.rs
View File

@ -373,7 +373,7 @@ impl RPCProcessor {
#[instrument(level = "debug", skip_all, err)] #[instrument(level = "debug", skip_all, err)]
pub async fn startup(&self) -> EyreResult<()> { pub async fn startup(&self) -> EyreResult<()> {
debug!("startup rpc processor"); log_rpc!(debug "startup rpc processor");
{ {
let mut inner = self.inner.lock(); let mut inner = self.inner.lock();
@ -382,7 +382,7 @@ impl RPCProcessor {
inner.stop_source = Some(StopSource::new()); inner.stop_source = Some(StopSource::new());
// spin up N workers // spin up N workers
trace!( log_rpc!(
"Spinning up {} RPC workers", "Spinning up {} RPC workers",
self.unlocked_inner.concurrency self.unlocked_inner.concurrency
); );
@ -408,7 +408,7 @@ impl RPCProcessor {
#[instrument(level = "debug", skip_all)] #[instrument(level = "debug", skip_all)]
pub async fn shutdown(&self) { pub async fn shutdown(&self) {
debug!("starting rpc processor shutdown"); log_rpc!(debug "starting rpc processor shutdown");
// Stop storage manager from using us // Stop storage manager from using us
self.storage_manager.set_rpc_processor(None).await; self.storage_manager.set_rpc_processor(None).await;
@ -424,17 +424,17 @@ impl RPCProcessor {
// drop the stop // drop the stop
drop(inner.stop_source.take()); drop(inner.stop_source.take());
} }
debug!("stopping {} rpc worker tasks", unord.len()); log_rpc!(debug "stopping {} rpc worker tasks", unord.len());
// Wait for them to complete // Wait for them to complete
while unord.next().await.is_some() {} while unord.next().await.is_some() {}
debug!("resetting rpc processor state"); log_rpc!(debug "resetting rpc processor state");
// Release the rpc processor // Release the rpc processor
*self.inner.lock() = Self::new_inner(); *self.inner.lock() = Self::new_inner();
debug!("finished rpc processor shutdown"); log_rpc!(debug "finished rpc processor shutdown");
} }
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////

33
veilid-core/src/veilid_api/api.rs
View File

@ -41,6 +41,8 @@ pub struct VeilidAPI {
impl VeilidAPI { impl VeilidAPI {
#[instrument(target = "veilid_api", level = "debug", skip_all)] #[instrument(target = "veilid_api", level = "debug", skip_all)]
pub(crate) fn new(context: VeilidCoreContext) -> Self { pub(crate) fn new(context: VeilidCoreContext) -> Self {
event!(target: "veilid_api", Level::DEBUG,
"VeilidAPI::new()");
Self { Self {
inner: Arc::new(Mutex::new(VeilidAPIInner { inner: Arc::new(Mutex::new(VeilidAPIInner {
context: Some(context), context: Some(context),
@ -51,6 +53,8 @@ impl VeilidAPI {
/// Shut down Veilid and terminate the API /// Shut down Veilid and terminate the API
#[instrument(target = "veilid_api", level = "debug", skip_all)] #[instrument(target = "veilid_api", level = "debug", skip_all)]
pub async fn shutdown(self) { pub async fn shutdown(self) {
event!(target: "veilid_api", Level::DEBUG,
"VeilidAPI::shutdown()");
let context = { self.inner.lock().context.take() }; let context = { self.inner.lock().context.take() };
if let Some(context) = context { if let Some(context) = context {
api_shutdown(context).await; api_shutdown(context).await;
@ -168,8 +172,11 @@ impl VeilidAPI {
} }
/// Connect to the network /// Connect to the network
#[instrument(target = "veilid_api", level = "debug", skip_all)] #[instrument(target = "veilid_api", level = "debug", skip_all, ret, err)]
pub async fn attach(&self) -> VeilidAPIResult<()> { pub async fn attach(&self) -> VeilidAPIResult<()> {
event!(target: "veilid_api", Level::DEBUG,
"VeilidAPI::attach()");
let attachment_manager = self.attachment_manager()?; let attachment_manager = self.attachment_manager()?;
if !attachment_manager.attach().await { if !attachment_manager.attach().await {
apibail_generic!("Already attached"); apibail_generic!("Already attached");
@ -178,8 +185,11 @@ impl VeilidAPI {
} }
/// Disconnect from the network /// Disconnect from the network
#[instrument(target = "veilid_api", level = "debug", skip_all)] #[instrument(target = "veilid_api", level = "debug", skip_all, ret, err)]
pub async fn detach(&self) -> VeilidAPIResult<()> { pub async fn detach(&self) -> VeilidAPIResult<()> {
event!(target: "veilid_api", Level::DEBUG,
"VeilidAPI::detach()");
let attachment_manager = self.attachment_manager()?; let attachment_manager = self.attachment_manager()?;
if !attachment_manager.detach().await { if !attachment_manager.detach().await {
apibail_generic!("Already detached"); apibail_generic!("Already detached");
@ -193,6 +203,9 @@ impl VeilidAPI {
/// Get a new `RoutingContext` object to use to send messages over the Veilid network. /// Get a new `RoutingContext` object to use to send messages over the Veilid network.
#[instrument(target = "veilid_api", level = "debug", skip_all, err, ret)] #[instrument(target = "veilid_api", level = "debug", skip_all, err, ret)]
pub fn routing_context(&self) -> VeilidAPIResult<RoutingContext> { pub fn routing_context(&self) -> VeilidAPIResult<RoutingContext> {
event!(target: "veilid_api", Level::DEBUG,
"VeilidAPI::routing_context()");
RoutingContext::try_new(self.clone()) RoutingContext::try_new(self.clone())
} }
@ -207,6 +220,9 @@ impl VeilidAPI {
pub async fn parse_as_target<S: ToString>(&self, s: S) -> VeilidAPIResult<Target> { pub async fn parse_as_target<S: ToString>(&self, s: S) -> VeilidAPIResult<Target> {
let s = s.to_string(); let s = s.to_string();
event!(target: "veilid_api", Level::DEBUG,
"VeilidAPI::parse_as_target(s: {:?})", s);
// Is this a route id? // Is this a route id?
if let Ok(rrid) = RouteId::from_str(&s) { if let Ok(rrid) = RouteId::from_str(&s) {
let routing_table = self.routing_table()?; let routing_table = self.routing_table()?;
@ -258,6 +274,12 @@ impl VeilidAPI {
stability: Stability, stability: Stability,
sequencing: Sequencing, sequencing: Sequencing,
) -> VeilidAPIResult<(RouteId, Vec<u8>)> { ) -> VeilidAPIResult<(RouteId, Vec<u8>)> {
event!(target: "veilid_api", Level::DEBUG,
"VeilidAPI::new_custom_private_route(crypto_kinds: {:?}, stability: {:?}, sequencing: {:?})",
crypto_kinds,
stability,
sequencing);
for kind in crypto_kinds { for kind in crypto_kinds {
Crypto::validate_crypto_kind(*kind)?; Crypto::validate_crypto_kind(*kind)?;
} }
@ -301,6 +323,8 @@ impl VeilidAPI {
/// Returns a route id that can be used to send private messages to the node creating this route. /// Returns a route id that can be used to send private messages to the node creating this route.
#[instrument(target = "veilid_api", level = "debug", skip(self), ret, err)] #[instrument(target = "veilid_api", level = "debug", skip(self), ret, err)]
pub fn import_remote_private_route(&self, blob: Vec<u8>) -> VeilidAPIResult<RouteId> { pub fn import_remote_private_route(&self, blob: Vec<u8>) -> VeilidAPIResult<RouteId> {
event!(target: "veilid_api", Level::DEBUG,
"VeilidAPI::import_remote_private_route(blob: {:?})", blob);
let rss = self.routing_table()?.route_spec_store(); let rss = self.routing_table()?.route_spec_store();
rss.import_remote_private_route_blob(blob) rss.import_remote_private_route_blob(blob)
} }
@ -311,6 +335,8 @@ impl VeilidAPI {
/// or received from. /// or received from.
#[instrument(target = "veilid_api", level = "debug", skip(self), ret, err)] #[instrument(target = "veilid_api", level = "debug", skip(self), ret, err)]
pub fn release_private_route(&self, route_id: RouteId) -> VeilidAPIResult<()> { pub fn release_private_route(&self, route_id: RouteId) -> VeilidAPIResult<()> {
event!(target: "veilid_api", Level::DEBUG,
"VeilidAPI::release_private_route(route_id: {:?})", route_id);
let rss = self.routing_table()?.route_spec_store(); let rss = self.routing_table()?.route_spec_store();
if !rss.release_route(route_id) { if !rss.release_route(route_id) {
apibail_invalid_argument!("release_private_route", "key", route_id); apibail_invalid_argument!("release_private_route", "key", route_id);
@ -331,6 +357,9 @@ impl VeilidAPI {
call_id: OperationId, call_id: OperationId,
message: Vec<u8>, message: Vec<u8>,
) -> VeilidAPIResult<()> { ) -> VeilidAPIResult<()> {
event!(target: "veilid_api", Level::DEBUG,
"VeilidAPI::app_call_reply(call_id: {:?}, message: {:?})", call_id, message);
let rpc_processor = self.rpc_processor()?; let rpc_processor = self.rpc_processor()?;
rpc_processor rpc_processor
.app_call_reply(call_id, message) .app_call_reply(call_id, message)

42
veilid-core/src/veilid_api/routing_context.rs
View File

@ -74,6 +74,9 @@ impl RoutingContext {
/// To customize the safety selection in use, use [RoutingContext::with_safety()]. /// To customize the safety selection in use, use [RoutingContext::with_safety()].
#[instrument(target = "veilid_api", level = "debug", ret, err)] #[instrument(target = "veilid_api", level = "debug", ret, err)]
pub fn with_default_safety(self) -> VeilidAPIResult<Self> { pub fn with_default_safety(self) -> VeilidAPIResult<Self> {
event!(target: "veilid_api", Level::DEBUG,
"RoutingContext::with_default_safety(self: {:?})", self);
let config = self.api.config()?; let config = self.api.config()?;
let c = config.get(); let c = config.get();
@ -88,6 +91,9 @@ impl RoutingContext {
/// Use a custom [SafetySelection]. Can be used to disable safety via [SafetySelection::Unsafe] /// Use a custom [SafetySelection]. Can be used to disable safety via [SafetySelection::Unsafe]
#[instrument(target = "veilid_api", level = "debug", ret, err)] #[instrument(target = "veilid_api", level = "debug", ret, err)]
pub fn with_safety(self, safety_selection: SafetySelection) -> VeilidAPIResult<Self> { pub fn with_safety(self, safety_selection: SafetySelection) -> VeilidAPIResult<Self> {
event!(target: "veilid_api", Level::DEBUG,
"RoutingContext::with_safety(self: {:?}, safety_selection: {:?})", self, safety_selection);
Ok(Self { Ok(Self {
api: self.api.clone(), api: self.api.clone(),
inner: Arc::new(Mutex::new(RoutingContextInner {})), inner: Arc::new(Mutex::new(RoutingContextInner {})),
@ -98,6 +104,9 @@ impl RoutingContext {
/// Use a specified [Sequencing] preference, with or without privacy /// Use a specified [Sequencing] preference, with or without privacy
#[instrument(target = "veilid_api", level = "debug", ret)] #[instrument(target = "veilid_api", level = "debug", ret)]
pub fn with_sequencing(self, sequencing: Sequencing) -> Self { pub fn with_sequencing(self, sequencing: Sequencing) -> Self {
event!(target: "veilid_api", Level::DEBUG,
"RoutingContext::with_sequencing(self: {:?}, sequencing: {:?})", self, sequencing);
Self { Self {
api: self.api.clone(), api: self.api.clone(),
inner: Arc::new(Mutex::new(RoutingContextInner {})), inner: Arc::new(Mutex::new(RoutingContextInner {})),
@ -134,6 +143,9 @@ impl RoutingContext {
#[instrument(target = "veilid_api", level = "debug", ret, err)] #[instrument(target = "veilid_api", level = "debug", ret, err)]
async fn get_destination(&self, target: Target) -> VeilidAPIResult<rpc_processor::Destination> { async fn get_destination(&self, target: Target) -> VeilidAPIResult<rpc_processor::Destination> {
event!(target: "veilid_api", Level::DEBUG,
"RoutingContext::get_destination(self: {:?}, target: {:?})", self, target);
let rpc_processor = self.api.rpc_processor()?; let rpc_processor = self.api.rpc_processor()?;
rpc_processor rpc_processor
.resolve_target_to_destination(target, self.unlocked_inner.safety_selection) .resolve_target_to_destination(target, self.unlocked_inner.safety_selection)
@ -154,6 +166,9 @@ impl RoutingContext {
/// Returns an answer blob of up to 32768 bytes /// Returns an answer blob of up to 32768 bytes
#[instrument(target = "veilid_api", level = "debug", ret, err)] #[instrument(target = "veilid_api", level = "debug", ret, err)]
pub async fn app_call(&self, target: Target, message: Vec<u8>) -> VeilidAPIResult<Vec<u8>> { pub async fn app_call(&self, target: Target, message: Vec<u8>) -> VeilidAPIResult<Vec<u8>> {
event!(target: "veilid_api", Level::DEBUG,
"RoutingContext::app_call(self: {:?}, target: {:?}, message: {:?})", self, target, message);
let rpc_processor = self.api.rpc_processor()?; let rpc_processor = self.api.rpc_processor()?;
// Get destination // Get destination
@ -185,6 +200,9 @@ impl RoutingContext {
/// * `message` - an arbitrary message blob of up to 32768 bytes /// * `message` - an arbitrary message blob of up to 32768 bytes
#[instrument(target = "veilid_api", level = "debug", ret, err)] #[instrument(target = "veilid_api", level = "debug", ret, err)]
pub async fn app_message(&self, target: Target, message: Vec<u8>) -> VeilidAPIResult<()> { pub async fn app_message(&self, target: Target, message: Vec<u8>) -> VeilidAPIResult<()> {
event!(target: "veilid_api", Level::DEBUG,
"RoutingContext::app_message(self: {:?}, target: {:?}, message: {:?})", self, target, message);
let rpc_processor = self.api.rpc_processor()?; let rpc_processor = self.api.rpc_processor()?;
// Get destination // Get destination
@ -221,6 +239,9 @@ impl RoutingContext {
schema: DHTSchema, schema: DHTSchema,
kind: Option<CryptoKind>, kind: Option<CryptoKind>,
) -> VeilidAPIResult<DHTRecordDescriptor> { ) -> VeilidAPIResult<DHTRecordDescriptor> {
event!(target: "veilid_api", Level::DEBUG,
"RoutingContext::create_dht_record(self: {:?}, schema: {:?}, kind: {:?})", self, schema, kind);
let kind = kind.unwrap_or(best_crypto_kind()); let kind = kind.unwrap_or(best_crypto_kind());
Crypto::validate_crypto_kind(kind)?; Crypto::validate_crypto_kind(kind)?;
let storage_manager = self.api.storage_manager()?; let storage_manager = self.api.storage_manager()?;
@ -246,6 +267,9 @@ impl RoutingContext {
key: TypedKey, key: TypedKey,
default_writer: Option<KeyPair>, default_writer: Option<KeyPair>,
) -> VeilidAPIResult<DHTRecordDescriptor> { ) -> VeilidAPIResult<DHTRecordDescriptor> {
event!(target: "veilid_api", Level::DEBUG,
"RoutingContext::open_dht_record(self: {:?}, key: {:?}, default_writer: {:?})", self, key, default_writer);
Crypto::validate_crypto_kind(key.kind)?; Crypto::validate_crypto_kind(key.kind)?;
let storage_manager = self.api.storage_manager()?; let storage_manager = self.api.storage_manager()?;
storage_manager storage_manager
@ -258,6 +282,9 @@ impl RoutingContext {
/// Closing a record allows you to re-open it with a different routing context /// Closing a record allows you to re-open it with a different routing context
#[instrument(target = "veilid_api", level = "debug", ret, err)] #[instrument(target = "veilid_api", level = "debug", ret, err)]
pub async fn close_dht_record(&self, key: TypedKey) -> VeilidAPIResult<()> { pub async fn close_dht_record(&self, key: TypedKey) -> VeilidAPIResult<()> {
event!(target: "veilid_api", Level::DEBUG,
"RoutingContext::close_dht_record(self: {:?}, key: {:?})", self, key);
Crypto::validate_crypto_kind(key.kind)?; Crypto::validate_crypto_kind(key.kind)?;
let storage_manager = self.api.storage_manager()?; let storage_manager = self.api.storage_manager()?;
storage_manager.close_record(key).await storage_manager.close_record(key).await
@ -270,6 +297,9 @@ impl RoutingContext {
/// locally, and will prevent its value from being refreshed on the network by this node. /// locally, and will prevent its value from being refreshed on the network by this node.
#[instrument(target = "veilid_api", level = "debug", ret, err)] #[instrument(target = "veilid_api", level = "debug", ret, err)]
pub async fn delete_dht_record(&self, key: TypedKey) -> VeilidAPIResult<()> { pub async fn delete_dht_record(&self, key: TypedKey) -> VeilidAPIResult<()> {
event!(target: "veilid_api", Level::DEBUG,
"RoutingContext::delete_dht_record(self: {:?}, key: {:?})", self, key);
Crypto::validate_crypto_kind(key.kind)?; Crypto::validate_crypto_kind(key.kind)?;
let storage_manager = self.api.storage_manager()?; let storage_manager = self.api.storage_manager()?;
storage_manager.delete_record(key).await storage_manager.delete_record(key).await
@ -288,6 +318,9 @@ impl RoutingContext {
subkey: ValueSubkey, subkey: ValueSubkey,
force_refresh: bool, force_refresh: bool,
) -> VeilidAPIResult<Option<ValueData>> { ) -> VeilidAPIResult<Option<ValueData>> {
event!(target: "veilid_api", Level::DEBUG,
"RoutingContext::get_dht_value(self: {:?}, key: {:?}, subkey: {:?}, force_refresh: {:?})", self, key, subkey, force_refresh);
Crypto::validate_crypto_kind(key.kind)?; Crypto::validate_crypto_kind(key.kind)?;
let storage_manager = self.api.storage_manager()?; let storage_manager = self.api.storage_manager()?;
storage_manager.get_value(key, subkey, force_refresh).await storage_manager.get_value(key, subkey, force_refresh).await
@ -308,6 +341,9 @@ impl RoutingContext {
data: Vec<u8>, data: Vec<u8>,
writer: Option<KeyPair>, writer: Option<KeyPair>,
) -> VeilidAPIResult<Option<ValueData>> { ) -> VeilidAPIResult<Option<ValueData>> {
event!(target: "veilid_api", Level::DEBUG,
"RoutingContext::set_dht_value(self: {:?}, key: {:?}, subkey: {:?}, data: {:?}, writer: {:?})", self, key, subkey, data, writer);
Crypto::validate_crypto_kind(key.kind)?; Crypto::validate_crypto_kind(key.kind)?;
let storage_manager = self.api.storage_manager()?; let storage_manager = self.api.storage_manager()?;
storage_manager.set_value(key, subkey, data, writer).await storage_manager.set_value(key, subkey, data, writer).await
@ -340,6 +376,9 @@ impl RoutingContext {
expiration: Timestamp, expiration: Timestamp,
count: u32, count: u32,
) -> VeilidAPIResult<Timestamp> { ) -> VeilidAPIResult<Timestamp> {
event!(target: "veilid_api", Level::DEBUG,
"RoutingContext::watch_dht_values(self: {:?}, key: {:?}, subkeys: {:?}, expiration: {:?}, count: {:?})", self, key, subkeys, expiration, count);
Crypto::validate_crypto_kind(key.kind)?; Crypto::validate_crypto_kind(key.kind)?;
let storage_manager = self.api.storage_manager()?; let storage_manager = self.api.storage_manager()?;
storage_manager storage_manager
@ -358,6 +397,9 @@ impl RoutingContext {
key: TypedKey, key: TypedKey,
subkeys: ValueSubkeyRangeSet, subkeys: ValueSubkeyRangeSet,
) -> VeilidAPIResult<bool> { ) -> VeilidAPIResult<bool> {
event!(target: "veilid_api", Level::DEBUG,
"RoutingContext::cancel_dht_watch(self: {:?}, key: {:?}, subkeys: {:?}", self, key, subkeys);
Crypto::validate_crypto_kind(key.kind)?; Crypto::validate_crypto_kind(key.kind)?;
let storage_manager = self.api.storage_manager()?; let storage_manager = self.api.storage_manager()?;
storage_manager.cancel_watch_values(key, subkeys).await storage_manager.cancel_watch_values(key, subkeys).await

18
veilid-core/src/veilid_layer_filter.rs
View File

@ -16,13 +16,25 @@ pub struct VeilidLayerFilter {
impl VeilidLayerFilter { impl VeilidLayerFilter {
pub fn new( pub fn new(
max_level: VeilidConfigLogLevel, max_level: VeilidConfigLogLevel,
ignore_list: Option<Vec<String>>, ignore_log_targets: &[String],
) -> VeilidLayerFilter { ) -> VeilidLayerFilter {
let mut ignore_list = DEFAULT_LOG_IGNORE_LIST.map(|x| x.to_owned()).to_vec();
for igedit in ignore_log_targets {
if let Some(rest) = igedit.strip_prefix('-') {
for i in 0..ignore_list.len() {
if ignore_list[i] == rest {
ignore_list.remove(i);
break;
}
}
} else {
ignore_list.push(igedit.clone());
}
}
Self { Self {
inner: Arc::new(RwLock::new(VeilidLayerFilterInner { inner: Arc::new(RwLock::new(VeilidLayerFilterInner {
max_level: max_level.to_tracing_level_filter(), max_level: max_level.to_tracing_level_filter(),
ignore_list: ignore_list ignore_list,
.unwrap_or_else(|| DEFAULT_LOG_IGNORE_LIST.map(|x| x.to_owned()).to_vec()),
})), })),
} }
} }

20
veilid-flutter/example/lib/veilid_init.dart
View File

@ -11,24 +11,30 @@ void veilidInit() {
enabled: true, enabled: true,
level: VeilidConfigLogLevel.debug, level: VeilidConfigLogLevel.debug,
logsInTimings: true, logsInTimings: true,
logsInConsole: false), logsInConsole: false,
ignoreLogTargets: []),
api: VeilidWASMConfigLoggingApi( api: VeilidWASMConfigLoggingApi(
enabled: true, level: VeilidConfigLogLevel.info))); enabled: true,
level: VeilidConfigLogLevel.info,
ignoreLogTargets: [])));
Veilid.instance.initializeVeilidCore(platformConfig.toJson()); Veilid.instance.initializeVeilidCore(platformConfig.toJson());
} else { } else {
var platformConfig = const VeilidFFIConfig( var platformConfig = const VeilidFFIConfig(
logging: VeilidFFIConfigLogging( logging: VeilidFFIConfigLogging(
terminal: VeilidFFIConfigLoggingTerminal( terminal: VeilidFFIConfigLoggingTerminal(
enabled: false, enabled: false,
level: VeilidConfigLogLevel.debug, level: VeilidConfigLogLevel.debug,
), ignoreLogTargets: []),
otlp: VeilidFFIConfigLoggingOtlp( otlp: VeilidFFIConfigLoggingOtlp(
enabled: false, enabled: false,
level: VeilidConfigLogLevel.trace, level: VeilidConfigLogLevel.trace,
grpcEndpoint: "localhost:4317", grpcEndpoint: "localhost:4317",
serviceName: "VeilidExample"), serviceName: "VeilidExample",
ignoreLogTargets: []),
api: VeilidFFIConfigLoggingApi( api: VeilidFFIConfigLoggingApi(
enabled: true, level: VeilidConfigLogLevel.info))); enabled: true,
level: VeilidConfigLogLevel.info,
ignoreLogTargets: [])));
Veilid.instance.initializeVeilidCore(platformConfig.toJson()); Veilid.instance.initializeVeilidCore(platformConfig.toJson());
} }
} }

316
veilid-flutter/lib/routing_context.freezed.dart
View File

@ -12,7 +12,7 @@ part of 'routing_context.dart';
T _$identity<T>(T value) => value; T _$identity<T>(T value) => value;
final _privateConstructorUsedError = UnsupportedError( final _privateConstructorUsedError = UnsupportedError(
'It seems like you constructed your class using `MyClass._()`. This constructor is only meant to be used by freezed and you are not supposed to need it nor use it.\nPlease check the documentation here for more information: https://github.com/rrousselGit/freezed#custom-getters-and-methods'); 'It seems like you constructed your class using `MyClass._()`. This constructor is only meant to be used by freezed and you are not supposed to need it nor use it.\nPlease check the documentation here for more information: https://github.com/rrousselGit/freezed#adding-getters-and-methods-to-our-models');
DHTSchema _$DHTSchemaFromJson(Map<String, dynamic> json) { DHTSchema _$DHTSchemaFromJson(Map<String, dynamic> json) {
switch (json['kind']) { switch (json['kind']) {
@ -107,22 +107,22 @@ class _$DHTSchemaCopyWithImpl<$Res, $Val extends DHTSchema>
} }
/// @nodoc /// @nodoc
abstract class _$$DHTSchemaDFLTCopyWith<$Res> abstract class _$$DHTSchemaDFLTImplCopyWith<$Res>
implements $DHTSchemaCopyWith<$Res> { implements $DHTSchemaCopyWith<$Res> {
factory _$$DHTSchemaDFLTCopyWith( factory _$$DHTSchemaDFLTImplCopyWith(
_$DHTSchemaDFLT value, $Res Function(_$DHTSchemaDFLT) then) = _$DHTSchemaDFLTImpl value, $Res Function(_$DHTSchemaDFLTImpl) then) =
__$$DHTSchemaDFLTCopyWithImpl<$Res>; __$$DHTSchemaDFLTImplCopyWithImpl<$Res>;
@override @override
@useResult @useResult
$Res call({int oCnt}); $Res call({int oCnt});
} }
/// @nodoc /// @nodoc
class __$$DHTSchemaDFLTCopyWithImpl<$Res> class __$$DHTSchemaDFLTImplCopyWithImpl<$Res>
extends _$DHTSchemaCopyWithImpl<$Res, _$DHTSchemaDFLT> extends _$DHTSchemaCopyWithImpl<$Res, _$DHTSchemaDFLTImpl>
implements _$$DHTSchemaDFLTCopyWith<$Res> { implements _$$DHTSchemaDFLTImplCopyWith<$Res> {
__$$DHTSchemaDFLTCopyWithImpl( __$$DHTSchemaDFLTImplCopyWithImpl(
_$DHTSchemaDFLT _value, $Res Function(_$DHTSchemaDFLT) _then) _$DHTSchemaDFLTImpl _value, $Res Function(_$DHTSchemaDFLTImpl) _then)
: super(_value, _then); : super(_value, _then);
@pragma('vm:prefer-inline') @pragma('vm:prefer-inline')
@ -130,7 +130,7 @@ class __$$DHTSchemaDFLTCopyWithImpl<$Res>
$Res call({ $Res call({
Object? oCnt = null, Object? oCnt = null,
}) { }) {
return _then(_$DHTSchemaDFLT( return _then(_$DHTSchemaDFLTImpl(
oCnt: null == oCnt oCnt: null == oCnt
? _value.oCnt ? _value.oCnt
: oCnt // ignore: cast_nullable_to_non_nullable : oCnt // ignore: cast_nullable_to_non_nullable
@ -141,12 +141,12 @@ class __$$DHTSchemaDFLTCopyWithImpl<$Res>
/// @nodoc /// @nodoc
@JsonSerializable() @JsonSerializable()
class _$DHTSchemaDFLT implements DHTSchemaDFLT { class _$DHTSchemaDFLTImpl implements DHTSchemaDFLT {
const _$DHTSchemaDFLT({required this.oCnt, final String? $type}) const _$DHTSchemaDFLTImpl({required this.oCnt, final String? $type})
: $type = $type ?? 'DFLT'; : $type = $type ?? 'DFLT';
factory _$DHTSchemaDFLT.fromJson(Map<String, dynamic> json) => factory _$DHTSchemaDFLTImpl.fromJson(Map<String, dynamic> json) =>
_$$DHTSchemaDFLTFromJson(json); _$$DHTSchemaDFLTImplFromJson(json);
@override @override
final int oCnt; final int oCnt;
@ -160,10 +160,10 @@ class _$DHTSchemaDFLT implements DHTSchemaDFLT {
} }
@override @override
bool operator ==(dynamic other) { bool operator ==(Object other) {
return identical(this, other) || return identical(this, other) ||
(other.runtimeType == runtimeType && (other.runtimeType == runtimeType &&
other is _$DHTSchemaDFLT && other is _$DHTSchemaDFLTImpl &&
(identical(other.oCnt, oCnt) || other.oCnt == oCnt)); (identical(other.oCnt, oCnt) || other.oCnt == oCnt));
} }
@ -174,8 +174,8 @@ class _$DHTSchemaDFLT implements DHTSchemaDFLT {
@JsonKey(ignore: true) @JsonKey(ignore: true)
@override @override
@pragma('vm:prefer-inline') @pragma('vm:prefer-inline')
_$$DHTSchemaDFLTCopyWith<_$DHTSchemaDFLT> get copyWith => _$$DHTSchemaDFLTImplCopyWith<_$DHTSchemaDFLTImpl> get copyWith =>
__$$DHTSchemaDFLTCopyWithImpl<_$DHTSchemaDFLT>(this, _$identity); __$$DHTSchemaDFLTImplCopyWithImpl<_$DHTSchemaDFLTImpl>(this, _$identity);
@override @override
@optionalTypeArgs @optionalTypeArgs
@ -241,43 +241,43 @@ class _$DHTSchemaDFLT implements DHTSchemaDFLT {
@override @override
Map<String, dynamic> toJson() { Map<String, dynamic> toJson() {
return _$$DHTSchemaDFLTToJson( return _$$DHTSchemaDFLTImplToJson(
this, this,
); );
} }
} }
abstract class DHTSchemaDFLT implements DHTSchema { abstract class DHTSchemaDFLT implements DHTSchema {
const factory DHTSchemaDFLT({required final int oCnt}) = _$DHTSchemaDFLT; const factory DHTSchemaDFLT({required final int oCnt}) = _$DHTSchemaDFLTImpl;
factory DHTSchemaDFLT.fromJson(Map<String, dynamic> json) = factory DHTSchemaDFLT.fromJson(Map<String, dynamic> json) =
_$DHTSchemaDFLT.fromJson; _$DHTSchemaDFLTImpl.fromJson;
@override @override
int get oCnt; int get oCnt;
@override @override
@JsonKey(ignore: true) @JsonKey(ignore: true)
_$$DHTSchemaDFLTCopyWith<_$DHTSchemaDFLT> get copyWith => _$$DHTSchemaDFLTImplCopyWith<_$DHTSchemaDFLTImpl> get copyWith =>
throw _privateConstructorUsedError; throw _privateConstructorUsedError;
} }
/// @nodoc /// @nodoc
abstract class _$$DHTSchemaSMPLCopyWith<$Res> abstract class _$$DHTSchemaSMPLImplCopyWith<$Res>
implements $DHTSchemaCopyWith<$Res> { implements $DHTSchemaCopyWith<$Res> {
factory _$$DHTSchemaSMPLCopyWith( factory _$$DHTSchemaSMPLImplCopyWith(
_$DHTSchemaSMPL value, $Res Function(_$DHTSchemaSMPL) then) = _$DHTSchemaSMPLImpl value, $Res Function(_$DHTSchemaSMPLImpl) then) =
__$$DHTSchemaSMPLCopyWithImpl<$Res>; __$$DHTSchemaSMPLImplCopyWithImpl<$Res>;
@override @override
@useResult @useResult
$Res call({int oCnt, List<DHTSchemaMember> members}); $Res call({int oCnt, List<DHTSchemaMember> members});
} }
/// @nodoc /// @nodoc
class __$$DHTSchemaSMPLCopyWithImpl<$Res> class __$$DHTSchemaSMPLImplCopyWithImpl<$Res>
extends _$DHTSchemaCopyWithImpl<$Res, _$DHTSchemaSMPL> extends _$DHTSchemaCopyWithImpl<$Res, _$DHTSchemaSMPLImpl>
implements _$$DHTSchemaSMPLCopyWith<$Res> { implements _$$DHTSchemaSMPLImplCopyWith<$Res> {
__$$DHTSchemaSMPLCopyWithImpl( __$$DHTSchemaSMPLImplCopyWithImpl(
_$DHTSchemaSMPL _value, $Res Function(_$DHTSchemaSMPL) _then) _$DHTSchemaSMPLImpl _value, $Res Function(_$DHTSchemaSMPLImpl) _then)
: super(_value, _then); : super(_value, _then);
@pragma('vm:prefer-inline') @pragma('vm:prefer-inline')
@ -286,7 +286,7 @@ class __$$DHTSchemaSMPLCopyWithImpl<$Res>
Object? oCnt = null, Object? oCnt = null,
Object? members = null, Object? members = null,
}) { }) {
return _then(_$DHTSchemaSMPL( return _then(_$DHTSchemaSMPLImpl(
oCnt: null == oCnt oCnt: null == oCnt
? _value.oCnt ? _value.oCnt
: oCnt // ignore: cast_nullable_to_non_nullable : oCnt // ignore: cast_nullable_to_non_nullable
@ -301,16 +301,16 @@ class __$$DHTSchemaSMPLCopyWithImpl<$Res>
/// @nodoc /// @nodoc
@JsonSerializable() @JsonSerializable()
class _$DHTSchemaSMPL implements DHTSchemaSMPL { class _$DHTSchemaSMPLImpl implements DHTSchemaSMPL {
const _$DHTSchemaSMPL( const _$DHTSchemaSMPLImpl(
{required this.oCnt, {required this.oCnt,
required final List<DHTSchemaMember> members, required final List<DHTSchemaMember> members,
final String? $type}) final String? $type})
: _members = members, : _members = members,
$type = $type ?? 'SMPL'; $type = $type ?? 'SMPL';
factory _$DHTSchemaSMPL.fromJson(Map<String, dynamic> json) => factory _$DHTSchemaSMPLImpl.fromJson(Map<String, dynamic> json) =>
_$$DHTSchemaSMPLFromJson(json); _$$DHTSchemaSMPLImplFromJson(json);
@override @override
final int oCnt; final int oCnt;
@ -331,10 +331,10 @@ class _$DHTSchemaSMPL implements DHTSchemaSMPL {
} }
@override @override
bool operator ==(dynamic other) { bool operator ==(Object other) {
return identical(this, other) || return identical(this, other) ||
(other.runtimeType == runtimeType && (other.runtimeType == runtimeType &&
other is _$DHTSchemaSMPL && other is _$DHTSchemaSMPLImpl &&
(identical(other.oCnt, oCnt) || other.oCnt == oCnt) && (identical(other.oCnt, oCnt) || other.oCnt == oCnt) &&
const DeepCollectionEquality().equals(other._members, _members)); const DeepCollectionEquality().equals(other._members, _members));
} }
@ -347,8 +347,8 @@ class _$DHTSchemaSMPL implements DHTSchemaSMPL {
@JsonKey(ignore: true) @JsonKey(ignore: true)
@override @override
@pragma('vm:prefer-inline') @pragma('vm:prefer-inline')
_$$DHTSchemaSMPLCopyWith<_$DHTSchemaSMPL> get copyWith => _$$DHTSchemaSMPLImplCopyWith<_$DHTSchemaSMPLImpl> get copyWith =>
__$$DHTSchemaSMPLCopyWithImpl<_$DHTSchemaSMPL>(this, _$identity); __$$DHTSchemaSMPLImplCopyWithImpl<_$DHTSchemaSMPLImpl>(this, _$identity);
@override @override
@optionalTypeArgs @optionalTypeArgs
@ -414,7 +414,7 @@ class _$DHTSchemaSMPL implements DHTSchemaSMPL {
@override @override
Map<String, dynamic> toJson() { Map<String, dynamic> toJson() {
return _$$DHTSchemaSMPLToJson( return _$$DHTSchemaSMPLImplToJson(
this, this,
); );
} }
@ -423,17 +423,17 @@ class _$DHTSchemaSMPL implements DHTSchemaSMPL {
abstract class DHTSchemaSMPL implements DHTSchema { abstract class DHTSchemaSMPL implements DHTSchema {
const factory DHTSchemaSMPL( const factory DHTSchemaSMPL(
{required final int oCnt, {required final int oCnt,
required final List<DHTSchemaMember> members}) = _$DHTSchemaSMPL; required final List<DHTSchemaMember> members}) = _$DHTSchemaSMPLImpl;
factory DHTSchemaSMPL.fromJson(Map<String, dynamic> json) = factory DHTSchemaSMPL.fromJson(Map<String, dynamic> json) =
_$DHTSchemaSMPL.fromJson; _$DHTSchemaSMPLImpl.fromJson;
@override @override
int get oCnt; int get oCnt;
List<DHTSchemaMember> get members; List<DHTSchemaMember> get members;
@override @override
@JsonKey(ignore: true) @JsonKey(ignore: true)
_$$DHTSchemaSMPLCopyWith<_$DHTSchemaSMPL> get copyWith => _$$DHTSchemaSMPLImplCopyWith<_$DHTSchemaSMPLImpl> get copyWith =>
throw _privateConstructorUsedError; throw _privateConstructorUsedError;
} }
@ -491,22 +491,22 @@ class _$DHTSchemaMemberCopyWithImpl<$Res, $Val extends DHTSchemaMember>
} }
/// @nodoc /// @nodoc
abstract class _$$_DHTSchemaMemberCopyWith<$Res> abstract class _$$DHTSchemaMemberImplCopyWith<$Res>
implements $DHTSchemaMemberCopyWith<$Res> { implements $DHTSchemaMemberCopyWith<$Res> {
factory _$$_DHTSchemaMemberCopyWith( factory _$$DHTSchemaMemberImplCopyWith(_$DHTSchemaMemberImpl value,
_$_DHTSchemaMember value, $Res Function(_$_DHTSchemaMember) then) = $Res Function(_$DHTSchemaMemberImpl) then) =
__$$_DHTSchemaMemberCopyWithImpl<$Res>; __$$DHTSchemaMemberImplCopyWithImpl<$Res>;
@override @override
@useResult @useResult
$Res call({FixedEncodedString43 mKey, int mCnt}); $Res call({FixedEncodedString43 mKey, int mCnt});
} }
/// @nodoc /// @nodoc
class __$$_DHTSchemaMemberCopyWithImpl<$Res> class __$$DHTSchemaMemberImplCopyWithImpl<$Res>
extends _$DHTSchemaMemberCopyWithImpl<$Res, _$_DHTSchemaMember> extends _$DHTSchemaMemberCopyWithImpl<$Res, _$DHTSchemaMemberImpl>
implements _$$_DHTSchemaMemberCopyWith<$Res> { implements _$$DHTSchemaMemberImplCopyWith<$Res> {
__$$_DHTSchemaMemberCopyWithImpl( __$$DHTSchemaMemberImplCopyWithImpl(
_$_DHTSchemaMember _value, $Res Function(_$_DHTSchemaMember) _then) _$DHTSchemaMemberImpl _value, $Res Function(_$DHTSchemaMemberImpl) _then)
: super(_value, _then); : super(_value, _then);
@pragma('vm:prefer-inline') @pragma('vm:prefer-inline')
@ -515,7 +515,7 @@ class __$$_DHTSchemaMemberCopyWithImpl<$Res>
Object? mKey = null, Object? mKey = null,
Object? mCnt = null, Object? mCnt = null,
}) { }) {
return _then(_$_DHTSchemaMember( return _then(_$DHTSchemaMemberImpl(
mKey: null == mKey mKey: null == mKey
? _value.mKey ? _value.mKey
: mKey // ignore: cast_nullable_to_non_nullable : mKey // ignore: cast_nullable_to_non_nullable
@ -530,12 +530,12 @@ class __$$_DHTSchemaMemberCopyWithImpl<$Res>
/// @nodoc /// @nodoc
@JsonSerializable() @JsonSerializable()
class _$_DHTSchemaMember implements _DHTSchemaMember { class _$DHTSchemaMemberImpl implements _DHTSchemaMember {
const _$_DHTSchemaMember({required this.mKey, required this.mCnt}) const _$DHTSchemaMemberImpl({required this.mKey, required this.mCnt})
: assert(mCnt > 0 && mCnt <= 65535, 'value out of range'); : assert(mCnt > 0 && mCnt <= 65535, 'value out of range');
factory _$_DHTSchemaMember.fromJson(Map<String, dynamic> json) => factory _$DHTSchemaMemberImpl.fromJson(Map<String, dynamic> json) =>
_$$_DHTSchemaMemberFromJson(json); _$$DHTSchemaMemberImplFromJson(json);
@override @override
final FixedEncodedString43 mKey; final FixedEncodedString43 mKey;
@ -548,10 +548,10 @@ class _$_DHTSchemaMember implements _DHTSchemaMember {
} }
@override @override
bool operator ==(dynamic other) { bool operator ==(Object other) {
return identical(this, other) || return identical(this, other) ||
(other.runtimeType == runtimeType && (other.runtimeType == runtimeType &&
other is _$_DHTSchemaMember && other is _$DHTSchemaMemberImpl &&
(identical(other.mKey, mKey) || other.mKey == mKey) && (identical(other.mKey, mKey) || other.mKey == mKey) &&
(identical(other.mCnt, mCnt) || other.mCnt == mCnt)); (identical(other.mCnt, mCnt) || other.mCnt == mCnt));
} }
@ -563,12 +563,13 @@ class _$_DHTSchemaMember implements _DHTSchemaMember {
@JsonKey(ignore: true) @JsonKey(ignore: true)
@override @override
@pragma('vm:prefer-inline') @pragma('vm:prefer-inline')
_$$_DHTSchemaMemberCopyWith<_$_DHTSchemaMember> get copyWith => _$$DHTSchemaMemberImplCopyWith<_$DHTSchemaMemberImpl> get copyWith =>
__$$_DHTSchemaMemberCopyWithImpl<_$_DHTSchemaMember>(this, _$identity); __$$DHTSchemaMemberImplCopyWithImpl<_$DHTSchemaMemberImpl>(
this, _$identity);
@override @override
Map<String, dynamic> toJson() { Map<String, dynamic> toJson() {
return _$$_DHTSchemaMemberToJson( return _$$DHTSchemaMemberImplToJson(
this, this,
); );
} }
@ -577,10 +578,10 @@ class _$_DHTSchemaMember implements _DHTSchemaMember {
abstract class _DHTSchemaMember implements DHTSchemaMember { abstract class _DHTSchemaMember implements DHTSchemaMember {
const factory _DHTSchemaMember( const factory _DHTSchemaMember(
{required final FixedEncodedString43 mKey, {required final FixedEncodedString43 mKey,
required final int mCnt}) = _$_DHTSchemaMember; required final int mCnt}) = _$DHTSchemaMemberImpl;
factory _DHTSchemaMember.fromJson(Map<String, dynamic> json) = factory _DHTSchemaMember.fromJson(Map<String, dynamic> json) =
_$_DHTSchemaMember.fromJson; _$DHTSchemaMemberImpl.fromJson;
@override @override
FixedEncodedString43 get mKey; FixedEncodedString43 get mKey;
@ -588,7 +589,7 @@ abstract class _DHTSchemaMember implements DHTSchemaMember {
int get mCnt; int get mCnt;
@override @override
@JsonKey(ignore: true) @JsonKey(ignore: true)
_$$_DHTSchemaMemberCopyWith<_$_DHTSchemaMember> get copyWith => _$$DHTSchemaMemberImplCopyWith<_$DHTSchemaMemberImpl> get copyWith =>
throw _privateConstructorUsedError; throw _privateConstructorUsedError;
} }
@ -672,11 +673,11 @@ class _$DHTRecordDescriptorCopyWithImpl<$Res, $Val extends DHTRecordDescriptor>
} }
/// @nodoc /// @nodoc
abstract class _$$_DHTRecordDescriptorCopyWith<$Res> abstract class _$$DHTRecordDescriptorImplCopyWith<$Res>
implements $DHTRecordDescriptorCopyWith<$Res> { implements $DHTRecordDescriptorCopyWith<$Res> {
factory _$$_DHTRecordDescriptorCopyWith(_$_DHTRecordDescriptor value, factory _$$DHTRecordDescriptorImplCopyWith(_$DHTRecordDescriptorImpl value,
$Res Function(_$_DHTRecordDescriptor) then) = $Res Function(_$DHTRecordDescriptorImpl) then) =
__$$_DHTRecordDescriptorCopyWithImpl<$Res>; __$$DHTRecordDescriptorImplCopyWithImpl<$Res>;
@override @override
@useResult @useResult
$Res call( $Res call(
@ -690,11 +691,11 @@ abstract class _$$_DHTRecordDescriptorCopyWith<$Res>
} }
/// @nodoc /// @nodoc
class __$$_DHTRecordDescriptorCopyWithImpl<$Res> class __$$DHTRecordDescriptorImplCopyWithImpl<$Res>
extends _$DHTRecordDescriptorCopyWithImpl<$Res, _$_DHTRecordDescriptor> extends _$DHTRecordDescriptorCopyWithImpl<$Res, _$DHTRecordDescriptorImpl>
implements _$$_DHTRecordDescriptorCopyWith<$Res> { implements _$$DHTRecordDescriptorImplCopyWith<$Res> {
__$$_DHTRecordDescriptorCopyWithImpl(_$_DHTRecordDescriptor _value, __$$DHTRecordDescriptorImplCopyWithImpl(_$DHTRecordDescriptorImpl _value,
$Res Function(_$_DHTRecordDescriptor) _then) $Res Function(_$DHTRecordDescriptorImpl) _then)
: super(_value, _then); : super(_value, _then);
@pragma('vm:prefer-inline') @pragma('vm:prefer-inline')
@ -705,7 +706,7 @@ class __$$_DHTRecordDescriptorCopyWithImpl<$Res>
Object? schema = null, Object? schema = null,
Object? ownerSecret = freezed, Object? ownerSecret = freezed,
}) { }) {
return _then(_$_DHTRecordDescriptor( return _then(_$DHTRecordDescriptorImpl(
key: null == key key: null == key
? _value.key ? _value.key
: key // ignore: cast_nullable_to_non_nullable : key // ignore: cast_nullable_to_non_nullable
@ -728,15 +729,15 @@ class __$$_DHTRecordDescriptorCopyWithImpl<$Res>
/// @nodoc /// @nodoc
@JsonSerializable() @JsonSerializable()
class _$_DHTRecordDescriptor implements _DHTRecordDescriptor { class _$DHTRecordDescriptorImpl implements _DHTRecordDescriptor {
const _$_DHTRecordDescriptor( const _$DHTRecordDescriptorImpl(
{required this.key, {required this.key,
required this.owner, required this.owner,
required this.schema, required this.schema,
this.ownerSecret}); this.ownerSecret});
factory _$_DHTRecordDescriptor.fromJson(Map<String, dynamic> json) => factory _$DHTRecordDescriptorImpl.fromJson(Map<String, dynamic> json) =>
_$$_DHTRecordDescriptorFromJson(json); _$$DHTRecordDescriptorImplFromJson(json);
@override @override
final Typed<FixedEncodedString43> key; final Typed<FixedEncodedString43> key;
@ -753,10 +754,10 @@ class _$_DHTRecordDescriptor implements _DHTRecordDescriptor {
} }
@override @override
bool operator ==(dynamic other) { bool operator ==(Object other) {
return identical(this, other) || return identical(this, other) ||
(other.runtimeType == runtimeType && (other.runtimeType == runtimeType &&
other is _$_DHTRecordDescriptor && other is _$DHTRecordDescriptorImpl &&
(identical(other.key, key) || other.key == key) && (identical(other.key, key) || other.key == key) &&
(identical(other.owner, owner) || other.owner == owner) && (identical(other.owner, owner) || other.owner == owner) &&
(identical(other.schema, schema) || other.schema == schema) && (identical(other.schema, schema) || other.schema == schema) &&
@ -771,13 +772,13 @@ class _$_DHTRecordDescriptor implements _DHTRecordDescriptor {
@JsonKey(ignore: true) @JsonKey(ignore: true)
@override @override
@pragma('vm:prefer-inline') @pragma('vm:prefer-inline')
_$$_DHTRecordDescriptorCopyWith<_$_DHTRecordDescriptor> get copyWith => _$$DHTRecordDescriptorImplCopyWith<_$DHTRecordDescriptorImpl> get copyWith =>
__$$_DHTRecordDescriptorCopyWithImpl<_$_DHTRecordDescriptor>( __$$DHTRecordDescriptorImplCopyWithImpl<_$DHTRecordDescriptorImpl>(
this, _$identity); this, _$identity);
@override @override
Map<String, dynamic> toJson() { Map<String, dynamic> toJson() {
return _$$_DHTRecordDescriptorToJson( return _$$DHTRecordDescriptorImplToJson(
this, this,
); );
} }
@ -788,10 +789,10 @@ abstract class _DHTRecordDescriptor implements DHTRecordDescriptor {
{required final Typed<FixedEncodedString43> key, {required final Typed<FixedEncodedString43> key,
required final FixedEncodedString43 owner, required final FixedEncodedString43 owner,
required final DHTSchema schema, required final DHTSchema schema,
final FixedEncodedString43? ownerSecret}) = _$_DHTRecordDescriptor; final FixedEncodedString43? ownerSecret}) = _$DHTRecordDescriptorImpl;
factory _DHTRecordDescriptor.fromJson(Map<String, dynamic> json) = factory _DHTRecordDescriptor.fromJson(Map<String, dynamic> json) =
_$_DHTRecordDescriptor.fromJson; _$DHTRecordDescriptorImpl.fromJson;
@override @override
Typed<FixedEncodedString43> get key; Typed<FixedEncodedString43> get key;
@ -803,7 +804,7 @@ abstract class _DHTRecordDescriptor implements DHTRecordDescriptor {
FixedEncodedString43? get ownerSecret; FixedEncodedString43? get ownerSecret;
@override @override
@JsonKey(ignore: true) @JsonKey(ignore: true)
_$$_DHTRecordDescriptorCopyWith<_$_DHTRecordDescriptor> get copyWith => _$$DHTRecordDescriptorImplCopyWith<_$DHTRecordDescriptorImpl> get copyWith =>
throw _privateConstructorUsedError; throw _privateConstructorUsedError;
} }
@ -870,10 +871,11 @@ class _$ValueDataCopyWithImpl<$Res, $Val extends ValueData>
} }
/// @nodoc /// @nodoc
abstract class _$$_ValueDataCopyWith<$Res> implements $ValueDataCopyWith<$Res> { abstract class _$$ValueDataImplCopyWith<$Res>
factory _$$_ValueDataCopyWith( implements $ValueDataCopyWith<$Res> {
_$_ValueData value, $Res Function(_$_ValueData) then) = factory _$$ValueDataImplCopyWith(
__$$_ValueDataCopyWithImpl<$Res>; _$ValueDataImpl value, $Res Function(_$ValueDataImpl) then) =
__$$ValueDataImplCopyWithImpl<$Res>;
@override @override
@useResult @useResult
$Res call( $Res call(
@ -883,11 +885,11 @@ abstract class _$$_ValueDataCopyWith<$Res> implements $ValueDataCopyWith<$Res> {
} }
/// @nodoc /// @nodoc
class __$$_ValueDataCopyWithImpl<$Res> class __$$ValueDataImplCopyWithImpl<$Res>
extends _$ValueDataCopyWithImpl<$Res, _$_ValueData> extends _$ValueDataCopyWithImpl<$Res, _$ValueDataImpl>
implements _$$_ValueDataCopyWith<$Res> { implements _$$ValueDataImplCopyWith<$Res> {
__$$_ValueDataCopyWithImpl( __$$ValueDataImplCopyWithImpl(
_$_ValueData _value, $Res Function(_$_ValueData) _then) _$ValueDataImpl _value, $Res Function(_$ValueDataImpl) _then)
: super(_value, _then); : super(_value, _then);
@pragma('vm:prefer-inline') @pragma('vm:prefer-inline')
@ -897,7 +899,7 @@ class __$$_ValueDataCopyWithImpl<$Res>
Object? data = null, Object? data = null,
Object? writer = null, Object? writer = null,
}) { }) {
return _then(_$_ValueData( return _then(_$ValueDataImpl(
seq: null == seq seq: null == seq
? _value.seq ? _value.seq
: seq // ignore: cast_nullable_to_non_nullable : seq // ignore: cast_nullable_to_non_nullable
@ -916,15 +918,15 @@ class __$$_ValueDataCopyWithImpl<$Res>
/// @nodoc /// @nodoc
@JsonSerializable() @JsonSerializable()
class _$_ValueData implements _ValueData { class _$ValueDataImpl implements _ValueData {
const _$_ValueData( const _$ValueDataImpl(
{required this.seq, {required this.seq,
@Uint8ListJsonConverter.jsIsArray() required this.data, @Uint8ListJsonConverter.jsIsArray() required this.data,
required this.writer}) required this.writer})
: assert(seq >= 0, 'seq out of range'); : assert(seq >= 0, 'seq out of range');
factory _$_ValueData.fromJson(Map<String, dynamic> json) => factory _$ValueDataImpl.fromJson(Map<String, dynamic> json) =>
_$$_ValueDataFromJson(json); _$$ValueDataImplFromJson(json);
@override @override
final int seq; final int seq;
@ -940,10 +942,10 @@ class _$_ValueData implements _ValueData {
} }
@override @override
bool operator ==(dynamic other) { bool operator ==(Object other) {
return identical(this, other) || return identical(this, other) ||
(other.runtimeType == runtimeType && (other.runtimeType == runtimeType &&
other is _$_ValueData && other is _$ValueDataImpl &&
(identical(other.seq, seq) || other.seq == seq) && (identical(other.seq, seq) || other.seq == seq) &&
const DeepCollectionEquality().equals(other.data, data) && const DeepCollectionEquality().equals(other.data, data) &&
(identical(other.writer, writer) || other.writer == writer)); (identical(other.writer, writer) || other.writer == writer));
@ -957,12 +959,12 @@ class _$_ValueData implements _ValueData {
@JsonKey(ignore: true) @JsonKey(ignore: true)
@override @override
@pragma('vm:prefer-inline') @pragma('vm:prefer-inline')
_$$_ValueDataCopyWith<_$_ValueData> get copyWith => _$$ValueDataImplCopyWith<_$ValueDataImpl> get copyWith =>
__$$_ValueDataCopyWithImpl<_$_ValueData>(this, _$identity); __$$ValueDataImplCopyWithImpl<_$ValueDataImpl>(this, _$identity);
@override @override
Map<String, dynamic> toJson() { Map<String, dynamic> toJson() {
return _$$_ValueDataToJson( return _$$ValueDataImplToJson(
this, this,
); );
} }
@ -972,10 +974,10 @@ abstract class _ValueData implements ValueData {
const factory _ValueData( const factory _ValueData(
{required final int seq, {required final int seq,
@Uint8ListJsonConverter.jsIsArray() required final Uint8List data, @Uint8ListJsonConverter.jsIsArray() required final Uint8List data,
required final FixedEncodedString43 writer}) = _$_ValueData; required final FixedEncodedString43 writer}) = _$ValueDataImpl;
factory _ValueData.fromJson(Map<String, dynamic> json) = factory _ValueData.fromJson(Map<String, dynamic> json) =
_$_ValueData.fromJson; _$ValueDataImpl.fromJson;
@override @override
int get seq; int get seq;
@ -986,7 +988,7 @@ abstract class _ValueData implements ValueData {
FixedEncodedString43 get writer; FixedEncodedString43 get writer;
@override @override
@JsonKey(ignore: true) @JsonKey(ignore: true)
_$$_ValueDataCopyWith<_$_ValueData> get copyWith => _$$ValueDataImplCopyWith<_$ValueDataImpl> get copyWith =>
throw _privateConstructorUsedError; throw _privateConstructorUsedError;
} }
@ -1060,11 +1062,11 @@ class _$SafetySpecCopyWithImpl<$Res, $Val extends SafetySpec>
} }
/// @nodoc /// @nodoc
abstract class _$$_SafetySpecCopyWith<$Res> abstract class _$$SafetySpecImplCopyWith<$Res>
implements $SafetySpecCopyWith<$Res> { implements $SafetySpecCopyWith<$Res> {
factory _$$_SafetySpecCopyWith( factory _$$SafetySpecImplCopyWith(
_$_SafetySpec value, $Res Function(_$_SafetySpec) then) = _$SafetySpecImpl value, $Res Function(_$SafetySpecImpl) then) =
__$$_SafetySpecCopyWithImpl<$Res>; __$$SafetySpecImplCopyWithImpl<$Res>;
@override @override
@useResult @useResult
$Res call( $Res call(
@ -1075,11 +1077,11 @@ abstract class _$$_SafetySpecCopyWith<$Res>
} }
/// @nodoc /// @nodoc
class __$$_SafetySpecCopyWithImpl<$Res> class __$$SafetySpecImplCopyWithImpl<$Res>
extends _$SafetySpecCopyWithImpl<$Res, _$_SafetySpec> extends _$SafetySpecCopyWithImpl<$Res, _$SafetySpecImpl>
implements _$$_SafetySpecCopyWith<$Res> { implements _$$SafetySpecImplCopyWith<$Res> {
__$$_SafetySpecCopyWithImpl( __$$SafetySpecImplCopyWithImpl(
_$_SafetySpec _value, $Res Function(_$_SafetySpec) _then) _$SafetySpecImpl _value, $Res Function(_$SafetySpecImpl) _then)
: super(_value, _then); : super(_value, _then);
@pragma('vm:prefer-inline') @pragma('vm:prefer-inline')
@ -1090,7 +1092,7 @@ class __$$_SafetySpecCopyWithImpl<$Res>
Object? sequencing = null, Object? sequencing = null,
Object? preferredRoute = freezed, Object? preferredRoute = freezed,
}) { }) {
return _then(_$_SafetySpec( return _then(_$SafetySpecImpl(
hopCount: null == hopCount hopCount: null == hopCount
? _value.hopCount ? _value.hopCount
: hopCount // ignore: cast_nullable_to_non_nullable : hopCount // ignore: cast_nullable_to_non_nullable
@ -1113,15 +1115,15 @@ class __$$_SafetySpecCopyWithImpl<$Res>
/// @nodoc /// @nodoc
@JsonSerializable() @JsonSerializable()
class _$_SafetySpec implements _SafetySpec { class _$SafetySpecImpl implements _SafetySpec {
const _$_SafetySpec( const _$SafetySpecImpl(
{required this.hopCount, {required this.hopCount,
required this.stability, required this.stability,
required this.sequencing, required this.sequencing,
this.preferredRoute}); this.preferredRoute});
factory _$_SafetySpec.fromJson(Map<String, dynamic> json) => factory _$SafetySpecImpl.fromJson(Map<String, dynamic> json) =>
_$$_SafetySpecFromJson(json); _$$SafetySpecImplFromJson(json);
@override @override
final int hopCount; final int hopCount;
@ -1138,10 +1140,10 @@ class _$_SafetySpec implements _SafetySpec {
} }
@override @override
bool operator ==(dynamic other) { bool operator ==(Object other) {
return identical(this, other) || return identical(this, other) ||
(other.runtimeType == runtimeType && (other.runtimeType == runtimeType &&
other is _$_SafetySpec && other is _$SafetySpecImpl &&
(identical(other.hopCount, hopCount) || (identical(other.hopCount, hopCount) ||
other.hopCount == hopCount) && other.hopCount == hopCount) &&
(identical(other.stability, stability) || (identical(other.stability, stability) ||
@ -1160,12 +1162,12 @@ class _$_SafetySpec implements _SafetySpec {
@JsonKey(ignore: true) @JsonKey(ignore: true)
@override @override
@pragma('vm:prefer-inline') @pragma('vm:prefer-inline')
_$$_SafetySpecCopyWith<_$_SafetySpec> get copyWith => _$$SafetySpecImplCopyWith<_$SafetySpecImpl> get copyWith =>
__$$_SafetySpecCopyWithImpl<_$_SafetySpec>(this, _$identity); __$$SafetySpecImplCopyWithImpl<_$SafetySpecImpl>(this, _$identity);
@override @override
Map<String, dynamic> toJson() { Map<String, dynamic> toJson() {
return _$$_SafetySpecToJson( return _$$SafetySpecImplToJson(
this, this,
); );
} }
@ -1176,10 +1178,10 @@ abstract class _SafetySpec implements SafetySpec {
{required final int hopCount, {required final int hopCount,
required final Stability stability, required final Stability stability,
required final Sequencing sequencing, required final Sequencing sequencing,
final String? preferredRoute}) = _$_SafetySpec; final String? preferredRoute}) = _$SafetySpecImpl;
factory _SafetySpec.fromJson(Map<String, dynamic> json) = factory _SafetySpec.fromJson(Map<String, dynamic> json) =
_$_SafetySpec.fromJson; _$SafetySpecImpl.fromJson;
@override @override
int get hopCount; int get hopCount;
@ -1191,7 +1193,7 @@ abstract class _SafetySpec implements SafetySpec {
String? get preferredRoute; String? get preferredRoute;
@override @override
@JsonKey(ignore: true) @JsonKey(ignore: true)
_$$_SafetySpecCopyWith<_$_SafetySpec> get copyWith => _$$SafetySpecImplCopyWith<_$SafetySpecImpl> get copyWith =>
throw _privateConstructorUsedError; throw _privateConstructorUsedError;
} }
@ -1249,21 +1251,22 @@ class _$RouteBlobCopyWithImpl<$Res, $Val extends RouteBlob>
} }
/// @nodoc /// @nodoc
abstract class _$$_RouteBlobCopyWith<$Res> implements $RouteBlobCopyWith<$Res> { abstract class _$$RouteBlobImplCopyWith<$Res>
factory _$$_RouteBlobCopyWith( implements $RouteBlobCopyWith<$Res> {
_$_RouteBlob value, $Res Function(_$_RouteBlob) then) = factory _$$RouteBlobImplCopyWith(
__$$_RouteBlobCopyWithImpl<$Res>; _$RouteBlobImpl value, $Res Function(_$RouteBlobImpl) then) =
__$$RouteBlobImplCopyWithImpl<$Res>;
@override @override
@useResult @useResult
$Res call({String routeId, @Uint8ListJsonConverter() Uint8List blob}); $Res call({String routeId, @Uint8ListJsonConverter() Uint8List blob});
} }
/// @nodoc /// @nodoc
class __$$_RouteBlobCopyWithImpl<$Res> class __$$RouteBlobImplCopyWithImpl<$Res>
extends _$RouteBlobCopyWithImpl<$Res, _$_RouteBlob> extends _$RouteBlobCopyWithImpl<$Res, _$RouteBlobImpl>
implements _$$_RouteBlobCopyWith<$Res> { implements _$$RouteBlobImplCopyWith<$Res> {
__$$_RouteBlobCopyWithImpl( __$$RouteBlobImplCopyWithImpl(
_$_RouteBlob _value, $Res Function(_$_RouteBlob) _then) _$RouteBlobImpl _value, $Res Function(_$RouteBlobImpl) _then)
: super(_value, _then); : super(_value, _then);
@pragma('vm:prefer-inline') @pragma('vm:prefer-inline')
@ -1272,7 +1275,7 @@ class __$$_RouteBlobCopyWithImpl<$Res>
Object? routeId = null, Object? routeId = null,
Object? blob = null, Object? blob = null,
}) { }) {
return _then(_$_RouteBlob( return _then(_$RouteBlobImpl(
routeId: null == routeId routeId: null == routeId
? _value.routeId ? _value.routeId
: routeId // ignore: cast_nullable_to_non_nullable : routeId // ignore: cast_nullable_to_non_nullable
@ -1287,12 +1290,12 @@ class __$$_RouteBlobCopyWithImpl<$Res>
/// @nodoc /// @nodoc
@JsonSerializable() @JsonSerializable()
class _$_RouteBlob implements _RouteBlob { class _$RouteBlobImpl implements _RouteBlob {
const _$_RouteBlob( const _$RouteBlobImpl(
{required this.routeId, @Uint8ListJsonConverter() required this.blob}); {required this.routeId, @Uint8ListJsonConverter() required this.blob});
factory _$_RouteBlob.fromJson(Map<String, dynamic> json) => factory _$RouteBlobImpl.fromJson(Map<String, dynamic> json) =>
_$$_RouteBlobFromJson(json); _$$RouteBlobImplFromJson(json);
@override @override
final String routeId; final String routeId;
@ -1306,10 +1309,10 @@ class _$_RouteBlob implements _RouteBlob {
} }
@override @override
bool operator ==(dynamic other) { bool operator ==(Object other) {
return identical(this, other) || return identical(this, other) ||
(other.runtimeType == runtimeType && (other.runtimeType == runtimeType &&
other is _$_RouteBlob && other is _$RouteBlobImpl &&
(identical(other.routeId, routeId) || other.routeId == routeId) && (identical(other.routeId, routeId) || other.routeId == routeId) &&
const DeepCollectionEquality().equals(other.blob, blob)); const DeepCollectionEquality().equals(other.blob, blob));
} }
@ -1322,12 +1325,12 @@ class _$_RouteBlob implements _RouteBlob {
@JsonKey(ignore: true) @JsonKey(ignore: true)
@override @override
@pragma('vm:prefer-inline') @pragma('vm:prefer-inline')
_$$_RouteBlobCopyWith<_$_RouteBlob> get copyWith => _$$RouteBlobImplCopyWith<_$RouteBlobImpl> get copyWith =>
__$$_RouteBlobCopyWithImpl<_$_RouteBlob>(this, _$identity); __$$RouteBlobImplCopyWithImpl<_$RouteBlobImpl>(this, _$identity);
@override @override
Map<String, dynamic> toJson() { Map<String, dynamic> toJson() {
return _$$_RouteBlobToJson( return _$$RouteBlobImplToJson(
this, this,
); );
} }
@ -1335,11 +1338,12 @@ class _$_RouteBlob implements _RouteBlob {
abstract class _RouteBlob implements RouteBlob { abstract class _RouteBlob implements RouteBlob {
const factory _RouteBlob( const factory _RouteBlob(
{required final String routeId, {required final String routeId,
@Uint8ListJsonConverter() required final Uint8List blob}) = _$_RouteBlob; @Uint8ListJsonConverter() required final Uint8List blob}) =
_$RouteBlobImpl;
factory _RouteBlob.fromJson(Map<String, dynamic> json) = factory _RouteBlob.fromJson(Map<String, dynamic> json) =
_$_RouteBlob.fromJson; _$RouteBlobImpl.fromJson;
@override @override
String get routeId; String get routeId;
@ -1348,6 +1352,6 @@ abstract class _RouteBlob implements RouteBlob {
Uint8List get blob; Uint8List get blob;
@override @override
@JsonKey(ignore: true) @JsonKey(ignore: true)
_$$_RouteBlobCopyWith<_$_RouteBlob> get copyWith => _$$RouteBlobImplCopyWith<_$RouteBlobImpl> get copyWith =>
throw _privateConstructorUsedError; throw _privateConstructorUsedError;
} }

44
veilid-flutter/lib/routing_context.g.dart
View File

@ -6,20 +6,20 @@ part of 'routing_context.dart';
// JsonSerializableGenerator // JsonSerializableGenerator
// ************************************************************************** // **************************************************************************
_$DHTSchemaDFLT _$$DHTSchemaDFLTFromJson(Map<String, dynamic> json) => _$DHTSchemaDFLTImpl _$$DHTSchemaDFLTImplFromJson(Map<String, dynamic> json) =>
_$DHTSchemaDFLT( _$DHTSchemaDFLTImpl(
oCnt: json['o_cnt'] as int, oCnt: json['o_cnt'] as int,
$type: json['kind'] as String?, $type: json['kind'] as String?,
); );
Map<String, dynamic> _$$DHTSchemaDFLTToJson(_$DHTSchemaDFLT instance) => Map<String, dynamic> _$$DHTSchemaDFLTImplToJson(_$DHTSchemaDFLTImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'o_cnt': instance.oCnt, 'o_cnt': instance.oCnt,
'kind': instance.$type, 'kind': instance.$type,
}; };
_$DHTSchemaSMPL _$$DHTSchemaSMPLFromJson(Map<String, dynamic> json) => _$DHTSchemaSMPLImpl _$$DHTSchemaSMPLImplFromJson(Map<String, dynamic> json) =>
_$DHTSchemaSMPL( _$DHTSchemaSMPLImpl(
oCnt: json['o_cnt'] as int, oCnt: json['o_cnt'] as int,
members: (json['members'] as List<dynamic>) members: (json['members'] as List<dynamic>)
.map(DHTSchemaMember.fromJson) .map(DHTSchemaMember.fromJson)
@ -27,28 +27,30 @@ _$DHTSchemaSMPL _$$DHTSchemaSMPLFromJson(Map<String, dynamic> json) =>
$type: json['kind'] as String?, $type: json['kind'] as String?,
); );
Map<String, dynamic> _$$DHTSchemaSMPLToJson(_$DHTSchemaSMPL instance) => Map<String, dynamic> _$$DHTSchemaSMPLImplToJson(_$DHTSchemaSMPLImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'o_cnt': instance.oCnt, 'o_cnt': instance.oCnt,
'members': instance.members.map((e) => e.toJson()).toList(), 'members': instance.members.map((e) => e.toJson()).toList(),
'kind': instance.$type, 'kind': instance.$type,
}; };
_$_DHTSchemaMember _$$_DHTSchemaMemberFromJson(Map<String, dynamic> json) => _$DHTSchemaMemberImpl _$$DHTSchemaMemberImplFromJson(
_$_DHTSchemaMember( Map<String, dynamic> json) =>
_$DHTSchemaMemberImpl(
mKey: FixedEncodedString43.fromJson(json['m_key']), mKey: FixedEncodedString43.fromJson(json['m_key']),
mCnt: json['m_cnt'] as int, mCnt: json['m_cnt'] as int,
); );
Map<String, dynamic> _$$_DHTSchemaMemberToJson(_$_DHTSchemaMember instance) => Map<String, dynamic> _$$DHTSchemaMemberImplToJson(
_$DHTSchemaMemberImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'm_key': instance.mKey.toJson(), 'm_key': instance.mKey.toJson(),
'm_cnt': instance.mCnt, 'm_cnt': instance.mCnt,
}; };
_$_DHTRecordDescriptor _$$_DHTRecordDescriptorFromJson( _$DHTRecordDescriptorImpl _$$DHTRecordDescriptorImplFromJson(
Map<String, dynamic> json) => Map<String, dynamic> json) =>
_$_DHTRecordDescriptor( _$DHTRecordDescriptorImpl(
key: Typed<FixedEncodedString43>.fromJson(json['key']), key: Typed<FixedEncodedString43>.fromJson(json['key']),
owner: FixedEncodedString43.fromJson(json['owner']), owner: FixedEncodedString43.fromJson(json['owner']),
schema: DHTSchema.fromJson(json['schema']), schema: DHTSchema.fromJson(json['schema']),
@ -57,8 +59,8 @@ _$_DHTRecordDescriptor _$$_DHTRecordDescriptorFromJson(
: FixedEncodedString43.fromJson(json['owner_secret']), : FixedEncodedString43.fromJson(json['owner_secret']),
); );
Map<String, dynamic> _$$_DHTRecordDescriptorToJson( Map<String, dynamic> _$$DHTRecordDescriptorImplToJson(
_$_DHTRecordDescriptor instance) => _$DHTRecordDescriptorImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'key': instance.key.toJson(), 'key': instance.key.toJson(),
'owner': instance.owner.toJson(), 'owner': instance.owner.toJson(),
@ -66,28 +68,29 @@ Map<String, dynamic> _$$_DHTRecordDescriptorToJson(
'owner_secret': instance.ownerSecret?.toJson(), 'owner_secret': instance.ownerSecret?.toJson(),
}; };
_$_ValueData _$$_ValueDataFromJson(Map<String, dynamic> json) => _$_ValueData( _$ValueDataImpl _$$ValueDataImplFromJson(Map<String, dynamic> json) =>
_$ValueDataImpl(
seq: json['seq'] as int, seq: json['seq'] as int,
data: const Uint8ListJsonConverter.jsIsArray().fromJson(json['data']), data: const Uint8ListJsonConverter.jsIsArray().fromJson(json['data']),
writer: FixedEncodedString43.fromJson(json['writer']), writer: FixedEncodedString43.fromJson(json['writer']),
); );
Map<String, dynamic> _$$_ValueDataToJson(_$_ValueData instance) => Map<String, dynamic> _$$ValueDataImplToJson(_$ValueDataImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'seq': instance.seq, 'seq': instance.seq,
'data': const Uint8ListJsonConverter.jsIsArray().toJson(instance.data), 'data': const Uint8ListJsonConverter.jsIsArray().toJson(instance.data),
'writer': instance.writer.toJson(), 'writer': instance.writer.toJson(),
}; };
_$_SafetySpec _$$_SafetySpecFromJson(Map<String, dynamic> json) => _$SafetySpecImpl _$$SafetySpecImplFromJson(Map<String, dynamic> json) =>
_$_SafetySpec( _$SafetySpecImpl(
hopCount: json['hop_count'] as int, hopCount: json['hop_count'] as int,
stability: Stability.fromJson(json['stability']), stability: Stability.fromJson(json['stability']),
sequencing: Sequencing.fromJson(json['sequencing']), sequencing: Sequencing.fromJson(json['sequencing']),
preferredRoute: json['preferred_route'] as String?, preferredRoute: json['preferred_route'] as String?,
); );
Map<String, dynamic> _$$_SafetySpecToJson(_$_SafetySpec instance) => Map<String, dynamic> _$$SafetySpecImplToJson(_$SafetySpecImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'hop_count': instance.hopCount, 'hop_count': instance.hopCount,
'stability': instance.stability.toJson(), 'stability': instance.stability.toJson(),
@ -95,12 +98,13 @@ Map<String, dynamic> _$$_SafetySpecToJson(_$_SafetySpec instance) =>
'preferred_route': instance.preferredRoute, 'preferred_route': instance.preferredRoute,
}; };
_$_RouteBlob _$$_RouteBlobFromJson(Map<String, dynamic> json) => _$_RouteBlob( _$RouteBlobImpl _$$RouteBlobImplFromJson(Map<String, dynamic> json) =>
_$RouteBlobImpl(
routeId: json['route_id'] as String, routeId: json['route_id'] as String,
blob: const Uint8ListJsonConverter().fromJson(json['blob']), blob: const Uint8ListJsonConverter().fromJson(json['blob']),
); );
Map<String, dynamic> _$$_RouteBlobToJson(_$_RouteBlob instance) => Map<String, dynamic> _$$RouteBlobImplToJson(_$RouteBlobImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'route_id': instance.routeId, 'route_id': instance.routeId,
'blob': const Uint8ListJsonConverter().toJson(instance.blob), 'blob': const Uint8ListJsonConverter().toJson(instance.blob),

5
veilid-flutter/lib/veilid_config.dart
View File

@ -14,6 +14,7 @@ class VeilidFFIConfigLoggingTerminal with _$VeilidFFIConfigLoggingTerminal {
const factory VeilidFFIConfigLoggingTerminal({ const factory VeilidFFIConfigLoggingTerminal({
required bool enabled, required bool enabled,
required VeilidConfigLogLevel level, required VeilidConfigLogLevel level,
@Default([]) List<String> ignoreLogTargets,
}) = _VeilidFFIConfigLoggingTerminal; }) = _VeilidFFIConfigLoggingTerminal;
factory VeilidFFIConfigLoggingTerminal.fromJson(dynamic json) => factory VeilidFFIConfigLoggingTerminal.fromJson(dynamic json) =>
@ -27,6 +28,7 @@ class VeilidFFIConfigLoggingOtlp with _$VeilidFFIConfigLoggingOtlp {
required VeilidConfigLogLevel level, required VeilidConfigLogLevel level,
required String grpcEndpoint, required String grpcEndpoint,
required String serviceName, required String serviceName,
@Default([]) List<String> ignoreLogTargets,
}) = _VeilidFFIConfigLoggingOtlp; }) = _VeilidFFIConfigLoggingOtlp;
factory VeilidFFIConfigLoggingOtlp.fromJson(dynamic json) => factory VeilidFFIConfigLoggingOtlp.fromJson(dynamic json) =>
@ -38,6 +40,7 @@ class VeilidFFIConfigLoggingApi with _$VeilidFFIConfigLoggingApi {
const factory VeilidFFIConfigLoggingApi({ const factory VeilidFFIConfigLoggingApi({
required bool enabled, required bool enabled,
required VeilidConfigLogLevel level, required VeilidConfigLogLevel level,
@Default([]) List<String> ignoreLogTargets,
}) = _VeilidFFIConfigLoggingApi; }) = _VeilidFFIConfigLoggingApi;
factory VeilidFFIConfigLoggingApi.fromJson(dynamic json) => factory VeilidFFIConfigLoggingApi.fromJson(dynamic json) =>
@ -76,6 +79,7 @@ class VeilidWASMConfigLoggingPerformance
required VeilidConfigLogLevel level, required VeilidConfigLogLevel level,
required bool logsInTimings, required bool logsInTimings,
required bool logsInConsole, required bool logsInConsole,
@Default([]) List<String> ignoreLogTargets,
}) = _VeilidWASMConfigLoggingPerformance; }) = _VeilidWASMConfigLoggingPerformance;
factory VeilidWASMConfigLoggingPerformance.fromJson(dynamic json) => factory VeilidWASMConfigLoggingPerformance.fromJson(dynamic json) =>
@ -88,6 +92,7 @@ class VeilidWASMConfigLoggingApi with _$VeilidWASMConfigLoggingApi {
const factory VeilidWASMConfigLoggingApi({ const factory VeilidWASMConfigLoggingApi({
required bool enabled, required bool enabled,
required VeilidConfigLogLevel level, required VeilidConfigLogLevel level,
@Default([]) List<String> ignoreLogTargets,
}) = _VeilidWASMConfigLoggingApi; }) = _VeilidWASMConfigLoggingApi;
factory VeilidWASMConfigLoggingApi.fromJson(dynamic json) => factory VeilidWASMConfigLoggingApi.fromJson(dynamic json) =>

1542
veilid-flutter/lib/veilid_config.freezed.dart
View File

File diff suppressed because it is too large Load Diff

336
veilid-flutter/lib/veilid_config.g.dart
View File

@ -6,191 +6,226 @@ part of 'veilid_config.dart';
// JsonSerializableGenerator // JsonSerializableGenerator
// ************************************************************************** // **************************************************************************
_$_VeilidFFIConfigLoggingTerminal _$$_VeilidFFIConfigLoggingTerminalFromJson( _$VeilidFFIConfigLoggingTerminalImpl
Map<String, dynamic> json) => _$$VeilidFFIConfigLoggingTerminalImplFromJson(Map<String, dynamic> json) =>
_$_VeilidFFIConfigLoggingTerminal( _$VeilidFFIConfigLoggingTerminalImpl(
enabled: json['enabled'] as bool, enabled: json['enabled'] as bool,
level: VeilidConfigLogLevel.fromJson(json['level']), level: VeilidConfigLogLevel.fromJson(json['level']),
); ignoreLogTargets: (json['ignore_log_targets'] as List<dynamic>?)
?.map((e) => e as String)
.toList() ??
const [],
);
Map<String, dynamic> _$$_VeilidFFIConfigLoggingTerminalToJson( Map<String, dynamic> _$$VeilidFFIConfigLoggingTerminalImplToJson(
_$_VeilidFFIConfigLoggingTerminal instance) => _$VeilidFFIConfigLoggingTerminalImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'enabled': instance.enabled, 'enabled': instance.enabled,
'level': instance.level.toJson(), 'level': instance.level.toJson(),
'ignore_log_targets': instance.ignoreLogTargets,
}; };
_$_VeilidFFIConfigLoggingOtlp _$$_VeilidFFIConfigLoggingOtlpFromJson( _$VeilidFFIConfigLoggingOtlpImpl _$$VeilidFFIConfigLoggingOtlpImplFromJson(
Map<String, dynamic> json) => Map<String, dynamic> json) =>
_$_VeilidFFIConfigLoggingOtlp( _$VeilidFFIConfigLoggingOtlpImpl(
enabled: json['enabled'] as bool, enabled: json['enabled'] as bool,
level: VeilidConfigLogLevel.fromJson(json['level']), level: VeilidConfigLogLevel.fromJson(json['level']),
grpcEndpoint: json['grpc_endpoint'] as String, grpcEndpoint: json['grpc_endpoint'] as String,
serviceName: json['service_name'] as String, serviceName: json['service_name'] as String,
ignoreLogTargets: (json['ignore_log_targets'] as List<dynamic>?)
?.map((e) => e as String)
.toList() ??
const [],
); );
Map<String, dynamic> _$$_VeilidFFIConfigLoggingOtlpToJson( Map<String, dynamic> _$$VeilidFFIConfigLoggingOtlpImplToJson(
_$_VeilidFFIConfigLoggingOtlp instance) => _$VeilidFFIConfigLoggingOtlpImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'enabled': instance.enabled, 'enabled': instance.enabled,
'level': instance.level.toJson(), 'level': instance.level.toJson(),
'grpc_endpoint': instance.grpcEndpoint, 'grpc_endpoint': instance.grpcEndpoint,
'service_name': instance.serviceName, 'service_name': instance.serviceName,
'ignore_log_targets': instance.ignoreLogTargets,
}; };
_$_VeilidFFIConfigLoggingApi _$$_VeilidFFIConfigLoggingApiFromJson( _$VeilidFFIConfigLoggingApiImpl _$$VeilidFFIConfigLoggingApiImplFromJson(
Map<String, dynamic> json) => Map<String, dynamic> json) =>
_$_VeilidFFIConfigLoggingApi( _$VeilidFFIConfigLoggingApiImpl(
enabled: json['enabled'] as bool, enabled: json['enabled'] as bool,
level: VeilidConfigLogLevel.fromJson(json['level']), level: VeilidConfigLogLevel.fromJson(json['level']),
ignoreLogTargets: (json['ignore_log_targets'] as List<dynamic>?)
?.map((e) => e as String)
.toList() ??
const [],
); );
Map<String, dynamic> _$$_VeilidFFIConfigLoggingApiToJson( Map<String, dynamic> _$$VeilidFFIConfigLoggingApiImplToJson(
_$_VeilidFFIConfigLoggingApi instance) => _$VeilidFFIConfigLoggingApiImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'enabled': instance.enabled, 'enabled': instance.enabled,
'level': instance.level.toJson(), 'level': instance.level.toJson(),
'ignore_log_targets': instance.ignoreLogTargets,
}; };
_$_VeilidFFIConfigLogging _$$_VeilidFFIConfigLoggingFromJson( _$VeilidFFIConfigLoggingImpl _$$VeilidFFIConfigLoggingImplFromJson(
Map<String, dynamic> json) => Map<String, dynamic> json) =>
_$_VeilidFFIConfigLogging( _$VeilidFFIConfigLoggingImpl(
terminal: VeilidFFIConfigLoggingTerminal.fromJson(json['terminal']), terminal: VeilidFFIConfigLoggingTerminal.fromJson(json['terminal']),
otlp: VeilidFFIConfigLoggingOtlp.fromJson(json['otlp']), otlp: VeilidFFIConfigLoggingOtlp.fromJson(json['otlp']),
api: VeilidFFIConfigLoggingApi.fromJson(json['api']), api: VeilidFFIConfigLoggingApi.fromJson(json['api']),
); );
Map<String, dynamic> _$$_VeilidFFIConfigLoggingToJson( Map<String, dynamic> _$$VeilidFFIConfigLoggingImplToJson(
_$_VeilidFFIConfigLogging instance) => _$VeilidFFIConfigLoggingImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'terminal': instance.terminal.toJson(), 'terminal': instance.terminal.toJson(),
'otlp': instance.otlp.toJson(), 'otlp': instance.otlp.toJson(),
'api': instance.api.toJson(), 'api': instance.api.toJson(),
}; };
_$_VeilidFFIConfig _$$_VeilidFFIConfigFromJson(Map<String, dynamic> json) => _$VeilidFFIConfigImpl _$$VeilidFFIConfigImplFromJson(
_$_VeilidFFIConfig( Map<String, dynamic> json) =>
_$VeilidFFIConfigImpl(
logging: VeilidFFIConfigLogging.fromJson(json['logging']), logging: VeilidFFIConfigLogging.fromJson(json['logging']),
); );
Map<String, dynamic> _$$_VeilidFFIConfigToJson(_$_VeilidFFIConfig instance) => Map<String, dynamic> _$$VeilidFFIConfigImplToJson(
_$VeilidFFIConfigImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'logging': instance.logging.toJson(), 'logging': instance.logging.toJson(),
}; };
_$_VeilidWASMConfigLoggingPerformance _$VeilidWASMConfigLoggingPerformanceImpl
_$$_VeilidWASMConfigLoggingPerformanceFromJson(Map<String, dynamic> json) => _$$VeilidWASMConfigLoggingPerformanceImplFromJson(
_$_VeilidWASMConfigLoggingPerformance( Map<String, dynamic> json) =>
_$VeilidWASMConfigLoggingPerformanceImpl(
enabled: json['enabled'] as bool, enabled: json['enabled'] as bool,
level: VeilidConfigLogLevel.fromJson(json['level']), level: VeilidConfigLogLevel.fromJson(json['level']),
logsInTimings: json['logs_in_timings'] as bool, logsInTimings: json['logs_in_timings'] as bool,
logsInConsole: json['logs_in_console'] as bool, logsInConsole: json['logs_in_console'] as bool,
ignoreLogTargets: (json['ignore_log_targets'] as List<dynamic>?)
?.map((e) => e as String)
.toList() ??
const [],
); );
Map<String, dynamic> _$$_VeilidWASMConfigLoggingPerformanceToJson( Map<String, dynamic> _$$VeilidWASMConfigLoggingPerformanceImplToJson(
_$_VeilidWASMConfigLoggingPerformance instance) => _$VeilidWASMConfigLoggingPerformanceImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'enabled': instance.enabled, 'enabled': instance.enabled,
'level': instance.level.toJson(), 'level': instance.level.toJson(),
'logs_in_timings': instance.logsInTimings, 'logs_in_timings': instance.logsInTimings,
'logs_in_console': instance.logsInConsole, 'logs_in_console': instance.logsInConsole,
'ignore_log_targets': instance.ignoreLogTargets,
}; };
_$_VeilidWASMConfigLoggingApi _$$_VeilidWASMConfigLoggingApiFromJson( _$VeilidWASMConfigLoggingApiImpl _$$VeilidWASMConfigLoggingApiImplFromJson(
Map<String, dynamic> json) => Map<String, dynamic> json) =>
_$_VeilidWASMConfigLoggingApi( _$VeilidWASMConfigLoggingApiImpl(
enabled: json['enabled'] as bool, enabled: json['enabled'] as bool,
level: VeilidConfigLogLevel.fromJson(json['level']), level: VeilidConfigLogLevel.fromJson(json['level']),
ignoreLogTargets: (json['ignore_log_targets'] as List<dynamic>?)
?.map((e) => e as String)
.toList() ??
const [],
); );
Map<String, dynamic> _$$_VeilidWASMConfigLoggingApiToJson( Map<String, dynamic> _$$VeilidWASMConfigLoggingApiImplToJson(
_$_VeilidWASMConfigLoggingApi instance) => _$VeilidWASMConfigLoggingApiImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'enabled': instance.enabled, 'enabled': instance.enabled,
'level': instance.level.toJson(), 'level': instance.level.toJson(),
'ignore_log_targets': instance.ignoreLogTargets,
}; };
_$_VeilidWASMConfigLogging _$$_VeilidWASMConfigLoggingFromJson( _$VeilidWASMConfigLoggingImpl _$$VeilidWASMConfigLoggingImplFromJson(
Map<String, dynamic> json) => Map<String, dynamic> json) =>
_$_VeilidWASMConfigLogging( _$VeilidWASMConfigLoggingImpl(
performance: performance:
VeilidWASMConfigLoggingPerformance.fromJson(json['performance']), VeilidWASMConfigLoggingPerformance.fromJson(json['performance']),
api: VeilidWASMConfigLoggingApi.fromJson(json['api']), api: VeilidWASMConfigLoggingApi.fromJson(json['api']),
); );
Map<String, dynamic> _$$_VeilidWASMConfigLoggingToJson( Map<String, dynamic> _$$VeilidWASMConfigLoggingImplToJson(
_$_VeilidWASMConfigLogging instance) => _$VeilidWASMConfigLoggingImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'performance': instance.performance.toJson(), 'performance': instance.performance.toJson(),
'api': instance.api.toJson(), 'api': instance.api.toJson(),
}; };
_$_VeilidWASMConfig _$$_VeilidWASMConfigFromJson(Map<String, dynamic> json) => _$VeilidWASMConfigImpl _$$VeilidWASMConfigImplFromJson(
_$_VeilidWASMConfig( Map<String, dynamic> json) =>
_$VeilidWASMConfigImpl(
logging: VeilidWASMConfigLogging.fromJson(json['logging']), logging: VeilidWASMConfigLogging.fromJson(json['logging']),
); );
Map<String, dynamic> _$$_VeilidWASMConfigToJson(_$_VeilidWASMConfig instance) => Map<String, dynamic> _$$VeilidWASMConfigImplToJson(
_$VeilidWASMConfigImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'logging': instance.logging.toJson(), 'logging': instance.logging.toJson(),
}; };
_$_VeilidConfigHTTPS _$$_VeilidConfigHTTPSFromJson(Map<String, dynamic> json) => _$VeilidConfigHTTPSImpl _$$VeilidConfigHTTPSImplFromJson(
_$_VeilidConfigHTTPS(
enabled: json['enabled'] as bool,
listenAddress: json['listen_address'] as String,
path: json['path'] as String,
url: json['url'] as String?,
);
Map<String, dynamic> _$$_VeilidConfigHTTPSToJson(
_$_VeilidConfigHTTPS instance) =>
<String, dynamic>{
'enabled': instance.enabled,
'listen_address': instance.listenAddress,
'path': instance.path,
'url': instance.url,
};
_$_VeilidConfigHTTP _$$_VeilidConfigHTTPFromJson(Map<String, dynamic> json) =>
_$_VeilidConfigHTTP(
enabled: json['enabled'] as bool,
listenAddress: json['listen_address'] as String,
path: json['path'] as String,
url: json['url'] as String?,
);
Map<String, dynamic> _$$_VeilidConfigHTTPToJson(_$_VeilidConfigHTTP instance) =>
<String, dynamic>{
'enabled': instance.enabled,
'listen_address': instance.listenAddress,
'path': instance.path,
'url': instance.url,
};
_$_VeilidConfigApplication _$$_VeilidConfigApplicationFromJson(
Map<String, dynamic> json) => Map<String, dynamic> json) =>
_$_VeilidConfigApplication( _$VeilidConfigHTTPSImpl(
enabled: json['enabled'] as bool,
listenAddress: json['listen_address'] as String,
path: json['path'] as String,
url: json['url'] as String?,
);
Map<String, dynamic> _$$VeilidConfigHTTPSImplToJson(
_$VeilidConfigHTTPSImpl instance) =>
<String, dynamic>{
'enabled': instance.enabled,
'listen_address': instance.listenAddress,
'path': instance.path,
'url': instance.url,
};
_$VeilidConfigHTTPImpl _$$VeilidConfigHTTPImplFromJson(
Map<String, dynamic> json) =>
_$VeilidConfigHTTPImpl(
enabled: json['enabled'] as bool,
listenAddress: json['listen_address'] as String,
path: json['path'] as String,
url: json['url'] as String?,
);
Map<String, dynamic> _$$VeilidConfigHTTPImplToJson(
_$VeilidConfigHTTPImpl instance) =>
<String, dynamic>{
'enabled': instance.enabled,
'listen_address': instance.listenAddress,
'path': instance.path,
'url': instance.url,
};
_$VeilidConfigApplicationImpl _$$VeilidConfigApplicationImplFromJson(
Map<String, dynamic> json) =>
_$VeilidConfigApplicationImpl(
https: VeilidConfigHTTPS.fromJson(json['https']), https: VeilidConfigHTTPS.fromJson(json['https']),
http: VeilidConfigHTTP.fromJson(json['http']), http: VeilidConfigHTTP.fromJson(json['http']),
); );
Map<String, dynamic> _$$_VeilidConfigApplicationToJson( Map<String, dynamic> _$$VeilidConfigApplicationImplToJson(
_$_VeilidConfigApplication instance) => _$VeilidConfigApplicationImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'https': instance.https.toJson(), 'https': instance.https.toJson(),
'http': instance.http.toJson(), 'http': instance.http.toJson(),
}; };
_$_VeilidConfigUDP _$$_VeilidConfigUDPFromJson(Map<String, dynamic> json) => _$VeilidConfigUDPImpl _$$VeilidConfigUDPImplFromJson(
_$_VeilidConfigUDP( Map<String, dynamic> json) =>
_$VeilidConfigUDPImpl(
enabled: json['enabled'] as bool, enabled: json['enabled'] as bool,
socketPoolSize: json['socket_pool_size'] as int, socketPoolSize: json['socket_pool_size'] as int,
listenAddress: json['listen_address'] as String, listenAddress: json['listen_address'] as String,
publicAddress: json['public_address'] as String?, publicAddress: json['public_address'] as String?,
); );
Map<String, dynamic> _$$_VeilidConfigUDPToJson(_$_VeilidConfigUDP instance) => Map<String, dynamic> _$$VeilidConfigUDPImplToJson(
_$VeilidConfigUDPImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'enabled': instance.enabled, 'enabled': instance.enabled,
'socket_pool_size': instance.socketPoolSize, 'socket_pool_size': instance.socketPoolSize,
@ -198,8 +233,9 @@ Map<String, dynamic> _$$_VeilidConfigUDPToJson(_$_VeilidConfigUDP instance) =>
'public_address': instance.publicAddress, 'public_address': instance.publicAddress,
}; };
_$_VeilidConfigTCP _$$_VeilidConfigTCPFromJson(Map<String, dynamic> json) => _$VeilidConfigTCPImpl _$$VeilidConfigTCPImplFromJson(
_$_VeilidConfigTCP( Map<String, dynamic> json) =>
_$VeilidConfigTCPImpl(
connect: json['connect'] as bool, connect: json['connect'] as bool,
listen: json['listen'] as bool, listen: json['listen'] as bool,
maxConnections: json['max_connections'] as int, maxConnections: json['max_connections'] as int,
@ -207,7 +243,8 @@ _$_VeilidConfigTCP _$$_VeilidConfigTCPFromJson(Map<String, dynamic> json) =>
publicAddress: json['public_address'] as String?, publicAddress: json['public_address'] as String?,
); );
Map<String, dynamic> _$$_VeilidConfigTCPToJson(_$_VeilidConfigTCP instance) => Map<String, dynamic> _$$VeilidConfigTCPImplToJson(
_$VeilidConfigTCPImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'connect': instance.connect, 'connect': instance.connect,
'listen': instance.listen, 'listen': instance.listen,
@ -216,8 +253,8 @@ Map<String, dynamic> _$$_VeilidConfigTCPToJson(_$_VeilidConfigTCP instance) =>
'public_address': instance.publicAddress, 'public_address': instance.publicAddress,
}; };
_$_VeilidConfigWS _$$_VeilidConfigWSFromJson(Map<String, dynamic> json) => _$VeilidConfigWSImpl _$$VeilidConfigWSImplFromJson(Map<String, dynamic> json) =>
_$_VeilidConfigWS( _$VeilidConfigWSImpl(
connect: json['connect'] as bool, connect: json['connect'] as bool,
listen: json['listen'] as bool, listen: json['listen'] as bool,
maxConnections: json['max_connections'] as int, maxConnections: json['max_connections'] as int,
@ -226,7 +263,8 @@ _$_VeilidConfigWS _$$_VeilidConfigWSFromJson(Map<String, dynamic> json) =>
url: json['url'] as String?, url: json['url'] as String?,
); );
Map<String, dynamic> _$$_VeilidConfigWSToJson(_$_VeilidConfigWS instance) => Map<String, dynamic> _$$VeilidConfigWSImplToJson(
_$VeilidConfigWSImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'connect': instance.connect, 'connect': instance.connect,
'listen': instance.listen, 'listen': instance.listen,
@ -236,37 +274,39 @@ Map<String, dynamic> _$$_VeilidConfigWSToJson(_$_VeilidConfigWS instance) =>
'url': instance.url, 'url': instance.url,
}; };
_$_VeilidConfigWSS _$$_VeilidConfigWSSFromJson(Map<String, dynamic> json) => _$VeilidConfigWSSImpl _$$VeilidConfigWSSImplFromJson(
_$_VeilidConfigWSS(
connect: json['connect'] as bool,
listen: json['listen'] as bool,
maxConnections: json['max_connections'] as int,
listenAddress: json['listen_address'] as String,
path: json['path'] as String,
url: json['url'] as String?,
);
Map<String, dynamic> _$$_VeilidConfigWSSToJson(_$_VeilidConfigWSS instance) =>
<String, dynamic>{
'connect': instance.connect,
'listen': instance.listen,
'max_connections': instance.maxConnections,
'listen_address': instance.listenAddress,
'path': instance.path,
'url': instance.url,
};
_$_VeilidConfigProtocol _$$_VeilidConfigProtocolFromJson(
Map<String, dynamic> json) => Map<String, dynamic> json) =>
_$_VeilidConfigProtocol( _$VeilidConfigWSSImpl(
connect: json['connect'] as bool,
listen: json['listen'] as bool,
maxConnections: json['max_connections'] as int,
listenAddress: json['listen_address'] as String,
path: json['path'] as String,
url: json['url'] as String?,
);
Map<String, dynamic> _$$VeilidConfigWSSImplToJson(
_$VeilidConfigWSSImpl instance) =>
<String, dynamic>{
'connect': instance.connect,
'listen': instance.listen,
'max_connections': instance.maxConnections,
'listen_address': instance.listenAddress,
'path': instance.path,
'url': instance.url,
};
_$VeilidConfigProtocolImpl _$$VeilidConfigProtocolImplFromJson(
Map<String, dynamic> json) =>
_$VeilidConfigProtocolImpl(
udp: VeilidConfigUDP.fromJson(json['udp']), udp: VeilidConfigUDP.fromJson(json['udp']),
tcp: VeilidConfigTCP.fromJson(json['tcp']), tcp: VeilidConfigTCP.fromJson(json['tcp']),
ws: VeilidConfigWS.fromJson(json['ws']), ws: VeilidConfigWS.fromJson(json['ws']),
wss: VeilidConfigWSS.fromJson(json['wss']), wss: VeilidConfigWSS.fromJson(json['wss']),
); );
Map<String, dynamic> _$$_VeilidConfigProtocolToJson( Map<String, dynamic> _$$VeilidConfigProtocolImplToJson(
_$_VeilidConfigProtocol instance) => _$VeilidConfigProtocolImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'udp': instance.udp.toJson(), 'udp': instance.udp.toJson(),
'tcp': instance.tcp.toJson(), 'tcp': instance.tcp.toJson(),
@ -274,22 +314,25 @@ Map<String, dynamic> _$$_VeilidConfigProtocolToJson(
'wss': instance.wss.toJson(), 'wss': instance.wss.toJson(),
}; };
_$_VeilidConfigTLS _$$_VeilidConfigTLSFromJson(Map<String, dynamic> json) => _$VeilidConfigTLSImpl _$$VeilidConfigTLSImplFromJson(
_$_VeilidConfigTLS( Map<String, dynamic> json) =>
_$VeilidConfigTLSImpl(
certificatePath: json['certificate_path'] as String, certificatePath: json['certificate_path'] as String,
privateKeyPath: json['private_key_path'] as String, privateKeyPath: json['private_key_path'] as String,
connectionInitialTimeoutMs: json['connection_initial_timeout_ms'] as int, connectionInitialTimeoutMs: json['connection_initial_timeout_ms'] as int,
); );
Map<String, dynamic> _$$_VeilidConfigTLSToJson(_$_VeilidConfigTLS instance) => Map<String, dynamic> _$$VeilidConfigTLSImplToJson(
_$VeilidConfigTLSImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'certificate_path': instance.certificatePath, 'certificate_path': instance.certificatePath,
'private_key_path': instance.privateKeyPath, 'private_key_path': instance.privateKeyPath,
'connection_initial_timeout_ms': instance.connectionInitialTimeoutMs, 'connection_initial_timeout_ms': instance.connectionInitialTimeoutMs,
}; };
_$_VeilidConfigDHT _$$_VeilidConfigDHTFromJson(Map<String, dynamic> json) => _$VeilidConfigDHTImpl _$$VeilidConfigDHTImplFromJson(
_$_VeilidConfigDHT( Map<String, dynamic> json) =>
_$VeilidConfigDHTImpl(
resolveNodeTimeoutMs: json['resolve_node_timeout_ms'] as int, resolveNodeTimeoutMs: json['resolve_node_timeout_ms'] as int,
resolveNodeCount: json['resolve_node_count'] as int, resolveNodeCount: json['resolve_node_count'] as int,
resolveNodeFanout: json['resolve_node_fanout'] as int, resolveNodeFanout: json['resolve_node_fanout'] as int,
@ -317,7 +360,8 @@ _$_VeilidConfigDHT _$$_VeilidConfigDHTFromJson(Map<String, dynamic> json) =>
maxWatchExpirationMs: json['max_watch_expiration_ms'] as int, maxWatchExpirationMs: json['max_watch_expiration_ms'] as int,
); );
Map<String, dynamic> _$$_VeilidConfigDHTToJson(_$_VeilidConfigDHT instance) => Map<String, dynamic> _$$VeilidConfigDHTImplToJson(
_$VeilidConfigDHTImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'resolve_node_timeout_ms': instance.resolveNodeTimeoutMs, 'resolve_node_timeout_ms': instance.resolveNodeTimeoutMs,
'resolve_node_count': instance.resolveNodeCount, 'resolve_node_count': instance.resolveNodeCount,
@ -345,8 +389,9 @@ Map<String, dynamic> _$$_VeilidConfigDHTToJson(_$_VeilidConfigDHT instance) =>
'max_watch_expiration_ms': instance.maxWatchExpirationMs, 'max_watch_expiration_ms': instance.maxWatchExpirationMs,
}; };
_$_VeilidConfigRPC _$$_VeilidConfigRPCFromJson(Map<String, dynamic> json) => _$VeilidConfigRPCImpl _$$VeilidConfigRPCImplFromJson(
_$_VeilidConfigRPC( Map<String, dynamic> json) =>
_$VeilidConfigRPCImpl(
concurrency: json['concurrency'] as int, concurrency: json['concurrency'] as int,
queueSize: json['queue_size'] as int, queueSize: json['queue_size'] as int,
timeoutMs: json['timeout_ms'] as int, timeoutMs: json['timeout_ms'] as int,
@ -356,7 +401,8 @@ _$_VeilidConfigRPC _$$_VeilidConfigRPCFromJson(Map<String, dynamic> json) =>
maxTimestampAheadMs: json['max_timestamp_ahead_ms'] as int?, maxTimestampAheadMs: json['max_timestamp_ahead_ms'] as int?,
); );
Map<String, dynamic> _$$_VeilidConfigRPCToJson(_$_VeilidConfigRPC instance) => Map<String, dynamic> _$$VeilidConfigRPCImplToJson(
_$VeilidConfigRPCImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'concurrency': instance.concurrency, 'concurrency': instance.concurrency,
'queue_size': instance.queueSize, 'queue_size': instance.queueSize,
@ -367,9 +413,9 @@ Map<String, dynamic> _$$_VeilidConfigRPCToJson(_$_VeilidConfigRPC instance) =>
'max_timestamp_ahead_ms': instance.maxTimestampAheadMs, 'max_timestamp_ahead_ms': instance.maxTimestampAheadMs,
}; };
_$_VeilidConfigRoutingTable _$$_VeilidConfigRoutingTableFromJson( _$VeilidConfigRoutingTableImpl _$$VeilidConfigRoutingTableImplFromJson(
Map<String, dynamic> json) => Map<String, dynamic> json) =>
_$_VeilidConfigRoutingTable( _$VeilidConfigRoutingTableImpl(
nodeId: (json['node_id'] as List<dynamic>) nodeId: (json['node_id'] as List<dynamic>)
.map(Typed<FixedEncodedString43>.fromJson) .map(Typed<FixedEncodedString43>.fromJson)
.toList(), .toList(),
@ -385,8 +431,8 @@ _$_VeilidConfigRoutingTable _$$_VeilidConfigRoutingTableFromJson(
limitAttachedWeak: json['limit_attached_weak'] as int, limitAttachedWeak: json['limit_attached_weak'] as int,
); );
Map<String, dynamic> _$$_VeilidConfigRoutingTableToJson( Map<String, dynamic> _$$VeilidConfigRoutingTableImplToJson(
_$_VeilidConfigRoutingTable instance) => _$VeilidConfigRoutingTableImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'node_id': instance.nodeId.map((e) => e.toJson()).toList(), 'node_id': instance.nodeId.map((e) => e.toJson()).toList(),
'node_id_secret': instance.nodeIdSecret.map((e) => e.toJson()).toList(), 'node_id_secret': instance.nodeIdSecret.map((e) => e.toJson()).toList(),
@ -398,9 +444,9 @@ Map<String, dynamic> _$$_VeilidConfigRoutingTableToJson(
'limit_attached_weak': instance.limitAttachedWeak, 'limit_attached_weak': instance.limitAttachedWeak,
}; };
_$_VeilidConfigNetwork _$$_VeilidConfigNetworkFromJson( _$VeilidConfigNetworkImpl _$$VeilidConfigNetworkImplFromJson(
Map<String, dynamic> json) => Map<String, dynamic> json) =>
_$_VeilidConfigNetwork( _$VeilidConfigNetworkImpl(
connectionInitialTimeoutMs: json['connection_initial_timeout_ms'] as int, connectionInitialTimeoutMs: json['connection_initial_timeout_ms'] as int,
connectionInactivityTimeoutMs: connectionInactivityTimeoutMs:
json['connection_inactivity_timeout_ms'] as int, json['connection_inactivity_timeout_ms'] as int,
@ -426,8 +472,8 @@ _$_VeilidConfigNetwork _$$_VeilidConfigNetworkFromJson(
networkKeyPassword: json['network_key_password'] as String?, networkKeyPassword: json['network_key_password'] as String?,
); );
Map<String, dynamic> _$$_VeilidConfigNetworkToJson( Map<String, dynamic> _$$VeilidConfigNetworkImplToJson(
_$_VeilidConfigNetwork instance) => _$VeilidConfigNetworkImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'connection_initial_timeout_ms': instance.connectionInitialTimeoutMs, 'connection_initial_timeout_ms': instance.connectionInitialTimeoutMs,
'connection_inactivity_timeout_ms': 'connection_inactivity_timeout_ms':
@ -453,37 +499,37 @@ Map<String, dynamic> _$$_VeilidConfigNetworkToJson(
'network_key_password': instance.networkKeyPassword, 'network_key_password': instance.networkKeyPassword,
}; };
_$_VeilidConfigTableStore _$$_VeilidConfigTableStoreFromJson( _$VeilidConfigTableStoreImpl _$$VeilidConfigTableStoreImplFromJson(
Map<String, dynamic> json) => Map<String, dynamic> json) =>
_$_VeilidConfigTableStore( _$VeilidConfigTableStoreImpl(
directory: json['directory'] as String, directory: json['directory'] as String,
delete: json['delete'] as bool, delete: json['delete'] as bool,
); );
Map<String, dynamic> _$$_VeilidConfigTableStoreToJson( Map<String, dynamic> _$$VeilidConfigTableStoreImplToJson(
_$_VeilidConfigTableStore instance) => _$VeilidConfigTableStoreImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'directory': instance.directory, 'directory': instance.directory,
'delete': instance.delete, 'delete': instance.delete,
}; };
_$_VeilidConfigBlockStore _$$_VeilidConfigBlockStoreFromJson( _$VeilidConfigBlockStoreImpl _$$VeilidConfigBlockStoreImplFromJson(
Map<String, dynamic> json) => Map<String, dynamic> json) =>
_$_VeilidConfigBlockStore( _$VeilidConfigBlockStoreImpl(
directory: json['directory'] as String, directory: json['directory'] as String,
delete: json['delete'] as bool, delete: json['delete'] as bool,
); );
Map<String, dynamic> _$$_VeilidConfigBlockStoreToJson( Map<String, dynamic> _$$VeilidConfigBlockStoreImplToJson(
_$_VeilidConfigBlockStore instance) => _$VeilidConfigBlockStoreImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'directory': instance.directory, 'directory': instance.directory,
'delete': instance.delete, 'delete': instance.delete,
}; };
_$_VeilidConfigProtectedStore _$$_VeilidConfigProtectedStoreFromJson( _$VeilidConfigProtectedStoreImpl _$$VeilidConfigProtectedStoreImplFromJson(
Map<String, dynamic> json) => Map<String, dynamic> json) =>
_$_VeilidConfigProtectedStore( _$VeilidConfigProtectedStoreImpl(
allowInsecureFallback: json['allow_insecure_fallback'] as bool, allowInsecureFallback: json['allow_insecure_fallback'] as bool,
alwaysUseInsecureStorage: json['always_use_insecure_storage'] as bool, alwaysUseInsecureStorage: json['always_use_insecure_storage'] as bool,
directory: json['directory'] as String, directory: json['directory'] as String,
@ -494,8 +540,8 @@ _$_VeilidConfigProtectedStore _$$_VeilidConfigProtectedStoreFromJson(
json['new_device_encryption_key_password'] as String?, json['new_device_encryption_key_password'] as String?,
); );
Map<String, dynamic> _$$_VeilidConfigProtectedStoreToJson( Map<String, dynamic> _$$VeilidConfigProtectedStoreImplToJson(
_$_VeilidConfigProtectedStore instance) => _$VeilidConfigProtectedStoreImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'allow_insecure_fallback': instance.allowInsecureFallback, 'allow_insecure_fallback': instance.allowInsecureFallback,
'always_use_insecure_storage': instance.alwaysUseInsecureStorage, 'always_use_insecure_storage': instance.alwaysUseInsecureStorage,
@ -506,21 +552,21 @@ Map<String, dynamic> _$$_VeilidConfigProtectedStoreToJson(
instance.newDeviceEncryptionKeyPassword, instance.newDeviceEncryptionKeyPassword,
}; };
_$_VeilidConfigCapabilities _$$_VeilidConfigCapabilitiesFromJson( _$VeilidConfigCapabilitiesImpl _$$VeilidConfigCapabilitiesImplFromJson(
Map<String, dynamic> json) => Map<String, dynamic> json) =>
_$_VeilidConfigCapabilities( _$VeilidConfigCapabilitiesImpl(
disable: disable:
(json['disable'] as List<dynamic>).map((e) => e as String).toList(), (json['disable'] as List<dynamic>).map((e) => e as String).toList(),
); );
Map<String, dynamic> _$$_VeilidConfigCapabilitiesToJson( Map<String, dynamic> _$$VeilidConfigCapabilitiesImplToJson(
_$_VeilidConfigCapabilities instance) => _$VeilidConfigCapabilitiesImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'disable': instance.disable, 'disable': instance.disable,
}; };
_$_VeilidConfig _$$_VeilidConfigFromJson(Map<String, dynamic> json) => _$VeilidConfigImpl _$$VeilidConfigImplFromJson(Map<String, dynamic> json) =>
_$_VeilidConfig( _$VeilidConfigImpl(
programName: json['program_name'] as String, programName: json['program_name'] as String,
namespace: json['namespace'] as String, namespace: json['namespace'] as String,
capabilities: VeilidConfigCapabilities.fromJson(json['capabilities']), capabilities: VeilidConfigCapabilities.fromJson(json['capabilities']),
@ -531,7 +577,7 @@ _$_VeilidConfig _$$_VeilidConfigFromJson(Map<String, dynamic> json) =>
network: VeilidConfigNetwork.fromJson(json['network']), network: VeilidConfigNetwork.fromJson(json['network']),
); );
Map<String, dynamic> _$$_VeilidConfigToJson(_$_VeilidConfig instance) => Map<String, dynamic> _$$VeilidConfigImplToJson(_$VeilidConfigImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'program_name': instance.programName, 'program_name': instance.programName,
'namespace': instance.namespace, 'namespace': instance.namespace,

823
veilid-flutter/lib/veilid_state.freezed.dart
View File

File diff suppressed because it is too large Load Diff

127
veilid-flutter/lib/veilid_state.g.dart
View File

@ -6,29 +6,29 @@ part of 'veilid_state.dart';
// JsonSerializableGenerator // JsonSerializableGenerator
// ************************************************************************** // **************************************************************************
_$_LatencyStats _$$_LatencyStatsFromJson(Map<String, dynamic> json) => _$LatencyStatsImpl _$$LatencyStatsImplFromJson(Map<String, dynamic> json) =>
_$_LatencyStats( _$LatencyStatsImpl(
fastest: TimestampDuration.fromJson(json['fastest']), fastest: TimestampDuration.fromJson(json['fastest']),
average: TimestampDuration.fromJson(json['average']), average: TimestampDuration.fromJson(json['average']),
slowest: TimestampDuration.fromJson(json['slowest']), slowest: TimestampDuration.fromJson(json['slowest']),
); );
Map<String, dynamic> _$$_LatencyStatsToJson(_$_LatencyStats instance) => Map<String, dynamic> _$$LatencyStatsImplToJson(_$LatencyStatsImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'fastest': instance.fastest.toJson(), 'fastest': instance.fastest.toJson(),
'average': instance.average.toJson(), 'average': instance.average.toJson(),
'slowest': instance.slowest.toJson(), 'slowest': instance.slowest.toJson(),
}; };
_$_TransferStats _$$_TransferStatsFromJson(Map<String, dynamic> json) => _$TransferStatsImpl _$$TransferStatsImplFromJson(Map<String, dynamic> json) =>
_$_TransferStats( _$TransferStatsImpl(
total: BigInt.parse(json['total'] as String), total: BigInt.parse(json['total'] as String),
maximum: BigInt.parse(json['maximum'] as String), maximum: BigInt.parse(json['maximum'] as String),
average: BigInt.parse(json['average'] as String), average: BigInt.parse(json['average'] as String),
minimum: BigInt.parse(json['minimum'] as String), minimum: BigInt.parse(json['minimum'] as String),
); );
Map<String, dynamic> _$$_TransferStatsToJson(_$_TransferStats instance) => Map<String, dynamic> _$$TransferStatsImplToJson(_$TransferStatsImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'total': instance.total.toString(), 'total': instance.total.toString(),
'maximum': instance.maximum.toString(), 'maximum': instance.maximum.toString(),
@ -36,21 +36,22 @@ Map<String, dynamic> _$$_TransferStatsToJson(_$_TransferStats instance) =>
'minimum': instance.minimum.toString(), 'minimum': instance.minimum.toString(),
}; };
_$_TransferStatsDownUp _$$_TransferStatsDownUpFromJson( _$TransferStatsDownUpImpl _$$TransferStatsDownUpImplFromJson(
Map<String, dynamic> json) => Map<String, dynamic> json) =>
_$_TransferStatsDownUp( _$TransferStatsDownUpImpl(
down: TransferStats.fromJson(json['down']), down: TransferStats.fromJson(json['down']),
up: TransferStats.fromJson(json['up']), up: TransferStats.fromJson(json['up']),
); );
Map<String, dynamic> _$$_TransferStatsDownUpToJson( Map<String, dynamic> _$$TransferStatsDownUpImplToJson(
_$_TransferStatsDownUp instance) => _$TransferStatsDownUpImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'down': instance.down.toJson(), 'down': instance.down.toJson(),
'up': instance.up.toJson(), 'up': instance.up.toJson(),
}; };
_$_RPCStats _$$_RPCStatsFromJson(Map<String, dynamic> json) => _$_RPCStats( _$RPCStatsImpl _$$RPCStatsImplFromJson(Map<String, dynamic> json) =>
_$RPCStatsImpl(
messagesSent: json['messages_sent'] as int, messagesSent: json['messages_sent'] as int,
messagesRcvd: json['messages_rcvd'] as int, messagesRcvd: json['messages_rcvd'] as int,
questionsInFlight: json['questions_in_flight'] as int, questionsInFlight: json['questions_in_flight'] as int,
@ -67,7 +68,7 @@ _$_RPCStats _$$_RPCStatsFromJson(Map<String, dynamic> json) => _$_RPCStats(
failedToSend: json['failed_to_send'] as int, failedToSend: json['failed_to_send'] as int,
); );
Map<String, dynamic> _$$_RPCStatsToJson(_$_RPCStats instance) => Map<String, dynamic> _$$RPCStatsImplToJson(_$RPCStatsImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'messages_sent': instance.messagesSent, 'messages_sent': instance.messagesSent,
'messages_rcvd': instance.messagesRcvd, 'messages_rcvd': instance.messagesRcvd,
@ -79,7 +80,8 @@ Map<String, dynamic> _$$_RPCStatsToJson(_$_RPCStats instance) =>
'failed_to_send': instance.failedToSend, 'failed_to_send': instance.failedToSend,
}; };
_$_PeerStats _$$_PeerStatsFromJson(Map<String, dynamic> json) => _$_PeerStats( _$PeerStatsImpl _$$PeerStatsImplFromJson(Map<String, dynamic> json) =>
_$PeerStatsImpl(
timeAdded: Timestamp.fromJson(json['time_added']), timeAdded: Timestamp.fromJson(json['time_added']),
rpcStats: RPCStats.fromJson(json['rpc_stats']), rpcStats: RPCStats.fromJson(json['rpc_stats']),
transfer: TransferStatsDownUp.fromJson(json['transfer']), transfer: TransferStatsDownUp.fromJson(json['transfer']),
@ -88,7 +90,7 @@ _$_PeerStats _$$_PeerStatsFromJson(Map<String, dynamic> json) => _$_PeerStats(
: LatencyStats.fromJson(json['latency']), : LatencyStats.fromJson(json['latency']),
); );
Map<String, dynamic> _$$_PeerStatsToJson(_$_PeerStats instance) => Map<String, dynamic> _$$PeerStatsImplToJson(_$PeerStatsImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'time_added': instance.timeAdded.toJson(), 'time_added': instance.timeAdded.toJson(),
'rpc_stats': instance.rpcStats.toJson(), 'rpc_stats': instance.rpcStats.toJson(),
@ -96,8 +98,8 @@ Map<String, dynamic> _$$_PeerStatsToJson(_$_PeerStats instance) =>
'latency': instance.latency?.toJson(), 'latency': instance.latency?.toJson(),
}; };
_$_PeerTableData _$$_PeerTableDataFromJson(Map<String, dynamic> json) => _$PeerTableDataImpl _$$PeerTableDataImplFromJson(Map<String, dynamic> json) =>
_$_PeerTableData( _$PeerTableDataImpl(
nodeIds: (json['node_ids'] as List<dynamic>) nodeIds: (json['node_ids'] as List<dynamic>)
.map(Typed<FixedEncodedString43>.fromJson) .map(Typed<FixedEncodedString43>.fromJson)
.toList(), .toList(),
@ -105,21 +107,22 @@ _$_PeerTableData _$$_PeerTableDataFromJson(Map<String, dynamic> json) =>
peerStats: PeerStats.fromJson(json['peer_stats']), peerStats: PeerStats.fromJson(json['peer_stats']),
); );
Map<String, dynamic> _$$_PeerTableDataToJson(_$_PeerTableData instance) => Map<String, dynamic> _$$PeerTableDataImplToJson(_$PeerTableDataImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'node_ids': instance.nodeIds.map((e) => e.toJson()).toList(), 'node_ids': instance.nodeIds.map((e) => e.toJson()).toList(),
'peer_address': instance.peerAddress, 'peer_address': instance.peerAddress,
'peer_stats': instance.peerStats.toJson(), 'peer_stats': instance.peerStats.toJson(),
}; };
_$VeilidLog _$$VeilidLogFromJson(Map<String, dynamic> json) => _$VeilidLog( _$VeilidLogImpl _$$VeilidLogImplFromJson(Map<String, dynamic> json) =>
_$VeilidLogImpl(
logLevel: VeilidLogLevel.fromJson(json['log_level']), logLevel: VeilidLogLevel.fromJson(json['log_level']),
message: json['message'] as String, message: json['message'] as String,
backtrace: json['backtrace'] as String?, backtrace: json['backtrace'] as String?,
$type: json['kind'] as String?, $type: json['kind'] as String?,
); );
Map<String, dynamic> _$$VeilidLogToJson(_$VeilidLog instance) => Map<String, dynamic> _$$VeilidLogImplToJson(_$VeilidLogImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'log_level': instance.logLevel.toJson(), 'log_level': instance.logLevel.toJson(),
'message': instance.message, 'message': instance.message,
@ -127,8 +130,9 @@ Map<String, dynamic> _$$VeilidLogToJson(_$VeilidLog instance) =>
'kind': instance.$type, 'kind': instance.$type,
}; };
_$VeilidAppMessage _$$VeilidAppMessageFromJson(Map<String, dynamic> json) => _$VeilidAppMessageImpl _$$VeilidAppMessageImplFromJson(
_$VeilidAppMessage( Map<String, dynamic> json) =>
_$VeilidAppMessageImpl(
message: const Uint8ListJsonConverter().fromJson(json['message']), message: const Uint8ListJsonConverter().fromJson(json['message']),
sender: json['sender'] == null sender: json['sender'] == null
? null ? null
@ -136,15 +140,16 @@ _$VeilidAppMessage _$$VeilidAppMessageFromJson(Map<String, dynamic> json) =>
$type: json['kind'] as String?, $type: json['kind'] as String?,
); );
Map<String, dynamic> _$$VeilidAppMessageToJson(_$VeilidAppMessage instance) => Map<String, dynamic> _$$VeilidAppMessageImplToJson(
_$VeilidAppMessageImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'message': const Uint8ListJsonConverter().toJson(instance.message), 'message': const Uint8ListJsonConverter().toJson(instance.message),
'sender': instance.sender?.toJson(), 'sender': instance.sender?.toJson(),
'kind': instance.$type, 'kind': instance.$type,
}; };
_$VeilidAppCall _$$VeilidAppCallFromJson(Map<String, dynamic> json) => _$VeilidAppCallImpl _$$VeilidAppCallImplFromJson(Map<String, dynamic> json) =>
_$VeilidAppCall( _$VeilidAppCallImpl(
message: const Uint8ListJsonConverter().fromJson(json['message']), message: const Uint8ListJsonConverter().fromJson(json['message']),
callId: json['call_id'] as String, callId: json['call_id'] as String,
sender: json['sender'] == null sender: json['sender'] == null
@ -153,7 +158,7 @@ _$VeilidAppCall _$$VeilidAppCallFromJson(Map<String, dynamic> json) =>
$type: json['kind'] as String?, $type: json['kind'] as String?,
); );
Map<String, dynamic> _$$VeilidAppCallToJson(_$VeilidAppCall instance) => Map<String, dynamic> _$$VeilidAppCallImplToJson(_$VeilidAppCallImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'message': const Uint8ListJsonConverter().toJson(instance.message), 'message': const Uint8ListJsonConverter().toJson(instance.message),
'call_id': instance.callId, 'call_id': instance.callId,
@ -161,17 +166,17 @@ Map<String, dynamic> _$$VeilidAppCallToJson(_$VeilidAppCall instance) =>
'kind': instance.$type, 'kind': instance.$type,
}; };
_$VeilidUpdateAttachment _$$VeilidUpdateAttachmentFromJson( _$VeilidUpdateAttachmentImpl _$$VeilidUpdateAttachmentImplFromJson(
Map<String, dynamic> json) => Map<String, dynamic> json) =>
_$VeilidUpdateAttachment( _$VeilidUpdateAttachmentImpl(
state: AttachmentState.fromJson(json['state']), state: AttachmentState.fromJson(json['state']),
publicInternetReady: json['public_internet_ready'] as bool, publicInternetReady: json['public_internet_ready'] as bool,
localNetworkReady: json['local_network_ready'] as bool, localNetworkReady: json['local_network_ready'] as bool,
$type: json['kind'] as String?, $type: json['kind'] as String?,
); );
Map<String, dynamic> _$$VeilidUpdateAttachmentToJson( Map<String, dynamic> _$$VeilidUpdateAttachmentImplToJson(
_$VeilidUpdateAttachment instance) => _$VeilidUpdateAttachmentImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'state': instance.state.toJson(), 'state': instance.state.toJson(),
'public_internet_ready': instance.publicInternetReady, 'public_internet_ready': instance.publicInternetReady,
@ -179,9 +184,9 @@ Map<String, dynamic> _$$VeilidUpdateAttachmentToJson(
'kind': instance.$type, 'kind': instance.$type,
}; };
_$VeilidUpdateNetwork _$$VeilidUpdateNetworkFromJson( _$VeilidUpdateNetworkImpl _$$VeilidUpdateNetworkImplFromJson(
Map<String, dynamic> json) => Map<String, dynamic> json) =>
_$VeilidUpdateNetwork( _$VeilidUpdateNetworkImpl(
started: json['started'] as bool, started: json['started'] as bool,
bpsDown: BigInt.parse(json['bps_down'] as String), bpsDown: BigInt.parse(json['bps_down'] as String),
bpsUp: BigInt.parse(json['bps_up'] as String), bpsUp: BigInt.parse(json['bps_up'] as String),
@ -190,8 +195,8 @@ _$VeilidUpdateNetwork _$$VeilidUpdateNetworkFromJson(
$type: json['kind'] as String?, $type: json['kind'] as String?,
); );
Map<String, dynamic> _$$VeilidUpdateNetworkToJson( Map<String, dynamic> _$$VeilidUpdateNetworkImplToJson(
_$VeilidUpdateNetwork instance) => _$VeilidUpdateNetworkImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'started': instance.started, 'started': instance.started,
'bps_down': instance.bpsDown.toString(), 'bps_down': instance.bpsDown.toString(),
@ -200,22 +205,23 @@ Map<String, dynamic> _$$VeilidUpdateNetworkToJson(
'kind': instance.$type, 'kind': instance.$type,
}; };
_$VeilidUpdateConfig _$$VeilidUpdateConfigFromJson(Map<String, dynamic> json) => _$VeilidUpdateConfigImpl _$$VeilidUpdateConfigImplFromJson(
_$VeilidUpdateConfig( Map<String, dynamic> json) =>
_$VeilidUpdateConfigImpl(
config: VeilidConfig.fromJson(json['config']), config: VeilidConfig.fromJson(json['config']),
$type: json['kind'] as String?, $type: json['kind'] as String?,
); );
Map<String, dynamic> _$$VeilidUpdateConfigToJson( Map<String, dynamic> _$$VeilidUpdateConfigImplToJson(
_$VeilidUpdateConfig instance) => _$VeilidUpdateConfigImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'config': instance.config.toJson(), 'config': instance.config.toJson(),
'kind': instance.$type, 'kind': instance.$type,
}; };
_$VeilidUpdateRouteChange _$$VeilidUpdateRouteChangeFromJson( _$VeilidUpdateRouteChangeImpl _$$VeilidUpdateRouteChangeImplFromJson(
Map<String, dynamic> json) => Map<String, dynamic> json) =>
_$VeilidUpdateRouteChange( _$VeilidUpdateRouteChangeImpl(
deadRoutes: (json['dead_routes'] as List<dynamic>) deadRoutes: (json['dead_routes'] as List<dynamic>)
.map((e) => e as String) .map((e) => e as String)
.toList(), .toList(),
@ -225,17 +231,17 @@ _$VeilidUpdateRouteChange _$$VeilidUpdateRouteChangeFromJson(
$type: json['kind'] as String?, $type: json['kind'] as String?,
); );
Map<String, dynamic> _$$VeilidUpdateRouteChangeToJson( Map<String, dynamic> _$$VeilidUpdateRouteChangeImplToJson(
_$VeilidUpdateRouteChange instance) => _$VeilidUpdateRouteChangeImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'dead_routes': instance.deadRoutes, 'dead_routes': instance.deadRoutes,
'dead_remote_routes': instance.deadRemoteRoutes, 'dead_remote_routes': instance.deadRemoteRoutes,
'kind': instance.$type, 'kind': instance.$type,
}; };
_$VeilidUpdateValueChange _$$VeilidUpdateValueChangeFromJson( _$VeilidUpdateValueChangeImpl _$$VeilidUpdateValueChangeImplFromJson(
Map<String, dynamic> json) => Map<String, dynamic> json) =>
_$VeilidUpdateValueChange( _$VeilidUpdateValueChangeImpl(
key: Typed<FixedEncodedString43>.fromJson(json['key']), key: Typed<FixedEncodedString43>.fromJson(json['key']),
subkeys: (json['subkeys'] as List<dynamic>) subkeys: (json['subkeys'] as List<dynamic>)
.map(ValueSubkeyRange.fromJson) .map(ValueSubkeyRange.fromJson)
@ -245,8 +251,8 @@ _$VeilidUpdateValueChange _$$VeilidUpdateValueChangeFromJson(
$type: json['kind'] as String?, $type: json['kind'] as String?,
); );
Map<String, dynamic> _$$VeilidUpdateValueChangeToJson( Map<String, dynamic> _$$VeilidUpdateValueChangeImplToJson(
_$VeilidUpdateValueChange instance) => _$VeilidUpdateValueChangeImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'key': instance.key.toJson(), 'key': instance.key.toJson(),
'subkeys': instance.subkeys.map((e) => e.toJson()).toList(), 'subkeys': instance.subkeys.map((e) => e.toJson()).toList(),
@ -255,25 +261,25 @@ Map<String, dynamic> _$$VeilidUpdateValueChangeToJson(
'kind': instance.$type, 'kind': instance.$type,
}; };
_$_VeilidStateAttachment _$$_VeilidStateAttachmentFromJson( _$VeilidStateAttachmentImpl _$$VeilidStateAttachmentImplFromJson(
Map<String, dynamic> json) => Map<String, dynamic> json) =>
_$_VeilidStateAttachment( _$VeilidStateAttachmentImpl(
state: AttachmentState.fromJson(json['state']), state: AttachmentState.fromJson(json['state']),
publicInternetReady: json['public_internet_ready'] as bool, publicInternetReady: json['public_internet_ready'] as bool,
localNetworkReady: json['local_network_ready'] as bool, localNetworkReady: json['local_network_ready'] as bool,
); );
Map<String, dynamic> _$$_VeilidStateAttachmentToJson( Map<String, dynamic> _$$VeilidStateAttachmentImplToJson(
_$_VeilidStateAttachment instance) => _$VeilidStateAttachmentImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'state': instance.state.toJson(), 'state': instance.state.toJson(),
'public_internet_ready': instance.publicInternetReady, 'public_internet_ready': instance.publicInternetReady,
'local_network_ready': instance.localNetworkReady, 'local_network_ready': instance.localNetworkReady,
}; };
_$_VeilidStateNetwork _$$_VeilidStateNetworkFromJson( _$VeilidStateNetworkImpl _$$VeilidStateNetworkImplFromJson(
Map<String, dynamic> json) => Map<String, dynamic> json) =>
_$_VeilidStateNetwork( _$VeilidStateNetworkImpl(
started: json['started'] as bool, started: json['started'] as bool,
bpsDown: BigInt.parse(json['bps_down'] as String), bpsDown: BigInt.parse(json['bps_down'] as String),
bpsUp: BigInt.parse(json['bps_up'] as String), bpsUp: BigInt.parse(json['bps_up'] as String),
@ -281,8 +287,8 @@ _$_VeilidStateNetwork _$$_VeilidStateNetworkFromJson(
(json['peers'] as List<dynamic>).map(PeerTableData.fromJson).toList(), (json['peers'] as List<dynamic>).map(PeerTableData.fromJson).toList(),
); );
Map<String, dynamic> _$$_VeilidStateNetworkToJson( Map<String, dynamic> _$$VeilidStateNetworkImplToJson(
_$_VeilidStateNetwork instance) => _$VeilidStateNetworkImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'started': instance.started, 'started': instance.started,
'bps_down': instance.bpsDown.toString(), 'bps_down': instance.bpsDown.toString(),
@ -290,25 +296,26 @@ Map<String, dynamic> _$$_VeilidStateNetworkToJson(
'peers': instance.peers.map((e) => e.toJson()).toList(), 'peers': instance.peers.map((e) => e.toJson()).toList(),
}; };
_$_VeilidStateConfig _$$_VeilidStateConfigFromJson(Map<String, dynamic> json) => _$VeilidStateConfigImpl _$$VeilidStateConfigImplFromJson(
_$_VeilidStateConfig( Map<String, dynamic> json) =>
_$VeilidStateConfigImpl(
config: VeilidConfig.fromJson(json['config']), config: VeilidConfig.fromJson(json['config']),
); );
Map<String, dynamic> _$$_VeilidStateConfigToJson( Map<String, dynamic> _$$VeilidStateConfigImplToJson(
_$_VeilidStateConfig instance) => _$VeilidStateConfigImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'config': instance.config.toJson(), 'config': instance.config.toJson(),
}; };
_$_VeilidState _$$_VeilidStateFromJson(Map<String, dynamic> json) => _$VeilidStateImpl _$$VeilidStateImplFromJson(Map<String, dynamic> json) =>
_$_VeilidState( _$VeilidStateImpl(
attachment: VeilidStateAttachment.fromJson(json['attachment']), attachment: VeilidStateAttachment.fromJson(json['attachment']),
network: VeilidStateNetwork.fromJson(json['network']), network: VeilidStateNetwork.fromJson(json['network']),
config: VeilidStateConfig.fromJson(json['config']), config: VeilidStateConfig.fromJson(json['config']),
); );
Map<String, dynamic> _$$_VeilidStateToJson(_$_VeilidState instance) => Map<String, dynamic> _$$VeilidStateImplToJson(_$VeilidStateImpl instance) =>
<String, dynamic>{ <String, dynamic>{
'attachment': instance.attachment.toJson(), 'attachment': instance.attachment.toJson(),
'network': instance.network.toJson(), 'network': instance.network.toJson(),

2
veilid-flutter/pubspec.yaml
View File

@ -8,7 +8,7 @@ publish_to: "none" # Remove this line if you wish to publish to pub.dev
environment: environment:
sdk: '>=3.0.0 <4.0.0' sdk: '>=3.0.0 <4.0.0'
flutter: '>=3.10.6' flutter: '>=3.19.1'
dependencies: dependencies:
change_case: ^2.0.1 change_case: ^2.0.1

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

@ -99,6 +99,7 @@ const APIRESULT_VOID: APIResult<()> = APIResult::Ok(());
pub struct VeilidFFIConfigLoggingTerminal { pub struct VeilidFFIConfigLoggingTerminal {
pub enabled: bool, pub enabled: bool,
pub level: veilid_core::VeilidConfigLogLevel, pub level: veilid_core::VeilidConfigLogLevel,
pub ignore_log_targets: Vec<String>,
} }
#[derive(Debug, Deserialize, Serialize)] #[derive(Debug, Deserialize, Serialize)]
@ -107,12 +108,14 @@ pub struct VeilidFFIConfigLoggingOtlp {
pub level: veilid_core::VeilidConfigLogLevel, pub level: veilid_core::VeilidConfigLogLevel,
pub grpc_endpoint: String, pub grpc_endpoint: String,
pub service_name: String, pub service_name: String,
pub ignore_log_targets: Vec<String>,
} }
#[derive(Debug, Deserialize, Serialize)] #[derive(Debug, Deserialize, Serialize)]
pub struct VeilidFFIConfigLoggingApi { pub struct VeilidFFIConfigLoggingApi {
pub enabled: bool, pub enabled: bool,
pub level: veilid_core::VeilidConfigLogLevel, pub level: veilid_core::VeilidConfigLogLevel,
pub ignore_log_targets: Vec<String>,
} }
#[derive(Debug, Deserialize, Serialize)] #[derive(Debug, Deserialize, Serialize)]
@ -205,7 +208,7 @@ pub extern "C" fn initialize_veilid_core(platform_config: FfiStr) {
cfg_if! { cfg_if! {
if #[cfg(target_os = "android")] { if #[cfg(target_os = "android")] {
let filter = let filter =
veilid_core::VeilidLayerFilter::new(platform_config.logging.terminal.level, None); veilid_core::VeilidLayerFilter::new(platform_config.logging.terminal.level, &platform_config.logging.terminal.ignore_log_targets);
let layer = paranoid_android::layer("veilid-flutter") let layer = paranoid_android::layer("veilid-flutter")
.with_ansi(false) .with_ansi(false)
.with_filter(filter.clone()); .with_filter(filter.clone());
@ -213,7 +216,7 @@ pub extern "C" fn initialize_veilid_core(platform_config: FfiStr) {
layers.push(layer.boxed()); layers.push(layer.boxed());
} else { } else {
let filter = let filter =
veilid_core::VeilidLayerFilter::new(platform_config.logging.terminal.level, None); veilid_core::VeilidLayerFilter::new(platform_config.logging.terminal.level, &platform_config.logging.terminal.ignore_log_targets);
let layer = tracing_subscriber::fmt::Layer::new() let layer = tracing_subscriber::fmt::Layer::new()
.compact() .compact()
.with_writer(std::io::stdout) .with_writer(std::io::stdout)
@ -263,7 +266,10 @@ pub extern "C" fn initialize_veilid_core(platform_config: FfiStr) {
.map_err(|e| format!("failed to install OpenTelemetry tracer: {}", e)) .map_err(|e| format!("failed to install OpenTelemetry tracer: {}", e))
.unwrap(); .unwrap();
let filter = veilid_core::VeilidLayerFilter::new(platform_config.logging.otlp.level, None); let filter = veilid_core::VeilidLayerFilter::new(
platform_config.logging.otlp.level,
&platform_config.logging.otlp.ignore_log_targets,
);
let layer = tracing_opentelemetry::layer() let layer = tracing_opentelemetry::layer()
.with_tracer(tracer) .with_tracer(tracer)
.with_filter(filter.clone()); .with_filter(filter.clone());
@ -273,7 +279,10 @@ pub extern "C" fn initialize_veilid_core(platform_config: FfiStr) {
// API logger // API logger
if platform_config.logging.api.enabled { if platform_config.logging.api.enabled {
let filter = veilid_core::VeilidLayerFilter::new(platform_config.logging.api.level, None); let filter = veilid_core::VeilidLayerFilter::new(
platform_config.logging.api.level,
&platform_config.logging.api.ignore_log_targets,
);
let layer = veilid_core::ApiTracingLayer::get().with_filter(filter.clone()); let layer = veilid_core::ApiTracingLayer::get().with_filter(filter.clone());
filters.insert("api", filter); filters.insert("api", filter);
layers.push(layer.boxed()); layers.push(layer.boxed());

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

@ -415,6 +415,7 @@ impl NamedSocketAddrs {
pub struct Terminal { pub struct Terminal {
pub enabled: bool, pub enabled: bool,
pub level: LogLevel, pub level: LogLevel,
pub ignore_log_targets: Vec<String>,
} }
#[derive(Debug, Deserialize, Serialize)] #[derive(Debug, Deserialize, Serialize)]
@ -428,18 +429,21 @@ pub struct File {
pub path: String, pub path: String,
pub append: bool, pub append: bool,
pub level: LogLevel, pub level: LogLevel,
pub ignore_log_targets: Vec<String>,
} }
#[derive(Debug, Deserialize, Serialize)] #[derive(Debug, Deserialize, Serialize)]
pub struct System { pub struct System {
pub enabled: bool, pub enabled: bool,
pub level: LogLevel, pub level: LogLevel,
pub ignore_log_targets: Vec<String>,
} }
#[derive(Debug, Deserialize, Serialize)] #[derive(Debug, Deserialize, Serialize)]
pub struct Api { pub struct Api {
pub enabled: bool, pub enabled: bool,
pub level: LogLevel, pub level: LogLevel,
pub ignore_log_targets: Vec<String>,
} }
#[derive(Debug, Deserialize, Serialize)] #[derive(Debug, Deserialize, Serialize)]
@ -447,6 +451,7 @@ pub struct Otlp {
pub enabled: bool, pub enabled: bool,
pub level: LogLevel, pub level: LogLevel,
pub grpc_endpoint: NamedSocketAddrs, pub grpc_endpoint: NamedSocketAddrs,
pub ignore_log_targets: Vec<String>,
} }
#[derive(Debug, Deserialize, Serialize)] #[derive(Debug, Deserialize, Serialize)]

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

@ -61,7 +61,7 @@ impl VeilidLogs {
if settingsr.logging.terminal.enabled { if settingsr.logging.terminal.enabled {
let filter = veilid_core::VeilidLayerFilter::new( let filter = veilid_core::VeilidLayerFilter::new(
convert_loglevel(settingsr.logging.terminal.level), convert_loglevel(settingsr.logging.terminal.level),
None, &settingsr.logging.terminal.ignore_log_targets,
); );
let layer = fmt::Layer::new() let layer = fmt::Layer::new()
.compact() .compact()
@ -72,7 +72,7 @@ impl VeilidLogs {
} }
// OpenTelemetry logger // OpenTelemetry logger
#[cfg(feature="opentelemetry-otlp")] #[cfg(feature = "opentelemetry-otlp")]
if settingsr.logging.otlp.enabled { if settingsr.logging.otlp.enabled {
let grpc_endpoint = settingsr.logging.otlp.grpc_endpoint.name.clone(); let grpc_endpoint = settingsr.logging.otlp.grpc_endpoint.name.clone();
@ -111,7 +111,7 @@ impl VeilidLogs {
let filter = veilid_core::VeilidLayerFilter::new( let filter = veilid_core::VeilidLayerFilter::new(
convert_loglevel(settingsr.logging.otlp.level), convert_loglevel(settingsr.logging.otlp.level),
None, &settingsr.logging.otlp.ignore_log_targets,
); );
let layer = tracing_opentelemetry::layer() let layer = tracing_opentelemetry::layer()
.with_tracer(tracer) .with_tracer(tracer)
@ -147,7 +147,7 @@ impl VeilidLogs {
let filter = veilid_core::VeilidLayerFilter::new( let filter = veilid_core::VeilidLayerFilter::new(
convert_loglevel(settingsr.logging.file.level), convert_loglevel(settingsr.logging.file.level),
None, &settingsr.logging.file.ignore_log_targets,
); );
let layer = fmt::Layer::new() let layer = fmt::Layer::new()
.compact() .compact()
@ -162,7 +162,7 @@ impl VeilidLogs {
if settingsr.logging.api.enabled { if settingsr.logging.api.enabled {
let filter = veilid_core::VeilidLayerFilter::new( let filter = veilid_core::VeilidLayerFilter::new(
convert_loglevel(settingsr.logging.api.level), convert_loglevel(settingsr.logging.api.level),
None, &settingsr.logging.api.ignore_log_targets,
); );
let layer = veilid_core::ApiTracingLayer::get().with_filter(filter.clone()); let layer = veilid_core::ApiTracingLayer::get().with_filter(filter.clone());
filters.insert("api", filter); filters.insert("api", filter);
@ -175,7 +175,7 @@ impl VeilidLogs {
if settingsr.logging.system.enabled { if settingsr.logging.system.enabled {
let filter = veilid_core::VeilidLayerFilter::new( let filter = veilid_core::VeilidLayerFilter::new(
convert_loglevel(settingsr.logging.system.level), convert_loglevel(settingsr.logging.system.level),
None, &settingsr.logging.system.ignore_log_targets,
); );
let layer = tracing_journald::layer().wrap_err("failed to set up journald logging")? let layer = tracing_journald::layer().wrap_err("failed to set up journald logging")?
.with_filter(filter.clone()); .with_filter(filter.clone());

2
veilid-tools/src/log_thru.rs
View File

@ -69,7 +69,7 @@ macro_rules! log_rpc {
(warn $fmt:literal, $($arg:expr),+) => { (warn $fmt:literal, $($arg:expr),+) => {
warn!(target:"rpc", $fmt, $($arg),+); warn!(target:"rpc", $fmt, $($arg),+);
}; };
(debug $text:expr) => { error!( (debug $text:expr) => { debug!(
target: "rpc", target: "rpc",
"{}", "{}",
$text, $text,

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

@ -145,6 +145,7 @@ pub struct VeilidWASMConfigLoggingPerformance {
pub level: veilid_core::VeilidConfigLogLevel, pub level: veilid_core::VeilidConfigLogLevel,
pub logs_in_timings: bool, pub logs_in_timings: bool,
pub logs_in_console: bool, pub logs_in_console: bool,
pub ignore_log_targets: Vec<String>,
} }
#[derive(Debug, Deserialize, Serialize)] #[derive(Debug, Deserialize, Serialize)]
@ -152,6 +153,7 @@ pub struct VeilidWASMConfigLoggingPerformance {
pub struct VeilidWASMConfigLoggingAPI { pub struct VeilidWASMConfigLoggingAPI {
pub enabled: bool, pub enabled: bool,
pub level: veilid_core::VeilidConfigLogLevel, pub level: veilid_core::VeilidConfigLogLevel,
pub ignore_log_targets: Vec<String>,
} }
#[derive(Debug, Deserialize, Serialize)] #[derive(Debug, Deserialize, Serialize)]
@ -204,8 +206,10 @@ pub fn initialize_veilid_core(platform_config: String) {
// Performance logger // Performance logger
if platform_config.logging.performance.enabled { if platform_config.logging.performance.enabled {
let filter = let filter = veilid_core::VeilidLayerFilter::new(
veilid_core::VeilidLayerFilter::new(platform_config.logging.performance.level, None); platform_config.logging.performance.level,
&platform_config.logging.performance.ignore_log_targets,
);
let layer = WASMLayer::new( let layer = WASMLayer::new(
WASMLayerConfigBuilder::new() WASMLayerConfigBuilder::new()
.set_report_logs_in_timings(platform_config.logging.performance.logs_in_timings) .set_report_logs_in_timings(platform_config.logging.performance.logs_in_timings)
@ -223,7 +227,10 @@ pub fn initialize_veilid_core(platform_config: String) {
// API logger // API logger
if platform_config.logging.api.enabled { if platform_config.logging.api.enabled {
let filter = veilid_core::VeilidLayerFilter::new(platform_config.logging.api.level, None); let filter = veilid_core::VeilidLayerFilter::new(
platform_config.logging.api.level,
&platform_config.logging.api.ignore_log_targets,
);
let layer = veilid_core::ApiTracingLayer::get().with_filter(filter.clone()); let layer = veilid_core::ApiTracingLayer::get().with_filter(filter.clone());
filters.insert("api", filter); filters.insert("api", filter);
layers.push(layer.boxed()); layers.push(layer.boxed());