Signaling: keep heartbeat detection alive when delivery stalls (#104)

* Signaling: keep heartbeat detection alive when delivery stalls

The receive loop awaited event_sender.send() without a bound. When the main loop was parked in PeerConnection::close after a released peer, the 64-slot event queue filled and the receiver blocked inside the loop body, so the Engine.IO deadline in the same select! never ran. The host stayed online with a half-closed socket for hours.

- add a watchdog over the last inbound frame, independent of the receive loop
- bound event, pong and control sends with a timeout or try_send
- timeout PeerConnection::close so one dead peer cannot stall signaling
- regression test with a blocked event consumer

Co-Authored-By: Claude Code <[email protected]>

* Signaling: always report Disconnected when the receiver stops

The receive loop can break without enqueueing Disconnected: event delivery exceeded SEND_STALL_TIMEOUT, or the writer already stopped. receiver_done then lets the watchdog exit, while the main loop's rx_event stays open because the idle-renewal timer holds a sender. The host stays in a dead room until the 15-minute renewal, which is deferred while a peer is connected.

Hand a Disconnected off from a detached task after every loop exit. Duplicates are harmless: the main loop breaks on the first one and drops the old receiver.

The new test keeps the consumer blocked past SEND_STALL_TIMEOUT, then drains the queue and expects Disconnected.

Co-Authored-By: Claude Code <[email protected]>

---------

Co-authored-by: Claude Code <[email protected]>
This commit is contained in:
Mr. ErrorandClaude Code authored and GitHub committed 2026-10-24 16:38:43 +08:00
1 parent df9429495f
commit bcde9f967c
2 files changed
+179 -44

No files matched your search

+15 -7
View File
@@ -73,6 +73,14 @@ fn superseded_peer_ids(sessions: &HashMap<String, WebRtcSession>, ice: &str, des
sessions.iter().filter(|(id, peer)| id.as_str() == ice || (desktop && peer.desktop))
.map(|(id, _)| id.clone()).collect()
}
/// A peer whose transport is already broken can leave `PeerConnection::close`
/// waiting indefinitely; signaling must keep flowing without it.
async fn close_peer(pc: &::webrtc::peer_connection::RTCPeerConnection) {
if tokio::time::timeout(std::time::Duration::from_secs(5), pc.close()).await.is_err() {
log::warn!("Peer connection close timed out; continuing");
}
}
fn released_peer_ids<T>(sessions: &HashMap<String, T>, ice: Option<&serde_json::Value>) -> Vec<String> {
let ice = ice.map(|id| id.as_str().map(str::to_owned).unwrap_or_else(|| id.to_string()));
sessions.keys().filter(|id| ice.as_deref().map_or(true, |ice| id.as_str() == ice)).cloned().collect()
@@ -685,7 +693,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
if let Some(task) = command_task { task.abort(); }
// One exit path for commands, signals, transport failures and UI failures.
if let Some(session) = assist.as_mut() { session.allowed = false; }
for (_, old) in webrtc_sessions.lock().await.drain() { let _ = old.pc.close().await; }
for (_, old) in webrtc_sessions.lock().await.drain() { close_peer(&old.pc).await; }
virtual_audio::disable(); input.shutdown(); terminal::shutdown_all();
// Switching identity (signed in / out) restarts at once and the new identity republishes the same
// device share: logout already withdrew it, and after a QR login the cloud moved it to the account
@@ -858,7 +866,7 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Closed |
::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Failed)).map(|(id, _)| id.clone()).collect();
let mut desktop_ended = false;
for id in ended { if let Some(s) = sessions.remove(&id) { desktop_ended |= s.role.is_desktop(); let _ = s.pc.close().await; } }
for id in ended { if let Some(s) = sessions.remove(&id) { desktop_ended |= s.role.is_desktop(); close_peer(&s.pc).await; } }
if desktop_ended && !sessions.values().any(|s| s.role.is_desktop()) { if let Some(s) = assist.as_mut() { s.session_ended()?; } }
if let Some(s) = assist.as_mut() { s.tick()?; }
}
@@ -946,7 +954,7 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Closed |
::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Failed)).map(|(k, _)| k.clone()).collect();
let mut desktop_ended = false;
for k in ended { if let Some(old) = sessions.remove(&k) { desktop_ended |= old.role.is_desktop(); let _ = old.pc.close().await; } }
for k in ended { if let Some(old) = sessions.remove(&k) { desktop_ended |= old.role.is_desktop(); close_peer(&old.pc).await; } }
if desktop_ended && !sessions.values().any(|s| s.role.is_desktop()) { if let Some(s) = assist.as_mut() { s.session_ended()?; } }
if let Some(s) = assist.as_mut() { s.tick()?; }
@@ -961,7 +969,7 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
if desktop { video::warm_auto_probe(); video::check_ffmpeg_usable(); }
// Replace only this ICE id or a previous desktop, never tool peers.
for id in superseded_peer_ids(&sessions, &ice, desktop) {
if let Some(old) = sessions.remove(&id) { let _ = old.pc.close().await; }
if let Some(old) = sessions.remove(&id) { close_peer(&old.pc).await; }
}
// A tool peer promoted by capture_desktop stops its desktop but keeps its tools.
if desktop { for old in sessions.values() { old.demote(); } }
@@ -1014,7 +1022,7 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
}
Err(_) => {
log::error!("Failed to handle offer (details omitted)");
if let Some(session) = sessions.remove(&ice) { let _ = session.pc.close().await; }
if let Some(session) = sessions.remove(&ice) { close_peer(&session.pc).await; }
}
}},
Err(_) => log::error!("Create peer failed (details omitted)"),
@@ -1037,7 +1045,7 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
for k in targets {
if let Some(old) = sessions.remove(&k) {
desktop_ended |= old.role.is_desktop();
if let Err(e) = old.pc.close().await { log::warn!("Close released peer failed: {}", e); }
close_peer(&old.pc).await;
}
}
if desktop_ended && !sessions.values().any(|s| s.role.is_desktop()) { if let Some(s) = assist.as_mut() { s.session_ended()?; } }
@@ -1075,7 +1083,7 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
let superseded: Vec<String> = sessions.iter().filter(|(id, old)| id.as_str() != ice && old.role.is_desktop())
.map(|(id, _)| id.clone()).collect();
for id in superseded {
if sessions[&id].desktop { if let Some(old) = sessions.remove(&id) { let _ = old.pc.close().await; } }
if sessions[&id].desktop { if let Some(old) = sessions.remove(&id) { close_peer(&old.pc).await; } }
else { sessions[&id].demote(); }
}
if let Some(peer) = sessions.get(&ice) { peer.promote(screen); }
+164 -37
View File
@@ -3,12 +3,20 @@
use futures_util::{SinkExt, StreamExt};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::Arc;
use std::time::{Duration, Instant};
use tokio::sync::mpsc;
use tokio_tungstenite::connect_async;
use tokio_tungstenite::tungstenite::client::IntoClientRequest;
use tokio_tungstenite::tungstenite::Message;
/// A peer that stops reading must not park the heartbeat loop on a full queue.
/// Kept below the Engine.IO window so the protocol deadline still fires.
const SEND_STALL_TIMEOUT: Duration = Duration::from_secs(10);
/// How often the watchdog checks the last inbound frame.
const WATCHDOG_TICK: Duration = Duration::from_secs(1);
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SoacMessage {
#[serde(rename = "type")]
@@ -70,6 +78,11 @@ fn refreshed_key(ack:&Value)->Option<String> {
(!key.is_empty() && key.len()<=16384).then(||key.to_owned())
}
/// Deliver an event without letting a stalled consumer hide a dead socket.
async fn send_event(sender: &mpsc::Sender<SignalingEvent>, event: SignalingEvent) -> bool {
matches!(tokio::time::timeout(SEND_STALL_TIMEOUT, sender.send(event)).await, Ok(Ok(())))
}
#[cfg(test)]
mod refresh_tests {
use super::refreshed_key;
@@ -128,6 +141,73 @@ mod refresh_tests {
assert!(disconnected.is_ok(),"a socket without pings must be reported dead");
drop(hold_tx);
}
#[tokio::test]
async fn blocked_event_consumer_does_not_hide_a_dead_socket() {
use futures_util::{SinkExt,StreamExt};
use tokio_tungstenite::tungstenite::Message;
let listener=tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let address=listener.local_addr().unwrap();
let (closed_tx,closed_rx)=tokio::sync::oneshot::channel::<()>();
tokio::spawn(async move {
let (tcp,_)=listener.accept().await.unwrap();
let socket=tokio_tungstenite::accept_async(tcp).await.unwrap();
let (mut sink,mut stream)=socket.split();
// Shortest accepted window (clamped to 5 s); never ping, only events.
sink.send(Message::Text(r#"0{"pingInterval":1000,"pingTimeout":1000}"#.into())).await.unwrap();
let _=stream.next().await;
sink.send(Message::Text("40{}".into())).await.unwrap();
loop {
tokio::select! {
r=stream.next()=>match r {
None|Some(Err(_))|Some(Ok(Message::Close(_)))=>{let _=closed_tx.send(());return;}
_=>{}
},
_=tokio::time::sleep(std::time::Duration::from_millis(50))=>{
if sink.send(Message::Text(r#"42["bmsg_push",{}]"#.into())).await.is_err() {
let _=closed_tx.send(());return;
}
}
}
}
});
// Capacity 1 and no reader: the first event fills the queue, so the
// receive loop would park inside `send().await` without the watchdog.
let (sender,_events)=tokio::sync::mpsc::channel(1);
let _client=super::SignalingClient::connect(&format!("ws://{address}"),"synthetic-only",sender).await.unwrap();
let closed=tokio::time::timeout(std::time::Duration::from_secs(15),closed_rx).await;
assert!(closed.is_ok(),"a blocked consumer must not keep a dead signaling socket open");
}
#[tokio::test]
async fn stalled_event_delivery_still_reports_disconnected() {
use futures_util::{SinkExt,StreamExt};
use tokio_tungstenite::tungstenite::Message;
let listener=tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let address=listener.local_addr().unwrap();
tokio::spawn(async move {
let (tcp,_)=listener.accept().await.unwrap();
let socket=tokio_tungstenite::accept_async(tcp).await.unwrap();
let (mut sink,mut stream)=socket.split();
// A long window: the send stall must fire before the heartbeat deadline.
sink.send(Message::Text(r#"0{"pingInterval":30000,"pingTimeout":30000}"#.into())).await.unwrap();
let _=stream.next().await;
sink.send(Message::Text("40{}".into())).await.unwrap();
loop {
tokio::select! {
r=stream.next()=>{ if matches!(r,None|Some(Err(_))|Some(Ok(Message::Close(_)))){return} }
_=tokio::time::sleep(std::time::Duration::from_millis(50))=>{
if sink.send(Message::Text(r#"42["bmsg_push",{}]"#.into())).await.is_err(){return}
}
}
}
});
let (sender,mut events)=tokio::sync::mpsc::channel(1);
let _client=super::SignalingClient::connect(&format!("ws://{address}"),"synthetic-only",sender).await.unwrap();
// Let SEND_STALL_TIMEOUT expire while nothing drains the queue.
tokio::time::sleep(std::time::Duration::from_secs(12)).await;
assert!(matches!(events.recv().await,Some(super::SignalingEvent::Connected)));
let disconnected=tokio::time::timeout(std::time::Duration::from_secs(5),events.recv()).await;
assert!(matches!(disconnected,Ok(Some(super::SignalingEvent::Disconnected))),"a stalled delivery must still report Disconnected");
}
}
impl SignalingClient {
@@ -158,17 +238,25 @@ impl SignalingClient {
log::info!("Connected to Engine.IO / Socket.IO");
let (mut write, mut read) = ws_stream.split();
let (tx_outgoing, mut rx_outgoing) = mpsc::channel::<String>(32);
let started = Instant::now();
let last_rx = Arc::new(AtomicU64::new(0));
let ping_window_ms = Arc::new(AtomicU64::new(45_000));
let receiver_done = Arc::new(AtomicBool::new(false));
// 发送协程
let writer=tokio::spawn(async move {
while let Some(msg) = rx_outgoing.recv().await {
if let Err(e) = write.send(Message::Text(msg)).await {
let _ = e;
log::warn!("WS send failed (details omitted)");
break;
match tokio::time::timeout(SEND_STALL_TIMEOUT, write.send(Message::Text(msg))).await {
Ok(Ok(())) => {}
Ok(Err(_)) | Err(_) => {
// A peer that stopped reading must not park every producer.
log::warn!("WS send failed or stalled (details omitted)");
break;
}
}
}
});
let writer_abort = writer.abort_handle();
let tx_out_clone = tx_outgoing.clone();
static GENERATION: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
@@ -177,9 +265,12 @@ impl SignalingClient {
let refreshed=reconnect_key.clone();
// 接收与状态机协程
tokio::spawn(async move {
let watchdog_events = event_sender.clone();
let watchdog_last_rx = last_rx.clone();
let watchdog_ping_window_ms = ping_window_ms.clone();
let watchdog_done = receiver_done.clone();
let receiver = tokio::spawn(async move {
let mut req_counter = 10;
let started=std::time::Instant::now();
let mut last_ping=started;
let mut pings=0u64;
let mut pong_queued=0u64;
@@ -202,7 +293,7 @@ impl SignalingClient {
_=event_sender.closed()=>break,
_=tokio::time::sleep_until(ping_deadline) => {
log::warn!("Signaling heartbeat lost: generation={} age_s={} pings={} last_ping_gap_s={}",generation,started.elapsed().as_secs(),pings,last_ping.elapsed().as_secs());
let _ = event_sender.send(SignalingEvent::Disconnected).await;
let _ = send_event(&event_sender, SignalingEvent::Disconnected).await;
break;
},
// Official ControlledSession RefreshSignalTokenLoop: first
@@ -213,8 +304,8 @@ impl SignalingClient {
refresh_acks.push_back(req_counter);
if refresh_acks.len()>16 { refresh_acks.pop_front(); }
let packet=format!("42{}[\"refresh_reconnect_key\"]",req_counter);
if tx_out_clone.send(packet).await.is_err() {
let _=event_sender.send(SignalingEvent::Disconnected).await;break;
if tx_out_clone.try_send(packet).is_err() {
let _=send_event(&event_sender, SignalingEvent::Disconnected).await;break;
}
next_refresh=tokio::time::Instant::now()+std::time::Duration::from_secs(30);
log::info!("Signaling reconnect-key refresh requested: generation={} age_s={}",generation,started.elapsed().as_secs());
@@ -222,9 +313,14 @@ impl SignalingClient {
},
msg=read.next()=>match msg {
Some(msg)=>msg,
None=>{let _=event_sender.send(SignalingEvent::Disconnected).await;break;}
None=>{let _=send_event(&event_sender, SignalingEvent::Disconnected).await;break;}
},
};
// Any inbound frame proves the socket is alive. A reader parked on
// event delivery stops updating this, which the watchdog catches.
if msg_res.is_ok() {
last_rx.store(started.elapsed().as_millis() as u64, Ordering::Relaxed);
}
match msg_res {
Ok(Message::Text(txt)) => {
// Engine.IO 报文处理
@@ -233,16 +329,20 @@ impl SignalingClient {
log::info!("Signaling heartbeat config: generation={} ping_interval_ms={:?} ping_timeout_ms={:?}",generation,open.get("pingInterval").and_then(Value::as_u64),open.get("pingTimeout").and_then(Value::as_u64));
if let (Some(interval),Some(timeout))=(open.get("pingInterval").and_then(Value::as_u64),open.get("pingTimeout").and_then(Value::as_u64)) {
ping_window=std::time::Duration::from_millis(interval.saturating_add(timeout).clamp(5_000,300_000));
ping_window_ms.store(ping_window.as_millis() as u64, Ordering::Relaxed);
ping_deadline=tokio::time::Instant::now()+ping_window;
}
}
// Open packet -> 发送 Socket.IO connect
let _ = tx_out_clone.send("40".into()).await;
if tx_out_clone.try_send("40".into()).is_err() {
let _=send_event(&event_sender, SignalingEvent::Disconnected).await;break;
}
} else if txt == "2" {
// Ping -> 回复 Pong
let gap=last_ping.elapsed().as_secs();last_ping=std::time::Instant::now();pings+=1;
ping_deadline=tokio::time::Instant::now()+ping_window;
if tx_out_clone.send("3".into()).await.is_ok() { pong_queued+=1; }
if tx_out_clone.try_send("3".into()).is_ok() { pong_queued+=1; }
else { let _=send_event(&event_sender, SignalingEvent::Disconnected).await;break; }
if pings==1 || pings%12==0 {
log::info!("Signaling heartbeat progress: generation={} age_s={} pings={} pong_queued={} gap_s={}",generation,started.elapsed().as_secs(),pings,pong_queued,gap);
}
@@ -252,8 +352,10 @@ impl SignalingClient {
// Socket.IO connected -> 发送 room_info 请求
req_counter += 1;
let room_req = format!("42{}[\"room_info\"]", req_counter);
let _ = tx_out_clone.send(room_req).await;
let _ = event_sender.send(SignalingEvent::Connected).await;
if tx_out_clone.try_send(room_req).is_err() {
let _=send_event(&event_sender, SignalingEvent::Disconnected).await;break;
}
if !send_event(&event_sender, SignalingEvent::Connected).await { break; }
} else if txt.starts_with("43") {
// Socket.IO ack 回调
let begin=txt.find('[').unwrap_or(2);
@@ -272,7 +374,7 @@ impl SignalingClient {
next_refresh=tokio::time::Instant::now()+std::time::Duration::from_secs(300);
}
log::info!("Signaling reconnect-key refresh acknowledged: generation={} age_s={} success={}",generation,started.elapsed().as_secs(),success);
} else { let _ = event_sender.send(SignalingEvent::RoomInfoAck(v)).await; }
} else if !send_event(&event_sender, SignalingEvent::RoomInfoAck(v)).await { break; }
}
} else if txt.starts_with("45") || txt.starts_with("46") {
// Socket.IO binary event/ack: header text, attachments follow as binary frames.
@@ -296,14 +398,10 @@ impl SignalingClient {
match event_name {
"bmsg_push" => {
let _ = event_sender
.send(SignalingEvent::DeviceInfoChanged(data.clone()))
.await;
if !send_event(&event_sender, SignalingEvent::DeviceInfoChanged(data.clone())).await { break; }
}
"be-controlled" => {
let _ = event_sender
.send(SignalingEvent::BeControlled(data.clone()))
.await;
if !send_event(&event_sender, SignalingEvent::BeControlled(data.clone())).await { break; }
}
"soac" => {
// Offers only: structure (keys, types, lengths), never SDP text or ids.
@@ -326,9 +424,7 @@ impl SignalingClient {
if soac.client_id.is_none() {
soac.client_id = client_id_opt;
}
let _ = event_sender
.send(SignalingEvent::Soac(soac))
.await;
if !send_event(&event_sender, SignalingEvent::Soac(soac)).await { break; }
}
Err(e) => {
let _ = e;
@@ -338,20 +434,16 @@ impl SignalingClient {
}
"released" => {
log::info!("Cloud peer event: generation={} event=released age_s={} pings={} last_ping_gap_s={} ice_id_present={}",generation,started.elapsed().as_secs(),pings,last_ping.elapsed().as_secs(),data.get("ice_id").is_some());
let _ = event_sender
.send(SignalingEvent::Released(data.clone()))
.await;
if !send_event(&event_sender, SignalingEvent::Released(data.clone())).await { break; }
}
"left" | "leave" => {
log::info!("Cloud peer event: generation={} event={} age_s={} pings={} last_ping_gap_s={} ice_id_present={}",generation,event_name,started.elapsed().as_secs(),pings,last_ping.elapsed().as_secs(),data.get("ice_id").is_some());
let ice_id = data.get("ice_id").and_then(|v| v.as_str()).unwrap_or("");
if ice_id.is_empty() {
log::warn!("Cloud room leave without peer identifier; renewing signaling (expiry cause unknown)");
let _ = event_sender.send(SignalingEvent::Disconnected).await;
if !send_event(&event_sender, SignalingEvent::Disconnected).await { break; }
} else {
let _ = event_sender
.send(SignalingEvent::Left(data.clone()))
.await;
if !send_event(&event_sender, SignalingEvent::Left(data.clone())).await { break; }
}
}
_ => {
@@ -401,28 +493,60 @@ impl SignalingClient {
let controller_mac = platform.is_some_and(|v| v.as_i64() == Some(4)
|| v.as_str().is_some_and(|s| s == "4" || s.to_ascii_lowercase().contains("mac") || s.to_ascii_lowercase().contains("darwin")));
log::info!("Controller platform: {} mac={}", platform.map(|v| v.to_string()).unwrap_or_default().chars().take(24).collect::<String>(), controller_mac);
let _ = event_sender.send(SignalingEvent::ConnectRequest { capture_type, ice_id, transport:crate::session_ice::SessionIce::from_header(&header), controller_mac }).await;
if !send_event(&event_sender, SignalingEvent::ConnectRequest { capture_type, ice_id, transport:crate::session_ice::SessionIce::from_header(&header), controller_mac }).await { break; }
}
}
}
Ok(Message::Close(frame)) => {
log::warn!("Signaling socket closed: generation={} age_s={} close_code={:?} pings={} last_ping_gap_s={}",generation,started.elapsed().as_secs(),frame.map(|f|u16::from(f.code)),pings,last_ping.elapsed().as_secs());
let _ = event_sender.send(SignalingEvent::Disconnected).await;
let _ = send_event(&event_sender, SignalingEvent::Disconnected).await;
break;
}
Err(_) => {
log::warn!("Signaling socket receive failed: generation={} age_s={} pings={} last_ping_gap_s={}",generation,started.elapsed().as_secs(),pings,last_ping.elapsed().as_secs());
let _ = event_sender.send(SignalingEvent::Disconnected).await;
let _ = send_event(&event_sender, SignalingEvent::Disconnected).await;
break;
}
_ => {}
}
}
// A stalled event queue or a writer that already stopped can end this
// loop without a delivered Disconnected. Hand one off from a detached
// task so the main loop always learns the room is dead; duplicates are
// harmless because it breaks on the first one.
let events = event_sender.clone();
tokio::spawn(async move { let _ = events.send(SignalingEvent::Disconnected).await; });
receiver_done.store(true, Ordering::Relaxed);
log::info!("Signaling receiver stopped: generation={} age_s={}",generation,started.elapsed().as_secs());
// Live peer callbacks can retain the old SignalingClient sender.
// Explicitly drop its write half too when this room stops reading.
writer.abort();
});
let receiver_abort = receiver.abort_handle();
// Independent of the receive loop: a consumer that stops draining events
// parks the loop inside an `.await`, where the ping deadline can no longer
// be observed. The watchdog closes the socket anyway.
tokio::spawn(async move {
let mut tick = tokio::time::interval(WATCHDOG_TICK);
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
loop {
tick.tick().await;
if watchdog_done.load(Ordering::Relaxed) || watchdog_events.is_closed() { return; }
let window_ms = watchdog_ping_window_ms.load(Ordering::Relaxed);
let idle_ms = (started.elapsed().as_millis() as u64)
.saturating_sub(watchdog_last_rx.load(Ordering::Relaxed));
if idle_ms <= window_ms { continue; }
log::warn!("Signaling heartbeat lost (watchdog): idle_s={} window_ms={}", idle_ms/1000, window_ms);
// Deliver from a detached task: the receiver may be the one parked
// on a full queue, and the main loop still needs this event.
let events = watchdog_events.clone();
tokio::spawn(async move { let _ = events.send(SignalingEvent::Disconnected).await; });
receiver_abort.abort();
writer_abort.abort();
return;
}
});
Ok(Self { tx_outgoing, _reconnect_key:reconnect_key })
}
@@ -430,7 +554,10 @@ impl SignalingClient {
pub async fn emit_event(&self, event: &str, payload: serde_json::Value) -> Result<(), String> {
let packet = format!("42{}", serde_json::json!([event, payload]));
log::info!("Emitting signaling event: {}", event);
self.tx_outgoing.send(packet).await.map_err(|e| e.to_string())
tokio::time::timeout(SEND_STALL_TIMEOUT, self.tx_outgoing.send(packet))
.await
.map_err(|_| "signaling send stalled".to_string())?
.map_err(|e| e.to_string())
}
/// 发送 SOAC 消息(Answer 或 Candidate)
@@ -445,9 +572,9 @@ impl SignalingClient {
};
let msg = format!("42[\"soac\",{}]", payload);
log::info!("Emitting soac packet: type={}", soac.msg_type);
self.tx_outgoing
.send(msg)
tokio::time::timeout(SEND_STALL_TIMEOUT, self.tx_outgoing.send(msg))
.await
.map_err(|_| "Send soac timed out".to_string())?
.map_err(|e| format!("Send soac error: {}", e))
}
}