checkpoint: integrate authenticated transports

tests/reconnect.rs

@@ -0,0 +1,161 @@
+use std::{path::Path, time::Duration};
+
+use tempfile::tempdir;
+use tokio::{
+    net::UdpSocket,
+    time::{sleep, timeout},
+};
+use wgcloak::{
+    client,
+    config::{self, Config},
+    control, server,
+};
+
+const SECRET: &str = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
+
+fn free_udp_port() -> u16 {
+    let socket = std::net::UdpSocket::bind("127.0.0.1:0").unwrap();
+    socket.local_addr().unwrap().port()
+}
+
+fn server_config(port: u16, backend: std::net::SocketAddr) -> config::ServerConfig {
+    Config::from_str(&format!(
+        "[server]\nlisten='127.0.0.1'\n[backend]\ntarget='{backend}'\n[transports.direct_udp]\nenabled=true\nport={port}\n[transports.quic]\nenabled=false\n[transports.http3]\nenabled=false\n[transports.tls_tcp]\nenabled=false\n[[auth.clients]]\nid='reconnect-test'\nsecret='{SECRET}'\n"
+    ))
+    .unwrap()
+    .into_server()
+    .unwrap()
+}
+
+fn client_config(port: u16, local_port: u16) -> config::ClientConfig {
+    Config::from_str(&format!(
+        "[client]\nserver='127.0.0.1'\nid='reconnect-test'\nsecret='{SECRET}'\n[local]\nlisten='127.0.0.1:{local_port}'\n[transport]\nmode='direct_udp'\n[transport.direct_udp]\nport={port}\n[transport.auto]\nprobe_timeout_ms=150\nretries=1\n"
+    ))
+    .unwrap()
+    .into_client()
+    .unwrap()
+}
+
+async fn wait_for_contains(path: &Path, command: &str, needle: &str) -> String {
+    timeout(Duration::from_secs(10), async {
+        loop {
+            if let Ok(response) = control::send_command(path, command).await {
+                if response.contains(needle) {
+                    return response;
+                }
+            }
+            sleep(Duration::from_millis(20)).await;
+        }
+    })
+    .await
+    .unwrap_or_else(|_| panic!("control {command} did not contain {needle:?}"))
+}
+
+async fn wait_for_reconnected_stats(path: &Path) -> String {
+    timeout(Duration::from_secs(10), async {
+        loop {
+            if let Ok(response) = control::send_command(path, "stats").await {
+                if response.contains("\"state\":\"connected\"")
+                    && response.contains("\"reconnections\":1")
+                {
+                    return response;
+                }
+            }
+            sleep(Duration::from_millis(20)).await;
+        }
+    })
+    .await
+    .expect("client did not publish its connected reconnect state")
+}
+
+async fn wait_for_echo(app: &UdpSocket, local_port: u16, payload: &[u8]) {
+    let mut response = [0u8; 128];
+    app.send_to(payload, ("127.0.0.1", local_port))
+        .await
+        .unwrap();
+    let (len, _) = timeout(Duration::from_secs(5), app.recv_from(&mut response))
+        .await
+        .expect("application echo timed out")
+        .unwrap();
+    assert_eq!(&response[..len], payload);
+}
+
+#[tokio::test]
+async fn client_recovers_through_backoff_after_server_restart() {
+    let directory = tempdir().unwrap();
+    let backend = UdpSocket::bind("127.0.0.1:0").await.unwrap();
+    let backend_addr = backend.local_addr().unwrap();
+    let backend_task = tokio::spawn(async move {
+        let mut packet = vec![0u8; 2048];
+        while let Ok((len, peer)) = backend.recv_from(&mut packet).await {
+            let _ = backend.send_to(&packet[..len], peer).await;
+        }
+    });
+
+    let port = free_udp_port();
+    let local_port = free_udp_port();
+    let runtime_dir = directory.path().join("runtime");
+    let server_control = runtime_dir.join("server.sock");
+    let client_control = runtime_dir.join("client.sock");
+    let server_task = tokio::spawn(server::run_with_control_path(
+        server_config(port, backend_addr),
+        server_control.clone(),
+    ));
+    wait_for_contains(&server_control, "status", "transports=direct_udp").await;
+
+    let client_task = tokio::spawn(client::run_with_http3_connector_and_control_path(
+        client_config(port, local_port),
+        client_control.clone(),
+        None,
+    ));
+    wait_for_contains(&client_control, "status", "connected; server=127.0.0.1").await;
+    let app = UdpSocket::bind("127.0.0.1:0").await.unwrap();
+    wait_for_echo(&app, local_port, b"before-restart").await;
+
+    let stopped = control::send_command(&server_control, "shutdown")
+        .await
+        .unwrap();
+    assert!(stopped.contains("\"ok\":true"));
+    timeout(Duration::from_secs(5), server_task)
+        .await
+        .expect("first server instance should stop")
+        .unwrap()
+        .unwrap();
+
+    let requested = control::send_command(&client_control, "reconnect")
+        .await
+        .unwrap();
+    assert!(requested.contains("\"ok\":true"));
+    // Wait until the client has made a failed connection attempt and entered
+    // jittered backoff before starting the replacement server. This exercises
+    // the daemon loop without relying on a guessed sleep duration.
+    wait_for_contains(&client_control, "status", "error=").await;
+
+    let replacement = tokio::spawn(server::run_with_control_path(
+        server_config(port, backend_addr),
+        server_control.clone(),
+    ));
+    wait_for_contains(&server_control, "status", "transports=direct_udp").await;
+    let _stats = wait_for_reconnected_stats(&client_control).await;
+    wait_for_echo(&app, local_port, b"after-restart").await;
+
+    let stopped = control::send_command(&server_control, "shutdown")
+        .await
+        .unwrap();
+    assert!(stopped.contains("\"ok\":true"));
+    timeout(Duration::from_secs(5), replacement)
+        .await
+        .expect("replacement server should stop")
+        .unwrap()
+        .unwrap();
+    let stopped = control::send_command(&client_control, "shutdown")
+        .await
+        .unwrap();
+    assert!(stopped.contains("\"ok\":true"));
+    timeout(Duration::from_secs(5), client_task)
+        .await
+        .expect("client should stop")
+        .unwrap()
+        .unwrap();
+    backend_task.abort();
+}