Feature/game state recovery restart

docker-compose.yml

@@ -3,4 +3,6 @@ services:
     image: ghcr.io/ss26-se2-codenames/backend:latest
     restart: unless-stopped
     ports:
-      - "53213:8080"
+      - "53213:8080"
+    volumes:
+      - ./data:/app/data

src/main/java/com/codenames/codenames/backend/game/controller/GameSocketController.java

@@ -6,6 +6,7 @@
 import com.codenames.codenames.backend.game.dto.RevealCardMessage;
 import com.codenames.codenames.backend.game.dto.StartGameMessage;
 import com.codenames.codenames.backend.playingfield.GameService;
+import com.codenames.codenames.backend.recovery.SystemStatePersistenceService;
 import org.springframework.messaging.handler.annotation.MessageMapping;
 import org.springframework.messaging.simp.SimpMessagingTemplate;
 import org.springframework.stereotype.Controller;
@@ -22,6 +23,7 @@ public class GameSocketController {
   private final GameService gameService;
 
   private final SimpMessagingTemplate messagingTemplate;
+  private final SystemStatePersistenceService persistenceService;
 
   private static final String GAME_TOPIC_PREFIX = "/topic/game/";
 
@@ -30,11 +32,16 @@ public class GameSocketController {
    *
    * @param gameService service responsible for gameplay logic
    * @param messagingTemplate template used for broadcasting websocket messages
+   * @param persistenceService service used to persist current backend state
    */
-  public GameSocketController(GameService gameService, SimpMessagingTemplate messagingTemplate) {
+  public GameSocketController(
+      GameService gameService,
+      SimpMessagingTemplate messagingTemplate,
+      SystemStatePersistenceService persistenceService) {
 
     this.gameService = gameService;
     this.messagingTemplate = messagingTemplate;
+    this.persistenceService = persistenceService;
   }
 
   /**
@@ -61,6 +68,7 @@ public void startGame(StartGameMessage message) {
   public void revealCard(RevealCardMessage message) {
 
     gameService.flipCard(message.getLobbyCode(), message.getPosition(), message.getCurrentTurn());
+    persistenceService.persistCurrentState();
 
     messagingTemplate.convertAndSend(
         GAME_TOPIC_PREFIX + message.getLobbyCode(),
@@ -81,6 +89,7 @@ public void submitClue(ClueMessage message) {
         message.getLobbyCode(),
         new Clue(message.getWord(), message.getGuessAmount()),
         message.getCurrentTurn());
+    persistenceService.persistCurrentState();
 
     messagingTemplate.convertAndSend(
         GAME_TOPIC_PREFIX + message.getLobbyCode(),
@@ -96,6 +105,7 @@ public void submitClue(ClueMessage message) {
   public void passTurn(PassTurnMessage message) {
 
     gameService.passTurn(message.getLobbyCode(), message.getCurrentTurn());
+    persistenceService.persistCurrentState();
 
     messagingTemplate.convertAndSend(
         GAME_TOPIC_PREFIX + message.getLobbyCode(),

src/main/java/com/codenames/codenames/backend/lobby/controller/LobbyController.java

@@ -3,6 +3,7 @@
 import com.codenames.codenames.backend.lobby.dto.LobbyResponse;
 import com.codenames.codenames.backend.lobby.dto.PlayerDto;
 import com.codenames.codenames.backend.lobby.services.LobbyService;
+import com.codenames.codenames.backend.recovery.SystemStatePersistenceService;
 import java.util.List;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -19,21 +20,23 @@
  * <p>Provides endpoints for creating, joining, and leaving lobbies. Delegates business logic to
  * {@link LobbyService}.
  */
-
 @RestController
 @RequestMapping("/lobby")
 public class LobbyController {
 
   private final LobbyService service;
+  private final SystemStatePersistenceService persistenceService;
   private static final String LOBBY_NOT_FOUND = "Could not find lobby.";
 
   /**
    * Creates a new {@code LobbyController}.
    *
    * @param service the lobby service used to handle business logic
+   * @param persistenceService service used to persist current backend state
    */
-  public LobbyController(LobbyService service) {
+  public LobbyController(LobbyService service, SystemStatePersistenceService persistenceService) {
     this.service = service;
+    this.persistenceService = persistenceService;
   }
 
   /**
@@ -42,93 +45,84 @@ public LobbyController(LobbyService service) {
    * @param username the username of the requesting user
    * @return a response containing the result and the generated lobby code
    */
-
   @GetMapping("/create")
   public ResponseEntity<LobbyResponse> createLobby(@RequestParam String username) {
     String lobbyCode = service.createLobby(username);
     if (lobbyCode == null || lobbyCode.isBlank()) {
       return ResponseEntity.internalServerError()
-              .body(new LobbyResponse("Error while creating lobby.", "", null, false));
+          .body(new LobbyResponse("Error while creating lobby.", "", null, false));
     } else {
+
       List<PlayerDto> players = service.getPlayersDto(lobbyCode);
       return ResponseEntity.ok(
-              new LobbyResponse("Successfully created Lobby.", lobbyCode, players, false)
-      );
+          new LobbyResponse("Successfully created Lobby.", lobbyCode, players, false));
     }
   }
 
   /**
    * Handles a request to join an existing lobby.
    *
-   * @param username  the username of the player
+   * @param username the username of the player
    * @param lobbyCode the lobby code identifying the lobby
    * @return a response indicating whether the join was successful
    */
   @GetMapping("/{lobbyCode}/join")
   public ResponseEntity<LobbyResponse> joinLobby(
-          @RequestParam String username, @PathVariable String lobbyCode) {
+      @RequestParam String username, @PathVariable String lobbyCode) {
     boolean joined = service.joinLobby(username, lobbyCode);
     if (joined) {
+
       return ResponseEntity.ok(
-              new LobbyResponse(
-                      "Joined Lobby successfully.",
-                      lobbyCode,
-                      service.getPlayersDto(lobbyCode),
-                      false
-              )
-      );
+          new LobbyResponse(
+              "Joined Lobby successfully.", lobbyCode, service.getPlayersDto(lobbyCode), false));
     } else {
       return ResponseEntity.badRequest()
-              .body(new LobbyResponse(LOBBY_NOT_FOUND, lobbyCode, null, false));
+          .body(new LobbyResponse(LOBBY_NOT_FOUND, lobbyCode, null, false));
     }
   }
 
   /**
    * Handles a request to leave a lobby.
    *
-   * @param username  the username of the player
+   * @param username the username of the player
    * @param lobbyCode the lobby code identifying the lobby
    * @return a response indicating whether the operation was successful
    */
   @GetMapping("/{lobbyCode}/leave")
   public ResponseEntity<LobbyResponse> leaveLobby(
-          @PathVariable String lobbyCode,
-          @RequestParam String username) {
+      @PathVariable String lobbyCode, @RequestParam String username) {
+    boolean wasStarted = service.getIsStarted(lobbyCode);
     boolean left = service.leaveLobby(username, lobbyCode);
+
     if (left) {
-      ResponseEntity<LobbyResponse> response = ResponseEntity.ok(
-              new LobbyResponse(
-                      "Left lobby successfully.",
-                      lobbyCode,
-                      service.getPlayersDto(lobbyCode),
-                      false
-              )
-      );
       service.checkLobbyStillHasPlayers(lobbyCode);
-      return response;
+
+      if (wasStarted) {
+        persistenceService.persistCurrentState();
+      }
+
+      return ResponseEntity.ok(
+          new LobbyResponse(
+              "Left lobby successfully.", lobbyCode, service.getPlayersDto(lobbyCode), false));
     } else {
       return ResponseEntity.badRequest()
-              .body(new LobbyResponse(LOBBY_NOT_FOUND, lobbyCode, null, false));
+          .body(new LobbyResponse(LOBBY_NOT_FOUND, lobbyCode, null, false));
     }
   }
 
   /**
    * An endpoint for retrieving all lobby-specific info used during polling in lobby-state.
    *
    * @param lobbyCode unique lobby code
-   * @return a response entity with the http code 200 for ok and
-   *         400 for bad request, if an error occurred
+   * @return a response entity with the http code 200 for ok and 400 for bad request, if an error
+   *     occurred
    */
-
   @GetMapping("/{lobbyCode}")
-  public ResponseEntity<LobbyResponse> getLobbyInfo(
-          @PathVariable String lobbyCode
-  ) {
+  public ResponseEntity<LobbyResponse> getLobbyInfo(@PathVariable String lobbyCode) {
     List<PlayerDto> players = service.getPlayersDto(lobbyCode);
     boolean isStarted = service.getIsStarted(lobbyCode);
     return ResponseEntity.ok(
-            new LobbyResponse("Lobby info retrieved successfully.", lobbyCode, players, isStarted)
-    );
+        new LobbyResponse("Lobby info retrieved successfully.", lobbyCode, players, isStarted));
   }
 
   /**
@@ -139,33 +133,26 @@ public ResponseEntity<LobbyResponse> getLobbyInfo(
    */
   @PostMapping("/{lobbyCode}/select-position")
   public ResponseEntity<LobbyResponse> selectPosition(
-          @PathVariable String lobbyCode, @RequestBody PlayerDto request
-  ) {
-    boolean updated = service.selectPosition(
-            request.username(),
-            lobbyCode,
-            request.team(),
-            request.role()
-    );
+      @PathVariable String lobbyCode, @RequestBody PlayerDto request) {
+    boolean updated =
+        service.selectPosition(request.username(), lobbyCode, request.team(), request.role());
 
     if (updated) {
+
       return ResponseEntity.ok(
-              new LobbyResponse(
-                      "Position selected successfully.",
-                      lobbyCode,
-                      service.getPlayersDto(lobbyCode),
-                      false
-              )
-      );
+          new LobbyResponse(
+              "Position selected successfully.",
+              lobbyCode,
+              service.getPlayersDto(lobbyCode),
+              false));
     } else {
-      return ResponseEntity.badRequest().body(
+      return ResponseEntity.badRequest()
+          .body(
               new LobbyResponse(
-                      "Could not assign selected team/role.",
-                      lobbyCode,
-                      service.getPlayersDto(lobbyCode),
-                      false
-              )
-      );
+                  "Could not assign selected team/role.",
+                  lobbyCode,
+                  service.getPlayersDto(lobbyCode),
+                  false));
     }
   }
 
@@ -175,32 +162,22 @@ public ResponseEntity<LobbyResponse> selectPosition(
    * @param lobbyCode the unique lobby code
    * @param username the name of the requesting user
    * @return a response entity of a lobby response, with isStarted @code true or @code false,
-   *      whether the starting was successful or not
+   *     whether the starting was successful or not
    */
-
   @GetMapping("/{lobbyCode}/start-game")
   public ResponseEntity<LobbyResponse> startGame(
-          @PathVariable String lobbyCode, @RequestParam String username
-  ) {
+      @PathVariable String lobbyCode, @RequestParam String username) {
     boolean isStarted = service.startGame(lobbyCode, username);
 
     if (isStarted) {
+      persistenceService.persistCurrentState();
       return ResponseEntity.ok(
-              new LobbyResponse(
-                      "Game is starting now.",
-                      lobbyCode,
-                      service.getPlayersDto(lobbyCode),
-                      true
-              )
-      );
+          new LobbyResponse(
+              "Game is starting now.", lobbyCode, service.getPlayersDto(lobbyCode), true));
     }
-    return ResponseEntity.badRequest().body(
+    return ResponseEntity.badRequest()
+        .body(
             new LobbyResponse(
-                    "Could not start the game.",
-                    lobbyCode,
-                    service.getPlayersDto(lobbyCode),
-                    false
-            )
-    );
+                "Could not start the game.", lobbyCode, service.getPlayersDto(lobbyCode), false));
   }
 }