94 lines
2.8 KiB
Python
94 lines
2.8 KiB
Python
"""Player sessions and their websocket connections.
|
|
|
|
A ``Session`` identifies a human player across reconnects (e.g. a page
|
|
reload) via a secret token. A ``Connection`` wraps one websocket and owns an
|
|
outgoing message queue so that messages are sent in order and never
|
|
concurrently.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import contextlib
|
|
import logging
|
|
import secrets
|
|
import time
|
|
import uuid
|
|
from typing import Any
|
|
|
|
from starlette.websockets import WebSocket
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class Connection:
|
|
def __init__(self, websocket: WebSocket) -> None:
|
|
self.websocket = websocket
|
|
self._queue: asyncio.Queue[dict[str, Any] | None] = asyncio.Queue()
|
|
self._writer: asyncio.Task | None = None
|
|
|
|
def start(self) -> None:
|
|
self._writer = asyncio.create_task(self._write_loop())
|
|
|
|
def send(self, message: dict[str, Any]) -> None:
|
|
self._queue.put_nowait(message)
|
|
|
|
async def close(self, code: int = 1000) -> None:
|
|
self._queue.put_nowait(None)
|
|
if self._writer:
|
|
with contextlib.suppress(Exception):
|
|
await self._writer
|
|
with contextlib.suppress(Exception):
|
|
await self.websocket.close(code)
|
|
|
|
async def _write_loop(self) -> None:
|
|
while (message := await self._queue.get()) is not None:
|
|
try:
|
|
await self.websocket.send_json(message)
|
|
except Exception: # connection is gone; the reader loop cleans up
|
|
logger.debug("Failed to send message", exc_info=True)
|
|
return
|
|
|
|
|
|
class Session:
|
|
def __init__(self) -> None:
|
|
self.player_id = uuid.uuid4().hex[:12]
|
|
self.token = secrets.token_urlsafe(24)
|
|
self.name: str | None = None
|
|
self.lobby_code: str | None = None
|
|
self.connection: Connection | None = None
|
|
self.last_seen = time.monotonic()
|
|
|
|
@property
|
|
def connected(self) -> bool:
|
|
return self.connection is not None
|
|
|
|
def send(self, message: dict[str, Any]) -> None:
|
|
if self.connection:
|
|
self.connection.send(message)
|
|
|
|
|
|
class SessionRegistry:
|
|
def __init__(self) -> None:
|
|
self._by_token: dict[str, Session] = {}
|
|
|
|
def create(self) -> Session:
|
|
session = Session()
|
|
self._by_token[session.token] = session
|
|
return session
|
|
|
|
def get(self, token: str | None) -> Session | None:
|
|
if not token:
|
|
return None
|
|
return self._by_token.get(token)
|
|
|
|
def remove(self, session: Session) -> None:
|
|
self._by_token.pop(session.token, None)
|
|
|
|
def expired(self, ttl: float) -> list[Session]:
|
|
now = time.monotonic()
|
|
return [s for s in self._by_token.values() if not s.connected and now - s.last_seen > ttl]
|
|
|
|
def __len__(self) -> int:
|
|
return len(self._by_token)
|