TD-34: Endpoint for getting all players and tests for this endpoint

.forgejo/workflows/build.yml

@@ -36,11 +36,6 @@ jobs:
         with:
           name: api.yml
           path: api/api.yml
-      - name: Upload Websocket Spec as Artifact
-        uses: "https://git.euph.dev/actions/upload-artifact@v3"
-        with:
-          name: ws.yml
-          path: ws/ws.yml
       - name: "Stop Gradle"
         run: gradle --stop
 
@@ -90,11 +85,6 @@ jobs:
         with:
           name: api.yml
           path: release
-      - name: Download Websocket Spec
-        uses: "https://git.euph.dev/actions/download-artifact@v3"
-        with:
-          name: ws.yml
-          path: release
       - name: Create Release
         uses: "https://git.euph.dev/actions/release@v2"
         with:
@@ -106,3 +96,6 @@ jobs:
           release-notes: |
             # Tower Defence - Server ${{ github.ref_name }}
             Read the [Documentation](https://git.euph.dev/TowerDefence/Dokumentation/wiki/Server/Config) to see how to setup the server.
+
+
+

api/api.yml

@@ -39,34 +39,6 @@ components:
         - username
         - password
     #############################################
-    #  PlayerLoginData                          #
-    #############################################
-    PlayerLoginData:
-      description: Data needed to log a Player in
-      type: object
-      properties:
-        username:
-          type: string
-        password:
-          type: string
-      required:
-        - username
-        - password
-    #############################################
-    #  PlayerLoginSession                       #
-    #############################################
-    PlayerLoginSession:
-      description: Data needed to log a Player in
-      type: object
-      properties:
-        username:
-          type: string
-        token:
-          type: string
-      required:
-        - username
-        - token
-    #############################################
     #  AdminAuthInfo                            #
     #############################################
     ServerHealth:
@@ -127,8 +99,6 @@ components:
   responses:
     201PlayerCreated:
       description: "201 - Player Created"
-    401PlayerNameOrPasswordWrong:
-      description: "401 - Player Name or Password is Wrong"
     401Unauthorized:
       description: "401 - Unauthorized"
     404NotFound:
@@ -180,28 +150,6 @@ paths:
           $ref: "#/components/responses/409UsernameTaken"
         500:
           $ref: "#/components/responses/500InternalError"
-  /player/login:
-    post:
-      operationId: "PlayerLogin"
-      tags:
-        - server
-      description: "Endpoint for logging a Player in"
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: "#/components/schemas/PlayerLoginData"
-      responses:
-        200:
-          description: "A Login Session, which can be used in the Webhook"
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/PlayerLoginSession"
-        401:
-          $ref: "#/components/responses/401PlayerNameOrPasswordWrong"
-        500:
-          $ref: "#/components/responses/500InternalError"
   /server/health:
     get:
       operationId: "ServerGetHealthcheck"

build.gradle.kts

@@ -53,11 +53,6 @@ dependencies {
     implementation("org.springframework.boot:spring-boot-starter-oauth2-resource-server")
     developmentOnly("org.springframework.boot:spring-boot-devtools")
 
-    //JWT
-    implementation("io.jsonwebtoken:jjwt-api:0.12.6")
-    runtimeOnly("io.jsonwebtoken:jjwt-impl:0.12.6")
-    runtimeOnly("io.jsonwebtoken:jjwt-jackson:0.12.6")
-
     // Postgres
     runtimeOnly("org.postgresql:postgresql")
 

src/main/java/de/towerdefence/server/match/Match.java

@@ -1,13 +0,0 @@
-package de.towerdefence.server.match;
-
-import de.towerdefence.server.player.Player;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-
-@AllArgsConstructor
-@Getter
-public class Match {
-    private final String matchId;
-    private final Player playerOne;
-    private final Player playerTwo;
-}

src/main/java/de/towerdefence/server/match/confirmation/AbortCallback.java

@@ -1,8 +0,0 @@
-package de.towerdefence.server.match.confirmation;
-
-import de.towerdefence.server.player.Player;
-
-@FunctionalInterface
-public interface AbortCallback {
-    void call(Player player, String matchId);
-}

src/main/java/de/towerdefence/server/match/confirmation/ConfirmationCallbacks.java

@@ -1,16 +0,0 @@
-package de.towerdefence.server.match.confirmation;
-
-import de.towerdefence.server.match.queue.FoundCallback;
-import de.towerdefence.server.match.queue.QueuedCallback;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-
-@Getter
-@AllArgsConstructor
-public class ConfirmationCallbacks {
-    private final FoundCallback foundCallback;
-    private final QueuedCallback queuedCallback;
-    private final AbortCallback abortCallback;
-    private final EstablishedCallback establishedCallback;
-    private final RequeueCallback requeueCallback;
-}

src/main/java/de/towerdefence/server/match/confirmation/EstablishedCallback.java

@@ -1,10 +0,0 @@
-package de.towerdefence.server.match.confirmation;
-
-import de.towerdefence.server.player.Player;
-
-import java.io.IOException;
-
-@FunctionalInterface
-public interface EstablishedCallback {
-    void call(Player player, String matchId, Player opponent) throws IOException;
-}

src/main/java/de/towerdefence/server/match/confirmation/MatchConfirmationService.java

@@ -1,111 +0,0 @@
-package de.towerdefence.server.match.confirmation;
-
-import de.towerdefence.server.player.Player;
-import org.springframework.stereotype.Service;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Optional;
-
-@Service
-public class MatchConfirmationService {
-
-    private final Map<Player, UnconfirmedMatch> unconfirmedMatch = new HashMap<>();
-
-    public UnconfirmedMatch createMatch(Player player1,
-            Player player2,
-            ConfirmationCallbacks player1Callbacks,
-            ConfirmationCallbacks player2callbacks) {
-        UnconfirmedMatch match = new UnconfirmedMatch(
-                player1,
-                player2,
-                player1Callbacks,
-                player2callbacks);
-        unconfirmedMatch.put(player1, match);
-        unconfirmedMatch.put(player2, match);
-        return match;
-    }
-
-    public void accept(Player player, String matchId) {
-        setPlayerAcceptState(player, matchId, PlayerMatchConfirmState.CONFIRMED);
-    }
-
-    public void decline(Player player, String matchId) {
-        setPlayerAcceptState(player, matchId, PlayerMatchConfirmState.ABORTED);
-    }
-
-    private void setPlayerAcceptState(Player player, String matchId, PlayerMatchConfirmState state) {
-        Optional<UnconfirmedMatch> optionalMatch = getPlayerMatch(player, matchId);
-        if (optionalMatch.isEmpty()) {
-            return;
-        }
-        UnconfirmedMatch match = optionalMatch.get();
-
-        Optional<PlayerMatchConfirmState> optionalPlayerState = match.getPlayerState(player);
-        if (optionalPlayerState.isEmpty()) {
-            unconfirmedMatch.remove(player);
-            return;
-        }
-
-        if (optionalPlayerState.get() != PlayerMatchConfirmState.UNKNOWN) {
-            return;
-        }
-
-        Optional<UnconfirmedMatchState> matchState = match.setPlayerConfirmState(player, state);
-        if (matchState.isEmpty()) {
-            unconfirmedMatch.remove(player);
-            return;
-        }
-        handleMatchConfirmation(match, matchState.get());
-    }
-
-    private void handleMatchConfirmation(UnconfirmedMatch match, UnconfirmedMatchState state) {
-        if (state == UnconfirmedMatchState.WAITING) {
-            return;
-        }
-
-        unconfirmedMatch.remove(match.getPlayer1());
-        unconfirmedMatch.remove(match.getPlayer2());
-
-        ConfirmationCallbacks player1Callbacks = match.getPlayer1Callbacks();
-        ConfirmationCallbacks player2Callbacks = match.getPlayer2Callbacks();
-
-        switch (state) {
-            case ABORTED -> {
-                if (match.getPlayer1State() == PlayerMatchConfirmState.CONFIRMED) {
-                    player1Callbacks.getRequeueCallback().call(
-                            match.getPlayer1(),
-                            match.getMatchId(),
-                            player1Callbacks.getFoundCallback(),
-                            player1Callbacks.getQueuedCallback(),
-                            player1Callbacks.getAbortCallback(),
-                            player1Callbacks.getEstablishedCallback());
-                }
-                if (match.getPlayer2State() == PlayerMatchConfirmState.CONFIRMED) {
-                    player2Callbacks.getRequeueCallback().call(
-                            match.getPlayer2(),
-                            match.getMatchId(),
-                            player2Callbacks.getFoundCallback(),
-                            player2Callbacks.getQueuedCallback(),
-                            player2Callbacks.getAbortCallback(),
-                            player2Callbacks.getEstablishedCallback());
-                }
-            }
-            case CONFIRMED -> {
-                // TODO: Create Match and Send Players the info that the Match is created
-            }
-        }
-    }
-
-    private Optional<UnconfirmedMatch> getPlayerMatch(Player player, String matchId) {
-        UnconfirmedMatch match = unconfirmedMatch.get(player);
-        if (match == null) {
-            return Optional.empty();
-        }
-        if (!match.getMatchId().equals(matchId)) {
-            unconfirmedMatch.remove(player);
-            return Optional.empty();
-        }
-        return Optional.of(match);
-    }
-}

src/main/java/de/towerdefence/server/match/confirmation/PlayerMatchConfirmState.java

@@ -1,7 +0,0 @@
-package de.towerdefence.server.match.confirmation;
-
-public enum PlayerMatchConfirmState {
-    UNKNOWN,
-    CONFIRMED,
-    ABORTED
-}

src/main/java/de/towerdefence/server/match/confirmation/RequeueCallback.java

@@ -1,18 +0,0 @@
-package de.towerdefence.server.match.confirmation;
-
-import de.towerdefence.server.match.queue.FoundCallback;
-import de.towerdefence.server.match.queue.QueuedCallback;
-import de.towerdefence.server.player.Player;
-
-@FunctionalInterface
-public interface RequeueCallback {
-    void call(
-            Player player,
-            String matchId,
-            FoundCallback foundCallback,
-            QueuedCallback queuedCallback,
-            AbortCallback abortCallback,
-            EstablishedCallback establishedCallback
-    );
-}
-

src/main/java/de/towerdefence/server/match/confirmation/UnconfirmedMatch.java

@@ -1,85 +0,0 @@
-package de.towerdefence.server.match.confirmation;
-
-import de.towerdefence.server.player.Player;
-import lombok.Getter;
-
-import java.time.Instant;
-import java.util.Optional;
-import java.util.UUID;
-
-@Getter
-public class UnconfirmedMatch {
-    private final String matchId;
-    private final long created;
-    public static final long TTL = 30 * 1000;
-    private final Player player1;
-    private final Player player2;
-    private final ConfirmationCallbacks player1Callbacks;
-    private final ConfirmationCallbacks player2Callbacks;
-
-    public UnconfirmedMatch(
-            Player player1,
-            Player player2,
-            ConfirmationCallbacks player1Callbacks,
-            ConfirmationCallbacks player2Callbacks) {
-        this.player1 = player1;
-        this.player2 = player2;
-        this.player1Callbacks = player1Callbacks;
-        this.player2Callbacks = player2Callbacks;
-        this.created = Instant.now().toEpochMilli();
-        this.matchId = UUID.randomUUID().toString();
-    }
-
-    private PlayerMatchConfirmState player1State = PlayerMatchConfirmState.UNKNOWN;
-    private PlayerMatchConfirmState player2State = PlayerMatchConfirmState.UNKNOWN;
-
-    public Optional<UnconfirmedMatchState> setPlayerConfirmState(Player player, PlayerMatchConfirmState state) {
-        Optional<MatchPlayer> matchPlayer = getMatchPlayer(player);
-        if(matchPlayer.isEmpty()){
-            return Optional.empty();
-        }
-
-        switch (matchPlayer.get()){
-            case ONE -> player1State = state;
-            case TWO -> player2State = state;
-        }
-
-        if (player1State == PlayerMatchConfirmState.ABORTED || player2State == PlayerMatchConfirmState.ABORTED) {
-            return Optional.of(UnconfirmedMatchState.ABORTED);
-        }
-        if (player1State == PlayerMatchConfirmState.UNKNOWN || player2State == PlayerMatchConfirmState.UNKNOWN) {
-            return Optional.of(UnconfirmedMatchState.WAITING);
-        }
-        return Optional.of(UnconfirmedMatchState.CONFIRMED);
-    }
-
-    public Optional<PlayerMatchConfirmState> getPlayerState(Player player){
-        Optional<MatchPlayer> matchPlayer = getMatchPlayer(player);
-        if(matchPlayer.isEmpty()){
-            return Optional.empty();
-        }
-
-        return switch (matchPlayer.get()){
-            case ONE -> Optional.of(player1State);
-            case TWO -> Optional.of(player2State);
-        };
-    }
-
-    private enum MatchPlayer{
-        ONE,
-        TWO
-    }
-
-    private Optional<MatchPlayer> getMatchPlayer(Player player){
-        boolean isPlayerOne = player.equals(player1);
-        boolean isPlayerTwo = player.equals(player2);
-        if (!isPlayerOne && !isPlayerTwo) {
-            return Optional.empty();
-        }
-
-        if (isPlayerOne){
-            return Optional.of(MatchPlayer.ONE);
-        }
-        return Optional.of(MatchPlayer.TWO);
-    }
-}

src/main/java/de/towerdefence/server/match/confirmation/UnconfirmedMatchState.java

@@ -1,7 +0,0 @@
-package de.towerdefence.server.match.confirmation;
-
-public enum UnconfirmedMatchState {
-    WAITING,
-    ABORTED,
-    CONFIRMED
-}

src/main/java/de/towerdefence/server/match/queue/FoundCallback.java

@@ -1,10 +0,0 @@
-package de.towerdefence.server.match.queue;
-
-import de.towerdefence.server.player.Player;
-
-import java.io.IOException;
-
-@FunctionalInterface
-public interface FoundCallback {
-    void call(Player player, String matchId, long created, long ttl) throws IOException;
-}

src/main/java/de/towerdefence/server/match/queue/MatchQueueService.java

@@ -1,143 +0,0 @@
-package de.towerdefence.server.match.queue;
-
-import de.towerdefence.server.match.confirmation.*;
-import de.towerdefence.server.player.Player;
-import lombok.AllArgsConstructor;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-@Service
-@AllArgsConstructor
-public class MatchQueueService {
-    private final static int REQUIRED_PLAYER_COUNT = 2;
-
-    @Autowired
-    private final MatchConfirmationService matchConfirmationService;
-
-    private final List<Player> queue = new ArrayList<>();
-    private final Map<Player, ConfirmationCallbacks> confirmationCallbacks = new HashMap<>();
-
-    public void queuePlayer(
-            Player player,
-            FoundCallback foundCallback,
-            QueuedCallback queuedCallback,
-            AbortCallback abortCallback,
-            EstablishedCallback establishedCallback) {
-        queue.add(player);
-        confirmationCallbacks.put(player, new ConfirmationCallbacks(
-                foundCallback,
-                queuedCallback,
-                abortCallback,
-                establishedCallback,
-                this::onRequeue));
-        tryMatching();
-    }
-
-    public void onRequeue(
-            Player player,
-            String matchId,
-            FoundCallback foundCallback,
-            QueuedCallback queuedCallback,
-            AbortCallback abortCallback,
-            EstablishedCallback establishedCallback) {
-        abortCallback.call(player, matchId);
-        try {
-            queuedCallback.call(player);
-        } catch (IOException ignored) {
-            return;
-        }
-        queuePlayer(player, foundCallback, queuedCallback, abortCallback, establishedCallback);
-    }
-
-    public void unQueuePlayer(Player player) {
-        queue.remove(player);
-        confirmationCallbacks.remove(player);
-    }
-
-    private void tryMatching() {
-        if (queue.size() < REQUIRED_PLAYER_COUNT) {
-            return;
-        }
-
-        List<Player> loopQueue = new ArrayList<>(queue);
-        for (int i = 0; i < loopQueue.size() / REQUIRED_PLAYER_COUNT; i++) {
-            Player player1 = loopQueue.get(REQUIRED_PLAYER_COUNT * i);
-            Player player2 = loopQueue.get(REQUIRED_PLAYER_COUNT * i + 1);
-
-            ConfirmationCallbacks player1Callbacks = confirmationCallbacks.get(player1);
-            ConfirmationCallbacks player2Callbacks = confirmationCallbacks.get(player2);
-
-            UnconfirmedMatch match = this.matchConfirmationService.createMatch(
-                    player1,
-                    player2,
-                    player1Callbacks,
-                    player2Callbacks);
-            sentMatchFound(
-                    match,
-                    player1,
-                    player2,
-                    player1Callbacks,
-                    player2Callbacks);
-
-        }
-        if (queue.size() > REQUIRED_PLAYER_COUNT) {
-            tryMatching();
-        }
-    }
-
-    private void sentMatchFound(
-            UnconfirmedMatch match,
-            Player player1,
-            Player player2,
-            ConfirmationCallbacks player1Callbacks,
-            ConfirmationCallbacks player2Callbacks) {
-        boolean player1disconnected = setMatchFoundToPlayer(player1, player1Callbacks.getFoundCallback(), match);
-        boolean player2disconnected = setMatchFoundToPlayer(player2, player2Callbacks.getFoundCallback(), match);
-
-        queue.remove(player1);
-        queue.remove(player2);
-
-        if (!player1disconnected && !player2disconnected) {
-            return;
-        }
-
-        if (player1disconnected && match.getPlayer2State() != PlayerMatchConfirmState.ABORTED) {
-            player2Callbacks.getRequeueCallback().call(
-                    player2,
-                    match.getMatchId(),
-                    player2Callbacks.getFoundCallback(),
-                    player2Callbacks.getQueuedCallback(),
-                    player2Callbacks.getAbortCallback(),
-                    player2Callbacks.getEstablishedCallback());
-        }
-
-        if (player2disconnected && match.getPlayer1State() != PlayerMatchConfirmState.ABORTED) {
-            player1Callbacks.getRequeueCallback().call(
-                    player1,
-                    match.getMatchId(),
-                    player1Callbacks.getFoundCallback(),
-                    player1Callbacks.getQueuedCallback(),
-                    player1Callbacks.getAbortCallback(),
-                    player1Callbacks.getEstablishedCallback());
-        }
-    }
-
-    private boolean setMatchFoundToPlayer(Player player, FoundCallback callback, UnconfirmedMatch match) {
-        try {
-            callback.call(
-                    player,
-                    match.getMatchId(),
-                    match.getCreated(),
-                    UnconfirmedMatch.TTL);
-        } catch (IOException e) {
-            return true;
-        }
-        return false;
-    }
-}

src/main/java/de/towerdefence/server/match/queue/QueuedCallback.java

@@ -1,10 +0,0 @@
-package de.towerdefence.server.match.queue;
-
-import de.towerdefence.server.player.Player;
-
-import java.io.IOException;
-
-@FunctionalInterface
-public interface QueuedCallback {
-    void call(Player player) throws IOException;
-}

src/main/java/de/towerdefence/server/server/JsonMessage.java

@@ -1,37 +0,0 @@
-package de.towerdefence.server.server;
-
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeFactory;
-import com.fasterxml.jackson.databind.node.ObjectNode;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-
-import java.io.IOException;
-import java.util.Map;
-
-import org.springframework.web.socket.TextMessage;
-import org.springframework.web.socket.WebSocketSession;
-
-
-@Getter
-@AllArgsConstructor
-public abstract class JsonMessage {
-    protected abstract String getMessageId();
-    protected abstract Map<String, JsonNode> getData(JsonNodeFactory factory);
-
-    public void send(WebSocketSession session) throws IOException {
-        session.sendMessage(new TextMessage(getPayload()));
-    }
-
-    public String getPayload() {
-        JsonNodeFactory factory = new JsonNodeFactory(false);
-        ObjectNode msg = factory.objectNode().put("$id", getMessageId());
-        for (Map.Entry<String, JsonNode> entry : getData(factory).entrySet()) {
-            if(entry.getKey().equals("$id")){
-                continue;
-            }
-            msg.set(entry.getKey(), entry.getValue());
-        }
-        return msg.toString();
-    }
-}

src/main/java/de/towerdefence/server/server/JsonWebsocketHandler.java

@@ -1,49 +0,0 @@
-package de.towerdefence.server.server;
-
-import de.towerdefence.server.player.Player;
-import de.towerdefence.server.session.Channel;
-import de.towerdefence.server.session.SessionsService;
-import lombok.AllArgsConstructor;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.web.socket.CloseStatus;
-import org.springframework.web.socket.WebSocketSession;
-import org.springframework.web.socket.handler.TextWebSocketHandler;
-
-import java.util.Map;
-import java.util.Optional;
-import java.util.concurrent.ConcurrentHashMap;
-
-@AllArgsConstructor
-public abstract class JsonWebsocketHandler extends TextWebSocketHandler {
-    private static final Logger logger = LoggerFactory.getLogger(JsonWebsocketHandler.class);
-    public final Channel channel;
-    protected final SessionsService sessionsService;
-    protected final Map<WebSocketSession, Player> sessionPlayers = new ConcurrentHashMap<>();
-
-    @Override
-    public void afterConnectionEstablished(WebSocketSession session) {
-        String jwt = session.getHandshakeHeaders().getFirst("Authorization");
-        if (jwt == null){
-            closeSession(session, CloseStatus.NOT_ACCEPTABLE);
-            return;
-        }
-        Optional<Player> player = sessionsService.getSession(jwt, channel);
-        if(player.isEmpty()){
-            closeSession(session, CloseStatus.NOT_ACCEPTABLE);
-            return;
-        }
-        sessionPlayers.put(session, player.get());
-    }
-
-    protected void closeSession(WebSocketSession session, CloseStatus reason){
-        if(session.isOpen()){
-            try{
-                session.close(reason);
-            } catch (Exception exception) {
-                logger.info("Unable to Close the Session", exception);
-            }
-        }
-    }
-
-}

src/main/java/de/towerdefence/server/server/ServerApiController.java

@@ -2,15 +2,11 @@ package de.towerdefence.server.server;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import de.towerdefence.server.oas.ServerApi;
-import de.towerdefence.server.oas.models.PlayerLoginData;
-import de.towerdefence.server.oas.models.PlayerLoginSession;
 import de.towerdefence.server.oas.models.PlayerRegistrationData;
 import de.towerdefence.server.oas.models.ServerHealth;
 import de.towerdefence.server.player.Player;
 import de.towerdefence.server.player.PlayerRepository;
 import de.towerdefence.server.player.PlayerService;
-import de.towerdefence.server.session.Channel;
-import de.towerdefence.server.session.SessionsService;
 import jakarta.servlet.http.HttpServletRequest;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpStatus;
@@ -29,8 +25,6 @@ public class ServerApiController implements ServerApi {
     private PlayerRepository playerRepository;
     @Autowired
     private PlayerService playerService;
-    @Autowired
-    private SessionsService sessionsService;
 
     @Override
     public Optional<ObjectMapper> getObjectMapper() {
@@ -58,26 +52,6 @@ public class ServerApiController implements ServerApi {
         return new ResponseEntity<>(HttpStatus.CREATED);
     }
 
-    @Override
-    public ResponseEntity<PlayerLoginSession> playerLogin(PlayerLoginData body) {
-        Player player = playerRepository.findByUsername(body.getUsername());
-        if(player == null){
-            return new ResponseEntity<>(HttpStatus.UNAUTHORIZED);
-        }
-        try {
-            if(!playerService.checkPassword(player, body.getPassword())) {
-                return new ResponseEntity<>(HttpStatus.UNAUTHORIZED);
-            }
-        } catch (NoSuchAlgorithmException e) {
-            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
-        }
-        String token = sessionsService.createSession(player, Channel.CONNECTION);
-        PlayerLoginSession session = new PlayerLoginSession();
-        session.setUsername(player.getUsername());
-        session.setToken(token);
-        return new ResponseEntity<>(session, HttpStatus.OK);
-    }
-
     @Override
     public ResponseEntity<ServerHealth> serverGetHealthcheck() {
         ServerHealth health = new ServerHealth();

src/main/java/de/towerdefence/server/server/ServerWebsocketHandler.java

@@ -1,27 +1,19 @@
-package de.towerdefence.server.server.channels.time;
+package de.towerdefence.server.server;
 
-import de.towerdefence.server.server.JsonWebsocketHandler;
+import org.springframework.web.socket.TextMessage;
-import de.towerdefence.server.session.Channel;
-import de.towerdefence.server.session.SessionsService;
 import org.springframework.web.socket.WebSocketSession;
+import org.springframework.web.socket.handler.TextWebSocketHandler;
 
 import java.io.IOException;
 import java.util.Map;
 import java.util.concurrent.*;
 
-public class TimeWebsocketHandler extends JsonWebsocketHandler {
+public class ServerWebsocketHandler extends TextWebSocketHandler {
-
-    private final Map<WebSocketSession, ScheduledFuture<?>> sessionTaskMap = new ConcurrentHashMap<>();
     private static final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
-
+    private final Map<WebSocketSession, ScheduledFuture<?>> sessionTaskMap = new ConcurrentHashMap<>();
-    public TimeWebsocketHandler(SessionsService sessionsService) {
-        super(Channel.TIME, sessionsService);
-    }
 
     @Override
-    public void afterConnectionEstablished(WebSocketSession session) {
+    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
-        super.afterConnectionEstablished(session);
-
         ScheduledFuture<?> scheduledTask = scheduler.scheduleAtFixedRate(
                 () -> sendCurrentTime(session),
                 0,
@@ -31,16 +23,25 @@ public class TimeWebsocketHandler extends JsonWebsocketHandler {
         sessionTaskMap.put(session, scheduledTask);
     }
 
+    @Override
+    public void handleTextMessage(WebSocketSession session, TextMessage message) {
+        try {
+            String responseMessage = "You are Connected to the Tower Defence Server Websocket";
+            session.sendMessage(new TextMessage(responseMessage));
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
     private void sendCurrentTime(WebSocketSession session) {
         ScheduledFuture<?> task = sessionTaskMap.get(session);
         try {
-            if(!session.isOpen()){
+            session.sendMessage(new TextMessage(String.valueOf(System.currentTimeMillis())));
-                throw new RuntimeException("Session is not open");
+        } catch (IllegalStateException | IOException e) {
-            }
-            new TimeMessage(System.currentTimeMillis()).send(session);
-        } catch (RuntimeException | IOException e) {
             task.cancel(true);
             sessionTaskMap.remove(session);
+        } catch (Exception e) {
+            e.printStackTrace();
         }
     }
 }

src/main/java/de/towerdefence/server/server/WebSocketConfig.java

@@ -0,0 +1,15 @@
+package de.towerdefence.server.server;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.socket.config.annotation.EnableWebSocket;
+import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
+import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
+
+@Configuration
+@EnableWebSocket
+public class WebSocketConfig implements WebSocketConfigurer {
+    @Override
+    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
+        registry.addHandler(new ServerWebsocketHandler(), "/ws/server").setAllowedOrigins("*");
+    }
+}

src/main/java/de/towerdefence/server/server/channels/WebsocketConfig.java

@@ -1,46 +0,0 @@
-package de.towerdefence.server.server.channels;
-
-import de.towerdefence.server.match.confirmation.MatchConfirmationService;
-import de.towerdefence.server.match.queue.MatchQueueService;
-import de.towerdefence.server.server.JsonWebsocketHandler;
-import de.towerdefence.server.server.channels.connection.ConnectionWebsocketHandler;
-import de.towerdefence.server.server.channels.matchmaking.MatchmakingWebsocketHandler;
-import de.towerdefence.server.server.channels.time.TimeWebsocketHandler;
-import de.towerdefence.server.session.SessionsService;
-import lombok.AllArgsConstructor;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.web.socket.config.annotation.EnableWebSocket;
-import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
-import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
-
-@AllArgsConstructor
-@Configuration
-@EnableWebSocket
-public class WebsocketConfig implements WebSocketConfigurer {
-    private static final String CHANNEL_BASE_PATH = "/ws/";
-    @Autowired
-    private final SessionsService sessionsService;
-    @Autowired
-    private  final MatchQueueService matchQueueService;
-    @Autowired
-    private  final MatchConfirmationService matchConfirmationService;
-
-    @Override
-    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
-        registerJsonChannel(registry, new ConnectionWebsocketHandler(this.sessionsService));
-        registerJsonChannel(registry, new MatchmakingWebsocketHandler(
-                this.sessionsService,
-                this.matchQueueService,
-                this.matchConfirmationService
-        ));
-        registerJsonChannel(registry, new TimeWebsocketHandler(this.sessionsService));
-    }
-
-    private void registerJsonChannel(WebSocketHandlerRegistry registry, JsonWebsocketHandler handler){
-        registry.addHandler(
-                handler,
-                CHANNEL_BASE_PATH + handler.channel.getJsonName()
-        ).setAllowedOrigins("*");
-    }
-}

src/main/java/de/towerdefence/server/server/channels/connection/ConnectionWebsocketHandler.java

@@ -1,40 +0,0 @@
-package de.towerdefence.server.server.channels.connection;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-import de.towerdefence.server.player.Player;
-import de.towerdefence.server.server.JsonWebsocketHandler;
-import de.towerdefence.server.server.channels.connection.in.RequestConnectionTokenMessage;
-import de.towerdefence.server.server.channels.connection.out.ProvidedConnectionTokenMessage;
-import de.towerdefence.server.session.Channel;
-import de.towerdefence.server.session.SessionsService;
-import org.springframework.web.socket.CloseStatus;
-import org.springframework.web.socket.TextMessage;
-import org.springframework.web.socket.WebSocketSession;
-
-public class ConnectionWebsocketHandler extends JsonWebsocketHandler {
-    private final ObjectMapper objectMapper = new ObjectMapper();
-
-    public ConnectionWebsocketHandler(SessionsService sessionsService) {
-        super(Channel.CONNECTION, sessionsService);
-    }
-
-    @Override
-    protected void handleTextMessage(WebSocketSession session, TextMessage message) {
-        try{
-            String payload = message.getPayload();
-            switch ( objectMapper.readTree(payload).get("$id").asText()) {
-                case RequestConnectionTokenMessage.MESSAGE_ID -> handleRequestConnectionToken(session, payload);
-                default -> this.closeSession(session, CloseStatus.BAD_DATA);
-            }
-        } catch (Exception ignored) {
-            this.closeSession(session, CloseStatus.BAD_DATA);
-        }
-    }
-
-    private void handleRequestConnectionToken(WebSocketSession session, String payload) throws Exception {
-        RequestConnectionTokenMessage msg = objectMapper.readValue(payload, RequestConnectionTokenMessage.class);
-        Player player = this.sessionPlayers.get(session);
-        String jwt = this.sessionsService.createSession(player, msg.getChannel());
-        new ProvidedConnectionTokenMessage(msg.getChannel(), jwt).send(session);
-    }
-}

src/main/java/de/towerdefence/server/server/channels/connection/in/RequestConnectionTokenMessage.java

@@ -1,16 +0,0 @@
-package de.towerdefence.server.server.channels.connection.in;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import de.towerdefence.server.session.Channel;
-import jakarta.validation.constraints.NotNull;
-import lombok.*;
-
-@Data
-@NotNull
-public class RequestConnectionTokenMessage {
-    public static final String MESSAGE_ID = "RequestConnectionToken";
-
-    @JsonProperty("$id")
-    private String messageId;
-    private Channel channel;
-}

src/main/java/de/towerdefence/server/server/channels/connection/out/ProvidedConnectionTokenMessage.java

@@ -1,28 +0,0 @@
-package de.towerdefence.server.server.channels.connection.out;
-
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeFactory;
-import de.towerdefence.server.server.JsonMessage;
-import de.towerdefence.server.session.Channel;
-import lombok.AllArgsConstructor;
-
-import java.util.Map;
-
-@AllArgsConstructor
-public class ProvidedConnectionTokenMessage extends JsonMessage {
-    private final Channel channel;
-    private final String token;
-
-    @Override
-    protected String getMessageId() {
-        return "ProvidedConnectionToken";
-    }
-
-    @Override
-    protected Map<String, JsonNode> getData(JsonNodeFactory factory) {
-        return Map.of(
-                "channel", factory.textNode(channel.getJsonName()),
-                "token", factory.textNode(token)
-        );
-    }
-}

src/main/java/de/towerdefence/server/server/channels/matchmaking/MatchmakingWebsocketHandler.java

@@ -1,112 +0,0 @@
-package de.towerdefence.server.server.channels.matchmaking;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-import de.towerdefence.server.match.confirmation.MatchConfirmationService;
-import de.towerdefence.server.match.queue.MatchQueueService;
-import de.towerdefence.server.player.Player;
-import de.towerdefence.server.server.JsonWebsocketHandler;
-import de.towerdefence.server.server.channels.matchmaking.bi.MatchSetSearchStateMessage;
-import de.towerdefence.server.server.channels.matchmaking.in.MatchAcceptedMessage;
-import de.towerdefence.server.server.channels.matchmaking.out.MatchAbortedMessage;
-import de.towerdefence.server.server.channels.matchmaking.out.MatchEstablishedMessage;
-import de.towerdefence.server.server.channels.matchmaking.out.MatchFoundMessage;
-import de.towerdefence.server.session.Channel;
-import de.towerdefence.server.session.SessionsService;
-import org.springframework.web.socket.CloseStatus;
-import org.springframework.web.socket.TextMessage;
-import org.springframework.web.socket.WebSocketSession;
-
-import java.io.IOException;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
-public class MatchmakingWebsocketHandler extends JsonWebsocketHandler {
-    protected final Map<Player, WebSocketSession> playerSessions = new ConcurrentHashMap<>();
-    private final ObjectMapper objectMapper = new ObjectMapper();
-    private final MatchQueueService matchQueueService;
-    private final MatchConfirmationService matchConfirmationService;
-
-
-    public MatchmakingWebsocketHandler(
-            SessionsService sessionsService,
-            MatchQueueService matchQueueService,
-            MatchConfirmationService matchConfirmationService
-    ) {
-        super(Channel.MATCHMAKING, sessionsService);
-        this.matchQueueService = matchQueueService;
-        this.matchConfirmationService = matchConfirmationService;
-    }
-
-    @Override
-    public void afterConnectionEstablished(WebSocketSession session) {
-        super.afterConnectionEstablished(session);
-        playerSessions.put(sessionPlayers.get(session), session);
-    }
-
-    @Override
-    protected void handleTextMessage(WebSocketSession session, TextMessage message) {
-        try {
-            String payload = message.getPayload();
-            switch (objectMapper.readTree(payload).get("$id").asText()) {
-                case MatchSetSearchStateMessage.MESSAGE_ID -> handleMatchSetSearchStateMessage(session, payload);
-                case MatchAcceptedMessage.MESSAGE_ID -> handleMatchAcceptedMessage(session, payload);
-                default -> this.closeSession(session, CloseStatus.BAD_DATA);
-            }
-        } catch (Exception ignored) {
-            this.closeSession(session, CloseStatus.BAD_DATA);
-        }
-    }
-
-    private void handleMatchSetSearchStateMessage(WebSocketSession session, String payload) throws Exception {
-        MatchSetSearchStateMessage msg = objectMapper.readValue(payload, MatchSetSearchStateMessage.class);
-        Player player = sessionPlayers.get(session);
-        if (!msg.isSearching()) {
-            this.matchQueueService.unQueuePlayer(player);
-            return;
-        }
-        this.matchQueueService.queuePlayer(
-                player,
-                this::onFound,
-                this::onQueued,
-                this::onAbort,
-                this::onEstablished
-        );
-    }
-
-    private void onFound(Player player, String matchId, long created, long ttl) throws IOException {
-        WebSocketSession session = playerSessions.get(player);
-        MatchFoundMessage msg = new MatchFoundMessage(matchId, created, ttl);
-        msg.send(session);
-    }
-
-    private void onQueued(Player player) throws IOException{
-        WebSocketSession session = playerSessions.get(player);
-        MatchSetSearchStateMessage msg = new MatchSetSearchStateMessage(true);
-        msg.send(session);
-    }
-
-    private void onAbort(Player player, String matchId) {
-        WebSocketSession session = playerSessions.get(player);
-        MatchAbortedMessage msg = new MatchAbortedMessage(matchId);
-        try {
-            msg.send(session);
-        } catch (IOException ignored) {
-        }
-    }
-
-    private void onEstablished(Player player, String matchId, Player opponent) throws IOException {
-        WebSocketSession session = playerSessions.get(player);
-        MatchEstablishedMessage msg = new MatchEstablishedMessage(matchId, opponent.getUsername());
-        msg.send(session);
-    }
-
-    private void handleMatchAcceptedMessage(WebSocketSession session, String payload) throws Exception {
-        MatchAcceptedMessage msg = objectMapper.readValue(payload, MatchAcceptedMessage.class);
-        Player player = sessionPlayers.get(session);
-        if (msg.isAccepted()) {
-            this.matchConfirmationService.accept(player, msg.getMatchId());
-        } else {
-            this.matchConfirmationService.decline(player, msg.getMatchId());
-        }
-    }
-}

src/main/java/de/towerdefence/server/server/channels/matchmaking/bi/MatchSetSearchStateMessage.java

@@ -1,35 +0,0 @@
-package de.towerdefence.server.server.channels.matchmaking.bi;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeFactory;
-import de.towerdefence.server.server.JsonMessage;
-import jakarta.validation.constraints.NotNull;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-
-import java.util.Map;
-
-@Getter
-@NotNull
-@AllArgsConstructor
-public class MatchSetSearchStateMessage extends JsonMessage {
-    public static final String MESSAGE_ID = "MatchSetSearchState";
-
-    @Getter
-    @JsonProperty("$id")
-    private String messageId;
-
-    private boolean searching;
-
-    public MatchSetSearchStateMessage(boolean searching) {
-        this(MESSAGE_ID, searching);
-    }
-
-    @Override
-    protected Map<String, JsonNode> getData(JsonNodeFactory factory) {
-        return Map.of(
-                "searching", factory.booleanNode(this.searching)
-        );
-    }
-}

src/main/java/de/towerdefence/server/server/channels/matchmaking/in/MatchAcceptedMessage.java

@@ -1,15 +0,0 @@
-package de.towerdefence.server.server.channels.matchmaking.in;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import jakarta.validation.constraints.NotNull;
-import lombok.Data;
-
-@Data
-@NotNull
-public class MatchAcceptedMessage {
-    public static final String MESSAGE_ID = "MatchAccepted";
-    @JsonProperty("$id")
-    private String messageId;
-    private String matchId;
-    private boolean accepted;
-}

src/main/java/de/towerdefence/server/server/channels/matchmaking/out/MatchAbortedMessage.java

@@ -1,25 +0,0 @@
-package de.towerdefence.server.server.channels.matchmaking.out;
-
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeFactory;
-import de.towerdefence.server.server.JsonMessage;
-import lombok.AllArgsConstructor;
-
-import java.util.Map;
-
-@AllArgsConstructor
-public class MatchAbortedMessage extends JsonMessage {
-    private String matchId;
-
-    @Override
-    protected String getMessageId() {
-        return "MatchAborted";
-    }
-
-    @Override
-    protected Map<String, JsonNode> getData(JsonNodeFactory factory) {
-        return Map.of(
-                "matchId", factory.textNode(this.matchId)
-        );
-    }
-}

src/main/java/de/towerdefence/server/server/channels/matchmaking/out/MatchEstablishedMessage.java

@@ -1,27 +0,0 @@
-package de.towerdefence.server.server.channels.matchmaking.out;
-
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeFactory;
-import de.towerdefence.server.server.JsonMessage;
-import lombok.AllArgsConstructor;
-
-import java.util.Map;
-
-@AllArgsConstructor
-public class MatchEstablishedMessage extends JsonMessage {
-    private String matchId;
-    private String opponentName;
-
-    @Override
-    protected String getMessageId() {
-        return "MatchEstablished";
-    }
-
-    @Override
-    protected Map<String, JsonNode> getData(JsonNodeFactory factory) {
-        return Map.of(
-                "matchId", factory.textNode(this.matchId),
-                "opponentName", factory.textNode(this.opponentName)
-        );
-    }
-}

src/main/java/de/towerdefence/server/server/channels/matchmaking/out/MatchFoundMessage.java

@@ -1,29 +0,0 @@
-package de.towerdefence.server.server.channels.matchmaking.out;
-
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeFactory;
-import de.towerdefence.server.server.JsonMessage;
-import lombok.AllArgsConstructor;
-
-import java.util.Map;
-
-@AllArgsConstructor
-public class MatchFoundMessage extends JsonMessage {
-    private String matchId;
-    private long created;
-    private long ttl;
-
-    @Override
-    protected String getMessageId() {
-        return "MatchFound";
-    }
-
-    @Override
-    protected Map<String, JsonNode> getData(JsonNodeFactory factory) {
-        return Map.of(
-                "matchId", factory.textNode(this.matchId),
-                "created", factory.numberNode(this.created),
-                "ttl", factory.numberNode(this.ttl)
-        );
-    }
-}

src/main/java/de/towerdefence/server/server/channels/time/TimeMessage.java

@@ -1,23 +0,0 @@
-package de.towerdefence.server.server.channels.time;
-
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeFactory;
-import de.towerdefence.server.server.JsonMessage;
-import lombok.AllArgsConstructor;
-
-import java.util.Map;
-
-@AllArgsConstructor
-public class TimeMessage extends JsonMessage {
-    private final long time;
-
-    @Override
-    protected String getMessageId() {
-        return "CurrentUnixTime";
-    }
-
-    @Override
-    protected Map<String, JsonNode> getData(JsonNodeFactory factory) {
-        return Map.of("time", factory.numberNode(this.time));
-    }
-}

src/main/java/de/towerdefence/server/session/Channel.java

@@ -1,25 +0,0 @@
-package de.towerdefence.server.session;
-
-import com.fasterxml.jackson.annotation.JsonCreator;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-
-@Getter
-@AllArgsConstructor
-public enum Channel {
-    CONNECTION("connection"),
-    MATCHMAKING("matchmaking"),
-    TIME("time");
-
-    private final String jsonName;
-
-    @JsonCreator
-    public static Channel fromJsonName(String jsonName) {
-        for (Channel channel : Channel.values()) {
-            if (channel.getJsonName().equalsIgnoreCase(jsonName)) {
-                return channel;
-            }
-        }
-        throw new IllegalArgumentException("Unknown channel: " + jsonName);
-    }
-}

src/main/java/de/towerdefence/server/session/JwtService.java

@@ -1,61 +0,0 @@
-package de.towerdefence.server.session;
-
-import io.jsonwebtoken.Claims;
-import io.jsonwebtoken.Jwts;
-import io.jsonwebtoken.security.Keys;
-import io.jsonwebtoken.security.WeakKeyException;
-import jakarta.annotation.PostConstruct;
-import org.springframework.stereotype.Service;
-
-import javax.crypto.SecretKey;
-import java.nio.charset.StandardCharsets;
-import java.util.Date;
-import java.util.Optional;
-
-@Service
-public class JwtService {
-
-    private final SecretKey secretKey;
-
-    public JwtService(JwtServiceConfig config) throws WeakKeyException {
-        this.secretKey = Keys.hmacShaKeyFor(config.getSecret().getBytes(StandardCharsets.UTF_8));
-    }
-
-    public String generateToken(String username, Channel channel, long ttl) {
-        long now = System.currentTimeMillis();
-        Date issueDate = new Date(now);
-        Date expirationDate = new Date(now + ttl * 1000);
-
-        return Jwts.builder()
-                .subject(username)
-                .claim("channel", channel.getJsonName())
-                .issuedAt(issueDate)
-                .expiration(expirationDate)
-                .signWith(secretKey)
-                .compact();
-    }
-
-    public Optional<String> verifyToken(String token, Channel channel) {
-        Claims claims = Jwts.parser()
-                .verifyWith(secretKey)
-                .build()
-                .parseSignedClaims(token)
-                .getPayload();
-
-        if (claims.getExpiration().before(new Date())) {
-            return Optional.empty();
-        }
-
-        Channel tokenChannel;
-        try {
-            tokenChannel = Channel.fromJsonName(claims.get("channel", String.class));
-        } catch (IllegalArgumentException ignored) {
-            return Optional.empty();
-        }
-        if(!channel.equals(tokenChannel)) {
-            return Optional.empty();
-        }
-
-        return Optional.of(claims.getSubject());
-    }
-}

src/main/java/de/towerdefence/server/session/JwtServiceConfig.java

@@ -1,14 +0,0 @@
-package de.towerdefence.server.session;
-
-import lombok.Getter;
-import lombok.Setter;
-import org.springframework.boot.context.properties.ConfigurationProperties;
-import org.springframework.context.annotation.Configuration;
-
-@Getter
-@Setter
-@Configuration
-@ConfigurationProperties(prefix = "jwt")
-public class JwtServiceConfig {
-    private String secret;
-}

src/main/java/de/towerdefence/server/session/SessionsService.java

@@ -1,63 +0,0 @@
-package de.towerdefence.server.session;
-
-import de.towerdefence.server.player.Player;
-import lombok.AllArgsConstructor;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-
-import java.util.Map;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.concurrent.*;
-
-@Service
-@AllArgsConstructor
-public class SessionsService {
-    private static final int TIME_TO_LIVE_SECONDS = 30;
-
-    private final Map<String, Channel> tokenGrants = new ConcurrentHashMap<>();
-    private final Map<String, Player> sessions = new ConcurrentHashMap<>();
-    private final Map<String, ScheduledFuture<?>> tokenGarbageCollectors = new ConcurrentHashMap<>();
-
-    @Autowired
-    private final JwtService jwtService;
-    private static final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
-
-    public String createSession(Player player, Channel channel){
-        String jwt = jwtService.generateToken(player.getUsername(), channel, TIME_TO_LIVE_SECONDS);
-        if(tokenGrants.containsKey(jwt)){
-            throw new IllegalStateException("The exact same JWT allready exists");
-        }
-        tokenGrants.put(jwt, channel);
-        sessions.put(jwt, player);
-        this.tokenGarbageCollectors.put(jwt, scheduler.schedule(() -> {
-            tokenGrants.remove(jwt);
-            sessions.remove(jwt);
-            tokenGarbageCollectors.remove(jwt);
-        }, TIME_TO_LIVE_SECONDS, TimeUnit.SECONDS));
-        return jwt;
-    }
-
-    public Optional<Player> getSession(String jwt, Channel channel){
-        Channel grantedChannel = tokenGrants.get(jwt);
-        if (grantedChannel == null || !grantedChannel.equals(channel)) {
-            return Optional.empty();
-        }
-        Optional<String> username = jwtService.verifyToken(jwt, channel);
-        if (username.isEmpty()) {
-            return Optional.empty();
-        }
-        Player player = sessions.get(jwt);
-        if (!Objects.equals(player.getUsername(), username.get())) {
-            return Optional.empty();
-        }
-        ScheduledFuture<?> garbageCollector = tokenGarbageCollectors.get(jwt);
-        if (garbageCollector != null && !garbageCollector.isCancelled() && !garbageCollector.isDone()) {
-            garbageCollector.cancel(false);
-        }
-        tokenGarbageCollectors.remove(jwt);
-        tokenGrants.remove(jwt);
-        sessions.remove(jwt);
-        return Optional.of(player);
-    }
-}

src/main/resources/application.properties

@@ -9,11 +9,8 @@ spring.datasource.username=${TD_DB_USER:td_user}
 spring.datasource.password=${TD_DB_PASS:td123}
 spring.jpa.hibernate.ddl-auto=create-drop
 
-# Signing JWT
-jwt.secret=i-am-secret-key-that-you-wont-guess
-
 # TODO: Replace with our own IAM (After completion of the project)
-# JWT Auth for Keycloak
+# JWT Auth
 spring.security.oauth2.client.registration.keycloak.client-id=employee-management-service
 spring.security.oauth2.client.registration.keycloak.authorization-grant-type=authorization_code
 spring.security.oauth2.client.registration.keycloak.scope=openid

src/main/resources/spotbugs-exclude.xml

@@ -2,16 +2,11 @@
     xmlns="https://raw.githubusercontent.com/spotbugs/spotbugs/4.8.6/spotbugs/etc/findbugsfilter.xsd">
     <Match>
         <Source name="~.*" />
-        <Bug code="EI,EI2,UuF" /> <!-- We don't care about these codes -->
+        <Bug code="EI,EI2" /> <!-- We don't care about these codes -->
     </Match>
     <Match>
         <!--Ignore
         Auto Generated Code -->
         <Source name="~.*build/.*" />
     </Match>
-    <Match>
-        <!-- We are not Vulnerable to that Attack in our Context-->
-        <Class name="de.towerdefence.server.session.JwtService"/>
-        <Bug code="M,B,CT"/>
-    </Match>
 </FindBugsFilter>

src/test/java/de/towerdefence/server/IntegrationTest.java

@@ -3,6 +3,7 @@ package de.towerdefence.server;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import de.towerdefence.server.player.Player;
 import de.towerdefence.server.player.PlayerRepository;
+import de.towerdefence.server.player.PlayerService;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.springframework.beans.factory.annotation.Autowired;

ws/example/time_channel.sh

@@ -1,17 +0,0 @@
-#!/bin/sh
-
-response=$(curl -s -X 'POST' \
-  'http://localhost:8080/api/v1/player/login' \
-  -H 'accept: application/json' \
-  -H 'Content-Type: application/json' \
-  -d '{
-  "username": "Player1",
-  "password": "1234"
-}')
-
-token=$(echo "$response" | jq -r .token)
-payload='{"$id": "RequestConnectionToken", "channel": "time"}'
-response=$(echo "$payload" | websocat ws://localhost:8080/ws/connection -H "Authorization: $token")
-
-time_token=$(echo "$response" | jq -r .token)
-websocat ws://localhost:8080/ws/time -H "Authorization: $time_token"

ws/ws.yml

@@ -1,258 +0,0 @@
-asyncapi: 3.0.0
-info:
-  title: Game Server
-  version: 0.0.1
-  description: |
-    This is the Websocket Specification for the Tower Defence Game. <br>
-    Because of the limitations of Async API, we expect that the actual json,
-    which is send as payload to always contain a field called `$id` with
-    the corresponding `messageId`. <br>
-    The `messageId` should be handled case sensitive.
-defaultContentType: application/json
-servers:
-  localhost:
-    host: localhost:8080
-    protocol: ws
-    pathname: /ws
-    security:
-      - $ref: "#/components/securitySchemes/JwtAuth"
-
-channels:
-  connection:
-    title: Connection
-    description: |
-      The Base Channel used for:
-      - Authentication
-      - Receiving Tokens for other channels
-      - Reconnection
-    messages:
-      RequestConnectionToken:
-        description: |
-          A Message telling the Server, that
-          you want an Connection Token for a
-          Specific Channel
-        payload:
-          type: object
-          additionalProperties: false
-          properties:
-            $id:
-              type: string
-              format: messageId
-            channel:
-              $ref: "#/components/schemas/Channel"
-          required:
-            - $id
-            - channel
-      ProvidedConnectionToken:
-        description: |
-          A Message telling the Server, that
-          you want an Connection Token for a
-          Specific Channel
-        payload:
-          type: object
-          additionalProperties: false
-          properties:
-            $id:
-              type: string
-              format: messageId
-            channel:
-              $ref: "#/components/schemas/Channel"
-            token:
-              $ref: "#/components/schemas/JWT"
-          required:
-            - $id
-            - channel
-            - token
-
-  matchmaking:
-    title: Matchmaking
-    description:  |
-      A Channel used to search for a match and
-      to receive one
-    messages:
-      MatchSetSearchState:
-        payload:
-          type: object
-          additionalProperties: false
-          properties:
-            $id:
-              type: string
-              format: messageId
-            searching:
-              type: boolean
-          required:
-            - $id
-            - searching
-      MatchFound:
-        payload:
-          type: object
-          additionalProperties: false
-          properties:
-            $id:
-              type: string
-              format: messageId
-            matchId:
-              type: string
-            created:
-              description: "Unix Timestamp describing when this Match was found"
-              type: integer
-              format: int64
-            ttl:
-              description: "Time in Milliseconds, how long this Match is open for accepting"
-              type: integer
-              format: int64
-          required:
-            - $id
-            - matchId
-            - created
-            - ttl
-      MatchAccepted:
-        payload:
-          type: object
-          additionalProperties: false
-          properties:
-            $id:
-              type: string
-              format: messageId
-            matchId:
-              type: string
-            accepted:
-              type: boolean
-          required:
-            - $id
-            - matchId
-            - accepted
-      MatchAborted:
-        payload:
-          type: object
-          additionalProperties: false
-          properties:
-            $id:
-              type: string
-              format: messageId
-            matchId:
-              type: string
-          required:
-            - $id
-            - matchId
-      MatchEstablished:
-        payload:
-          type: object
-          additionalProperties: false
-          properties:
-            $id:
-              type: string
-              format: messageId
-            matchId:
-              type: string
-            opponentName:
-              type: string
-          required:
-            - $id
-            - matchId
-            - opponentName
-
-  time:
-    title: Time
-    description: |
-      A Simple example channel for receiving
-      the current Unix time
-    messages:
-      CurrentUnixTime:
-        description: The Current time in Unix Time
-        payload:
-          type: object
-          additionalProperties: false
-          properties:
-            $id:
-              type: string
-              format: messageId
-            time:
-              type: integer
-              format: int64
-          required:
-            - $id
-            - time
-
-operations:
-  requestConnectionToken:
-    title: RequestConnectionToken
-    action: send
-    channel:
-      $ref: "#/channels/connection"
-    messages:
-      - $ref: "#/channels/connection/messages/RequestConnectionToken"
-    reply:
-      channel:
-        $ref: "#/channels/connection"
-      messages:
-        - $ref: "#/channels/connection/messages/ProvidedConnectionToken"
-  searchMatch:
-    title: SearchMatch
-    action: send
-    channel:
-      $ref: "#/channels/matchmaking"
-    messages:
-      - $ref: "#/channels/matchmaking/messages/MatchSetSearchState"
-  setPlayerMatchSearching:
-    title: SetPlayerMatchSearching
-    action: receive
-    channel:
-      $ref: "#/channels/matchmaking"
-    messages:
-      - $ref: "#/channels/matchmaking/messages/MatchSetSearchState"
-  foundMatch:
-    title: FoundGame
-    action: receive
-    channel:
-      $ref: "#/channels/matchmaking"
-    messages:
-      - $ref: "#/channels/matchmaking/messages/MatchFound"
-    reply:
-      channel:
-        $ref: "#/channels/matchmaking"
-      messages:
-        - $ref: "#/channels/matchmaking/messages/MatchAccepted"
-  abortedMatch:
-    title: AbortedMatch
-    action: receive
-    channel:
-      $ref: "#/channels/matchmaking"
-    messages:
-      - $ref: "#/channels/matchmaking/messages/MatchAborted"
-  establishedMatch:
-    title: EstablishedMatch
-    action: receive
-    channel:
-      $ref: "#/channels/matchmaking"
-    messages:
-      - $ref: "#/channels/matchmaking/messages/MatchEstablished"
-  updateTime:
-    title: Updates of the current Unix Time
-    action: receive
-    channel:
-      $ref: "#/channels/time"
-    messages:
-      - $ref: "#/channels/time/messages/CurrentUnixTime"
-
-components:
-  securitySchemes:
-    JwtAuth:
-      name: Authorization
-      description: |
-        A JWT Token has to be provided in the Handshake Header. <br>
-        This Field is expected to be called `Authorization`. <br>
-        It is expected to not have a prefix like `bearer`.
-      type: httpApiKey
-      in: header
-  schemas:
-    JWT:
-      type: string
-      format: jwt
-    Channel:
-      type: string
-      enum:
-        - connection
-        - matchmaking
-        - time
-