wasm changes

2023-03-20 14:00:25 +00:00
parent 7313f56c01
commit 21bf0fb27b
4 changed files with 262 additions and 96 deletions
@@ -30,8 +30,12 @@ async fn setup_fresh_backend<P: AsRef<Path>>(
    // 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<P: AsRef<Path>>(
 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,
    )
 }

@@ -35,8 +35,12 @@ impl ReplyStorageBackend for Backend {
    ) -> Result<Self, Self::StorageError> {
        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,
            },
        })
    }
@@ -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<Traffic> 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<ConfigTraffic> 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<CoverTraffic> 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<ConfigCoverTraffic> 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<GatewayConnection> for ConfigGatewayConnection {
+    fn from(gateway_connection: GatewayConnection) -> Self {
+        ConfigGatewayConnection {
+            gateway_response_timeout: Duration::from_millis(
+                gateway_connection.gateway_response_timeout_ms,
+            ),
+        }
+    }
+}
+
+impl From<ConfigGatewayConnection> 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<Acknowledgements> 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<ConfigAcknowledgements> 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<Topology> 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<ConfigTopology> 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<Debug> 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<ReplySurbs> 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<ConfigReplySurbs> 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<Debug> 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<Debug> for ConfigDebug {
 impl From<ConfigDebug> 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(),
        }
    }
 }
@@ -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,
        )
    }