[client][server] file transfer working, ui not ready for it

crates/lanspread-server/Cargo.toml

@@ -30,3 +30,4 @@ semver = { workspace = true }
 tokio = { workspace = true }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
+walkdir = { workspace = true }

crates/lanspread-server/src/main.rs

@@ -1,15 +1,18 @@
 #![allow(clippy::doc_markdown)]
 
 use std::{
+    fs::File,
+    io::Read as _,
     net::{IpAddr, SocketAddr},
-    path::PathBuf,
+    path::{Path, PathBuf},
     sync::Arc,
 };
 
 use assets::Thumbnails;
+use bytes::Bytes;
 use clap::Parser;
 use lanspread_compat::eti::{self, EtiGame};
-use lanspread_db::db::{Game, GameDB};
+use lanspread_db::db::{Game, GameDB, GameFileDescription};
 use lanspread_mdns::{
     DaemonEvent,
     MdnsAdvertiser,
@@ -21,6 +24,7 @@ use lanspread_utils::maybe_addr;
 use s2n_quic::Server as QuicServer;
 use tokio::{io::AsyncWriteExt, sync::Mutex};
 use tracing_subscriber::EnvFilter;
+use walkdir::WalkDir;
 
 mod assets;
 
@@ -30,6 +34,7 @@ static CERT_PEM: &str = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../..
 #[derive(Clone, Debug)]
 struct ServerCtx {
     handler: RequestHandler,
+    games_folder: PathBuf,
 }
 
 #[derive(Clone, Debug)]
@@ -38,7 +43,7 @@ struct ConnectionCtx {
     remote_addr: String,
 }
 
-async fn run(addr: SocketAddr, db: GameDB) -> eyre::Result<()> {
+async fn run(addr: SocketAddr, db: GameDB, games_folder: PathBuf) -> eyre::Result<()> {
     let mut server = QuicServer::builder()
         .with_tls((CERT_PEM, KEY_PEM))?
         .with_io(addr)?
@@ -46,6 +51,7 @@ async fn run(addr: SocketAddr, db: GameDB) -> eyre::Result<()> {
 
     let server_ctx = Arc::new(ServerCtx {
         handler: RequestHandler::new(db),
+        games_folder,
     });
 
     while let Some(mut connection) = server.accept().await {
@@ -75,7 +81,69 @@ async fn run(addr: SocketAddr, db: GameDB) -> eyre::Result<()> {
 
                         let request = Request::decode(data);
                         tracing::debug!("{} msg: {:?}", conn_ctx.remote_addr, request);
-                        let response = conn_ctx.server_ctx.handler.handle_request(request).await;
+
+                        if let Request::GetGameFileData(game_file_desc) = &request {
+                            tracing::debug!(
+                                "{} client requested game file data: {:?}",
+                                conn_ctx.remote_addr,
+                                game_file_desc
+                            );
+
+                            // deliver file data to client
+                            let path = conn_ctx
+                                .server_ctx
+                                .games_folder
+                                .join(&game_file_desc.relative_path);
+
+                            if let Ok(mut file) = File::open(&path) {
+                                let mut buf = vec![0; 64 * 1024];
+
+                                while let Ok(n) = file.read(&mut buf) {
+                                    if n == 0 {
+                                        break;
+                                    }
+
+                                    if let Err(e) = tx.write_all(&buf[..n]).await {
+                                        tracing::error!(
+                                            "{} failed to send file data: {}",
+                                            conn_ctx.remote_addr,
+                                            e
+                                        );
+                                    }
+                                }
+
+                                // if let Err(e) = tokio::io::copy(&mut file, &mut tx).await {
+                                //     tracing::error!(
+                                //         "{} failed to send file data: {}",
+                                //         conn_ctx.remote_addr,
+                                //         e
+                                //     );
+                                // }
+                            } else {
+                                tracing::error!(
+                                    "{} failed to open file: {}",
+                                    conn_ctx.remote_addr,
+                                    path.display()
+                                );
+                            }
+
+                            if let Err(e) = tx.close().await {
+                                tracing::error!(
+                                    "{} failed to close stream: {}",
+                                    conn_ctx.remote_addr,
+                                    e
+                                );
+                            }
+
+                            continue;
+                        }
+
+                        let response = conn_ctx
+                            .server_ctx
+                            .handler
+                            .handle_request(request, &conn_ctx)
+                            .await;
+
                         tracing::trace!("{} server response: {:?}", conn_ctx.remote_addr, response);
                         let raw_response = response.encode();
                         tracing::trace!(
@@ -102,6 +170,21 @@ async fn run(addr: SocketAddr, db: GameDB) -> eyre::Result<()> {
     Ok(())
 }
 
+fn get_relative_path(base: &Path, deep_path: &Path) -> std::io::Result<PathBuf> {
+    let base_canonical = base.canonicalize()?;
+    let full_canonical = deep_path.canonicalize()?;
+
+    full_canonical
+        .strip_prefix(&base_canonical)
+        .map(std::path::Path::to_path_buf)
+        .map_err(|_| {
+            std::io::Error::new(
+                std::io::ErrorKind::Other,
+                "Path is not within base directory",
+            )
+        })
+}
+
 #[derive(Clone, Debug)]
 struct RequestHandler {
     db: Arc<Mutex<GameDB>>,
@@ -114,7 +197,7 @@ impl RequestHandler {
         }
     }
 
-    async fn handle_request(&self, request: Request) -> Response {
+    async fn handle_request(&self, request: Request, conn_ctx: &ConnectionCtx) -> Response {
         match request {
             Request::Ping => Response::Pong,
             Request::ListGames => {
@@ -122,11 +205,52 @@ impl RequestHandler {
                 Response::Games(db.all_games().into_iter().cloned().collect())
             }
             Request::GetGame { id } => {
-                let db = self.db.lock().await;
-                match db.get_game_by_id(&id) {
-                    Some(game) => Response::Game(game.clone()),
-                    None => Response::GameNotFound(id),
+                if self.db.lock().await.get_game_by_id(&id).is_none() {
+                    tracing::error!("Game not found in DB: {id}");
+                    return Response::GameNotFound(id);
                 }
+
+                let games_folder = &conn_ctx.server_ctx.games_folder;
+
+                let game_dir = games_folder.join(&id);
+                if !game_dir.exists() {
+                    tracing::error!("Game folder does not exist: {}", game_dir.display());
+                    return Response::GameNotFound(id);
+                }
+
+                let mut game_files_descs: Vec<GameFileDescription> = vec![];
+
+                for entry in WalkDir::new(&game_dir)
+                    .into_iter()
+                    .filter_map(std::result::Result::ok)
+                {
+                    match get_relative_path(games_folder, entry.path()) {
+                        Ok(relative_path) => match relative_path.to_str() {
+                            Some(relative_path) => {
+                                let game_file_description = GameFileDescription {
+                                    game_id: id.clone(),
+                                    relative_path: relative_path.to_string(),
+                                    is_dir: entry.file_type().is_dir(),
+                                };
+
+                                tracing::debug!("Found game file: {:?}", game_file_description);
+
+                                game_files_descs.push(game_file_description);
+                            }
+                            None => {
+                                tracing::error!("Failed to get relative path: {relative_path:?}",);
+                            }
+                        },
+                        Err(e) => {
+                            tracing::error!("Failed to get relative path: {e}");
+                        }
+                    }
+                }
+
+                Response::GetGame(game_files_descs)
+            }
+            Request::GetGameFileData(_) => {
+                Response::InvalidRequest(Bytes::new(), "Not implemented".to_string())
             }
             Request::Invalid(data, err_msg) => {
                 tracing::error!(
@@ -185,6 +309,14 @@ async fn main() -> eyre::Result<()> {
 
     let cli = Cli::parse();
 
+    #[allow(clippy::manual_assert)]
+    if !cli.folder.exists() {
+        panic!(
+            "Games folder does not exist: {}",
+            cli.folder.to_str().expect("Invalid path")
+        );
+    }
+
     let eti_games = eti::get_games(&cli.db).await?;
     let mut games: Vec<Game> = eti_games.into_iter().map(eti_game_to_game).collect();
     let thumbnails = Thumbnails::new(cli.thumbnails);
@@ -218,5 +350,5 @@ async fn main() -> eyre::Result<()> {
 
     tracing::info!("Server listening on {}:{}", cli.ip, cli.port);
 
-    run(SocketAddr::from((cli.ip, cli.port)), game_db).await
+    run(SocketAddr::from((cli.ip, cli.port)), game_db, cli.folder).await
 }