"""Small HTTP/JSON API for NETfishing public-room discovery.""" from __future__ import annotations import argparse from dataclasses import dataclass import ipaddress import json import logging import os import signal import threading from http import HTTPStatus from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer from socketserver import BaseServer from typing import Any from urllib.parse import parse_qs, urlsplit from . import __version__ from .registry import ( DEFAULT_MAX_ROOMS, DEFAULT_MAX_ROOMS_PER_ADDRESS, LeaseAuthorizationError, RoomLimitError, RoomNotFoundError, RoomRegistry, ValidationError, ) LOGGER = logging.getLogger("netfishing.discovery") DEFAULT_MAX_BODY_BYTES = 8 * 1024 @dataclass(frozen=True, slots=True) class ServerConfig: bind_host: str = "127.0.0.1" bind_port: int = 7770 room_ttl_seconds: float = 45.0 max_rooms: int = DEFAULT_MAX_ROOMS max_rooms_per_address: int = DEFAULT_MAX_ROOMS_PER_ADDRESS max_body_bytes: int = DEFAULT_MAX_BODY_BYTES trusted_proxy_cidrs: tuple[ipaddress.IPv4Network | ipaddress.IPv6Network, ...] = () @classmethod def from_environment(cls) -> "ServerConfig": proxy_cidrs: list[ipaddress.IPv4Network | ipaddress.IPv6Network] = [] raw_cidrs = os.getenv("NETFISHING_DISCOVERY_TRUSTED_PROXY_CIDRS", "") for value in raw_cidrs.split(","): value = value.strip() if value: proxy_cidrs.append(ipaddress.ip_network(value, strict=False)) return cls( bind_host=os.getenv("NETFISHING_DISCOVERY_HOST", "127.0.0.1"), bind_port=int(os.getenv("NETFISHING_DISCOVERY_PORT", "7770")), room_ttl_seconds=float(os.getenv("NETFISHING_DISCOVERY_ROOM_TTL", "45")), max_rooms=int( os.getenv("NETFISHING_DISCOVERY_MAX_ROOMS", str(DEFAULT_MAX_ROOMS)) ), max_rooms_per_address=int( os.getenv( "NETFISHING_DISCOVERY_MAX_ROOMS_PER_ADDRESS", str(DEFAULT_MAX_ROOMS_PER_ADDRESS), ) ), max_body_bytes=int( os.getenv("NETFISHING_DISCOVERY_MAX_BODY_BYTES", str(DEFAULT_MAX_BODY_BYTES)) ), trusted_proxy_cidrs=tuple(proxy_cidrs), ) class DiscoveryHTTPServer(ThreadingHTTPServer): daemon_threads = True allow_reuse_address = True def __init__(self, config: ServerConfig, registry: RoomRegistry | None = None) -> None: self.config = config self.registry = registry or RoomRegistry( config.room_ttl_seconds, config.max_rooms, config.max_rooms_per_address, ) super().__init__((config.bind_host, config.bind_port), DiscoveryRequestHandler) class DiscoveryRequestHandler(BaseHTTPRequestHandler): server: DiscoveryHTTPServer protocol_version = "HTTP/1.1" def do_GET(self) -> None: route = urlsplit(self.path) if route.path == "/health": self._send_json( HTTPStatus.OK, { "status": "ok", "service": "netfishing-discovery-server", "version": __version__, "active_rooms": self.server.registry.room_count(), }, ) return if route.path == "/v1/rooms": try: filters = parse_qs(route.query, keep_blank_values=False) game_version = self._single_query_value(filters, "game_version") raw_protocol = self._single_query_value(filters, "protocol_version") protocol_version = int(raw_protocol) if raw_protocol is not None else None if protocol_version is not None and protocol_version <= 0: raise ValueError except ValueError: self._send_error(HTTPStatus.BAD_REQUEST, "invalid_query", "invalid room filter") return rooms = self.server.registry.list_rooms( game_version=game_version, protocol_version=protocol_version, ) self._send_json( HTTPStatus.OK, { "rooms": [room.public_dict() for room in rooms], "ttl_seconds": self.server.registry.ttl_seconds, }, ) return self._send_error(HTTPStatus.NOT_FOUND, "not_found", "route not found") def do_POST(self) -> None: if urlsplit(self.path).path != "/v1/rooms": self._send_error(HTTPStatus.NOT_FOUND, "not_found", "route not found") return payload = self._read_json_object() if payload is None: return try: room, token = self.server.registry.create(self._client_address(), payload) except ValidationError as error: self._send_error(HTTPStatus.BAD_REQUEST, "invalid_room", str(error)) return except RoomLimitError as error: self._send_error(HTTPStatus.TOO_MANY_REQUESTS, "room_limit", str(error)) return self._send_json( HTTPStatus.CREATED, {"room": room.public_dict(), "lease_token": token}, ) def do_PUT(self) -> None: room_id = self._room_id_from_path() if room_id is None: self._send_error(HTTPStatus.NOT_FOUND, "not_found", "route not found") return payload = self._read_json_object() if payload is None: return try: room = self.server.registry.update( room_id, self._bearer_token(), self._client_address(), payload, ) except ValidationError as error: self._send_error(HTTPStatus.BAD_REQUEST, "invalid_room", str(error)) return except LeaseAuthorizationError as error: self._send_error(HTTPStatus.UNAUTHORIZED, "invalid_lease", str(error)) return except RoomNotFoundError as error: self._send_error(HTTPStatus.NOT_FOUND, "room_not_found", str(error)) return self._send_json(HTTPStatus.OK, {"room": room.public_dict()}) def do_DELETE(self) -> None: room_id = self._room_id_from_path() if room_id is None: self._send_error(HTTPStatus.NOT_FOUND, "not_found", "route not found") return try: self.server.registry.delete(room_id, self._bearer_token()) except LeaseAuthorizationError as error: self._send_error(HTTPStatus.UNAUTHORIZED, "invalid_lease", str(error)) return except RoomNotFoundError as error: self._send_error(HTTPStatus.NOT_FOUND, "room_not_found", str(error)) return self.send_response(HTTPStatus.NO_CONTENT) self.send_header("Content-Length", "0") self.end_headers() def log_message(self, format_string: str, *args: object) -> None: LOGGER.info("%s - %s", self.client_address[0], format_string % args) def _read_json_object(self) -> dict[str, Any] | None: content_type = self.headers.get("Content-Type", "").split(";", 1)[0].strip().lower() if content_type != "application/json": self._send_error( HTTPStatus.UNSUPPORTED_MEDIA_TYPE, "unsupported_media_type", "Content-Type must be application/json", ) return None try: content_length = int(self.headers.get("Content-Length", "")) except ValueError: content_length = -1 if content_length < 0: self._send_error( HTTPStatus.LENGTH_REQUIRED, "length_required", "Content-Length required", ) return None if content_length > self.server.config.max_body_bytes: self._send_error( HTTPStatus.REQUEST_ENTITY_TOO_LARGE, "body_too_large", "request too large", ) return None try: payload = json.loads(self.rfile.read(content_length)) except (json.JSONDecodeError, UnicodeDecodeError): self._send_error(HTTPStatus.BAD_REQUEST, "invalid_json", "invalid JSON body") return None if not isinstance(payload, dict): self._send_error(HTTPStatus.BAD_REQUEST, "invalid_json", "JSON body must be an object") return None return payload def _client_address(self) -> str: peer_text = self.client_address[0] try: peer = ipaddress.ip_address(peer_text) except ValueError: return peer_text if not any(peer in network for network in self.server.config.trusted_proxy_cidrs): return peer_text forwarded = self.headers.get("X-Forwarded-For", "").split(",", 1)[0].strip() try: return str(ipaddress.ip_address(forwarded)) except ValueError: return peer_text def _room_id_from_path(self) -> str | None: path = urlsplit(self.path).path prefix = "/v1/rooms/" room_id = path[len(prefix) :] if path.startswith(prefix) else "" if not room_id or "/" in room_id: return None return room_id def _bearer_token(self) -> str: value = self.headers.get("Authorization", "") scheme, separator, token = value.partition(" ") if separator and scheme.lower() == "bearer": return token.strip() return "" @staticmethod def _single_query_value(filters: dict[str, list[str]], key: str) -> str | None: values = filters.get(key) if not values: return None if len(values) != 1: raise ValueError return values[0] def _send_error(self, status: HTTPStatus, code: str, message: str) -> None: self._send_json(status, {"error": {"code": code, "message": message}}) def _send_json(self, status: HTTPStatus, payload: dict[str, Any]) -> None: body = json.dumps(payload, ensure_ascii=False, separators=(",", ":")).encode("utf-8") self.send_response(status) self.send_header("Content-Type", "application/json; charset=utf-8") self.send_header("Content-Length", str(len(body))) self.send_header("Cache-Control", "no-store") self.send_header("X-Content-Type-Options", "nosniff") self.end_headers() self.wfile.write(body) def _install_signal_handlers(server: BaseServer) -> None: def stop_server(_signum: int, _frame: object) -> None: LOGGER.info("shutdown requested") # BaseServer.shutdown() must run on a different thread from serve_forever(). threading.Thread(target=server.shutdown, name="discovery-shutdown", daemon=True).start() signal.signal(signal.SIGINT, stop_server) signal.signal(signal.SIGTERM, stop_server) def _argument_parser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--host", help="bind address (overrides environment)") parser.add_argument("--port", type=int, help="bind port (overrides environment)") parser.add_argument("--log-level", default=os.getenv("NETFISHING_DISCOVERY_LOG_LEVEL", "INFO")) return parser def main() -> None: arguments = _argument_parser().parse_args() config = ServerConfig.from_environment() if arguments.host is not None or arguments.port is not None: config = ServerConfig( bind_host=arguments.host or config.bind_host, bind_port=arguments.port or config.bind_port, room_ttl_seconds=config.room_ttl_seconds, max_rooms=config.max_rooms, max_rooms_per_address=config.max_rooms_per_address, max_body_bytes=config.max_body_bytes, trusted_proxy_cidrs=config.trusted_proxy_cidrs, ) logging.basicConfig( level=getattr(logging, arguments.log_level.upper(), logging.INFO), format="%(asctime)s %(levelname)s %(name)s: %(message)s", ) server = DiscoveryHTTPServer(config) _install_signal_handlers(server) LOGGER.info( "NETfishing discovery server %s listening on %s:%d (room TTL %.1fs)", __version__, config.bind_host, server.server_address[1], config.room_ttl_seconds, ) try: server.serve_forever(poll_interval=0.25) finally: server.server_close() LOGGER.info("server stopped") if __name__ == "__main__": main()