feat(radar-client): automatically reconnect to the server on connection failure

Author: WolverinDEV

radar/client-standalone/Cargo.toml

@@ -13,7 +13,7 @@ log = { workspace = true }
 obfstr.workspace = true
 radar-client = { path = "../client" }
 radar-shared = { path = "../shared" }
-tokio = { version = "1.34.0", features = ["io-util", "rt-multi-thread", "net"] }
+tokio = { version = "1.34.0", features = ["io-util", "rt-multi-thread", "net", "signal"] }
 url = "2.5.0"
 utils-state = { path = "../../utils/state" }
 

radar/client-standalone/src/main.rs

@@ -1,4 +1,7 @@
-use std::path::PathBuf;
+use std::{
+    path::PathBuf,
+    time::Duration,
+};
 
 use anyhow::Context;
 use clap::Parser;
@@ -11,8 +14,11 @@ use cs2::{
 use obfstr::obfstr;
 use radar_client::{
     CS2RadarGenerator,
+    DummyRadarGenerator,
+    RadarGenerator,
     WebRadarPublisher,
 };
+use tokio::signal;
 use url::Url;
 use utils_state::StateRegistry;
 
@@ -31,6 +37,11 @@ struct Args {
     /// instead of resolving them at runtime by the CS2 schema system.
     #[arg(short, long)]
     schema_file: Option<PathBuf>,
+
+    /// Use a dummy generator instead of generating the radar data from CS2.
+    /// This is usefull when testing the radar client without CS2.
+    #[arg(long, hide = true)]
+    dummy_generator: bool,
 }
 
 #[tokio::main]
@@ -49,10 +60,20 @@ async fn main() -> anyhow::Result<()> {
     Ok(())
 }
 
+const RECONNECT_INTERVAL: &[Duration] = &[
+    Duration::from_secs(1),
+    Duration::from_secs(5),
+    Duration::from_secs(10),
+    Duration::from_secs(30),
+    Duration::from_secs(60),
+];
+
 async fn real_main(args: &Args) -> anyhow::Result<()> {
     let url = Url::parse(&args.publish_url).context("invalid target server address")?;
 
-    let radar_generator = {
+    let radar_generator: Box<dyn RadarGenerator> = if args.dummy_generator {
+        Box::new(DummyRadarGenerator)
+    } else {
         let cs2 = match CS2Handle::create(true) {
             Ok(cs2) => cs2,
             Err(err) => {
@@ -93,7 +114,16 @@ async fn real_main(args: &Args) -> anyhow::Result<()> {
 
         Box::new(CS2RadarGenerator::new(states)?)
     };
-    let radar_client = WebRadarPublisher::connect(radar_generator, &url).await?;
+
+    self::radar_publish_loop(radar_generator, &url).await
+}
+
+async fn radar_publish_loop(
+    radar_generator: Box<dyn RadarGenerator>,
+    url: &Url,
+) -> anyhow::Result<()> {
+    let mut radar_client = WebRadarPublisher::connect(&url, None).await?;
+    radar_client.set_generator(radar_generator);
 
     let mut radar_url = url.clone();
     radar_url.set_path(&format!("/session/{}", radar_client.session_id));
@@ -105,7 +135,56 @@ async fn real_main(args: &Args) -> anyhow::Result<()> {
 
     log::info!("Radar session {}", radar_client.session_id);
     log::info!("Available at {}", radar_url);
+    log::info!("Press CTRL+C to exit");
+
+    loop {
+        tokio::select! {
+            result = radar_client.execute() => {
+                match result {
+                    Ok(_) => break,
+                    Err(error) => {
+                        log::error!("{:#}", error);
+                    }
+                }
+            },
+            _ = signal::ctrl_c() => {
+                log::info!("Stopping radar...");
+                break;
+            }
+        }
+
+        let radar_generator = radar_client.take_generator().context("missing generator")?;
+        let session_auth_token = radar_client.session_auth_token.clone();
+
+        /* ensure to close the connection in order to reconnect */
+        drop(radar_client);
+
+        let mut reconnect_index = 0;
+        radar_client = loop {
+            log::info!("Reconnecting...");
+            match WebRadarPublisher::connect(&url, Some(session_auth_token.clone())).await {
+                Ok(publisher) => break publisher,
+                Err(error) => {
+                    log::error!("Reconnect failed: {:#}", error);
+                    if reconnect_index >= RECONNECT_INTERVAL.len() {
+                        anyhow::bail!("reconnect failed");
+                    }
+
+                    let timeout = RECONNECT_INTERVAL[reconnect_index];
+                    reconnect_index += 1;
+
+                    log::error!("Try again in {:#?}", timeout);
+                    tokio::time::sleep(timeout).await;
+                }
+            }
+        };
+        radar_client.set_generator(radar_generator);
+        log::info!(
+            "Successfully reconnected (session id = {})",
+            radar_client.session_id
+        );
+    }
 
-    radar_client.await.context("radar error")?;
+    radar_client.close_connection().await;
     Ok(())
 }