From ffdcbf8d164eb347a2dc403b6144210a82060b26 Mon Sep 17 00:00:00 2001 From: ddidderr Date: Thu, 21 May 2026 20:46:36 +0200 Subject: [PATCH] feat(client): identify lifecycle leave events The relay now sends enough PeerJoined events for the client to learn the peers already in the room, but the client was still formatting PeerLeft with only the bare peer id. That made a gateway disconnect look the same as any other peer leaving. Keep a small in-memory peer map in the control-event logger. PeerJoined records or refreshes the peer identity, and PeerLeft removes it before formatting the message. Unknown leaves still use the generic fallback, so out-of-order or missed events remain understandable. Test Plan: - cargo fmt --check - cargo test -p lanparty-client-win formats_relay_lifecycle_events \ -- --nocapture - cargo test -p lanparty-client-win - cargo clippy -p lanparty-client-win --all-targets -- -D warnings - cargo test --workspace - cargo clippy --workspace --all-targets -- -D warnings - git diff --check Refs: PLAN.md --- README.md | 4 +- crates/lanparty-client-win/src/main.rs | 92 +++++++++++++++++++++----- 2 files changed, 80 insertions(+), 16 deletions(-) diff --git a/README.md b/README.md index 52203af..3b6a7d2 100644 --- a/README.md +++ b/README.md @@ -167,4 +167,6 @@ before bridging if the driver-reported MAC does not match the tunnel identity. It prints client diagnostics snapshots with relay reachability, route-pinning, QUIC datagram budget, TAP status/IP, frame/datagram counters, and drops. Relay lifecycle events are logged as they arrive, including gateway joins and -peer leaves. +peer leaves. The client remembers peer identities from join and catch-up events +so later leave logs can identify a disconnected LAN gateway or client MAC when +that peer was known. diff --git a/crates/lanparty-client-win/src/main.rs b/crates/lanparty-client-win/src/main.rs index 4b59279..efab30d 100644 --- a/crates/lanparty-client-win/src/main.rs +++ b/crates/lanparty-client-win/src/main.rs @@ -1,6 +1,6 @@ #[cfg(windows)] use std::net::IpAddr; -use std::{fs, net::SocketAddr, path::PathBuf}; +use std::{collections::BTreeMap, fs, net::SocketAddr, path::PathBuf}; #[cfg(windows)] use std::{ sync::{Arc, mpsc}, @@ -22,7 +22,7 @@ use lanparty_client_route::{ }; #[cfg(windows)] use lanparty_client_tap::TapAdapter; -use lanparty_ctrl::{ControlMessage, Role, RoomCode}; +use lanparty_ctrl::{ControlMessage, PeerInfo, Role, RoomCode}; use lanparty_obs::{ClientDiagnostics, RelayDiagnostics, TapDiagnostics}; use lanparty_proto::MacAddr; @@ -416,24 +416,73 @@ fn optional_label(value: Option) -> String { } async fn run_control_event_log(session: &ClientSession) -> Result<()> { + let mut formatter = ControlEventFormatter::default(); + loop { let event = session .recv_control_event() .await .context("failed to receive relay control event")?; - println!("{}", format_control_event(&event)); + println!("{}", formatter.format(&event)); } } +#[cfg(test)] fn format_control_event(event: &ControlMessage) -> String { - match event { - ControlMessage::PeerJoined(peer) if peer.role() == Role::Gateway => { + ControlEventFormatter::default().format(event) +} + +#[derive(Debug, Default)] +struct ControlEventFormatter { + peers: BTreeMap, +} + +impl ControlEventFormatter { + fn format(&mut self, event: &ControlMessage) -> String { + match event { + ControlMessage::PeerJoined(peer) => { + self.peers.insert(peer.peer_id(), peer.clone()); + format_peer_joined(peer) + } + ControlMessage::PeerLeft { peer_id, reason } => { + let Some(peer) = self.peers.remove(peer_id) else { + return format!("relay event: peer {peer_id} left ({reason:?})"); + }; + + match peer.role() { + Role::Gateway => { + format!( + "relay event: LAN gateway disconnected (peer {}, {reason:?})", + peer.peer_id() + ) + } + Role::Client => { + let mac = peer + .mac() + .map(|mac| mac.to_string()) + .unwrap_or_else(|| "unknown".to_string()); + format!( + "relay event: client peer {} with MAC {} left ({reason:?})", + peer.peer_id(), + mac + ) + } + } + } + _ => format!("relay event: {event:?}"), + } + } +} + +fn format_peer_joined(peer: &PeerInfo) -> String { + match peer.role() { + Role::Gateway => { format!( "relay event: LAN gateway connected as peer {}", peer.peer_id() ) } - ControlMessage::PeerJoined(peer) => { + Role::Client => { let mac = peer .mac() .map(|mac| mac.to_string()) @@ -444,10 +493,6 @@ fn format_control_event(event: &ControlMessage) -> String { mac ) } - ControlMessage::PeerLeft { peer_id, reason } => { - format!("relay event: peer {peer_id} left ({reason:?})") - } - _ => format!("relay event: {event:?}"), } } @@ -735,22 +780,39 @@ mod tests { let gateway = ControlMessage::PeerJoined(PeerInfo::new(1, Role::Gateway, None).unwrap()); let client = ControlMessage::PeerJoined(PeerInfo::new(2, Role::Client, Some(mac(2))).unwrap()); - let left = ControlMessage::PeerLeft { + let unknown_left = ControlMessage::PeerLeft { + peer_id: 3, + reason: DisconnectReason::Normal, + }; + let client_left = ControlMessage::PeerLeft { peer_id: 2, reason: DisconnectReason::Normal, }; + let gateway_left = ControlMessage::PeerLeft { + peer_id: 1, + reason: DisconnectReason::Normal, + }; + let mut formatter = ControlEventFormatter::default(); assert_eq!( - format_control_event(&gateway), + formatter.format(&gateway), "relay event: LAN gateway connected as peer 1" ); assert_eq!( - format_control_event(&client), + formatter.format(&client), "relay event: client peer 2 joined with MAC 02:00:00:00:00:02" ); assert_eq!( - format_control_event(&left), - "relay event: peer 2 left (Normal)" + format_control_event(&unknown_left), + "relay event: peer 3 left (Normal)" + ); + assert_eq!( + formatter.format(&client_left), + "relay event: client peer 2 with MAC 02:00:00:00:00:02 left (Normal)" + ); + assert_eq!( + formatter.format(&gateway_left), + "relay event: LAN gateway disconnected (peer 1, Normal)" ); }