From c0a88d513785e11d622fe36a67e3da109bb932f0 Mon Sep 17 00:00:00 2001 From: Lucas Habersaat Date: Mon, 22 Jun 2026 20:15:03 +0200 Subject: [PATCH] Add end point indicating whether a client id is disconnected and can be rejoined (#46) --- src/backend/autobeerpong/contexts/client.py | 6 ++ src/backend/autobeerpong/contexts/server.py | 3 + .../autobeerpong/messages/lobby/can_rejoin.py | 45 +++++++++ .../messages/lobby/can_rejoin_response.py | 17 ++++ .../autobeerpong/messages/lobby/rejoin.py | 6 +- src/backend/autobeerpong/messages/message.py | 1 + src/backend/autobeerpong/server.py | 9 +- src/backend/tests/test_lobby.py | 43 +++++++++ src/backend/tests/utils/client.py | 5 +- src/frontend/src/Connection.ts | 42 +++++++- .../src/UIElements/PlayerNameInput.ts | 96 ++++++++++--------- src/frontend/src/schemaValidators.ts | 4 + src/schema/lobby/can_rejoin.json | 22 +++++ src/schema/lobby/can_rejoin_response.json | 21 ++++ src/schema/message.json | 6 ++ 15 files changed, 272 insertions(+), 54 deletions(-) create mode 100644 src/backend/autobeerpong/messages/lobby/can_rejoin.py create mode 100644 src/backend/autobeerpong/messages/lobby/can_rejoin_response.py create mode 100644 src/schema/lobby/can_rejoin.json create mode 100644 src/schema/lobby/can_rejoin_response.json diff --git a/src/backend/autobeerpong/contexts/client.py b/src/backend/autobeerpong/contexts/client.py index 9c6f3f9..9653b54 100644 --- a/src/backend/autobeerpong/contexts/client.py +++ b/src/backend/autobeerpong/contexts/client.py @@ -1,5 +1,8 @@ +import json from websockets.asyncio.server import ServerConnection +from autobeerpong.types.raw import MessageRaw_T + class ClientContext: def __init__(self, websocket: ServerConnection) -> None: @@ -11,3 +14,6 @@ class ClientContext: def get_client_id(self) -> int: assert self.client_id is not None return self.client_id + + async def send(self, msg_dict: MessageRaw_T) -> None: + await self.websocket.send(json.dumps(msg_dict)) diff --git a/src/backend/autobeerpong/contexts/server.py b/src/backend/autobeerpong/contexts/server.py index 55d48b9..7930188 100644 --- a/src/backend/autobeerpong/contexts/server.py +++ b/src/backend/autobeerpong/contexts/server.py @@ -26,3 +26,6 @@ class ServerContext: def get_client(self, client_id: int) -> Client: assert client_id in self.clients return self.clients[client_id] + + def has_client(self, client_id: int) -> bool: + return client_id in self.clients \ No newline at end of file diff --git a/src/backend/autobeerpong/messages/lobby/can_rejoin.py b/src/backend/autobeerpong/messages/lobby/can_rejoin.py new file mode 100644 index 0000000..4347f40 --- /dev/null +++ b/src/backend/autobeerpong/messages/lobby/can_rejoin.py @@ -0,0 +1,45 @@ +from autobeerpong.messages.message import Message, MessageRaw_T +from autobeerpong.contexts.server import ServerContext +from autobeerpong.contexts.client import ClientContext +from autobeerpong.states.client import ClientState + +from autobeerpong.messages.lobby.can_rejoin_response import CanRejoinResponseMessage + +class CanRejoinMessage(Message): + has_direct_response = True + triggers_broadcast = False + + def _contents_from_raw(self, message_raw: MessageRaw_T): + self.id = int(message_raw["messageContent"]["id"]) + + def to_raw(self) -> MessageRaw_T: + msg_raw = super().to_raw() + msg_raw["messageContent"].update({"id": self.id}) + + self.validate(msg_raw) + + return msg_raw + + async def execute( + self, server_context: ServerContext, client_context: ClientContext + ) -> None: + assert client_context.has_joined is False + + canRejoin = self._canRejoin(server_context) + + can_rejoin_response_raw = CanRejoinResponseMessage({ + "messageType": "canRejoinResponse", + "messageContent": { "canRejoin": canRejoin} + }) + + await client_context.send(can_rejoin_response_raw.to_raw()) + + + def _canRejoin(self, server_context: ServerContext) -> bool: + client_exists = server_context.has_client(self.id) + + if not client_exists: + return False + + client = server_context.get_client(self.id) + return client.state is ClientState.DISCONNECTED \ No newline at end of file diff --git a/src/backend/autobeerpong/messages/lobby/can_rejoin_response.py b/src/backend/autobeerpong/messages/lobby/can_rejoin_response.py new file mode 100644 index 0000000..9b26cf6 --- /dev/null +++ b/src/backend/autobeerpong/messages/lobby/can_rejoin_response.py @@ -0,0 +1,17 @@ +from autobeerpong.messages.message import Message +from autobeerpong.types.raw import MessageRaw_T, ClientRaw_T + + +class CanRejoinResponseMessage(Message): + has_direct_response = False + + def _contents_from_raw(self, message_raw: MessageRaw_T): + self.can_rejoin: ClientRaw_T = message_raw["messageContent"]["canRejoin"] + + def to_raw(self) -> MessageRaw_T: + msg_raw = super().to_raw() + msg_raw["messageContent"].update({"canRejoin": self.can_rejoin}) + + self.validate(msg_raw) + + return msg_raw diff --git a/src/backend/autobeerpong/messages/lobby/rejoin.py b/src/backend/autobeerpong/messages/lobby/rejoin.py index 308f9e2..4279a81 100644 --- a/src/backend/autobeerpong/messages/lobby/rejoin.py +++ b/src/backend/autobeerpong/messages/lobby/rejoin.py @@ -1,7 +1,6 @@ from autobeerpong.messages.message import Message, MessageRaw_T from autobeerpong.contexts.server import ServerContext from autobeerpong.contexts.client import ClientContext -from autobeerpong.states.server import ServerState from autobeerpong.states.client import ClientState @@ -23,9 +22,12 @@ class RejoinMessage(Message): self, server_context: ServerContext, client_context: ClientContext ) -> None: - assert server_context.state is ServerState.LOBBY assert client_context.has_joined is False + if not server_context.has_client(self.id): + print(f'A client wanted to rejoin with id {self.id}, but no matching id found in disconnected clients.') + return + client = server_context.get_client(self.id) client.websocket = client_context.websocket diff --git a/src/backend/autobeerpong/messages/message.py b/src/backend/autobeerpong/messages/message.py index 4efb929..63cbbf3 100644 --- a/src/backend/autobeerpong/messages/message.py +++ b/src/backend/autobeerpong/messages/message.py @@ -24,6 +24,7 @@ def _retrieve_from_filesystem(uri: str): class Message: has_direct_response = False + triggers_broadcast = True registry = Registry(retrieve=_retrieve_from_filesystem) validator: jsonschema.protocols.Validator = jsonschema.Draft202012Validator( json.loads((config.SCHEMA_DIR / Path("message.json")).read_text()), diff --git a/src/backend/autobeerpong/server.py b/src/backend/autobeerpong/server.py index 071e0ad..d8c578f 100644 --- a/src/backend/autobeerpong/server.py +++ b/src/backend/autobeerpong/server.py @@ -9,6 +9,8 @@ from autobeerpong.messages.message import Message, MessageRaw_T from autobeerpong.messages.lobby.join import JoinMessage from autobeerpong.messages.lobby.join_response import JoinResponseMessage from autobeerpong.messages.lobby.rejoin import RejoinMessage +from autobeerpong.messages.lobby.can_rejoin import CanRejoinMessage +from autobeerpong.messages.lobby.can_rejoin_response import CanRejoinResponseMessage from autobeerpong.messages.lobby.toggle_ready import ToggleReadyMessage from autobeerpong.messages.lobby.toggle_role import ToggleRoleMessage from autobeerpong.messages.lobby.state import LobbyStateMessage @@ -27,6 +29,8 @@ class AutobeerpongServer: "join": JoinMessage, "joinResponse": JoinResponseMessage, "rejoin": RejoinMessage, + "canRejoin": CanRejoinMessage, + "canRejoinResponse": CanRejoinResponseMessage, "toggleReady": ToggleReadyMessage, "toggleRole": ToggleRoleMessage, "lobbyState": LobbyStateMessage, @@ -122,8 +126,9 @@ class AutobeerpongServer: client_context=client_context, ) - await self.broadcast(self.get_lobby_state().to_raw()) - await self.update_server_state() + if message.triggers_broadcast: + await self.broadcast(self.get_lobby_state().to_raw()) + await self.update_server_state() if client_context.has_joined: self.context.clients[client_context.get_client_id()].disconnect() diff --git a/src/backend/tests/test_lobby.py b/src/backend/tests/test_lobby.py index 9f0dc1d..e9089f5 100644 --- a/src/backend/tests/test_lobby.py +++ b/src/backend/tests/test_lobby.py @@ -3,6 +3,8 @@ from unittest import IsolatedAsyncioTestCase from autobeerpong.messages.lobby.join import JoinMessage from autobeerpong.messages.lobby.join_response import JoinResponseMessage from autobeerpong.messages.lobby.rejoin import RejoinMessage +from autobeerpong.messages.lobby.can_rejoin import CanRejoinMessage +from autobeerpong.messages.lobby.can_rejoin_response import CanRejoinResponseMessage from autobeerpong.messages.lobby.toggle_ready import ToggleReadyMessage from autobeerpong.messages.lobby.toggle_role import ToggleRoleMessage from autobeerpong.messages.lobby.state import LobbyStateMessage @@ -299,3 +301,44 @@ class TestLobby(IsolatedAsyncioTestCase): client_a.shutdown() client_b.shutdown() + + @manage_server + async def test_can_rejoin_true(self): + client = TestClient() + + client_responses = await client.send_messages( + [JoinMessage({"messageType": "join", "messageContent": {"name": "Ruedi"}})] + ) + join_response = client_responses[0] + assert type(join_response) is JoinResponseMessage + + joined_id = join_response.client_raw["id"] + + client.shutdown() + + restarted_client = TestClient() + restarted_client_responses = await restarted_client.send_messages( + [CanRejoinMessage({"messageType": "canRejoin", "messageContent": {"id": joined_id}})] + ) + + can_rejoin_response = restarted_client_responses[0] + assert type(can_rejoin_response) is CanRejoinResponseMessage + self.assertTrue(can_rejoin_response.can_rejoin) + + restarted_client.shutdown(); + + @manage_server + async def test_can_rejoin_false(self): + client = TestClient() + cannot_rejoin_responses = await client.send_messages( + [CanRejoinMessage({"messageType": "canRejoin", "messageContent": {"id": 0}})] + ) + + cannot_rejoin_response = cannot_rejoin_responses[-1] + print(cannot_rejoin_response) + assert type(cannot_rejoin_response) is CanRejoinResponseMessage + self.assertFalse(cannot_rejoin_response.can_rejoin) + + client.shutdown() + + diff --git a/src/backend/tests/utils/client.py b/src/backend/tests/utils/client.py index 62e16ca..c152862 100644 --- a/src/backend/tests/utils/client.py +++ b/src/backend/tests/utils/client.py @@ -71,10 +71,7 @@ class TestClient: for message in messages: await self.send_message(message) - if message.has_direct_response: - num_responses = 2 - else: - num_responses = 1 + num_responses = (1 if message.has_direct_response else 0) + (1 if message.triggers_broadcast else 0) for _ in range(num_responses): responses.append(await self.get_response()) diff --git a/src/frontend/src/Connection.ts b/src/frontend/src/Connection.ts index 996bc00..7ea6cae 100644 --- a/src/frontend/src/Connection.ts +++ b/src/frontend/src/Connection.ts @@ -10,7 +10,12 @@ import { MatchState } from "./MatchState"; import { BaseSocket, MessageEvent } from "./sockets/BaseSocket"; import { Socket } from "./sockets/Socket"; -type MessageType = "join" | "rejoin" | "toggleRole" | "toggleReady"; +type MessageType = + | "join" + | "rejoin" + | "canRejoin" + | "toggleRole" + | "toggleReady"; interface Request { messageType: MessageType; @@ -30,6 +35,13 @@ interface RejoinRequest { }; } +interface CanRejoinRequest { + messageType: "canRejoin"; + messageContent: { + id: Id; + }; +} + interface ToggleRoleRequest { messageType: "toggleRole"; messageContent: Record; @@ -97,7 +109,7 @@ export class Connection extends Evented { // TODO: Print error if not valid json. const messageObject = JSON.parse(message.json); - if (this._waitForJoin) { + if (this._waitForJoin && messageObject.messageType === "joinResponse") { const client = messageObject.messageContent.client; if (!validateClientSchema(client)) { return; @@ -193,6 +205,32 @@ export class Connection extends Evented { this._send(rejoinRequest); } + canRejoin(id: Id): Promise { + const canRejoinRequest = { + messageType: "canRejoin", + messageContent: { id }, + } as CanRejoinRequest; + + this._waitForJoin = true; + this._send(canRejoinRequest); + + let resolver: (canRejoin: boolean) => void; + const promise = new Promise((resolve) => { + resolver = resolve; + }); + + const handler = (message: MessageEvent) => { + const messageObject = JSON.parse(message.json); + if (messageObject.messageType === "canRejoinResponse") { + resolver(messageObject.messageContent.canRejoin); + this._socket?.off("message", handler); + } + }; + this._socket?.on("message", handler); + + return promise; + } + toggleRole(): void { const toggleRoleRequest = { messageType: "toggleRole", diff --git a/src/frontend/src/UIElements/PlayerNameInput.ts b/src/frontend/src/UIElements/PlayerNameInput.ts index 1c4c897..461a3c4 100644 --- a/src/frontend/src/UIElements/PlayerNameInput.ts +++ b/src/frontend/src/UIElements/PlayerNameInput.ts @@ -46,15 +46,62 @@ export class PlayerNameInput extends ex.ScreenElement { const rejoinClient = storedClient(); if (rejoinClient != null) { - this._rejoinButton = new Button({ - text: "Rejoin as " + rejoinClient.name, - anchor: ex.vec(0.5, 0), - onClick: () => this._rejoinCallback(rejoinClient.id), + this._connection.canRejoin(rejoinClient.id).then((canRejoin) => { + if (!canRejoin) { + return; + } + + this._rejoinButton = new Button({ + text: "Rejoin as " + rejoinClient.name, + anchor: ex.vec(0.5, 0), + onClick: () => this._rejoinCallback(rejoinClient.id), + }); + this._updateVisibility(); + this._updatePositions(); }); } - this._nameInput.on(TextInputEvents.Textchanged, () => this._update()); + this._nameInput.on(TextInputEvents.Textchanged, () => + this._updateVisibility(), + ); + this._updatePositions(); + + this._connection.on("connect", () => this._updateVisibility()); + this._connection.on("disconnect", () => this._updateVisibility()); + this._updateVisibility(); + } + + get playerName(): string { + return this._nameInput.text; + } + + override get height(): number { + return this._height; + } + + clear(): void { + this._nameInput.text = ""; + this._updateVisibility(); + } + + private _updateVisibility(): void { + const { connected } = this._connection; + const joinDisabled = !connected || this._nameInput.text === ""; + this._joinButton.disabled = joinDisabled; + + if (this._rejoinButton != null) { + if (connected) { + if (!this.children.includes(this._rejoinButton)) { + this.addChild(this._rejoinButton); + } + } else { + this.removeChild(this._rejoinButton); + } + } + } + + private _updatePositions(): void { let y = 0; this._nameLabel.pos = ex.vec(0, y); y += this._nameLabel.font.size + spacingM; @@ -71,44 +118,5 @@ export class PlayerNameInput extends ex.ScreenElement { } this._height = y; - - this._connection.on("connect", () => this._onConnect()); - this._connection.on("disconnect", () => this._onDisconnect()); - } - - get playerName(): string { - return this._nameInput.text; - } - - override get height(): number { - return this._height; - } - - clear(): void { - this._nameInput.text = ""; - this._update(); - } - - private _onConnect(): void { - this._update(); - } - - private _onDisconnect(): void { - this._update(); - } - - private _update(): void { - const { connected } = this._connection; - const joinDisabled = !connected || this._nameInput.text === ""; - this._joinButton.disabled = joinDisabled; - - if (this._rejoinButton != null) { - if (connected) { - if (this.children.includes(this._rejoinButton)) - this.addChild(this._rejoinButton); - } else { - this.removeChild(this._rejoinButton); - } - } } } diff --git a/src/frontend/src/schemaValidators.ts b/src/frontend/src/schemaValidators.ts index 6df7aee..6697a40 100644 --- a/src/frontend/src/schemaValidators.ts +++ b/src/frontend/src/schemaValidators.ts @@ -10,6 +10,8 @@ import playerSchemaFile from "../../schema/common/player.json"; import joinSchemaFile from "../../schema/lobby/join.json"; import joinResponseSchemaFile from "../../schema/lobby/join_response.json"; import rejoinSchemaFile from "../../schema/lobby/rejoin.json"; +import canRejoinSchemaFile from "../../schema/lobby/can_rejoin.json"; +import canRejoinResponseSchemaFile from "../../schema/lobby/can_rejoin_response.json"; import lobbyStateSchemaFile from "../../schema/lobby/state.json"; import toggleReadySchemaFile from "../../schema/lobby/toggle_ready.json"; import toggleRoleSchemaFile from "../../schema/lobby/toggle_role.json"; @@ -28,6 +30,8 @@ ajv.addSchema(playerSchemaFile, "player.json"); ajv.addSchema(joinSchemaFile, "join.json"); ajv.addSchema(joinResponseSchemaFile, "join_response.json"); ajv.addSchema(rejoinSchemaFile, "rejoin.json"); +ajv.addSchema(canRejoinSchemaFile, "can_rejoin.json"); +ajv.addSchema(canRejoinResponseSchemaFile, "can_rejoin_response.json"); ajv.addSchema(lobbyStateSchemaFile, "lobby_state.json"); ajv.addSchema(toggleReadySchemaFile, "toggle_ready.json"); ajv.addSchema(toggleRoleSchemaFile, "toggle_role.json"); diff --git a/src/schema/lobby/can_rejoin.json b/src/schema/lobby/can_rejoin.json new file mode 100644 index 0000000..e0386ee --- /dev/null +++ b/src/schema/lobby/can_rejoin.json @@ -0,0 +1,22 @@ +{ + "$id": "http://localhost/lobby/can_rejoin.json", + "type": "object", + "properties": { + "messageType": { + "const": "canRejoin" + }, + "messageContent": { + "type": "object", + "properties": { + "id": { + "type": "number", + "minimum": 0 + } + }, + "required": [ + "id" + ], + "additionalProperties": false + } + } +} \ No newline at end of file diff --git a/src/schema/lobby/can_rejoin_response.json b/src/schema/lobby/can_rejoin_response.json new file mode 100644 index 0000000..e867cad --- /dev/null +++ b/src/schema/lobby/can_rejoin_response.json @@ -0,0 +1,21 @@ +{ + "$id": "http://localhost/lobby/can_rejoin_response.json", + "type": "object", + "properties": { + "messageType": { + "const": "canRejoinResponse" + }, + "messageContent": { + "type": "object", + "properties": { + "canRejoin": { + "type": "boolean" + } + }, + "required": [ + "canRejoin" + ], + "additionalProperties": false + } + } +} \ No newline at end of file diff --git a/src/schema/message.json b/src/schema/message.json index 7ba5269..38b7725 100644 --- a/src/schema/message.json +++ b/src/schema/message.json @@ -21,6 +21,12 @@ { "$ref": "./lobby/rejoin.json" }, + { + "$ref": "./lobby/can_rejoin.json" + }, + { + "$ref": "./lobby/can_rejoin_response.json" + }, { "$ref": "./lobby/state.json" },