refactor(client): make configuration reusable across endpoints

crates/irtt-app/src/shared/client/config.rs

@@ -1,41 +1,45 @@
 use std::time::Duration;
 
-use irtt_client::{Authentication, ClientConfig, HmacKey, NegotiationPolicy, SocketConfig};
+use irtt_client::{
+    Authentication, ClientConfig, HmacKey, NegotiationPolicy, OpenPolicy, SessionRequest,
+    SocketConfig,
+};
 
 use super::args::CommonClientArgs;
 
-pub const DEFAULT_RECV_TIMEOUT: Duration = Duration::from_millis(20);
-
 impl CommonClientArgs {
     /// Build the shared client configuration template for a managed run.
     ///
-    /// The template carries no server address: the managed driver replaces it
-    /// per target from that target's configuration, so deriving one here from
-    /// an arbitrary target would be dead data.
+    /// The config is endpoint-independent; managed targets own their addresses.
     pub fn to_client_config(&self, duration: Duration) -> ClientConfig {
         ClientConfig {
-            duration: (!duration.is_zero()).then_some(duration),
-            interval: self.interval,
-            length: self.length,
-            received_stats: self.stats.into(),
-            stamp_at: self.tstamp.into(),
-            clock: self.clock.into(),
-            dscp: self.dscp,
+            open: OpenPolicy {
+                negotiation: if self.loose {
+                    NegotiationPolicy::Loose
+                } else {
+                    NegotiationPolicy::Strict
+                },
+                ..Default::default()
+            },
+            request: SessionRequest {
+                duration: (!duration.is_zero()).then_some(duration),
+                interval: self.interval,
+                length: self.length,
+                received_stats: self.stats.into(),
+                stamp_at: self.tstamp.into(),
+                clock: self.clock.into(),
+                dscp: self.dscp,
+                server_fill: self.server_fill.clone(),
+                ..Default::default()
+            },
             auth: self
                 .hmac
                 .as_ref()
                 .map_or(Authentication::Unauthenticated, |key| {
                     Authentication::Hmac(HmacKey::new(key.as_bytes()))
                 }),
-            server_fill: self.server_fill.clone(),
-            negotiation_policy: if self.loose {
-                NegotiationPolicy::Loose
-            } else {
-                NegotiationPolicy::Strict
-            },
-            socket_config: SocketConfig {
+            socket: SocketConfig {
                 ttl: self.ttl,
-                recv_timeout: Some(DEFAULT_RECV_TIMEOUT),
                 ..SocketConfig::default()
             },
             ..ClientConfig::default()