From 21bf0fb27ba241e793639d83dd25248a242fbc7d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C4=99drzej=20Stuczy=C5=84ski?= Date: Mon, 20 Mar 2023 14:00:25 +0000 Subject: [PATCH] wasm changes --- .../client/base_client/non_wasm_helpers.rs | 16 +- .../reply_storage/backend/browser_backend.rs | 8 +- clients/webassembly/src/client/config.rs | 324 +++++++++++++----- clients/webassembly/src/client/mod.rs | 10 +- 4 files changed, 262 insertions(+), 96 deletions(-) diff --git a/clients/client-core/src/client/base_client/non_wasm_helpers.rs b/clients/client-core/src/client/base_client/non_wasm_helpers.rs index 9dde32f9d2..8f253cd659 100644 --- a/clients/client-core/src/client/base_client/non_wasm_helpers.rs +++ b/clients/client-core/src/client/base_client/non_wasm_helpers.rs @@ -30,8 +30,12 @@ async fn setup_fresh_backend>( // it will only be happening on the very first run and in practice won't incur huge // costs since the storage is going to be empty let mem_store = CombinedReplyStorage::new( - debug_config.minimum_reply_surb_storage_threshold, - debug_config.maximum_reply_surb_storage_threshold, + debug_config + .reply_surbs + .minimum_reply_surb_storage_threshold, + debug_config + .reply_surbs + .maximum_reply_surb_storage_threshold, ); storage_backend .init_fresh(&mem_store) @@ -46,8 +50,12 @@ async fn setup_fresh_backend>( fn setup_inactive_backend(debug_config: &DebugConfig) -> fs_backend::Backend { info!("creating inactive surb database"); fs_backend::Backend::new_inactive( - debug_config.minimum_reply_surb_storage_threshold, - debug_config.maximum_reply_surb_storage_threshold, + debug_config + .reply_surbs + .minimum_reply_surb_storage_threshold, + debug_config + .reply_surbs + .maximum_reply_surb_storage_threshold, ) } diff --git a/clients/client-core/src/client/replies/reply_storage/backend/browser_backend.rs b/clients/client-core/src/client/replies/reply_storage/backend/browser_backend.rs index 2753d765cd..aa01742f06 100644 --- a/clients/client-core/src/client/replies/reply_storage/backend/browser_backend.rs +++ b/clients/client-core/src/client/replies/reply_storage/backend/browser_backend.rs @@ -35,8 +35,12 @@ impl ReplyStorageBackend for Backend { ) -> Result { Ok(Backend { empty: Empty { - min_surb_threshold: debug_config.minimum_reply_surb_storage_threshold, - max_surb_threshold: debug_config.maximum_reply_surb_storage_threshold, + min_surb_threshold: debug_config + .reply_surbs + .minimum_reply_surb_storage_threshold, + max_surb_threshold: debug_config + .reply_surbs + .maximum_reply_surb_storage_threshold, }, }) } diff --git a/clients/webassembly/src/client/config.rs b/clients/webassembly/src/client/config.rs index b69769936c..a51381a97a 100644 --- a/clients/webassembly/src/client/config.rs +++ b/clients/webassembly/src/client/config.rs @@ -4,7 +4,12 @@ // due to expansion of #[wasm_bindgen] macro on `Debug` Config struct #![allow(clippy::drop_non_drop)] -use client_core::config::{DebugConfig as ConfigDebug, ExtendedPacketSize, GatewayEndpointConfig}; +use client_core::config::{ + Acknowledgements as ConfigAcknowledgements, CoverTraffic as ConfigCoverTraffic, + DebugConfig as ConfigDebug, ExtendedPacketSize, GatewayConnection as ConfigGatewayConnection, + GatewayEndpointConfig, ReplySurbs as ConfigReplySurbs, Topology as ConfigTopology, + Traffic as ConfigTraffic, +}; use serde::{Deserialize, Serialize}; use std::time::Duration; use url::Url; @@ -48,15 +53,124 @@ impl Config { } } -// just a helper structure to more easily pass through the JS boundary #[wasm_bindgen] -pub struct Debug { +#[derive(Copy, Clone)] +pub struct Traffic { /// The parameter of Poisson distribution determining how long, on average, /// sent packet is going to be delayed at any given mix node. /// So for a packet going through three mix nodes, on average, it will take three times this value /// until the packet reaches its destination. pub average_packet_delay_ms: u64, + /// The parameter of Poisson distribution determining how long, on average, + /// it is going to take another 'real traffic stream' message to be sent. + /// If no real packets are available and cover traffic is enabled, + /// a loop cover message is sent instead in order to preserve the rate. + pub message_sending_average_delay_ms: u64, + + /// Controls whether the main packet stream constantly produces packets according to the predefined + /// poisson distribution. + pub disable_main_poisson_packet_distribution: bool, + + /// Controls whether the sent sphinx packet use the NON-DEFAULT bigger size. + pub use_extended_packet_size: bool, +} + +impl From for ConfigTraffic { + fn from(traffic: Traffic) -> Self { + let use_extended_packet_size = traffic + .use_extended_packet_size + .then(|| ExtendedPacketSize::Extended32); + + ConfigTraffic { + average_packet_delay: Duration::from_millis(traffic.average_packet_delay_ms), + message_sending_average_delay: Duration::from_millis( + traffic.message_sending_average_delay_ms, + ), + disable_main_poisson_packet_distribution: traffic + .disable_main_poisson_packet_distribution, + use_extended_packet_size, + } + } +} + +impl From for Traffic { + fn from(traffic: ConfigTraffic) -> Self { + Traffic { + average_packet_delay_ms: traffic.average_packet_delay.as_millis() as u64, + message_sending_average_delay_ms: traffic.message_sending_average_delay.as_millis() + as u64, + disable_main_poisson_packet_distribution: traffic + .disable_main_poisson_packet_distribution, + use_extended_packet_size: traffic.use_extended_packet_size.is_some(), + } + } +} + +#[wasm_bindgen] +#[derive(Copy, Clone)] +pub struct CoverTraffic { + /// The parameter of Poisson distribution determining how long, on average, + /// it is going to take for another loop cover traffic message to be sent. + pub loop_cover_traffic_average_delay_ms: u64, + + /// Controls whether the dedicated loop cover traffic stream should be enabled. + /// (and sending packets, on average, every [Self::loop_cover_traffic_average_delay]) + pub disable_loop_cover_traffic_stream: bool, +} + +impl From for ConfigCoverTraffic { + fn from(cover_traffic: CoverTraffic) -> Self { + ConfigCoverTraffic { + loop_cover_traffic_average_delay: Duration::from_millis( + cover_traffic.loop_cover_traffic_average_delay_ms, + ), + disable_loop_cover_traffic_stream: cover_traffic.disable_loop_cover_traffic_stream, + } + } +} + +impl From for CoverTraffic { + fn from(cover_traffic: ConfigCoverTraffic) -> Self { + CoverTraffic { + loop_cover_traffic_average_delay_ms: cover_traffic + .loop_cover_traffic_average_delay + .as_millis() as u64, + disable_loop_cover_traffic_stream: cover_traffic.disable_loop_cover_traffic_stream, + } + } +} + +#[wasm_bindgen] +#[derive(Copy, Clone)] +pub struct GatewayConnection { + /// How long we're willing to wait for a response to a message sent to the gateway, + /// before giving up on it. + pub gateway_response_timeout_ms: u64, +} + +impl From for ConfigGatewayConnection { + fn from(gateway_connection: GatewayConnection) -> Self { + ConfigGatewayConnection { + gateway_response_timeout: Duration::from_millis( + gateway_connection.gateway_response_timeout_ms, + ), + } + } +} + +impl From for GatewayConnection { + fn from(gateway_connection: ConfigGatewayConnection) -> Self { + GatewayConnection { + gateway_response_timeout_ms: gateway_connection.gateway_response_timeout.as_millis() + as u64, + } + } +} + +#[wasm_bindgen] +#[derive(Copy, Clone)] +pub struct Acknowledgements { /// The parameter of Poisson distribution determining how long, on average, /// sent acknowledgement is going to be delayed at any given mix node. /// So for an ack going through three mix nodes, on average, it will take three times this value @@ -72,21 +186,31 @@ pub struct Debug { /// it is assumed it was lost and retransmission of the data packet happens. /// In an ideal network with 0 latency, this value would have been 0. pub ack_wait_addition_ms: u64, +} - /// The parameter of Poisson distribution determining how long, on average, - /// it is going to take for another loop cover traffic message to be sent. - pub loop_cover_traffic_average_delay_ms: u64, +impl From for ConfigAcknowledgements { + fn from(acknowledgements: Acknowledgements) -> Self { + ConfigAcknowledgements { + average_ack_delay: Duration::from_millis(acknowledgements.average_ack_delay_ms), + ack_wait_multiplier: acknowledgements.ack_wait_multiplier, + ack_wait_addition: Duration::from_millis(acknowledgements.ack_wait_addition_ms), + } + } +} - /// The parameter of Poisson distribution determining how long, on average, - /// it is going to take another 'real traffic stream' message to be sent. - /// If no real packets are available and cover traffic is enabled, - /// a loop cover message is sent instead in order to preserve the rate. - pub message_sending_average_delay_ms: u64, - - /// How long we're willing to wait for a response to a message sent to the gateway, - /// before giving up on it. - pub gateway_response_timeout_ms: u64, +impl From for Acknowledgements { + fn from(acknowledgements: ConfigAcknowledgements) -> Self { + Acknowledgements { + average_ack_delay_ms: acknowledgements.average_ack_delay.as_millis() as u64, + ack_wait_multiplier: acknowledgements.ack_wait_multiplier, + ack_wait_addition_ms: acknowledgements.ack_wait_addition.as_millis() as u64, + } + } +} +#[wasm_bindgen] +#[derive(Copy, Clone)] +pub struct Topology { /// The uniform delay every which clients are querying the directory server /// to try to obtain a compatible network topology to send sphinx packets through. pub topology_refresh_rate_ms: u64, @@ -95,18 +219,31 @@ pub struct Debug { /// path. This timeout determines waiting period until it is decided that the packet /// did not reach its destination. pub topology_resolution_timeout_ms: u64, +} - /// Controls whether the dedicated loop cover traffic stream should be enabled. - /// (and sending packets, on average, every [Self::loop_cover_traffic_average_delay_ms]) - pub disable_loop_cover_traffic_stream: bool, +impl From for ConfigTopology { + fn from(topology: Topology) -> Self { + ConfigTopology { + topology_refresh_rate: Duration::from_millis(topology.topology_refresh_rate_ms), + topology_resolution_timeout: Duration::from_millis( + topology.topology_resolution_timeout_ms, + ), + } + } +} - /// Controls whether the main packet stream constantly produces packets according to the predefined - /// poisson distribution. - pub disable_main_poisson_packet_distribution: bool, - - /// Controls whether the sent sphinx packet use the NON-DEFAULT bigger size. - pub use_extended_packet_size: bool, +impl From for Topology { + fn from(topology: ConfigTopology) -> Self { + Topology { + topology_refresh_rate_ms: topology.topology_refresh_rate.as_millis() as u64, + topology_resolution_timeout_ms: topology.topology_resolution_timeout.as_millis() as u64, + } + } +} +#[wasm_bindgen] +#[derive(Copy, Clone)] +pub struct ReplySurbs { /// Defines the minimum number of reply surbs the client wants to keep in its storage at all times. /// It can only allow to go below that value if its to request additional reply surbs. pub minimum_reply_surb_storage_threshold: usize, @@ -140,46 +277,79 @@ pub struct Debug { pub maximum_reply_key_age_ms: u64, } -impl From for ConfigDebug { - fn from(debug: Debug) -> Self { - // For now we just always use the (older) 32kb extended size - let use_extended_packet_size = debug - .use_extended_packet_size - .then(|| ExtendedPacketSize::Extended32); - - ConfigDebug { - average_packet_delay: Duration::from_millis(debug.average_packet_delay_ms), - average_ack_delay: Duration::from_millis(debug.average_ack_delay_ms), - ack_wait_multiplier: debug.ack_wait_multiplier, - ack_wait_addition: Duration::from_millis(debug.ack_wait_addition_ms), - loop_cover_traffic_average_delay: Duration::from_millis( - debug.loop_cover_traffic_average_delay_ms, - ), - message_sending_average_delay: Duration::from_millis( - debug.message_sending_average_delay_ms, - ), - gateway_response_timeout: Duration::from_millis(debug.gateway_response_timeout_ms), - topology_refresh_rate: Duration::from_millis(debug.topology_refresh_rate_ms), - topology_resolution_timeout: Duration::from_millis( - debug.topology_resolution_timeout_ms, - ), - disable_loop_cover_traffic_stream: debug.disable_loop_cover_traffic_stream, - disable_main_poisson_packet_distribution: debug - .disable_main_poisson_packet_distribution, - use_extended_packet_size, - minimum_reply_surb_storage_threshold: debug.minimum_reply_surb_storage_threshold, - maximum_reply_surb_storage_threshold: debug.maximum_reply_surb_storage_threshold, - minimum_reply_surb_request_size: debug.minimum_reply_surb_request_size, - maximum_reply_surb_request_size: debug.maximum_reply_surb_request_size, - maximum_allowed_reply_surb_request_size: debug.maximum_allowed_reply_surb_request_size, +impl From for ConfigReplySurbs { + fn from(reply_surbs: ReplySurbs) -> Self { + ConfigReplySurbs { + minimum_reply_surb_storage_threshold: reply_surbs.minimum_reply_surb_storage_threshold, + maximum_reply_surb_storage_threshold: reply_surbs.maximum_reply_surb_storage_threshold, + minimum_reply_surb_request_size: reply_surbs.minimum_reply_surb_request_size, + maximum_reply_surb_request_size: reply_surbs.maximum_reply_surb_request_size, + maximum_allowed_reply_surb_request_size: reply_surbs + .maximum_allowed_reply_surb_request_size, maximum_reply_surb_rerequest_waiting_period: Duration::from_millis( - debug.maximum_reply_surb_rerequest_waiting_period_ms, + reply_surbs.maximum_reply_surb_rerequest_waiting_period_ms, ), maximum_reply_surb_drop_waiting_period: Duration::from_millis( - debug.maximum_reply_surb_drop_waiting_period_ms, + reply_surbs.maximum_reply_surb_drop_waiting_period_ms, ), - maximum_reply_surb_age: Duration::from_millis(debug.maximum_reply_surb_age_ms), - maximum_reply_key_age: Duration::from_millis(debug.maximum_reply_key_age_ms), + maximum_reply_surb_age: Duration::from_millis(reply_surbs.maximum_reply_surb_age_ms), + maximum_reply_key_age: Duration::from_millis(reply_surbs.maximum_reply_key_age_ms), + } + } +} + +impl From for ReplySurbs { + fn from(reply_surbs: ConfigReplySurbs) -> Self { + ReplySurbs { + minimum_reply_surb_storage_threshold: reply_surbs.minimum_reply_surb_storage_threshold, + maximum_reply_surb_storage_threshold: reply_surbs.maximum_reply_surb_storage_threshold, + minimum_reply_surb_request_size: reply_surbs.minimum_reply_surb_request_size, + maximum_reply_surb_request_size: reply_surbs.maximum_reply_surb_request_size, + maximum_allowed_reply_surb_request_size: reply_surbs + .maximum_allowed_reply_surb_request_size, + maximum_reply_surb_rerequest_waiting_period_ms: reply_surbs + .maximum_reply_surb_rerequest_waiting_period + .as_millis() as u64, + maximum_reply_surb_drop_waiting_period_ms: reply_surbs + .maximum_reply_surb_drop_waiting_period + .as_millis() as u64, + maximum_reply_surb_age_ms: reply_surbs.maximum_reply_surb_age.as_millis() as u64, + maximum_reply_key_age_ms: reply_surbs.maximum_reply_key_age.as_millis() as u64, + } + } +} + +// just a helper structure to more easily pass through the JS boundary +#[wasm_bindgen] +pub struct Debug { + /// Defines all configuration options related to traffic streams. + pub traffic: Traffic, + + /// Defines all configuration options related to cover traffic stream(s). + pub cover_traffic: CoverTraffic, + + /// Defines all configuration options related to the gateway connection. + pub gateway_connection: GatewayConnection, + + /// Defines all configuration options related to acknowledgements, such as delays or wait timeouts. + pub acknowledgements: Acknowledgements, + + /// Defines all configuration options related topology, such as refresh rates or timeouts. + pub topology: Topology, + + /// Defines all configuration options related to reply SURBs. + pub reply_surbs: ReplySurbs, +} + +impl From for ConfigDebug { + fn from(debug: Debug) -> Self { + ConfigDebug { + traffic: debug.traffic.into(), + cover_traffic: debug.cover_traffic.into(), + gateway_connection: debug.gateway_connection.into(), + acknowledgements: debug.acknowledgements.into(), + topology: debug.topology.into(), + reply_surbs: debug.reply_surbs.into(), } } } @@ -187,34 +357,12 @@ impl From for ConfigDebug { impl From for Debug { fn from(debug: ConfigDebug) -> Self { Debug { - average_packet_delay_ms: debug.average_packet_delay.as_millis() as u64, - average_ack_delay_ms: debug.average_ack_delay.as_millis() as u64, - ack_wait_multiplier: debug.ack_wait_multiplier, - ack_wait_addition_ms: debug.ack_wait_addition.as_millis() as u64, - loop_cover_traffic_average_delay_ms: debug.loop_cover_traffic_average_delay.as_millis() - as u64, - message_sending_average_delay_ms: debug.message_sending_average_delay.as_millis() - as u64, - gateway_response_timeout_ms: debug.gateway_response_timeout.as_millis() as u64, - topology_refresh_rate_ms: debug.topology_refresh_rate.as_millis() as u64, - topology_resolution_timeout_ms: debug.topology_resolution_timeout.as_millis() as u64, - disable_loop_cover_traffic_stream: debug.disable_loop_cover_traffic_stream, - disable_main_poisson_packet_distribution: debug - .disable_main_poisson_packet_distribution, - use_extended_packet_size: debug.use_extended_packet_size.is_some(), - minimum_reply_surb_storage_threshold: debug.minimum_reply_surb_storage_threshold, - maximum_reply_surb_storage_threshold: debug.maximum_reply_surb_storage_threshold, - minimum_reply_surb_request_size: debug.minimum_reply_surb_request_size, - maximum_reply_surb_request_size: debug.maximum_reply_surb_request_size, - maximum_allowed_reply_surb_request_size: debug.maximum_allowed_reply_surb_request_size, - maximum_reply_surb_rerequest_waiting_period_ms: debug - .maximum_reply_surb_rerequest_waiting_period - .as_millis() as u64, - maximum_reply_surb_drop_waiting_period_ms: debug - .maximum_reply_surb_drop_waiting_period - .as_millis() as u64, - maximum_reply_surb_age_ms: debug.maximum_reply_surb_age.as_millis() as u64, - maximum_reply_key_age_ms: debug.maximum_reply_key_age.as_millis() as u64, + traffic: debug.traffic.into(), + cover_traffic: debug.cover_traffic.into(), + gateway_connection: debug.gateway_connection.into(), + acknowledgements: debug.acknowledgements.into(), + topology: debug.topology.into(), + reply_surbs: debug.reply_surbs.into(), } } } diff --git a/clients/webassembly/src/client/mod.rs b/clients/webassembly/src/client/mod.rs index dd45c28bb8..f8a60eb70d 100644 --- a/clients/webassembly/src/client/mod.rs +++ b/clients/webassembly/src/client/mod.rs @@ -82,8 +82,14 @@ impl NymClientBuilder { // with no persistence fn setup_reply_surb_storage_backend(config: &Config) -> browser_backend::Backend { browser_backend::Backend::new( - config.debug.minimum_reply_surb_storage_threshold, - config.debug.maximum_reply_surb_storage_threshold, + config + .debug + .reply_surbs + .minimum_reply_surb_storage_threshold, + config + .debug + .reply_surbs + .maximum_reply_surb_storage_threshold, ) }