ChatGPT Codex 5.2 xhigh refactored > 45min

crates/lanspread-peer/src/network.rs

@@ -9,7 +9,16 @@ use bytes::BytesMut;
 use futures::{SinkExt, StreamExt};
 use if_addrs::{IfAddr, Interface, get_if_addrs};
 use lanspread_db::db::{Game, GameFileDescription};
-use lanspread_proto::{Message, Request, Response};
+use lanspread_proto::{
+    Hello,
+    HelloAck,
+    LibraryDelta,
+    LibrarySnapshot,
+    LibrarySummary,
+    Message,
+    Request,
+    Response,
+};
 use s2n_quic::{Client as QuicClient, Connection, client::Connect, provider::limits::Limits};
 use tokio_util::codec::{FramedRead, FramedWrite, LengthDelimitedCodec};
 
@@ -77,6 +86,43 @@ pub async fn ping_peer(peer_addr: SocketAddr) -> eyre::Result<bool> {
     Ok(is_alive)
 }
 
+/// Sends a single request without waiting for a response.
+pub async fn send_oneway_request(peer_addr: SocketAddr, request: Request) -> eyre::Result<()> {
+    let mut conn = connect_to_peer(peer_addr).await?;
+
+    let stream = conn.open_bidirectional_stream().await?;
+    let (_, tx) = stream.split();
+    let mut framed_tx = FramedWrite::new(tx, LengthDelimitedCodec::new());
+
+    framed_tx.send(request.encode()).await?;
+    let _ = framed_tx.close().await;
+    Ok(())
+}
+
+/// Performs a hello/ack handshake with a peer.
+pub async fn exchange_hello(peer_addr: SocketAddr, hello: Hello) -> eyre::Result<HelloAck> {
+    let mut conn = connect_to_peer(peer_addr).await?;
+
+    let stream = conn.open_bidirectional_stream().await?;
+    let (rx, tx) = stream.split();
+    let mut framed_rx = FramedRead::new(rx, LengthDelimitedCodec::new());
+    let mut framed_tx = FramedWrite::new(tx, LengthDelimitedCodec::new());
+
+    framed_tx.send(Request::Hello(hello).encode()).await?;
+    let _ = framed_tx.close().await;
+
+    let mut data = BytesMut::new();
+    while let Some(Ok(bytes)) = framed_rx.next().await {
+        data.extend_from_slice(&bytes);
+    }
+
+    let response = Response::decode(data.freeze());
+    match response {
+        Response::HelloAck(ack) => Ok(ack),
+        other => eyre::bail!("Unexpected response from peer {peer_addr}: {other:?}"),
+    }
+}
+
 /// Fetches the list of games from a peer.
 pub async fn fetch_games_from_peer(peer_addr: SocketAddr) -> eyre::Result<Vec<Game>> {
     let mut conn = connect_to_peer(peer_addr).await?;
@@ -107,19 +153,29 @@ pub async fn fetch_games_from_peer(peer_addr: SocketAddr) -> eyre::Result<Vec<Ga
 
 /// Announces local games to a peer.
 pub async fn announce_games_to_peer(peer_addr: SocketAddr, games: Vec<Game>) -> eyre::Result<()> {
-    let mut conn = connect_to_peer(peer_addr).await?;
+    send_oneway_request(peer_addr, Request::AnnounceGames(games)).await
+}
 
-    let stream = conn.open_bidirectional_stream().await?;
-    let (_, tx) = stream.split();
-    let mut framed_tx = FramedWrite::new(tx, LengthDelimitedCodec::new());
+pub async fn send_library_summary(
+    peer_addr: SocketAddr,
+    summary: LibrarySummary,
+) -> eyre::Result<()> {
+    send_oneway_request(peer_addr, Request::LibrarySummary(summary)).await
+}
 
-    // Send AnnounceGames request
-    framed_tx
-        .send(Request::AnnounceGames(games).encode())
-        .await?;
-    let _ = framed_tx.close().await;
+pub async fn send_library_snapshot(
+    peer_addr: SocketAddr,
+    snapshot: LibrarySnapshot,
+) -> eyre::Result<()> {
+    send_oneway_request(peer_addr, Request::LibrarySnapshot(snapshot)).await
+}
 
-    Ok(())
+pub async fn send_library_delta(peer_addr: SocketAddr, delta: LibraryDelta) -> eyre::Result<()> {
+    send_oneway_request(peer_addr, Request::LibraryDelta(delta)).await
+}
+
+pub async fn send_goodbye(peer_addr: SocketAddr, peer_id: String) -> eyre::Result<()> {
+    send_oneway_request(peer_addr, Request::Goodbye { peer_id }).await
 }
 
 /// Requests game file details from a peer.