ChatGPT Codex 5.5 xhigh refactored even more

crates/lanspread-peer/src/services/server.rs

@@ -0,0 +1,79 @@
+//! QUIC server accept loop.
+
+use std::{net::SocketAddr, time::Duration};
+
+use s2n_quic::{Connection, Server, provider::limits::Limits};
+use tokio::sync::mpsc::UnboundedSender;
+
+use crate::{
+    PeerEvent,
+    config::{CERT_PEM, KEY_PEM},
+    context::PeerCtx,
+    events,
+    services::{advertise::start_mdns_advertiser, stream::handle_peer_stream},
+};
+
+/// Runs the QUIC server and mDNS advertiser.
+pub async fn run_server_component(
+    addr: SocketAddr,
+    ctx: PeerCtx,
+    tx_notify_ui: UnboundedSender<PeerEvent>,
+) -> eyre::Result<()> {
+    let limits = Limits::default()
+        .with_max_handshake_duration(Duration::from_secs(3))?
+        .with_max_idle_timeout(Duration::from_secs(3))?;
+
+    let mut server = Server::builder()
+        .with_tls((CERT_PEM, KEY_PEM))?
+        .with_io(addr)?
+        .with_limits(limits)?
+        .start()?;
+
+    let server_addr = server.local_addr()?;
+    log::info!("Peer server listening on {server_addr}");
+
+    start_mdns_advertiser(&ctx, server_addr).await?;
+
+    while let Some(connection) = server.accept().await {
+        let ctx = ctx.clone();
+        let tx_notify_ui = tx_notify_ui.clone();
+
+        tokio::spawn(async move {
+            if let Err(err) = handle_peer_connection(connection, ctx, tx_notify_ui).await {
+                log::error!("Peer connection error: {err}");
+            }
+        });
+    }
+
+    Ok(())
+}
+
+async fn handle_peer_connection(
+    mut connection: Connection,
+    ctx: PeerCtx,
+    tx_notify_ui: UnboundedSender<PeerEvent>,
+) -> eyre::Result<()> {
+    let remote_addr = connection.remote_addr()?;
+    log::info!("{remote_addr} peer connected");
+    events::send(
+        &tx_notify_ui,
+        PeerEvent::PeerConnected(remote_addr),
+        "PeerConnected",
+    );
+
+    while let Ok(Some(stream)) = connection.accept_bidirectional_stream().await {
+        let ctx = ctx.clone();
+        tokio::spawn(async move {
+            if let Err(err) = handle_peer_stream(stream, ctx, Some(remote_addr)).await {
+                log::error!("{remote_addr:?} peer stream error: {err}");
+            }
+        });
+    }
+
+    events::send(
+        &tx_notify_ui,
+        PeerEvent::PeerDisconnected(remote_addr),
+        "PeerDisconnected",
+    );
+    Ok(())
+}