From 5931f1254f8f1c165e32bfc4544790edfb9d1108 Mon Sep 17 00:00:00 2001 From: John Smith Date: Fri, 10 Jun 2022 17:07:10 -0400 Subject: [PATCH] flutter and macos work --- setup_macos.sh | 20 +++++++--- veilid-core/ios_build.sh | 4 +- veilid-core/src/api_tracing_layer.rs | 3 ++ veilid-core/src/attachment_manager.rs | 13 +++++-- veilid-core/src/core_context.rs | 10 ++++- .../src/intf/native/protected_store.rs | 9 +++++ veilid-core/src/network_manager/mod.rs | 36 ++++++++++++++++-- veilid-core/src/network_manager/native/mod.rs | 9 ++++- .../native/network_class_discovery.rs | 37 ++++++++++++------- veilid-core/src/network_manager/wasm/mod.rs | 3 ++ veilid-core/src/receipt_manager.rs | 1 + veilid-core/src/routing_table/mod.rs | 17 +++++---- veilid-core/src/veilid_api/mod.rs | 20 ++++++++++ .../src/veilid_api/serialize_helpers.rs | 34 ++++++++++++----- veilid-core/src/veilid_config.rs | 9 +++++ veilid-flutter/example/lib/config.dart | 2 +- veilid-flutter/example/lib/main.dart | 22 ++++++++++- .../linux/flutter/generated_plugins.cmake | 8 ++++ veilid-flutter/example/macos/Podfile.lock | 4 +- veilid-flutter/example/pubspec.lock | 25 +++++-------- .../windows/flutter/generated_plugins.cmake | 8 ++++ veilid-flutter/ios/veilid.podspec | 4 +- veilid-flutter/lib/veilid.dart | 28 ++++++++++++++ veilid-flutter/lib/veilid_ffi.dart | 4 +- veilid-flutter/macos/veilid.podspec | 4 +- veilid-flutter/rust/ios_build.sh | 7 +++- veilid-flutter/rust/macos_build.sh | 4 +- veilid-flutter/rust/src/dart_ffi.rs | 5 +++ .../rust/src/dart_isolate_wrapper.rs | 28 ++++++++------ veilid-server/src/client_api.rs | 13 +++++++ veilid-server/src/main.rs | 2 + veilid-server/src/server.rs | 12 +++--- veilid-server/src/unix.rs | 3 ++ 33 files changed, 312 insertions(+), 96 deletions(-) diff --git a/setup_macos.sh b/setup_macos.sh index 89fd4fe4..83d9638b 100755 --- a/setup_macos.sh +++ b/setup_macos.sh @@ -13,10 +13,10 @@ rustup target add aarch64-apple-darwin aarch64-apple-ios x86_64-apple-darwin x86 cargo install wasm-bindgen-cli # install bitcode compatible ios toolchain -echo Manual Step: -echo install +ios-arm64-1.57.0 toolchain for bitcode from https://github.com/getditto/rust-bitcode/releases/latest and unzip -echo xattr -d -r com.apple.quarantine . -echo ./install.sh +# echo Manual Step: +# echo install +ios-arm64-1.57.0 toolchain for bitcode from https://github.com/getditto/rust-bitcode/releases/latest and unzip +# echo xattr -d -r com.apple.quarantine . +# echo ./install.sh # ensure brew is installed if command -v brew &> /dev/null; then @@ -39,8 +39,16 @@ xcode-select --install # ensure packages are installed if [ "$BREW_USER" == "" ]; then - BREW_USER=`ls -lad /opt/homebrew/. | cut -d\ -f4` - echo "Must sudo to homebrew user \"$BREW_USER\" to install capnp package:" + if [ -d /opt/homebrew ]; then + BREW_USER=`ls -lad /opt/homebrew/. | cut -d\ -f4` + echo "Must sudo to homebrew user \"$BREW_USER\" to install capnp package:" + elif [ -d /usr/local/Homebrew ]; then + BREW_USER=`ls -lad /usr/local/Homebrew/. | cut -d\ -f4` + echo "Must sudo to homebrew user \"$BREW_USER\" to install capnp package:" + else + echo "Homebrew is not installed in the normal place. Trying as current user" + BREW_USER=`whoami` + fi fi sudo -H -u $BREW_USER brew install capnp diff --git a/veilid-core/ios_build.sh b/veilid-core/ios_build.sh index 1986bfe5..4eb08eca 100755 --- a/veilid-core/ios_build.sh +++ b/veilid-core/ios_build.sh @@ -15,8 +15,8 @@ do if [ "$arch" == "arm64" ]; then echo arm64 CARGO_TARGET=aarch64-apple-ios - CARGO_TOOLCHAIN=+ios-arm64-1.57.0 - #CARGO_TOOLCHAIN= + #CARGO_TOOLCHAIN=+ios-arm64-1.57.0 + CARGO_TOOLCHAIN= elif [ "$arch" == "x86_64" ]; then echo x86_64 CARGO_TARGET=x86_64-apple-ios diff --git a/veilid-core/src/api_tracing_layer.rs b/veilid-core/src/api_tracing_layer.rs index 7579f477..a75cffc0 100644 --- a/veilid-core/src/api_tracing_layer.rs +++ b/veilid-core/src/api_tracing_layer.rs @@ -52,6 +52,7 @@ impl ApiTracingLayer { } } + #[instrument(level = "debug", skip(update_callback))] pub async fn init(max_level: Option, update_callback: UpdateCallback) { let api_logger = API_LOGGER.get_or_init(|| ApiTracingLayer { inner: Arc::new(Mutex::new(None)), @@ -60,6 +61,7 @@ impl ApiTracingLayer { *api_logger.inner.lock() = apilogger_inner; } + #[instrument(level = "debug")] pub async fn terminate() { if let Some(api_logger) = API_LOGGER.get() { let mut inner = api_logger.inner.lock(); @@ -75,6 +77,7 @@ impl ApiTracingLayer { .clone() } + #[instrument(level = "trace")] pub fn change_api_log_level(max_level: Option) { if let Some(api_logger) = API_LOGGER.get() { if let Some(inner) = &mut *api_logger.inner.lock() { diff --git a/veilid-core/src/attachment_manager.rs b/veilid-core/src/attachment_manager.rs index 2e55ecd0..15af8144 100644 --- a/veilid-core/src/attachment_manager.rs +++ b/veilid-core/src/attachment_manager.rs @@ -221,6 +221,7 @@ impl AttachmentManager { } } + #[instrument(level = "debug", skip(self))] async fn attachment_maintainer(self) { trace!("attachment starting"); let netman = { @@ -229,7 +230,6 @@ impl AttachmentManager { inner.network_manager.clone() }; - trace!("starting network"); let mut started = true; if let Err(err) = netman.startup().await { error!("network startup failed: {}", err); @@ -266,6 +266,7 @@ impl AttachmentManager { self.inner.lock().attach_timestamp = None; } + #[instrument(level = "debug", skip_all, err)] pub async fn init(&self, update_callback: UpdateCallback) -> Result<(), String> { trace!("init"); let network_manager = { @@ -286,6 +287,8 @@ impl AttachmentManager { Ok(()) } + + #[instrument(level = "debug", skip(self))] pub async fn terminate(&self) { // Ensure we detached self.detach().await; @@ -298,8 +301,8 @@ impl AttachmentManager { inner.update_callback = None; } + #[instrument(level = "trace", skip(self))] fn attach(&self) { - trace!("attach"); // Create long-running connection maintenance routine let this = self.clone(); self.inner.lock().maintain_peers = true; @@ -307,8 +310,8 @@ impl AttachmentManager { Some(intf::spawn(this.attachment_maintainer())); } + #[instrument(level = "trace", skip(self))] async fn detach(&self) { - trace!("detach"); let attachment_maintainer_jh = self.inner.lock().attachment_maintainer_jh.take(); if let Some(jh) = attachment_maintainer_jh { // Terminate long-running connection maintenance routine @@ -343,16 +346,18 @@ impl AttachmentManager { } } + #[instrument(level = "trace", skip(self), err)] pub async fn request_attach(&self) -> Result<(), String> { self.process_input(&AttachmentInput::AttachRequested) .await .map_err(|e| format!("Attach request failed: {}", e)) } + #[instrument(level = "trace", skip(self), err)] pub async fn request_detach(&self) -> Result<(), String> { self.process_input(&AttachmentInput::DetachRequested) .await - .map_err(|e| format!("Attach request failed: {}", e)) + .map_err(|e| format!("Detach request failed: {}", e)) } pub fn get_state(&self) -> AttachmentState { diff --git a/veilid-core/src/core_context.rs b/veilid-core/src/core_context.rs index 43753a59..ee54d88e 100644 --- a/veilid-core/src/core_context.rs +++ b/veilid-core/src/core_context.rs @@ -10,7 +10,6 @@ cfg_if! { if #[cfg(target_arch = "wasm32")] { pub type UpdateCallback = Arc; } else { - pub type UpdateCallback = Arc; } } @@ -59,6 +58,7 @@ impl ServicesContext { } } + #[instrument(err, skip_all)] pub async fn startup(&mut self) -> Result<(), VeilidAPIError> { let api_log_level: VeilidConfigLogLevel = self.config.get().api_log_level; if api_log_level != VeilidConfigLogLevel::Off { @@ -131,6 +131,7 @@ impl ServicesContext { Ok(()) } + #[instrument(skip_all)] pub async fn shutdown(&mut self) { info!("Veilid API shutting down"); @@ -179,6 +180,7 @@ pub struct VeilidCoreContext { } impl VeilidCoreContext { + #[instrument(err, skip_all)] async fn new_with_config_callback( update_callback: UpdateCallback, config_callback: ConfigCallback, @@ -193,6 +195,7 @@ impl VeilidCoreContext { Self::new_common(update_callback, config).await } + #[instrument(err, skip(update_callback))] async fn new_with_config_json( update_callback: UpdateCallback, config_json: String, @@ -206,6 +209,7 @@ impl VeilidCoreContext { Self::new_common(update_callback, config).await } + #[instrument(err, skip(update_callback))] async fn new_common( update_callback: UpdateCallback, config: VeilidConfig, @@ -233,6 +237,7 @@ impl VeilidCoreContext { }) } + #[instrument(skip_all)] async fn shutdown(self) { let mut sc = ServicesContext::new_full( self.config.clone(), @@ -251,6 +256,7 @@ impl VeilidCoreContext { static INITIALIZED: AsyncMutex = AsyncMutex::new(false); +#[instrument(err, skip_all)] pub async fn api_startup( update_callback: UpdateCallback, config_callback: ConfigCallback, @@ -273,6 +279,7 @@ pub async fn api_startup( Ok(veilid_api) } +#[instrument(err, skip(update_callback))] pub async fn api_startup_json( update_callback: UpdateCallback, config_json: String, @@ -294,6 +301,7 @@ pub async fn api_startup_json( Ok(veilid_api) } +#[instrument(skip_all)] pub(crate) async fn api_shutdown(context: VeilidCoreContext) { let mut initialized_lock = INITIALIZED.lock().await; context.shutdown().await; diff --git a/veilid-core/src/intf/native/protected_store.rs b/veilid-core/src/intf/native/protected_store.rs index 67165b87..63593702 100644 --- a/veilid-core/src/intf/native/protected_store.rs +++ b/veilid-core/src/intf/native/protected_store.rs @@ -29,6 +29,7 @@ impl ProtectedStore { } } + #[instrument(level = "trace", skip(self), err)] pub async fn delete_all(&self) -> Result<(), String> { // Delete all known keys if self.remove_user_secret_string("node_id").await? { @@ -43,6 +44,7 @@ impl ProtectedStore { Ok(()) } + #[instrument(level = "debug", skip(self), err)] pub async fn init(&self) -> Result<(), String> { let delete = { let c = self.config.get(); @@ -95,6 +97,7 @@ impl ProtectedStore { Ok(()) } + #[instrument(level = "debug", skip(self))] pub async fn terminate(&self) { *self.inner.lock() = Self::new_inner(); } @@ -108,6 +111,7 @@ impl ProtectedStore { } } + #[instrument(level = "trace", skip(self, value), ret, err)] pub async fn save_user_secret_string(&self, key: &str, value: &str) -> Result { let inner = self.inner.lock(); inner @@ -124,6 +128,7 @@ impl ProtectedStore { .map_err(logthru_pstore!()) } + #[instrument(level = "trace", skip(self), err)] pub async fn load_user_secret_string(&self, key: &str) -> Result, String> { let inner = self.inner.lock(); match inner @@ -139,6 +144,7 @@ impl ProtectedStore { } } + #[instrument(level = "trace", skip(self), ret, err)] pub async fn remove_user_secret_string(&self, key: &str) -> Result { let inner = self.inner.lock(); match inner @@ -154,6 +160,7 @@ impl ProtectedStore { } } + #[instrument(level = "trace", skip(self, value), ret, err)] pub async fn save_user_secret(&self, key: &str, value: &[u8]) -> Result { let mut s = BASE64URL_NOPAD.encode(value); s.push('!'); @@ -161,6 +168,7 @@ impl ProtectedStore { self.save_user_secret_string(key, s.as_str()).await } + #[instrument(level = "trace", skip(self), err)] pub async fn load_user_secret(&self, key: &str) -> Result>, String> { let mut s = match self.load_user_secret_string(key).await? { Some(s) => s, @@ -191,6 +199,7 @@ impl ProtectedStore { } } + #[instrument(level = "trace", skip(self), ret, err)] pub async fn remove_user_secret(&self, key: &str) -> Result { self.remove_user_secret_string(key).await } diff --git a/veilid-core/src/network_manager/mod.rs b/veilid-core/src/network_manager/mod.rs index e219b4ae..df797204 100644 --- a/veilid-core/src/network_manager/mod.rs +++ b/veilid-core/src/network_manager/mod.rs @@ -233,6 +233,7 @@ impl NetworkManager { self.inner.lock().relay_node.clone() } + #[instrument(level = "debug", skip_all, err)] pub async fn init(&self, update_callback: UpdateCallback) -> Result<(), String> { let routing_table = RoutingTable::new(self.clone()); routing_table.init().await?; @@ -240,6 +241,8 @@ impl NetworkManager { self.inner.lock().update_callback = Some(update_callback); Ok(()) } + + #[instrument(level = "debug", skip_all)] pub async fn terminate(&self) { let routing_table = { let mut inner = self.inner.lock(); @@ -251,6 +254,7 @@ impl NetworkManager { self.inner.lock().update_callback = None; } + #[instrument(level = "debug", skip_all, err)] pub async fn internal_startup(&self) -> Result<(), String> { trace!("NetworkManager::internal_startup begin"); if self.inner.lock().components.is_some() { @@ -281,6 +285,7 @@ impl NetworkManager { Ok(()) } + #[instrument(level = "debug", skip_all, err)] pub async fn startup(&self) -> Result<(), String> { if let Err(e) = self.internal_startup().await { self.shutdown().await; @@ -292,6 +297,7 @@ impl NetworkManager { Ok(()) } + #[instrument(level = "debug", skip_all)] pub async fn shutdown(&self) { trace!("NetworkManager::shutdown begin"); @@ -339,6 +345,7 @@ impl NetworkManager { } } + #[instrument(level = "trace", skip(self), ret)] pub fn check_client_whitelist(&self, client: DHTKey) -> bool { let mut inner = self.inner.lock(); @@ -351,6 +358,7 @@ impl NetworkManager { } } + #[instrument(level = "trace", skip(self))] pub fn purge_client_whitelist(&self) { let timeout_ms = self.config.get().network.client_whitelist_timeout_ms; let mut inner = self.inner.lock(); @@ -366,6 +374,15 @@ impl NetworkManager { } } + #[instrument(level = "debug", skip_all, err)] + async fn restart_net(&self, net: Network) -> Result<(), String> { + net.shutdown().await; + self.send_network_update(); + net.startup().await?; + self.send_network_update(); + Ok(()) + } + pub async fn tick(&self) -> Result<(), String> { let (routing_table, net, receipt_manager) = { let inner = self.inner.lock(); @@ -380,10 +397,7 @@ impl NetworkManager { // If the network needs to be reset, do it // if things can't restart, then we fail out of the attachment manager if net.needs_restart() { - net.shutdown().await; - self.send_network_update(); - net.startup().await?; - self.send_network_update(); + self.restart_net(net.clone()).await?; } // Run the rolling transfers task @@ -448,6 +462,7 @@ impl NetworkManager { } // Generates a multi-shot/normal receipt + #[instrument(level = "trace", skip(self, extra_data, callback), err)] pub fn generate_receipt>( &self, expiration_us: u64, @@ -473,6 +488,7 @@ impl NetworkManager { } // Generates a single-shot/normal receipt + #[instrument(level = "trace", skip(self, extra_data), err)] pub fn generate_single_shot_receipt>( &self, expiration_us: u64, @@ -498,6 +514,7 @@ impl NetworkManager { } // Process a received out-of-band receipt + #[instrument(level = "trace", skip(self, receipt_data), err)] pub async fn handle_out_of_band_receipt>( &self, receipt_data: R, @@ -511,6 +528,7 @@ impl NetworkManager { } // Process a received in-band receipt + #[instrument(level = "trace", skip(self, receipt_data), err)] pub async fn handle_in_band_receipt>( &self, receipt_data: R, @@ -527,6 +545,7 @@ impl NetworkManager { } // Process a received signal + #[instrument(level = "trace", skip(self), err)] pub async fn handle_signal(&self, signal_info: SignalInfo) -> Result<(), String> { match signal_info { SignalInfo::ReverseConnect { receipt, peer_info } => { @@ -588,6 +607,7 @@ impl NetworkManager { } // Builds an envelope for sending over the network + #[instrument(level = "trace", skip(self, body), err)] fn build_envelope>( &self, dest_node_id: DHTKey, @@ -614,6 +634,7 @@ impl NetworkManager { // node_ref is the direct destination to which the envelope will be sent // If 'node_id' is specified, it can be different than node_ref.node_id() // which will cause the envelope to be relayed + #[instrument(level = "trace", skip(self, body), ret, err)] pub async fn send_envelope>( &self, node_ref: NodeRef, @@ -665,6 +686,7 @@ impl NetworkManager { } // Called by the RPC handler when we want to issue an direct receipt + #[instrument(level = "trace", skip(self, rcpt_data), err)] pub async fn send_out_of_band_receipt( &self, dial_info: DialInfo, @@ -683,6 +705,7 @@ impl NetworkManager { } // Figure out how to reach a node + #[instrument(level = "trace", skip(self), ret, err)] fn get_contact_method(&self, mut target_node_ref: NodeRef) -> Result { let routing_table = self.routing_table(); @@ -802,6 +825,7 @@ impl NetworkManager { // Send a reverse connection signal and wait for the return receipt over it // Then send the data across the new connection + #[instrument(level = "trace", skip(self, data), err)] pub async fn do_reverse_connect( &self, relay_nr: NodeRef, @@ -872,6 +896,7 @@ impl NetworkManager { // Send a hole punch signal and do a negotiating ping and wait for the return receipt // Then send the data across the new connection + #[instrument(level = "trace", skip(self, data), err)] pub async fn do_hole_punch( &self, relay_nr: NodeRef, @@ -1036,6 +1061,7 @@ impl NetworkManager { // Called when a packet potentially containing an RPC envelope is received by a low-level // network protocol handler. Processes the envelope, authenticates and decrypts the RPC message // and passes it to the RPC handler + #[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))] async fn on_recv_envelope( &self, data: &[u8], @@ -1175,6 +1201,7 @@ impl NetworkManager { } // Keep relays assigned and accessible + #[instrument(level = "trace", skip(self), err)] async fn relay_management_task_routine(self, _last_ts: u64, cur_ts: u64) -> Result<(), String> { // log_net!("--- network manager relay_management task"); @@ -1227,6 +1254,7 @@ impl NetworkManager { } // Compute transfer statistics for the low level network + #[instrument(level = "trace", skip(self), err)] async fn rolling_transfers_task_routine(self, last_ts: u64, cur_ts: u64) -> Result<(), String> { // log_net!("--- network manager rolling_transfers task"); { diff --git a/veilid-core/src/network_manager/native/mod.rs b/veilid-core/src/network_manager/native/mod.rs index 8c1e5894..9d87c063 100644 --- a/veilid-core/src/network_manager/native/mod.rs +++ b/veilid-core/src/network_manager/native/mod.rs @@ -267,6 +267,7 @@ impl Network { // This creates a short-lived connection in the case of connection-oriented protocols // for the purpose of sending this one message. // This bypasses the connection table as it is not a 'node to node' connection. + #[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))] pub async fn send_data_unbound_to_dial_info( &self, dial_info: DialInfo, @@ -300,6 +301,7 @@ impl Network { res } + #[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))] pub async fn send_data_to_existing_connection( &self, descriptor: ConnectionDescriptor, @@ -357,6 +359,7 @@ impl Network { } // Send data directly to a dial info, possibly without knowing which node it is going to + #[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))] pub async fn send_data_to_dial_info( &self, dial_info: DialInfo, @@ -404,9 +407,8 @@ impl Network { self.inner.lock().protocol_config } + #[instrument(level = "debug", err, skip_all)] pub async fn startup(&self) -> Result<(), String> { - trace!("startup network"); - // initialize interfaces let mut interfaces = NetworkInterfaces::new(); interfaces.refresh().await?; @@ -492,10 +494,12 @@ impl Network { self.inner.lock().network_started } + #[instrument(level = "debug", skip_all)] pub fn restart_network(&self) { self.inner.lock().network_needs_restart = true; } + #[instrument(level = "debug", skip_all)] pub async fn shutdown(&self) { info!("stopping network"); @@ -524,6 +528,7 @@ impl Network { inner.network_class } + #[instrument(level = "debug", skip_all)] pub fn reset_network_class(&self) { let mut inner = self.inner.lock(); inner.network_class = None; diff --git a/veilid-core/src/network_manager/native/network_class_discovery.rs b/veilid-core/src/network_manager/native/network_class_discovery.rs index 620f9583..6c1f48a4 100644 --- a/veilid-core/src/network_manager/native/network_class_discovery.rs +++ b/veilid-core/src/network_manager/native/network_class_discovery.rs @@ -51,30 +51,30 @@ impl DiscoveryContext { // Pick the best network class we have seen so far pub fn set_detected_network_class(&self, network_class: NetworkClass) { let mut inner = self.inner.lock(); - log_net!( debug - "=== set_detected_network_class {:?} {:?}: {:?} ===", - inner.protocol_type, - inner.address_type, - network_class + debug!(target: "net", + protocol_type=?inner.protocol_type, + address_type=?inner.address_type, + ?network_class, + "set_detected_network_class" ); - inner.detected_network_class = Some(network_class); } pub fn set_detected_public_dial_info(&self, dial_info: DialInfo, class: DialInfoClass) { let mut inner = self.inner.lock(); - log_net!( debug - "=== set_detected_public_dial_info {:?} {:?}: {} {:?} ===", - inner.protocol_type, - inner.address_type, - dial_info, - class + debug!(target: "net", + protocol_type=?inner.protocol_type, + address_type=?inner.address_type, + ?dial_info, + ?class, + "set_detected_public_dial_info" ); inner.detected_public_dial_info = Some(DetectedPublicDialInfo { dial_info, class }); } // Ask for a public address check from a particular noderef // This is done over the normal port using RPC + #[instrument(level = "trace", skip(self), ret)] async fn request_public_address(&self, node_ref: NodeRef) -> Option { let rpc = self.routing_table.rpc_processor(); rpc.rpc_call_status(node_ref.clone()) @@ -93,6 +93,7 @@ impl DiscoveryContext { // find fast peers with a particular address type, and ask them to tell us what our external address is // This is done over the normal port using RPC + #[instrument(level = "trace", skip(self), ret)] async fn discover_external_address( &self, protocol_type: ProtocolType, @@ -122,6 +123,7 @@ impl DiscoveryContext { } // This pulls the already-detected local interface dial info from the routing table + #[instrument(level = "trace", skip(self), ret)] fn get_local_addresses( &self, protocol_type: ProtocolType, @@ -143,6 +145,7 @@ impl DiscoveryContext { .collect() } + #[instrument(level = "trace", skip(self), ret)] async fn validate_dial_info( &self, node_ref: NodeRef, @@ -165,6 +168,7 @@ impl DiscoveryContext { .unwrap_or(false) } + #[instrument(level = "trace", skip(self), ret)] async fn try_port_mapping(&self) -> Option { //xxx None @@ -189,6 +193,7 @@ impl DiscoveryContext { /////// // Per-protocol discovery routines + #[instrument(level = "trace", skip(self))] pub fn protocol_begin(&self, protocol_type: ProtocolType, address_type: AddressType) { // Get our interface addresses let intf_addrs = self.get_local_addresses(protocol_type, address_type); @@ -203,6 +208,7 @@ impl DiscoveryContext { } // Get our first node's view of our external IP address via normal RPC + #[instrument(level = "trace", skip(self), ret)] pub async fn protocol_get_external_address_1(&self) -> bool { let (protocol_type, address_type) = { let inner = self.inner.lock(); @@ -234,6 +240,7 @@ impl DiscoveryContext { } // If we know we are not behind NAT, check our firewall status + #[instrument(level = "trace", skip(self), err)] pub async fn protocol_process_no_nat(&self) -> Result<(), String> { let (node_1, external_1_dial_info) = { let inner = self.inner.lock(); @@ -264,6 +271,7 @@ impl DiscoveryContext { } // If we know we are behind NAT check what kind + #[instrument(level = "trace", skip(self), ret, err)] pub async fn protocol_process_nat(&self) -> Result { let (node_1, external_1_dial_info, external_1_address, protocol_type, address_type) = { let inner = self.inner.lock(); @@ -353,6 +361,7 @@ impl DiscoveryContext { } impl Network { + #[instrument(level = "trace", skip(self, context), err)] pub async fn update_ipv4_protocol_dialinfo( &self, context: &DiscoveryContext, @@ -414,6 +423,7 @@ impl Network { Ok(()) } + #[instrument(level = "trace", skip(self, context), err)] pub async fn update_ipv6_protocol_dialinfo( &self, context: &DiscoveryContext, @@ -454,9 +464,8 @@ impl Network { Ok(()) } + #[instrument(level = "trace", skip(self), err)] pub async fn update_network_class_task_routine(self, _l: u64, _t: u64) -> Result<(), String> { - log_net!("--- updating network class"); - // Ensure we aren't trying to update this without clearing it first let old_network_class = self.inner.lock().network_class; assert_eq!(old_network_class, None); diff --git a/veilid-core/src/network_manager/wasm/mod.rs b/veilid-core/src/network_manager/wasm/mod.rs index 61f94d1f..fe6e75b2 100644 --- a/veilid-core/src/network_manager/wasm/mod.rs +++ b/veilid-core/src/network_manager/wasm/mod.rs @@ -51,6 +51,7 @@ impl Network { ///////////////////////////////////////////////////////////////// + #[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))] pub async fn send_data_unbound_to_dial_info( &self, dial_info: DialInfo, @@ -79,6 +80,7 @@ impl Network { res } + #[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))] pub async fn send_data_to_existing_connection( &self, descriptor: ConnectionDescriptor, @@ -115,6 +117,7 @@ impl Network { } } + #[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))] pub async fn send_data_to_dial_info( &self, dial_info: DialInfo, diff --git a/veilid-core/src/receipt_manager.rs b/veilid-core/src/receipt_manager.rs index 5ebdf124..bb9a1b80 100644 --- a/veilid-core/src/receipt_manager.rs +++ b/veilid-core/src/receipt_manager.rs @@ -234,6 +234,7 @@ impl ReceiptManager { } } + #[instrument(level = "trace", skip(self))] pub async fn timeout_task_routine(self, now: u64) { // Go through all receipts and build a list of expired nonces let mut new_next_oldest_ts: Option = None; diff --git a/veilid-core/src/routing_table/mod.rs b/veilid-core/src/routing_table/mod.rs index 89096a1f..d21c25c6 100644 --- a/veilid-core/src/routing_table/mod.rs +++ b/veilid-core/src/routing_table/mod.rs @@ -730,6 +730,7 @@ impl RoutingTable { best_inbound_relay.map(|(k, e)| NodeRef::new(self.clone(), *k, e, None)) } + #[instrument(level = "trace", skip(self), ret, err)] pub fn register_find_node_answer(&self, fna: FindNodeAnswer) -> Result, String> { let node_id = self.node_id(); @@ -755,6 +756,7 @@ impl RoutingTable { Ok(out) } + #[instrument(level = "trace", skip(self), ret, err)] pub async fn find_node( &self, node_ref: NodeRef, @@ -773,26 +775,24 @@ impl RoutingTable { .await .map_err(map_to_string) .map_err(logthru_rtab!())?; - log_rtab!( - "find_self for at {:?} answered in {}ms", - &node_ref, - timestamp_to_secs(res.latency) * 1000.0f64 - ); // register nodes we'd found self.register_find_node_answer(res) } + #[instrument(level = "trace", skip(self), ret, err)] pub async fn find_self(&self, node_ref: NodeRef) -> Result, String> { let node_id = self.node_id(); self.find_node(node_ref, node_id).await } + #[instrument(level = "trace", skip(self), ret, err)] pub async fn find_target(&self, node_ref: NodeRef) -> Result, String> { let node_id = node_ref.node_id(); self.find_node(node_ref, node_id).await } + #[instrument(level = "trace", skip(self))] pub async fn reverse_find_node(&self, node_ref: NodeRef, wide: bool) { // Ask bootstrap node to 'find' our own node so we can get some more nodes near ourselves // and then contact those nodes to inform -them- that we exist @@ -827,6 +827,7 @@ impl RoutingTable { } // Bootstrap lookup process + #[instrument(level = "trace", skip(self), ret, err)] async fn resolve_bootstrap( &self, bootstrap: Vec, @@ -990,6 +991,7 @@ impl RoutingTable { Ok(bsmap) } + #[instrument(level = "trace", skip(self), err)] async fn bootstrap_task_routine(self) -> Result<(), String> { let (bootstrap, bootstrap_nodes) = { let c = self.config.get(); @@ -1092,9 +1094,8 @@ impl RoutingTable { // Ask our remaining peers to give us more peers before we go // back to the bootstrap servers to keep us from bothering them too much + #[instrument(level = "trace", skip(self), err)] async fn peer_minimum_refresh_task_routine(self) -> Result<(), String> { - // log_rtab!("--- peer_minimum_refresh task"); - // get list of all peers we know about, even the unreliable ones, and ask them to find nodes close to our node too let noderefs = { let mut inner = self.inner.lock(); @@ -1125,6 +1126,7 @@ impl RoutingTable { // Ping each node in the routing table if they need to be pinged // to determine their reliability + #[instrument(level = "trace", skip(self), err)] async fn ping_validator_task_routine(self, _last_ts: u64, cur_ts: u64) -> Result<(), String> { // log_rtab!("--- ping_validator task"); @@ -1149,6 +1151,7 @@ impl RoutingTable { } // Compute transfer statistics to determine how 'fast' a node is + #[instrument(level = "trace", skip(self), err)] async fn rolling_transfers_task_routine(self, last_ts: u64, cur_ts: u64) -> Result<(), String> { // log_rtab!("--- rolling_transfers task"); let inner = &mut *self.inner.lock(); diff --git a/veilid-core/src/veilid_api/mod.rs b/veilid-core/src/veilid_api/mod.rs index 5250ba74..c3e98587 100644 --- a/veilid-core/src/veilid_api/mod.rs +++ b/veilid-core/src/veilid_api/mod.rs @@ -1742,6 +1742,7 @@ pub struct VeilidAPI { } impl VeilidAPI { + #[instrument(skip_all)] pub(crate) fn new(context: VeilidCoreContext) -> Self { Self { inner: Arc::new(Mutex::new(VeilidAPIInner { @@ -1750,6 +1751,7 @@ impl VeilidAPI { } } + #[instrument(skip_all)] pub async fn shutdown(self) { let context = { self.inner.lock().context.take() }; if let Some(context) = context { @@ -1840,6 +1842,7 @@ impl VeilidAPI { // get network connectedness // connect to the network + #[instrument(level = "debug", err, skip_all)] pub async fn attach(&self) -> Result<(), VeilidAPIError> { let attachment_manager = self.attachment_manager()?; attachment_manager @@ -1849,6 +1852,7 @@ impl VeilidAPI { } // disconnect from the network + #[instrument(level = "debug", err, skip_all)] pub async fn detach(&self) -> Result<(), VeilidAPIError> { let attachment_manager = self.attachment_manager()?; attachment_manager @@ -1858,6 +1862,7 @@ impl VeilidAPI { } // Change api logging level if it is enabled + #[instrument(skip(self))] pub async fn change_api_log_level(&self, log_level: VeilidConfigLogLevel) { ApiTracingLayer::change_api_log_level(log_level.to_veilid_log_level()); } @@ -1865,6 +1870,7 @@ impl VeilidAPI { //////////////////////////////////////////////////////////////// // Direct Node Access (pretty much for testing only) + #[instrument(level = "debug", err, skip(self))] pub async fn status(&self, node_id: NodeId) -> Result { let rpc = self.rpc_processor()?; let routing_table = rpc.routing_table(); @@ -1879,6 +1885,7 @@ impl VeilidAPI { Ok(status_answer) } + #[instrument(level = "debug", err, skip(self))] pub async fn validate_dial_info( &self, node_id: NodeId, @@ -1896,6 +1903,7 @@ impl VeilidAPI { .map_err(map_rpc_error!()) } + #[instrument(level = "debug", err, skip(self))] pub async fn search_dht(&self, node_id: NodeId) -> Result { let rpc_processor = self.rpc_processor()?; let config = self.config()?; @@ -1923,6 +1931,7 @@ impl VeilidAPI { } } + #[instrument(level = "debug", err, skip(self))] pub async fn search_dht_multi(&self, node_id: NodeId) -> Result, VeilidAPIError> { let rpc_processor = self.rpc_processor()?; let config = self.config()?; @@ -1948,6 +1957,7 @@ impl VeilidAPI { //////////////////////////////////////////////////////////////// // Safety / Private Route Handling + #[instrument(level = "debug", err, skip(self))] pub async fn new_safety_route_spec( &self, _hops: u8, @@ -1955,6 +1965,7 @@ impl VeilidAPI { panic!("unimplemented"); } + #[instrument(level = "debug", err, skip(self))] pub async fn new_private_route_spec( &self, _hops: u8, @@ -1968,6 +1979,7 @@ impl VeilidAPI { // Safety route specified here is for _this_ node's anonymity as a sender, used via the 'route' operation // Private route specified here is for _this_ node's anonymity as a receiver, passed out via the 'respond_to' field for replies + #[instrument(skip(self))] pub async fn safe_private( &self, safety_route_spec: SafetyRouteSpec, @@ -1980,6 +1992,7 @@ impl VeilidAPI { .await } + #[instrument(level = "debug", skip(self))] pub async fn safe_public(&self, safety_route_spec: SafetyRouteSpec) -> RoutingContext { self.routing_context(RoutingContextOptions { safety_route_spec: Some(safety_route_spec), @@ -1988,6 +2001,7 @@ impl VeilidAPI { .await } + #[instrument(level = "debug", skip(self))] pub async fn unsafe_private(&self, private_route_spec: PrivateRouteSpec) -> RoutingContext { self.routing_context(RoutingContextOptions { safety_route_spec: None, @@ -1996,6 +2010,7 @@ impl VeilidAPI { .await } + #[instrument(level = "debug", skip(self))] pub async fn unsafe_public(&self) -> RoutingContext { self.routing_context(RoutingContextOptions { safety_route_spec: None, @@ -2003,6 +2018,8 @@ impl VeilidAPI { }) .await } + + #[instrument(level = "debug", skip(self))] pub async fn routing_context(&self, options: RoutingContextOptions) -> RoutingContext { RoutingContext::new(self.clone(), options) } @@ -2010,6 +2027,7 @@ impl VeilidAPI { //////////////////////////////////////////////////////////////// // Tunnel Building + #[instrument(level = "debug", err, skip(self))] pub async fn start_tunnel( &self, _endpoint_mode: TunnelMode, @@ -2018,6 +2036,7 @@ impl VeilidAPI { panic!("unimplemented"); } + #[instrument(level = "debug", err, skip(self))] pub async fn complete_tunnel( &self, _endpoint_mode: TunnelMode, @@ -2027,6 +2046,7 @@ impl VeilidAPI { panic!("unimplemented"); } + #[instrument(level = "debug", err, skip(self))] pub async fn cancel_tunnel(&self, _tunnel_id: TunnelId) -> Result { panic!("unimplemented"); } diff --git a/veilid-core/src/veilid_api/serialize_helpers.rs b/veilid-core/src/veilid_api/serialize_helpers.rs index 71842d4a..e2e6ecab 100644 --- a/veilid-core/src/veilid_api/serialize_helpers.rs +++ b/veilid-core/src/veilid_api/serialize_helpers.rs @@ -1,24 +1,40 @@ use super::*; +use core::fmt::Debug; -pub fn deserialize_json<'a, T: de::Deserialize<'a>>( +#[instrument(level = "trace", ret, err)] +pub fn deserialize_json<'a, T: de::Deserialize<'a> + Debug>( arg: &'a str, -) -> Result { +) -> Result { serde_json::from_str(arg).map_err(|e| VeilidAPIError::ParseError { message: e.to_string(), - value: String::new(), + value: format!( + "deserialize_json:\n---\n{}\n---\n to type {}", + arg, + std::any::type_name::() + ), }) } -pub fn deserialize_opt_json( +#[instrument(level = "trace", ret, err)] +pub fn deserialize_opt_json( arg: Option, ) -> Result { - let arg = arg.ok_or_else(|| VeilidAPIError::ParseError { + let arg = arg.as_ref().ok_or_else(|| VeilidAPIError::ParseError { message: "invalid null string".to_owned(), - value: String::new(), + value: format!( + "deserialize_json_opt: null to type {}", + std::any::type_name::() + ), })?; - deserialize_json(&arg) + deserialize_json(arg) } -pub fn serialize_json(val: T) -> String { - serde_json::to_string(&val).expect("failed to serialize json value") +#[instrument(level = "trace", ret)] +pub fn serialize_json(val: T) -> String { + match serde_json::to_string(&val) { + Ok(v) => v, + Err(e) => { + panic!("failed to serialize json value: {}\nval={:?}", e, val); + } + } } diff --git a/veilid-core/src/veilid_config.rs b/veilid-core/src/veilid_config.rs index f166d5ef..e81e9be5 100644 --- a/veilid-core/src/veilid_config.rs +++ b/veilid-core/src/veilid_config.rs @@ -237,6 +237,15 @@ pub struct VeilidConfig { inner: Arc>, } +impl fmt::Debug for VeilidConfig { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let inner = self.inner.read(); + f.debug_struct("VeilidConfig") + .field("inner", &*inner) + .finish() + } +} + impl Default for VeilidConfig { fn default() -> Self { Self::new() diff --git a/veilid-flutter/example/lib/config.dart b/veilid-flutter/example/lib/config.dart index a1e58a45..6fea6365 100644 --- a/veilid-flutter/example/lib/config.dart +++ b/veilid-flutter/example/lib/config.dart @@ -7,7 +7,7 @@ Future getDefaultVeilidConfig() async { return VeilidConfig( programName: "Veilid Plugin Test", namespace: "", - logLevel: VeilidConfigLogLevel.info, + apiLogLevel: VeilidConfigLogLevel.info, capabilities: VeilidConfigCapabilities( protocolUDP: !kIsWeb, protocolConnectTCP: !kIsWeb, diff --git a/veilid-flutter/example/lib/main.dart b/veilid-flutter/example/lib/main.dart index d6ef3bb3..fb0758d3 100644 --- a/veilid-flutter/example/lib/main.dart +++ b/veilid-flutter/example/lib/main.dart @@ -36,8 +36,28 @@ LogOptions getLogOptions(LogLevel? level) { ); } +VeilidConfigLogLevel convertToVeilidConfigLogLevel(LogLevel? level) { + if (level == null) { + return VeilidConfigLogLevel.off; + } + switch (level) { + case LogLevel.error: + return VeilidConfigLogLevel.error; + case LogLevel.warning: + return VeilidConfigLogLevel.warn; + case LogLevel.info: + return VeilidConfigLogLevel.info; + case LogLevel.debug: + return VeilidConfigLogLevel.debug; + case traceLevel: + return VeilidConfigLogLevel.trace; + } + return VeilidConfigLogLevel.off; +} + void setRootLogLevel(LogLevel? level) { Loggy('').level = getLogOptions(level); + Veilid.instance.changeApiLogLevel(convertToVeilidConfigLogLevel(level)); } void initLoggy() { @@ -138,7 +158,7 @@ class _MyAppState extends State with UiLoggy { if (update is VeilidUpdateLog) { await processUpdateLog(update); } else { - loggy.trace("Update: " + update.toString()); + loggy.trace("Update: " + update.json.toString()); } } } diff --git a/veilid-flutter/example/linux/flutter/generated_plugins.cmake b/veilid-flutter/example/linux/flutter/generated_plugins.cmake index c45d7200..003d7b50 100644 --- a/veilid-flutter/example/linux/flutter/generated_plugins.cmake +++ b/veilid-flutter/example/linux/flutter/generated_plugins.cmake @@ -6,6 +6,9 @@ list(APPEND FLUTTER_PLUGIN_LIST veilid ) +list(APPEND FLUTTER_FFI_PLUGIN_LIST +) + set(PLUGIN_BUNDLED_LIBRARIES) foreach(plugin ${FLUTTER_PLUGIN_LIST}) @@ -14,3 +17,8 @@ foreach(plugin ${FLUTTER_PLUGIN_LIST}) list(APPEND PLUGIN_BUNDLED_LIBRARIES $) list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${plugin}_bundled_libraries}) endforeach(plugin) + +foreach(ffi_plugin ${FLUTTER_FFI_PLUGIN_LIST}) + add_subdirectory(flutter/ephemeral/.plugin_symlinks/${ffi_plugin}/linux plugins/${ffi_plugin}) + list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${ffi_plugin}_bundled_libraries}) +endforeach(ffi_plugin) diff --git a/veilid-flutter/example/macos/Podfile.lock b/veilid-flutter/example/macos/Podfile.lock index 15a08438..86a4b17a 100644 --- a/veilid-flutter/example/macos/Podfile.lock +++ b/veilid-flutter/example/macos/Podfile.lock @@ -21,8 +21,8 @@ EXTERNAL SOURCES: SPEC CHECKSUMS: FlutterMacOS: 57701585bf7de1b3fc2bb61f6378d73bbdea8424 path_provider_macos: 160cab0d5461f0c0e02995469a98f24bdb9a3f1f - veilid: f6b04d095ac7058ddf9c00215eb2699de8cc4673 + veilid: 6bed3adec63fd8708a2ace498e0e17941c9fc32b PODFILE CHECKSUM: 6eac6b3292e5142cfc23bdeb71848a40ec51c14c -COCOAPODS: 1.11.2 +COCOAPODS: 1.11.3 diff --git a/veilid-flutter/example/pubspec.lock b/veilid-flutter/example/pubspec.lock index 7a9996d9..6e7869ce 100644 --- a/veilid-flutter/example/pubspec.lock +++ b/veilid-flutter/example/pubspec.lock @@ -49,7 +49,7 @@ packages: name: collection url: "https://pub.dartlang.org" source: hosted - version: "1.15.0" + version: "1.16.0" cupertino_icons: dependency: "direct main" description: @@ -63,7 +63,7 @@ packages: name: fake_async url: "https://pub.dartlang.org" source: hosted - version: "1.2.0" + version: "1.3.0" ffi: dependency: transitive description: @@ -113,7 +113,7 @@ packages: name: js url: "https://pub.dartlang.org" source: hosted - version: "0.6.3" + version: "0.6.4" lints: dependency: transitive description: @@ -141,7 +141,7 @@ packages: name: material_color_utilities url: "https://pub.dartlang.org" source: hosted - version: "0.1.3" + version: "0.1.4" meta: dependency: transitive description: @@ -155,7 +155,7 @@ packages: name: path url: "https://pub.dartlang.org" source: hosted - version: "1.8.0" + version: "1.8.1" path_provider: dependency: transitive description: @@ -244,7 +244,7 @@ packages: name: source_span url: "https://pub.dartlang.org" source: hosted - version: "1.8.1" + version: "1.8.2" stack_trace: dependency: transitive description: @@ -279,21 +279,14 @@ packages: name: test_api url: "https://pub.dartlang.org" source: hosted - version: "0.4.8" - typed_data: - dependency: transitive - description: - name: typed_data - url: "https://pub.dartlang.org" - source: hosted - version: "1.3.0" + version: "0.4.9" vector_math: dependency: transitive description: name: vector_math url: "https://pub.dartlang.org" source: hosted - version: "2.1.1" + version: "2.1.2" veilid: dependency: "direct main" description: @@ -316,5 +309,5 @@ packages: source: hosted version: "0.2.0+1" sdks: - dart: ">=2.16.1 <3.0.0" + dart: ">=2.17.0-0 <3.0.0" flutter: ">=2.8.0" diff --git a/veilid-flutter/example/windows/flutter/generated_plugins.cmake b/veilid-flutter/example/windows/flutter/generated_plugins.cmake index 9ac4a14b..658ec856 100644 --- a/veilid-flutter/example/windows/flutter/generated_plugins.cmake +++ b/veilid-flutter/example/windows/flutter/generated_plugins.cmake @@ -6,6 +6,9 @@ list(APPEND FLUTTER_PLUGIN_LIST veilid ) +list(APPEND FLUTTER_FFI_PLUGIN_LIST +) + set(PLUGIN_BUNDLED_LIBRARIES) foreach(plugin ${FLUTTER_PLUGIN_LIST}) @@ -14,3 +17,8 @@ foreach(plugin ${FLUTTER_PLUGIN_LIST}) list(APPEND PLUGIN_BUNDLED_LIBRARIES $) list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${plugin}_bundled_libraries}) endforeach(plugin) + +foreach(ffi_plugin ${FLUTTER_FFI_PLUGIN_LIST}) + add_subdirectory(flutter/ephemeral/.plugin_symlinks/${ffi_plugin}/windows plugins/${ffi_plugin}) + list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${ffi_plugin}_bundled_libraries}) +endforeach(ffi_plugin) diff --git a/veilid-flutter/ios/veilid.podspec b/veilid-flutter/ios/veilid.podspec index f600a07c..9088b982 100644 --- a/veilid-flutter/ios/veilid.podspec +++ b/veilid-flutter/ios/veilid.podspec @@ -33,8 +33,8 @@ Veilid Network Plugin s.script_phase = { :name => 'Cargo Build', :script => File.join(File.dirname(__dir__), 'rust', 'ios_build.sh'), - :execution_position => :before_compile, - :output_files => [ File.join(cargo_target_dir, 'ios_lib', 'libveilid_flutter.a') ] + :execution_position => :before_compile + # :output_files => [ File.join(cargo_target_dir, 'ios_lib', 'libveilid_flutter.a') ] } end diff --git a/veilid-flutter/lib/veilid.dart b/veilid-flutter/lib/veilid.dart index 499c8aaa..4361c7cf 100644 --- a/veilid-flutter/lib/veilid.dart +++ b/veilid-flutter/lib/veilid.dart @@ -815,6 +815,7 @@ abstract class VeilidUpdate { } } } + Map get json; } class VeilidUpdateLog implements VeilidUpdate { @@ -822,12 +823,29 @@ class VeilidUpdateLog implements VeilidUpdate { final String message; // VeilidUpdateLog(this.logLevel, this.message); + + @override + Map get json { + return { + 'kind': "Log", + 'log_level': logLevel.json, + 'message': message, + }; + } } class VeilidUpdateAttachment implements VeilidUpdate { final AttachmentState state; // VeilidUpdateAttachment(this.state); + + @override + Map get json { + return { + 'kind': "Attachment", + 'state': state.json, + }; + } } class VeilidUpdateNetwork implements VeilidUpdate { @@ -836,6 +854,16 @@ class VeilidUpdateNetwork implements VeilidUpdate { final int bpsUp; // VeilidUpdateNetwork(this.started, this.bpsDown, this.bpsUp); + + @override + Map get json { + return { + 'kind': "Network", + 'started': started, + 'bps_down': bpsDown, + 'bps_up': bpsUp + }; + } } ////////////////////////////////////// diff --git a/veilid-flutter/lib/veilid_ffi.dart b/veilid-flutter/lib/veilid_ffi.dart index 0e4c2acc..0601f944 100644 --- a/veilid-flutter/lib/veilid_ffi.dart +++ b/veilid-flutter/lib/veilid_ffi.dart @@ -300,7 +300,9 @@ class VeilidFFI implements Veilid { @override Future changeApiLogLevel(VeilidConfigLogLevel logLevel) async { - var nativeLogLevel = logLevel.json.toNativeUtf8(); + var nativeLogLevel = + jsonEncode(logLevel.json, toEncodable: veilidApiToEncodable) + .toNativeUtf8(); final recvPort = ReceivePort("change_api_log_level"); final sendPort = recvPort.sendPort; _changeApiLogLevel(sendPort.nativePort, nativeLogLevel); diff --git a/veilid-flutter/macos/veilid.podspec b/veilid-flutter/macos/veilid.podspec index 8cf1b4b1..c4139cd2 100644 --- a/veilid-flutter/macos/veilid.podspec +++ b/veilid-flutter/macos/veilid.podspec @@ -27,8 +27,8 @@ Veilid Network Plugin s.script_phase = { :name => 'Cargo Build', :script => File.join(File.dirname(__dir__), 'rust', 'macos_build.sh'), - :execution_position => :before_compile, - :output_files => [ File.join(cargo_target_dir, 'macos_lib', 'libveilid_flutter.dylib') ] + :execution_position => :before_compile + #:output_files => [ File.join(cargo_target_dir, 'macos_lib', 'libveilid_flutter.dylib') ] } end diff --git a/veilid-flutter/rust/ios_build.sh b/veilid-flutter/rust/ios_build.sh index dd7607f5..7c05d493 100755 --- a/veilid-flutter/rust/ios_build.sh +++ b/veilid-flutter/rust/ios_build.sh @@ -1,11 +1,13 @@ #!/bin/bash +set -e +echo Running veilid-flutter rust iOS build script # Setup varaiables SCRIPTDIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )" FLUTTER_DIR=$(dirname `which flutter`) HOMEBREW_DIR=$(dirname `which brew`) CARGO_DIR=$(dirname `which cargo`) -CARGO_MANIFEST_PATH=$(python -c "import os; print(os.path.realpath(\"$SCRIPTDIR/Cargo.toml\"))") +CARGO_MANIFEST_PATH=$(python3 -c "import os; print(os.path.realpath(\"$SCRIPTDIR/Cargo.toml\"))") TARGET_DIR=$(dirname `cargo locate-project --message-format plain`)/target # Configure outputs @@ -30,7 +32,8 @@ do if [ "$arch" == "arm64" ]; then echo arm64 CARGO_TARGET=aarch64-apple-ios - CARGO_TOOLCHAIN=+ios-arm64-1.57.0 + #CARGO_TOOLCHAIN=+ios-arm64-1.57.0 + CARGO_TOOLCHAIN= elif [ "$arch" == "x86_64" ]; then echo x86_64 CARGO_TARGET=x86_64-apple-ios diff --git a/veilid-flutter/rust/macos_build.sh b/veilid-flutter/rust/macos_build.sh index 55a9baa1..29f180bc 100755 --- a/veilid-flutter/rust/macos_build.sh +++ b/veilid-flutter/rust/macos_build.sh @@ -1,11 +1,13 @@ #!/bin/bash +set -e +echo Running veilid-flutter rust MacOS build script # Setup varaiables SCRIPTDIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )" FLUTTER_DIR=$(dirname `which flutter`) HOMEBREW_DIR=$(dirname `which brew`) CARGO_DIR=$(dirname `which cargo`) -CARGO_MANIFEST_PATH=$(python -c "import os; print(os.path.realpath(\"$SCRIPTDIR/Cargo.toml\"))") +CARGO_MANIFEST_PATH=$(python3 -c "import os; print(os.path.realpath(\"$SCRIPTDIR/Cargo.toml\"))") TARGET_DIR=$(dirname `cargo locate-project --message-format plain`)/target # Configure outputs diff --git a/veilid-flutter/rust/src/dart_ffi.rs b/veilid-flutter/rust/src/dart_ffi.rs index cff8508e..27b14914 100644 --- a/veilid-flutter/rust/src/dart_ffi.rs +++ b/veilid-flutter/rust/src/dart_ffi.rs @@ -54,6 +54,7 @@ macro_rules! check_err_json { ///////////////////////////////////////// // Initializer #[no_mangle] +#[instrument] pub extern "C" fn initialize_veilid_flutter(dart_post_c_object_ptr: ffi::DartPostCObjectFnType) { unsafe { store_dart_post_cobject(dart_post_c_object_ptr); @@ -91,6 +92,7 @@ pub extern "C" fn initialize_veilid_flutter(dart_post_c_object_ptr: ffi::DartPos /// C-compatible FFI Functions #[no_mangle] +#[instrument] pub extern "C" fn startup_veilid_core(port: i64, config: FfiStr) { let config = config.into_opt_string(); let stream = DartIsolateStream::new(port); @@ -141,6 +143,7 @@ pub extern "C" fn get_veilid_state(port: i64) { } #[no_mangle] +#[instrument(level = "debug")] pub extern "C" fn change_api_log_level(port: i64, log_level: FfiStr) { let log_level = log_level.into_opt_string(); DartIsolateWrapper::new(port).spawn_result_json(async move { @@ -153,6 +156,7 @@ pub extern "C" fn change_api_log_level(port: i64, log_level: FfiStr) { } #[no_mangle] +#[instrument] pub extern "C" fn shutdown_veilid_core(port: i64) { DartIsolateWrapper::new(port).spawn_result_json(async move { let veilid_api = take_veilid_api().await?; @@ -184,6 +188,7 @@ pub struct VeilidVersion { } #[no_mangle] +#[instrument] pub extern "C" fn veilid_version() -> VeilidVersion { let (major, minor, patch) = veilid_core::veilid_version(); VeilidVersion { diff --git a/veilid-flutter/rust/src/dart_isolate_wrapper.rs b/veilid-flutter/rust/src/dart_isolate_wrapper.rs index b9aebd30..cbd01466 100644 --- a/veilid-flutter/rust/src/dart_isolate_wrapper.rs +++ b/veilid-flutter/rust/src/dart_isolate_wrapper.rs @@ -1,6 +1,7 @@ pub use allo_isolate::ffi::DartCObject; pub use allo_isolate::IntoDart; use allo_isolate::Isolate; +use core::fmt::Debug; use core::future::Future; use parking_lot::Mutex; use serde::*; @@ -31,8 +32,8 @@ impl DartIsolateWrapper { pub fn spawn_result(self, future: F) where F: Future> + Send + 'static, - T: IntoDart, - E: Serialize, + T: IntoDart + Debug, + E: Serialize + Debug, { async_std::task::spawn(async move { self.result(future.await); @@ -42,21 +43,24 @@ impl DartIsolateWrapper { pub fn spawn_result_json(self, future: F) where F: Future> + Send + 'static, - T: Serialize, - E: Serialize, + T: Serialize + Debug, + E: Serialize + Debug, { async_std::task::spawn(async move { self.result_json(future.await); }); } - pub fn result(self, result: Result) -> bool { + pub fn result(self, result: Result) -> bool { match result { Ok(v) => self.ok(v), Err(e) => self.err_json(e), } } - pub fn result_json(self, result: Result) -> bool { + pub fn result_json( + self, + result: Result, + ) -> bool { match result { Ok(v) => self.ok_json(v), Err(e) => self.err_json(e), @@ -67,19 +71,19 @@ impl DartIsolateWrapper { .post(vec![MESSAGE_OK.into_dart(), value.into_dart()]) } - pub fn ok_json(self, value: T) -> bool { + pub fn ok_json(self, value: T) -> bool { self.isolate.post(vec![ MESSAGE_OK_JSON.into_dart(), veilid_core::serialize_json(value).into_dart(), ]) } - // pub fn err(self, error: E) -> bool { + // pub fn err(self, error: E) -> bool { // self.isolate // .post(vec![MESSAGE_ERR.into_dart(), error.into_dart()]) // } - pub fn err_json(self, error: E) -> bool { + pub fn err_json(self, error: E) -> bool { self.isolate.post(vec![ MESSAGE_ERR_JSON.into_dart(), veilid_core::serialize_json(error).into_dart(), @@ -122,7 +126,7 @@ impl DartIsolateStream { // } // } - pub fn item_json(&self, value: T) -> bool { + pub fn item_json(&self, value: T) -> bool { let inner = self.inner.lock(); if let Some(isolate) = &inner.isolate { isolate.post(vec![ @@ -134,7 +138,7 @@ impl DartIsolateStream { } } - // pub fn abort(self, error: E) -> bool { + // pub fn abort(self, error: E) -> bool { // let mut inner = self.inner.lock(); // if let Some(isolate) = inner.isolate.take() { // isolate.post(vec![MESSAGE_STREAM_ABORT.into_dart(), error.into_dart()]) @@ -143,7 +147,7 @@ impl DartIsolateStream { // } // } - pub fn abort_json(self, error: E) -> bool { + pub fn abort_json(self, error: E) -> bool { let mut inner = self.inner.lock(); if let Some(isolate) = inner.isolate.take() { isolate.post(vec![ diff --git a/veilid-server/src/client_api.rs b/veilid-server/src/client_api.rs index f26494a0..0fab05f4 100644 --- a/veilid-server/src/client_api.rs +++ b/veilid-server/src/client_api.rs @@ -73,6 +73,7 @@ struct VeilidServerImpl { } impl VeilidServerImpl { + #[instrument(level = "trace", skip_all)] pub fn new(veilid_api: veilid_core::VeilidAPI) -> Self { Self { next_id: 0, @@ -83,6 +84,7 @@ impl VeilidServerImpl { } impl veilid_server::Server for VeilidServerImpl { + #[instrument(level = "trace", skip_all)] fn register( &mut self, params: veilid_server::RegisterParams, @@ -126,6 +128,7 @@ impl veilid_server::Server for VeilidServerImpl { }) } + #[instrument(level = "trace", skip_all)] fn debug( &mut self, params: veilid_server::DebugParams, @@ -145,6 +148,7 @@ impl veilid_server::Server for VeilidServerImpl { }) } + #[instrument(level = "trace", skip_all)] fn attach( &mut self, _params: veilid_server::AttachParams, @@ -160,6 +164,7 @@ impl veilid_server::Server for VeilidServerImpl { }) } + #[instrument(level = "trace", skip_all)] fn detach( &mut self, _params: veilid_server::DetachParams, @@ -175,6 +180,7 @@ impl veilid_server::Server for VeilidServerImpl { }) } + #[instrument(level = "trace", skip_all)] fn shutdown( &mut self, _params: veilid_server::ShutdownParams, @@ -194,6 +200,7 @@ impl veilid_server::Server for VeilidServerImpl { Promise::ok(()) } + #[instrument(level = "trace", skip_all)] fn get_state( &mut self, _params: veilid_server::GetStateParams, @@ -239,6 +246,7 @@ pub struct ClientApi { } impl ClientApi { + #[instrument(level = "trace", skip_all)] pub fn new(veilid_api: veilid_core::VeilidAPI) -> Rc { Rc::new(Self { inner: RefCell::new(ClientApiInner { @@ -250,6 +258,7 @@ impl ClientApi { }) } + #[instrument(level = "trace", skip(self))] pub async fn stop(self: Rc) { trace!("ClientApi::stop requested"); let jh = { @@ -268,6 +277,7 @@ impl ClientApi { trace!("ClientApi::stop: stopped"); } + #[instrument(level = "trace", skip(self, client), err)] async fn handle_incoming( self: Rc, bind_addr: SocketAddr, @@ -301,6 +311,7 @@ impl ClientApi { incoming_loop.await } + #[instrument(level = "trace", skip_all)] fn send_request_to_all_clients(self: Rc, request: F) where F: Fn(u64, &mut RegistrationHandle) -> Option<::capnp::capability::RemotePromise>, @@ -338,6 +349,7 @@ impl ClientApi { } } + #[instrument(level = "trace", skip(self))] pub fn handle_update(self: Rc, veilid_update: veilid_core::VeilidUpdate) { // serialize update let veilid_update = serialize_json(veilid_update); @@ -360,6 +372,7 @@ impl ClientApi { }); } + #[instrument(level = "trace", skip(self))] pub fn run(self: Rc, bind_addrs: Vec) { // Create client api VeilidServer let veilid_server_impl = VeilidServerImpl::new(self.inner.borrow().veilid_api.clone()); diff --git a/veilid-server/src/main.rs b/veilid-server/src/main.rs index 7de5da7d..623aad45 100644 --- a/veilid-server/src/main.rs +++ b/veilid-server/src/main.rs @@ -15,6 +15,7 @@ mod windows; use async_std::task; use cfg_if::*; use server::*; +use tracing::*; use veilid_logs::*; #[allow(clippy::all)] @@ -22,6 +23,7 @@ pub mod veilid_client_capnp { include!(concat!(env!("OUT_DIR"), "/proto/veilid_client_capnp.rs")); } +#[instrument(err)] fn main() -> Result<(), String> { #[cfg(windows)] let _ = ansi_term::enable_ansi_support(); diff --git a/veilid-server/src/server.rs b/veilid-server/src/server.rs index 16fdfc05..ef23a15c 100644 --- a/veilid-server/src/server.rs +++ b/veilid-server/src/server.rs @@ -8,7 +8,7 @@ use std::time::{Duration, Instant}; use tracing::*; use veilid_core::xx::SingleShotEventual; -#[derive(Copy, Clone, PartialEq, Eq)] +#[derive(Debug, Copy, Clone, PartialEq, Eq)] pub enum ServerMode { Normal, ShutdownImmediate, @@ -20,6 +20,7 @@ lazy_static! { Mutex::new(Some(SingleShotEventual::new(Some(())))); } +#[instrument] pub fn shutdown() { let shutdown_switch = SHUTDOWN_SWITCH.lock().take(); if let Some(shutdown_switch) = shutdown_switch { @@ -28,13 +29,10 @@ pub fn shutdown() { } pub async fn run_veilid_server(settings: Settings, server_mode: ServerMode) -> Result<(), String> { - run_veilid_server_internal(settings, server_mode) - .await - .map_err(|e| { - error!("{}", e); - e - }) + run_veilid_server_internal(settings, server_mode).await } + +#[instrument(err)] pub async fn run_veilid_server_internal( settings: Settings, server_mode: ServerMode, diff --git a/veilid-server/src/unix.rs b/veilid-server/src/unix.rs index 96a878ac..95b74953 100644 --- a/veilid-server/src/unix.rs +++ b/veilid-server/src/unix.rs @@ -7,7 +7,9 @@ use clap::ArgMatches; use signal_hook::consts::signal::*; use signal_hook_async_std::Signals; use std::io::Read; +use tracing::*; +#[instrument(skip(signals))] async fn handle_signals(mut signals: Signals) { while let Some(signal) = signals.next().await { match signal { @@ -23,6 +25,7 @@ async fn handle_signals(mut signals: Signals) { } } +#[instrument(err)] pub fn run_daemon(settings: Settings, _matches: ArgMatches) -> Result<(), String> { let daemon = { let mut daemon = daemonize::Daemonize::new();