Reconnect SRS after disconnect

crates/guardian_core/src/dcs/mission.rs

@@ -56,6 +56,7 @@ fn connect_to_grpc(mut commands: Commands, tokio: Res<TokioResource>, url: Res<G
                 tokio::time::sleep(Duration::from_secs(5)).await;
                 continue;
             };
+            println!("Connected to DCS: {}", url);
 
             let Ok(mut stream) = client
                 .stream_units(StreamUnitsRequest {
@@ -86,10 +87,8 @@ fn connect_to_grpc(mut commands: Commands, tokio: Res<TokioResource>, url: Res<G
                 }
             }
 
-            eprintln!("Disconnected");
+            eprintln!("Disconnected from DCS: {}", url);
             tx.send(Response::Disconnected).ok();
-
-            tokio::time::sleep(Duration::from_secs(5)).await;
         }
     });
 

crates/guardian_core/src/srs.rs

@@ -164,8 +164,12 @@ fn listen_srs(
         let voice = radio.voice;
         let stt_url = stt_url.as_str().to_string();
         radio.handle = Some(tokio.0.spawn(async move {
-            // todo: add loop here to reconnect on disconnect/errors
-            let tcp = TcpStream::connect(addr).await?;
+            loop {
+                let Ok(tcp) = TcpStream::connect(addr).await else {
+                    eprintln!("Connection failed: {}", addr);
+                    sleep(Duration::from_secs(5)).await;
+                    continue;
+                };
 
                 let (tcp_stream, tcp_sink) = tcp.into_split();
                 let mut messages_sink = FramedWrite::new(tcp_sink, MessagesCodec::new());
@@ -179,13 +183,15 @@ fn listen_srs(
 
                 let mut packet_id = 1;
 
-            messages_sink
-                .send(MessageRequest::Sync(SyncMessageRequest {
+                if let Err(e) = messages_sink.send(MessageRequest::Sync(SyncMessageRequest {
                     msg_type: MsgType,
-                    client,
+                    client: client.clone(),
                     version: SRS_VERSION.to_string(),
-                }))
-                .await?;
+                })).await {
+                    eprintln!("Srs error: {:?}", e);
+                    sleep(Duration::from_secs(5)).await;
+                    continue;
+                };
 
                 let transmissions = Arc::new(RwLock::new(HashMap::<u32, Vec<VoicePacket>>::new()));
 
@@ -231,10 +237,13 @@ fn listen_srs(
                             }
                         }
                         Some(data) = message_handle.recv() => {
-                        messages_sink.send(data).await?;
+                            if messages_sink.send(data).await.is_err() {
+                                break;
+                            };
                         }
-                    Some(Ok(data)) = messages_stream.next() => {
-
+                        Some(data) = messages_stream.next() => {
+                            match data {
+                                Ok(data) => {
                                     match &data {
                                         Message::VersionMismatch(VersionMismatchMessage { version, .. }) => {
                                             eprintln!("Version mismatch {} != {}", SRS_VERSION, version);
@@ -250,10 +259,17 @@ fn listen_srs(
                                         _ => {},
                                     }
                                 }
+                                Err(_) => {
+                                    break;
+                                }
+                            }
+                        }
                         Some(data) = voice_handle.recv() => {
                             frames.push(synthesize(data.as_str(), &voice).await?).await;
                         }
-                    Some(Ok(data)) = voice_stream.next() => {
+                        Some(data) = voice_stream.next() => {
+                            match data {
+                                Ok(data) => {
                                     // Collect voice packets
                                     let (data, _) = data;
 
@@ -267,6 +283,11 @@ fn listen_srs(
                                         let t1 = t.get_mut(&unit_id).unwrap();
                                         t1.push(data);
                                     }
+                                },
+                                Err(_) => {
+                                    break;
+                                }
+                            }
                         }
                         _ = tokio::time::sleep(Duration::from_millis(200)) => {
                             // Process voice packets
@@ -297,10 +318,14 @@ fn listen_srs(
                             transmissions.clear();
                         }
                         _ = voice_ping_interval.tick() => {
-                        voice_sink.send((voice_codec::Packet::Ping(sguid), addr)).await?;
+                            if voice_sink.send((voice_codec::Packet::Ping(sguid), addr)).await.is_err() {
+                                break;
+                            };
                         }
                     };
                 }
+                eprintln!("Disconnected from SRS: {}", addr);
+            }
             #[allow(unreachable_code)]
             Ok(())
         }));