Introduce BoardDynamicMetadata

Author: blacelle

authorization/pom.xml

@@ -35,6 +35,12 @@
             <artifactId>spring-security-oauth2-resource-server</artifactId>
         </dependency>
 
+        <dependency>
+            <!-- Provides ServerHttpSecurity -->
+            <groupId>org.springframework.security</groupId>
+            <artifactId>spring-security-config</artifactId>
+        </dependency>
+
         <dependency>
             <groupId>org.springframework.security</groupId>
             <artifactId>spring-security-oauth2-jose</artifactId>

authorization/src/main/java/eu/solven/kumite/oauth2/IKumiteOAuth2Constants.java

@@ -4,4 +4,7 @@ public interface IKumiteOAuth2Constants {
 	// https://connect2id.com/products/server/docs/api/token#url
 	String KEY_OAUTH2_ISSUER = "kumite.oauth2.issuer-base-url";
 	String KEY_JWT_SIGNINGKEY = "kumite.oauth2.signing-key";
+
+	// Used to generate a signingKey on the fly. Useful for integrationTests
+	String GENERATE = "GENERATE";
 }

server/src/main/java/eu/solven/kumite/security/JwtWebFluxSecurity.java authorization/src/main/java/eu/solven/kumite/oauth2/resourceserver/JwtWebFluxSecurity.java

@@ -1,4 +1,4 @@
-package eu.solven.kumite.security;
+package eu.solven.kumite.oauth2.resourceserver;
 
 import org.springframework.context.annotation.Bean;
 import org.springframework.core.Ordered;
@@ -15,7 +15,6 @@
 import com.nimbusds.jwt.JWT;
 
 import eu.solven.kumite.app.IKumiteSpringProfiles;
-import eu.solven.kumite.oauth2.resourceserver.KumiteResourceServerConfiguration;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 
@@ -95,7 +94,6 @@ public SecurityWebFilterChain configureApi(Environment env,
 					e.authenticationEntryPoint(authenticationEntryPoint);
 				})
 
-				// .anonymous(a -> a.principal("AnonymousKarateka"))
 				.build();
 	}
 

authorization/src/main/java/eu/solven/kumite/oauth2/resourceserver/KumiteResourceServerConfiguration.java

