Initial implementation of WebSocket

Author: blacelle

authorization/src/main/java/eu/solven/kumite/oauth2/authorizationserver/KumiteTokenService.java

@@ -22,7 +22,6 @@
 import com.nimbusds.jwt.JWTClaimsSet;
 import com.nimbusds.jwt.SignedJWT;
 
-import eu.solven.kumite.account.internal.KumiteUserRaw;
 import eu.solven.kumite.login.AccessTokenWrapper;
 import eu.solven.kumite.login.RefreshTokenWrapper;
 import eu.solven.kumite.oauth2.IKumiteOAuth2Constants;
@@ -76,7 +75,7 @@ public static JWK generateSignatureSecret(IUuidGenerator uuidGenerator) {
 		return jwk;
 	}
 
-	public String generateAccessToken(KumiteUserRaw user,
+	public String generateAccessToken(UUID accountId,
 			Set<UUID> playerIds,
 			Duration accessTokenValidity,
 			boolean isRefreshToken) {
@@ -95,7 +94,7 @@ public String generateAccessToken(KumiteUserRaw user,
 		Instant now = Instant.now();
 
 		String issuer = getIssuer();
-		JWTClaimsSet.Builder claimsSetBuilder = new JWTClaimsSet.Builder().subject(user.getAccountId().toString())
+		JWTClaimsSet.Builder claimsSetBuilder = new JWTClaimsSet.Builder().subject(accountId.toString())
 				.audience("Kumite-Server")
 				// https://connect2id.com/products/server/docs/api/token#url
 				.issuer(issuer)
@@ -143,11 +142,11 @@ private String getIssuer() {
 	 * @return The generated JWT access token.
 	 * @throws IllegalStateException
 	 */
-	public AccessTokenWrapper wrapInJwtAccessToken(KumiteUserRaw user, UUID playerId) {
+	public AccessTokenWrapper wrapInJwtAccessToken(UUID accountId, UUID playerId) {
 		// access_token are short-lived
 		Duration accessTokenValidity = Duration.parse("PT1H");
 
-		String accessToken = generateAccessToken(user, Set.of(playerId), accessTokenValidity, false);
+		String accessToken = generateAccessToken(accountId, Set.of(playerId), accessTokenValidity, false);
 
 		// https://www.oauth.com/oauth2-servers/access-tokens/access-token-response/
 		return AccessTokenWrapper.builder()
@@ -161,11 +160,11 @@ public AccessTokenWrapper wrapInJwtAccessToken(KumiteUserRaw user, UUID playerId
 
 	// https://stackoverflow.com/questions/38986005/what-is-the-purpose-of-a-refresh-token
 	// https://stackoverflow.com/questions/40555855/does-the-refresh-token-expire-and-if-so-when
-	public RefreshTokenWrapper wrapInJwtRefreshToken(KumiteUserRaw user, Set<UUID> playerIds) {
+	public RefreshTokenWrapper wrapInJwtRefreshToken(UUID accountId, Set<UUID> playerIds) {
 		// refresh_token are long-lived
 		Duration refreshTokenValidity = Duration.parse("P365D");
 
-		String accessToken = generateAccessToken(user, playerIds, refreshTokenValidity, true);
+		String accessToken = generateAccessToken(accountId, playerIds, refreshTokenValidity, true);
 
 		// https://www.oauth.com/oauth2-servers/access-tokens/access-token-response/
 		return RefreshTokenWrapper.builder()

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

@@ -1,6 +1,7 @@
 package eu.solven.kumite.oauth2.resourceserver;
 
 import java.text.ParseException;
+import java.util.concurrent.atomic.AtomicReference;
 
 import javax.crypto.SecretKey;
 
@@ -27,6 +28,8 @@ public class KumiteResourceServerConfiguration {
 
 	public static final MacAlgorithm MAC_ALGORITHM = MacAlgorithm.HS256;
 
+	private static final AtomicReference<String> GENERATED_SIGNINGKEY = new AtomicReference<>();
+
 	// https://stackoverflow.com/questions/64758305/how-to-configure-a-reactive-resource-server-to-use-a-jwt-with-a-symmetric-key
 	// https://docs.spring.io/spring-security/reference/reactive/oauth2/resource-server/jwt.html
 	// The browser will get an JWT given `/api/login/v1/token`. This route is protected by oauth2Login, and will
@@ -55,8 +58,15 @@ public static OctetSequenceKey loadOAuth2SigningKey(Environment env, IUuidGenera
 			if (env.acceptsProfiles(Profiles.of(IKumiteSpringProfiles.P_PRDMODE))) {
 				throw new IllegalStateException("Can not GENERATE oauth2 signingKey in `prodmode`");
 			}
-			log.warn("We generate a random signingKey");
-			secretKeySpec = KumiteTokenService.generateSignatureSecret(uuidGenerator).toJSONString();
+			synchronized (secretKeySpec) {
+				if (GENERATED_SIGNINGKEY.get() == null) {
+					log.warn("We generate a random signingKey");
+					secretKeySpec = KumiteTokenService.generateSignatureSecret(uuidGenerator).toJSONString();
+					GENERATED_SIGNINGKEY.set(secretKeySpec);
+				} else {
+					secretKeySpec = GENERATED_SIGNINGKEY.get();
+				}
+			}
 		}
 
 		OctetSequenceKey octetSequenceKey = OctetSequenceKey.parse(secretKeySpec);

authorization/src/main/resources/application-unsafe_oauth2.yml

@@ -2,7 +2,7 @@
 
 kumite.oauth2:
     # This key is used to sign refresh_token and access_token
-    # We hardcode one in resource to make development easier
+    # We hardcode the JWK in resource to make development easier
     # Else, on each reboot, all access_token would be invalid
     signing-key: '{"kty":"oct","kid":"d6ff447e-2a6e-4ef6-9e3d-792f2d23f11e","k":"bJpLdV8t1P_Pv9nay4zTVAU7C9VaBsR5pBtuAsAPkOU","alg":"HS256"}'
     issuer-base-url: https://unsafe.oauth2.kumite

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

@@ -2,6 +2,7 @@
 
 import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
+import java.util.random.RandomGenerator;
 
 import org.greenrobot.eventbus.EventBus;
 import org.greenrobot.eventbus.Logger;
@@ -58,12 +59,19 @@
 @Slf4j
 public class KumiteServerComponentsConfiguration {
 	@Bean
-	public BoardLifecycleManager boardLifecycleManager(BoardsRegistry boardRegistry,
+	public BoardLifecycleManager boardLifecycleManager(ContestsRegistry contestsRegistry,
+			BoardsRegistry boardRegistry,
 			ContestPlayersRegistry contestPlayersRegistry,
-			EventBus eventBus) {
+			EventBus eventBus,
+			RandomGenerator randomGenerator) {
 		final Executor boardEvolutionExecutor = Executors.newFixedThreadPool(4);
 
-		return new BoardLifecycleManager(boardRegistry, contestPlayersRegistry, boardEvolutionExecutor, eventBus);
+		return new BoardLifecycleManager(contestsRegistry,
+				boardRegistry,
+				contestPlayersRegistry,
+				boardEvolutionExecutor,
+				eventBus,
+				randomGenerator);
 	}
 
 	@Bean

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

@@ -1,15 +1,9 @@
 package eu.solven.kumite.board;
 
-import java.util.UUID;
-
 import org.greenrobot.eventbus.EventBus;
-import org.greenrobot.eventbus.Subscribe;
 import org.springframework.beans.factory.InitializingBean;
 
-import eu.solven.kumite.contest.Contest;
 import eu.solven.kumite.contest.ContestsRegistry;
-import eu.solven.kumite.events.BoardIsUpdated;
-import eu.solven.kumite.events.ContestIsGameover;
 import lombok.AllArgsConstructor;
 
 @AllArgsConstructor
@@ -22,14 +16,15 @@ public void afterPropertiesSet() {
 		eventBus.register(this);
 	}
 
-	@Subscribe
-	public void onBoardUpdate(BoardIsUpdated boardIsUpdated) {
-		UUID contestId = boardIsUpdated.getContestId();
-
-		Contest contest = contestsRegistry.getContest(contestId);
-		if (contest.getGame().makeDynamicGameover(contest.getBoard()).isGameOver()) {
-			eventBus.post(ContestIsGameover.builder().contestId(contestId).build());
-		}
-	}
+	// BoardIsUpdated->ContestIsGameover is managed by BoardLifecycleManager
+	// @Subscribe
+	// public void onBoardUpdate(BoardIsUpdated boardIsUpdated) {
+	// UUID contestId = boardIsUpdated.getContestId();
+	//
+	// Contest contest = contestsRegistry.getContest(contestId);
+	// if (contest.getGame().makeDynamicGameover(contest.getBoard()).isGameOver()) {
+	// eventBus.post(ContestIsGameover.builder().contestId(contestId).build());
+	// }
+	// }
 
 }

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

@@ -1,18 +1,27 @@
 package eu.solven.kumite.board;
 
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.Executor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.random.RandomGenerator;
 import java.util.stream.Collectors;
 
 import org.greenrobot.eventbus.EventBus;
 
 import eu.solven.kumite.contest.Contest;
+import eu.solven.kumite.contest.ContestsRegistry;
+import eu.solven.kumite.events.ContestIsGameover;
+import eu.solven.kumite.events.PlayerCanMove;
 import eu.solven.kumite.events.PlayerJoinedBoard;
 import eu.solven.kumite.events.PlayerMoved;
+import eu.solven.kumite.move.IKumiteMove;
+import eu.solven.kumite.move.INoOpKumiteMove;
 import eu.solven.kumite.move.PlayerMoveRaw;
 import eu.solven.kumite.player.ContestPlayersRegistry;
 import eu.solven.kumite.player.PlayerJoinRaw;
@@ -22,6 +31,7 @@
 @RequiredArgsConstructor
 @Slf4j
 public class BoardLifecycleManager {
+	final ContestsRegistry contestsRegistry;
 	final BoardsRegistry boardRegistry;
 
 	final ContestPlayersRegistry contestPlayersRegistry;
@@ -31,13 +41,15 @@ public class BoardLifecycleManager {
 
 	final EventBus eventBus;
 
+	final RandomGenerator randomGenerator;
+
 	/**
 	 * When this returns, the caller is guaranteed its change has been executed
 	 * 
 	 * @param contestId
 	 * @param runnable
 	 */
-	public void executeBoardChange(UUID contestId, Runnable runnable) {
+	protected void executeBoardChange(UUID contestId, Runnable runnable) {
 		if (isDirect(boardEvolutionExecutor)) {
 			boardEvolutionExecutor.execute(runnable);
 		} else {
@@ -94,29 +106,83 @@ protected static boolean isDirect(Executor executor) {
 		return false;
 	}
 
-	public void registerPlayer(Contest contest, PlayerJoinRaw playerRegistrationRaw) {
+	/**
+	 * 
+	 * @param contest
+	 * @param playerRegistrationRaw
+	 * @return
+	 */
+	public IKumiteBoardView registerPlayer(Contest contest, PlayerJoinRaw playerRegistrationRaw) {
 		UUID contestId = contest.getContestId();
+		UUID playerId = playerRegistrationRaw.getPlayerId();
+
+		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
 			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));
 		});
 
+		IKumiteBoardView boardViewPostMove = refBoardView.get();
+
+		if (boardViewPostMove == null) {
+			throw new IllegalStateException("Should have failed, or have produced a view");
+		}
+
 		// We submit the event out of threadPool.
 		// Hence we are guaranteed the event is fully processed.
 		// The event subscriber can process it synchronously (through beware of deep-stack in case of long event-chains)
 		// Hence we do not guarantee other events interleaved when the event is processed
-		eventBus.post(
-				PlayerJoinedBoard.builder().contestId(contestId).playerId(playerRegistrationRaw.getPlayerId()).build());
+		eventBus.post(PlayerJoinedBoard.builder().contestId(contestId).playerId(playerId).build());
+
+		enabledPlayersIds.forEach(enabledPlayerId -> {
+			eventBus.post(PlayerCanMove.builder().contestId(contestId).playerId(playerId).build());
+		});
+
+		return boardViewPostMove;
+	}
+
+	private Set<UUID> playersCanMove(UUID contestId, IKumiteBoard board) {
+		Contest contest = contestsRegistry.getContest(contestId);
+
+		Set<UUID> movablePlayerIds = board.snapshotPlayers()
+				.stream()
+				.filter(playerId -> canPlay(
+						contest.getGame().exampleMoves(randomGenerator, board.asView(playerId), playerId)))
+				.collect(Collectors.toSet());
+
+		return movablePlayerIds;
+	}
+
+	private boolean canPlay(Map<String, IKumiteMove> exampleMoves) {
+		return exampleMoves.values().stream().anyMatch(move -> !(move instanceof INoOpKumiteMove));
 	}
 
 	public IKumiteBoardView onPlayerMove(Contest contest, PlayerMoveRaw playerMove) {
 		UUID contestId = contest.getContestId();
+		UUID playerId = playerMove.getPlayerId();
 
-		AtomicReference<IKumiteBoardView> refBoardView = new AtomicReference<>();
+		AtomicReference<IKumiteBoard> refBoard = new AtomicReference<>();
 
-		executeBoardChange(contestId, () -> {
-			UUID playerId = playerMove.getPlayerId();
+		Set<UUID> enabledPlayersIds = new HashSet<>();
 
+		executeBoardChange(contestId, () -> {
 			if (!contestPlayersRegistry.isRegisteredPlayer(contestId, playerId)) {
 				List<UUID> contestPlayers = contestPlayersRegistry.makeDynamicHasPlayers(contestId)
 						.getPlayers()
@@ -132,6 +198,8 @@ public IKumiteBoardView onPlayerMove(Contest contest, PlayerMoveRaw playerMove)
 
 			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);
@@ -144,20 +212,35 @@ public IKumiteBoardView onPlayerMove(Contest contest, PlayerMoveRaw playerMove)
 			// 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);
 
-			refBoardView.set(currentBoard.asView(playerId));
+			refBoard.set(currentBoard);
 
 		});
 
-		IKumiteBoardView boardViewPostMove = refBoardView.get();
+		IKumiteBoard boardAfter = refBoard.get();
+		IKumiteBoardView boardViewPostMove = boardAfter.asView(playerId);
 
 		if (boardViewPostMove == null) {
 			throw new IllegalStateException("Should have failed, or have produced a view");
 		}
 
-		eventBus.post(PlayerMoved.builder().contestId(contestId).playerId(playerMove.getPlayerId()).build());
+		eventBus.post(PlayerMoved.builder().contestId(contestId).playerId(playerId).build());
+
+		enabledPlayersIds.forEach(enabledPlayerId -> {
+			eventBus.post(PlayerCanMove.builder().contestId(contestId).playerId(playerId).build());
+		});
+
+		if (contest.getGame().makeDynamicGameover(() -> boardAfter).isGameOver()) {
+			eventBus.post(ContestIsGameover.builder().contestId(contestId).build());
+		}
 
 		return boardViewPostMove;
 	}