diff --git a/crates/lanspread-server/src/req.rs b/crates/lanspread-server/src/req.rs
index 6c5acb7..cac1c57 100644
--- a/crates/lanspread-server/src/req.rs
+++ b/crates/lanspread-server/src/req.rs
@@ -44,63 +44,77 @@ impl RequestHandler {
         Ok(())
     }
 
+    fn handle_ping() -> Response {
+        Response::Pong
+    }
+
+    async fn handle_list_games(&self) -> Response {
+        let db = self.db.read().await;
+        Response::ListGames(db.all_games().into_iter().cloned().collect())
+    }
+
+    async fn handle_get_game(&self, id: String, games_folder: &Path) -> Response {
+        if self.db.read().await.get_game_by_id(&id).is_none() {
+            tracing::error!("Game not found in DB: {id}");
+            return Response::GameNotFound(id);
+        }
+
+        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 {
+            id,
+            file_descriptions: game_files_descs,
+        }
+    }
+
+    fn handle_get_game_file_data(&self) -> Response {
+        Response::InvalidRequest(Bytes::new(), "Not implemented".to_string())
+    }
+
+    fn handle_invalid(&self, data: Bytes, err_msg: String) -> Response {
+        Response::InvalidRequest(data, err_msg)
+    }
+
     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::ListGames(db.all_games().into_iter().cloned().collect())
-            }
-            Request::GetGame { id } => {
-                if self.db.read().await.get_game_by_id(&id).is_none() {
-                    tracing::error!("Game not found in DB: {id}");
-                    return Response::GameNotFound(id);
-                }
-
-                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 {
-                    id,
-                    file_descriptions: game_files_descs,
-                }
-            }
-            Request::GetGameFileData(_) => {
-                Response::InvalidRequest(Bytes::new(), "Not implemented".to_string())
-            }
-            Request::Invalid(data, err_msg) => Response::InvalidRequest(data, err_msg),
+            Request::Ping => RequestHandler::handle_ping(),
+            Request::ListGames => self.handle_list_games().await,
+            Request::GetGame { id } => self.handle_get_game(id, games_folder).await,
+            Request::GetGameFileData(_) => self.handle_get_game_file_data(),
+            Request::Invalid(data, err_msg) => self.handle_invalid(data, err_msg),
         }
     }
 }