@@ -54,10 +54,12 @@ public static OctetSequenceKey loadOAuth2SigningKey(Environment env, IUuidGenera
 			throw new IllegalStateException("Lack proper `" + IKumiteOAuth2Constants.KEY_JWT_SIGNINGKEY
 					+ "` or spring.profiles.active="
 					+ IKumiteSpringProfiles.P_UNSAFE_SERVER);
-		} else if ("GENERATE".equals(secretKeySpec)) {
+		} else if (IKumiteOAuth2Constants.GENERATE.equals(secretKeySpec)) {
 			if (env.acceptsProfiles(Profiles.of(IKumiteSpringProfiles.P_PRDMODE))) {
 				throw new IllegalStateException("Can not GENERATE oauth2 signingKey in `prodmode`");
 			}
+			// Ensure we generate a signingKey only once, so that the key in IJwtDecoder and the token in Bearer token
+			// are based on the same signingKey
 			synchronized (secretKeySpec) {
 				if (GENERATED_SIGNINGKEY.get() == null) {
 					log.warn("We generate a random signingKey");

server/src/main/java/eu/solven/kumite/security/RsaKeyConfigProperties.java authorization/src/test/java/authorization/RsaKeyConfigProperties.java

@@ -1,4 +1,4 @@
-package eu.solven.kumite.security;
+package authorization;
 
 import java.security.interfaces.RSAPrivateKey;
 import java.security.interfaces.RSAPublicKey;

authorization/src/test/java/authorization/TestKumiteResourceServerConfiguration.java

@@ -0,0 +1,28 @@
+package authorization;
+
+import java.text.ParseException;
+
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.springframework.mock.env.MockEnvironment;
+
+import com.nimbusds.jose.jwk.OctetSequenceKey;
+
+import eu.solven.kumite.oauth2.IKumiteOAuth2Constants;
+import eu.solven.kumite.oauth2.resourceserver.KumiteResourceServerConfiguration;
+import eu.solven.kumite.tools.JdkUuidGenerator;
+
+public class TestKumiteResourceServerConfiguration {
+	KumiteResourceServerConfiguration conf = new KumiteResourceServerConfiguration();
+
+	@Test
+	public void testGenerateMultipleTimes() throws ParseException {
+		MockEnvironment env = new MockEnvironment();
+		env.setProperty(IKumiteOAuth2Constants.KEY_JWT_SIGNINGKEY, IKumiteOAuth2Constants.GENERATE);
+
+		OctetSequenceKey key1 = KumiteResourceServerConfiguration.loadOAuth2SigningKey(env, JdkUuidGenerator.INSTANCE);
+		OctetSequenceKey key2 = KumiteResourceServerConfiguration.loadOAuth2SigningKey(env, JdkUuidGenerator.INSTANCE);
+
+		Assertions.assertThat(key1.toJSONString()).isEqualTo(key2.toJSONString());
+	}
+}

server/src/test/java/eu/solven/kumite/account/login/TestKumiteTokenService.java authorization/src/test/java/eu/solven/kumite/oauth2/authorizationserver/TestKumiteTokenService.java

@@ -1,4 +1,4 @@
-package eu.solven.kumite.account.login;
+package eu.solven.kumite.oauth2.authorizationserver;
 
 import java.text.ParseException;
 import java.time.Duration;
@@ -23,8 +23,8 @@
 import com.nimbusds.jwt.SignedJWT;
 
 import eu.solven.kumite.account.internal.KumiteUser;
+import eu.solven.kumite.account.login.IKumiteTestConstants;
 import eu.solven.kumite.oauth2.IKumiteOAuth2Constants;
-import eu.solven.kumite.oauth2.authorizationserver.KumiteTokenService;
 import eu.solven.kumite.oauth2.resourceserver.KumiteResourceServerConfiguration;
 import eu.solven.kumite.tools.JdkUuidGenerator;
 

contest-core/src/main/java/eu/solven/kumite/app/persistence/InMemoryKumiteConfiguration.java

@@ -5,6 +5,7 @@
 
 import eu.solven.kumite.account.InMemoryUserRepository;
 import eu.solven.kumite.app.IKumiteSpringProfiles;
+import eu.solven.kumite.board.persistence.InMemoryBoardMetadataRepository;
 import eu.solven.kumite.board.persistence.InMemoryBoardRepository;
 import eu.solven.kumite.contest.persistence.InMemoryContestRepository;
 import eu.solven.kumite.player.persistence.InMemoryAccountPlayersRegistry;
@@ -16,10 +17,11 @@
 		InMemoryAccountPlayersRegistry.class,
 
 		InMemoryBoardRepository.class,
+		InMemoryBoardMetadataRepository.class,
 		InMemoryContestRepository.class,
 
 })
 @Profile(IKumiteSpringProfiles.P_INMEMORY)
 public class InMemoryKumiteConfiguration {
-	
+
 }

contest-core/src/main/java/eu/solven/kumite/board/BoardDynamicMetadata.java

@@ -0,0 +1,43 @@
+package eu.solven.kumite.board;
+
+import java.time.OffsetDateTime;
+import java.time.ZoneOffset;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.UUID;
+
+import lombok.Builder;
+import lombok.Builder.Default;
+import lombok.Value;
+import lombok.extern.jackson.Jacksonized;
+
+/**
+ * The set of board metadata which could evolve, and are not stored into the {@link IKumiteBoard}, independently of
+ * current player.
+ * 
+ * @author Benoit Lacelle
+ *
+ */
+@Value
+@Builder
+@Jacksonized
+public class BoardDynamicMetadata {
+
+	@Default
+	Map<UUID, OffsetDateTime> playerIdToLastMove = new TreeMap<>();
+
+	OffsetDateTime gameOverTs;
+
+	public BoardDynamicMetadata setGameOver() {
+		if (gameOverTs != null) {
+			// We are already gameOver: do not update its value
+			return this;
+		}
+
+		return BoardDynamicMetadata.builder()
+				.playerIdToLastMove(playerIdToLastMove)
+				.gameOverTs(OffsetDateTime.now().atZoneSameInstant(ZoneOffset.UTC).toOffsetDateTime())
+				.build();
+	}
+
+}

contest-core/src/main/java/eu/solven/kumite/board/BoardLifecycleManager.java

@@ -9,6 +9,7 @@
 import java.util.concurrent.Executor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Consumer;
 import java.util.random.RandomGenerator;
 import java.util.stream.Collectors;
 
@@ -48,20 +49,22 @@ public class BoardLifecycleManager {
 	 * 
 	 * @param contestId
 	 * @param runnable
+	 * @return
 	 */
-	protected void executeBoardChange(UUID contestId, Runnable runnable) {
+	protected BoardSnapshotPostEvent executeBoardChange(UUID contestId, Consumer<IKumiteBoard> runnable) {
 		if (isDirect(boardEvolutionExecutor)) {
-			boardEvolutionExecutor.execute(runnable);
+			return executeBoardMutation(contestId, runnable);
 		} else {
 			CountDownLatch cdl = new CountDownLatch(1);
 			AtomicReference<Throwable> refT = new AtomicReference<>();
+			AtomicReference<BoardSnapshotPostEvent> refBoard = new AtomicReference<>();
 
 			log.trace("Submitting task for contestId={}", contestId);
 			getExecutor(contestId).execute(() -> {
 				try {
-					log.trace("Runnning task for contestId={}", contestId);
-					runnable.run();
-					log.trace("Runnned task for contestId={}", contestId);
+					BoardSnapshotPostEvent snapshot = executeBoardMutation(contestId, runnable);
+
+					refBoard.set(snapshot);
 				} catch (Throwable t) {
 					refT.compareAndSet(null, t);
 				} finally {
@@ -90,9 +93,33 @@ protected void executeBoardChange(UUID contestId, Runnable runnable) {
 				// BEWARE WHAT DOES IT MEAN? THE BOARD IS CORRUPTED?
 				throw new IllegalStateException("One move has been too slow to be processed");
 			}
+
+			return refBoard.get();
 		}
 	}
 
+	private BoardSnapshotPostEvent executeBoardMutation(UUID contestId, Consumer<IKumiteBoard> runnable) {
+		IHasBoard hasBoard = boardRegistry.makeDynamicBoardHolder(contestId);
+		IKumiteBoard board = hasBoard.get();
+		Set<UUID> playerCanMoveBefore = playersCanMove(contestId, board);
+
+		log.trace("Runnning task for contestId={}", contestId);
+		runnable.accept(board);
+
+		Set<UUID> enabledPlayersIds = new HashSet<>();
+		{
+			Set<UUID> playerCanMoveAfter = playersCanMove(contestId, board);
+
+			// This does an intersection: players turned movable can now move, through they could not move
+			// before
+			enabledPlayersIds.addAll(playerCanMoveAfter);
+			enabledPlayersIds.removeAll(playerCanMoveBefore);
+		}
+
+		log.trace("Runnned task for contestId={}", contestId);
+		return BoardSnapshotPostEvent.builder().board(board).enabledPlayerIds(enabledPlayersIds).build();
+	}
+
 	/**
 	 * 
 	 * @param contestId
@@ -118,25 +145,11 @@ public IKumiteBoardView registerPlayer(Contest contest, PlayerJoinRaw playerRegi
 
 		AtomicReference<IKumiteBoardView> refBoardView = new AtomicReference<>();
 
-		Set<UUID> enabledPlayersIds = new HashSet<>();
-
-		executeBoardChange(contestId, () -> {
-			IKumiteBoard boardBefore = boardRegistry.makeDynamicBoardHolder(contestId).get();
-
-			Set<UUID> playerCanMoveBefore = playersCanMove(contestId, boardBefore);
-
-			// The registry takes in charge the registration in the board
+		BoardSnapshotPostEvent boardSnapshot = executeBoardChange(contestId, board -> {
+			// contestPlayersRegistry takes in charge the registration in the board
 			contestPlayersRegistry.registerPlayer(contest, playerRegistrationRaw);
 
-			IKumiteBoard boardAfter = boardRegistry.makeDynamicBoardHolder(contestId).get();
-
-			Set<UUID> playerCanMoveAfter = playersCanMove(contestId, boardBefore);
-
-			// This does an intersection: players turned movable can now move, through they could not move before
-			enabledPlayersIds.addAll(playerCanMoveAfter);
-			enabledPlayersIds.removeAll(playerCanMoveBefore);
-
-			refBoardView.set(boardAfter.asView(playerId));
+			refBoardView.set(board.asView(playerId));
 		});
 
 		IKumiteBoardView boardViewPostMove = refBoardView.get();
@@ -151,10 +164,14 @@ public IKumiteBoardView registerPlayer(Contest contest, PlayerJoinRaw playerRegi
 		// Hence we do not guarantee other events interleaved when the event is processed
 		eventBus.post(PlayerJoinedBoard.builder().contestId(contestId).playerId(playerId).build());
 
-		enabledPlayersIds.forEach(enabledPlayerId -> {
+		boardSnapshot.getEnabledPlayerIds().forEach(enabledPlayerId -> {
 			eventBus.post(PlayerCanMove.builder().contestId(contestId).playerId(playerId).build());
 		});
 
+		if (boardRegistry.hasGameover(contest.getGame(), contestId).isGameOver()) {
+			eventBus.post(ContestIsGameover.builder().contestId(contestId).build());
+		}
+
 		return boardViewPostMove;
 	}
 
@@ -178,11 +195,7 @@ public IKumiteBoardView onPlayerMove(Contest contest, PlayerMoveRaw playerMove)
 		UUID contestId = contest.getContestId();
 		UUID playerId = playerMove.getPlayerId();
 
-		AtomicReference<IKumiteBoard> refBoard = new AtomicReference<>();
-
-		Set<UUID> enabledPlayersIds = new HashSet<>();
-
-		executeBoardChange(contestId, () -> {
+		BoardSnapshotPostEvent boardSnapshot = executeBoardChange(contestId, currentBoard -> {
 			if (!contestPlayersRegistry.isRegisteredPlayer(contestId, playerId)) {
 				List<UUID> contestPlayers = contestPlayersRegistry.makeDynamicHasPlayers(contestId)
 						.getPlayers()
@@ -196,36 +209,28 @@ public IKumiteBoardView onPlayerMove(Contest contest, PlayerMoveRaw playerMove)
 						+ contestPlayers);
 			}
 
-			IKumiteBoard currentBoard = boardRegistry.makeDynamicBoardHolder(contestId).get();
-
-			Set<UUID> playerCanMoveBefore = playersCanMove(contestId, currentBoard);
-
 			// First `.checkMove`: these are generic checks (e.g. is the gamerOver?)
 			try {
 				contest.checkValidMove(playerMove);
 			} catch (IllegalArgumentException e) {
-				throw new IllegalArgumentException("Issue on contest=" + contest, e);
+				throw new IllegalArgumentException("Issue on contest=" + contest + " for move=" + playerMove, e);
 			}
 
 			log.info("Registering move for contestId={} by playerId={}", contestId, playerId);
 
 			// This may still fail (e.g. the move is illegal given game rules)
 			currentBoard.registerMove(playerMove);
 
-			Set<UUID> playerCanMoveAfter = playersCanMove(contestId, currentBoard);
-
-			// This does an intersection: players turned movable can now move, through they could not move before
-			enabledPlayersIds.addAll(playerCanMoveAfter);
-			enabledPlayersIds.removeAll(playerCanMoveBefore);
-
 			// Persist the board (e.g. for concurrent changes)
 			boardRegistry.updateBoard(contestId, currentBoard);
 
-			refBoard.set(currentBoard);
-
+			if (boardRegistry.hasGameover(contest.getGame(), contestId).isGameOver()) {
+				log.info("playerMove led to gameOver for contestId={}", contestId);
+				doGameOver(contestId);
+			}
 		});
 
-		IKumiteBoard boardAfter = refBoard.get();
+		IKumiteBoard boardAfter = boardSnapshot.getBoard();
 		IKumiteBoardView boardViewPostMove = boardAfter.asView(playerId);
 
 		if (boardViewPostMove == null) {
@@ -234,14 +239,38 @@ public IKumiteBoardView onPlayerMove(Contest contest, PlayerMoveRaw playerMove)
 
 		eventBus.post(PlayerMoved.builder().contestId(contestId).playerId(playerId).build());
 
-		enabledPlayersIds.forEach(enabledPlayerId -> {
+		boardSnapshot.getEnabledPlayerIds().forEach(enabledPlayerId -> {
 			eventBus.post(PlayerCanMove.builder().contestId(contestId).playerId(playerId).build());
 		});
 
-		if (contest.getGame().makeDynamicGameover(() -> boardAfter).isGameOver()) {
+		if (boardRegistry.hasGameover(contest.getGame(), contestId).isGameOver()) {
 			eventBus.post(ContestIsGameover.builder().contestId(contestId).build());
 		}
 
 		return boardViewPostMove;
 	}
+
+	public void forceGameOver(Contest contest) {
+		UUID contestId = contest.getContestId();
+
+		if (boardRegistry.hasGameover(contest.getGame(), contestId).isGameOver()) {
+			log.info("contestId={} is already gameOver", contestId);
+		}
+
+		executeBoardChange(contestId, board -> {
+			log.info("Registering forcedGameOver for contestId={}", contestId);
+
+			doGameOver(contestId);
+		});
+
+		if (boardRegistry.hasGameover(contest.getGame(), contestId).isGameOver()) {
+			eventBus.post(ContestIsGameover.builder().contestId(contestId).build());
+		}
+	}
+
+	private void doGameOver(UUID contestId) {
+		boardRegistry.forceGameover(contestId);
+		contestsRegistry.deleteContest(contestId);
+		contestPlayersRegistry.forceGameover(contestId);
+	}
 }