[code][fix] improvements for LAN 202503

- more robust client <-> server connection
  - new client event: DownloadGameFilesFailed
  - 3 seconds to reconnect
  - retry forever if server is gone and never lose a UI request

- code cleanup here and there (mostly server)

crates/lanspread-server/src/req.rs

@@ -3,12 +3,12 @@ use std::{
     sync::Arc,
 };
 
-use bytes::Bytes;
+use bytes::{Bytes, BytesMut};
 use lanspread_db::db::{GameDB, GameFileDescription};
-use lanspread_proto::{Request, Response};
+use lanspread_proto::{Message as _, Request, Response};
 use lanspread_utils::maybe_addr;
 use s2n_quic::stream::SendStream;
-use tokio::sync::RwLock;
+use tokio::{io::AsyncReadExt, sync::RwLock, time::Instant};
 use walkdir::WalkDir;
 
 #[derive(Clone, Debug)]
@@ -23,12 +23,33 @@ impl RequestHandler {
         }
     }
 
-    pub(crate) async fn handle_request(&self, request: Request, games_folder: &Path) -> Response {
+    pub(crate) async fn handle_request(
+        &self,
+        request: Request,
+        games_folder: &Path,
+        tx: &mut SendStream,
+    ) -> eyre::Result<()> {
+        let remote_addr = maybe_addr!(tx.connection().remote_addr());
+
+        // process request and generate response
+        let response = self.process_request(request, games_folder).await;
+        tracing::trace!("{remote_addr} server response: {response:?}");
+
+        // write response back to client
+        tx.send(response.encode()).await?;
+
+        // close the stream
+        tx.close().await?;
+
+        Ok(())
+    }
+
+    pub(crate) async fn process_request(&self, request: Request, games_folder: &Path) -> Response {
         match request {
             Request::Ping => Response::Pong,
             Request::ListGames => {
                 let db = self.db.read().await;
-                Response::Games(db.all_games().into_iter().cloned().collect())
+                Response::ListGames(db.all_games().into_iter().cloned().collect())
             }
             Request::GetGame { id } => {
                 if self.db.read().await.get_game_by_id(&id).is_none() {
@@ -71,19 +92,15 @@ impl RequestHandler {
                     }
                 }
 
-                Response::GetGame(game_files_descs)
+                Response::GetGame {
+                    id,
+                    file_descriptions: game_files_descs,
+                }
             }
             Request::GetGameFileData(_) => {
                 Response::InvalidRequest(Bytes::new(), "Not implemented".to_string())
             }
-            Request::Invalid(data, err_msg) => {
-                tracing::error!(
-                    "got invalid request from client (error: {}): {}",
-                    err_msg,
-                    String::from_utf8_lossy(&data)
-                );
-                Response::InvalidRequest(data, err_msg)
-            }
+            Request::Invalid(data, err_msg) => Response::InvalidRequest(data, err_msg),
         }
     }
 }
@@ -98,14 +115,48 @@ pub(crate) async fn send_game_file_data(
     tracing::debug!("{remote_addr} client requested game file data: {game_file_desc:?}",);
 
     // deliver file data to client
-    let path = game_dir.join(&game_file_desc.relative_path);
+    let game_file = game_dir.join(&game_file_desc.relative_path);
 
-    if let Ok(mut file) = tokio::fs::File::open(&path).await {
-        if let Err(e) = tokio::io::copy(&mut file, tx).await {
-            tracing::error!("{remote_addr} failed to send file data: {e}",);
+    let mut total_bytes = 0;
+    let mut last_total_bytes = 0;
+    let mut timestamp = Instant::now();
+
+    if let Ok(mut f) = tokio::fs::File::open(&game_file).await {
+        let mut buf = BytesMut::with_capacity(64 * 1024);
+        while let Ok(bytes_read) = f.read_buf(&mut buf).await {
+            if bytes_read == 0 {
+                break;
+            }
+
+            total_bytes += bytes_read;
+
+            if last_total_bytes + 10_000_000 < total_bytes {
+                let elapsed = timestamp.elapsed();
+                let diff_bytes = total_bytes - last_total_bytes;
+
+                if elapsed.as_secs_f64() >= 1.0 {
+                    #[allow(clippy::cast_precision_loss)]
+                    let mb_per_s = (diff_bytes as f64) / (elapsed.as_secs_f64() * 1000.0 * 1000.0);
+
+                    tracing::debug!(
+                        "{remote_addr} sending file data: {game_file:?}, MB/s: {mb_per_s:.2}",
+                    );
+                    last_total_bytes = total_bytes;
+                    timestamp = Instant::now();
+                }
+            }
+
+            if let Err(e) = tx.send(buf.split_to(bytes_read).freeze()).await {
+                tracing::error!("{remote_addr} failed to send file data: {e}",);
+                break;
+            }
         }
+
+        tracing::debug!(
+            "{remote_addr} finished sending file data: {game_file:?}, total_bytes: {total_bytes}",
+        );
     } else {
-        tracing::error!("{remote_addr} failed to open file: {}", path.display());
+        tracing::error!("{remote_addr} failed to open file: {}", game_file.display());
     }
 
     if let Err(e) = tx.close().await {