Add end point indicating whether a client id is disconnected and can be rejoined (#46)

This commit is contained in:
lucas authored and GitHub committed 2026-06-22 20:15:03 +02:00
1 parent 6d6df751dd
commit c0a88d5137
15 files changed
+272 -54

No files matched your search

@@ -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))
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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()),
+7 -2
View File
@@ -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()
+43
View File
@@ -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()
+1 -4
View File
@@ -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())
+40 -2
View File
@@ -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<string, never>;
@@ -97,7 +109,7 @@ export class Connection extends Evented<typeof ConnectionEvents> {
// 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<typeof ConnectionEvents> {
this._send(rejoinRequest);
}
canRejoin(id: Id): Promise<boolean> {
const canRejoinRequest = {
messageType: "canRejoin",
messageContent: { id },
} as CanRejoinRequest;
this._waitForJoin = true;
this._send(canRejoinRequest);
let resolver: (canRejoin: boolean) => void;
const promise = new Promise<boolean>((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",
+52 -44
View File
@@ -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);
}
}
}
}
+4
View File
@@ -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");
+22
View File
@@ -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
}
}
}
+21
View File
@@ -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
}
}
}
+6
View File
@@ -21,6 +21,12 @@
{
"$ref": "./lobby/rejoin.json"
},
{
"$ref": "./lobby/can_rejoin.json"
},
{
"$ref": "./lobby/can_rejoin_response.json"
},
{
"$ref": "./lobby/state.json"
},