from quart_common.web.logger import build_logger, await_log from quart_common.web.env import env_bool, env_int from server.Files import read_file from server.game_state_store import GameStateStoreBuilder from snakes import SnakeBuilder from server.storage import StorageLoader from server.database import GameplayDatabase from server.metrics import ( MetricsStoreBuilder, MetricsCollector, ) import asyncio, signal, logging, json, os, re, time from typing import cast from quart import Quart from server.blueprints import ( create_battlesnake_blueprint, create_metrics_blueprint, create_dashboard_blueprint, ) from server.services import ( DashboardEventsService, DashboardWebSocketHub, GameRuntimeService, GameplayTrackingService, DashboardQueryService, ) class Server: default_snake_config = { 'apiversion': '1', 'author': '', 'color': '#888888', 'head': 'default', 'tail': 'default', 'version': '1.0.0', } def __init__(self, data_path:str, snake_type:str, storage_type:str, debug:bool=False, check_tls_security:bool=False, game_state_backend:str='memory', game_state_redis_url:str='redis://localhost:6379/0', game_state_ttl_sec:int=900, game_state_local_cache:bool=True, metrics_backend:str='memory', metrics_redis_url:str='redis://localhost:6379/0', metrics_ttl_sec:int|None=None, gameplay_db_enabled:bool=True, gameplay_db_path:str|None=None, gameplay_db_busy_timeout_ms:int=5000): self.debug = debug self.snake_type = snake_type self.storage_type = storage_type self.config_file = os.path.join(data_path, 'data', 'snake-config.json') self.data_path = data_path self.check_tls_security = check_tls_security self.store_game_state = False normalized_backend = (game_state_backend or 'memory').strip().lower() self.game_state_local_cache = (game_state_local_cache and normalized_backend != 'memory') self.game_state_store = GameStateStoreBuilder.build( backend=game_state_backend, redis_url=game_state_redis_url, ttl_seconds=game_state_ttl_sec, ) metrics_backend_normalized = (metrics_backend or 'memory').strip().lower() self.metrics_backend_normalized = metrics_backend_normalized self.metrics_redis_url = metrics_redis_url self.stale_game_timeout_sec = self._get_stale_game_timeout_sec() self.game_runtime = GameRuntimeService( game_state_store=self.game_state_store, snake_type=self.snake_type, game_state_local_cache=self.game_state_local_cache, stale_game_timeout_sec=self.stale_game_timeout_sec, ) self.dashboard_ws_hub = DashboardWebSocketHub() dashboard_event_origin = f'worker-{os.getpid()}-{int(time.time() * 1000)}' dashboard_events_channel = os.getenv('DASHBOARD_EVENTS_CHANNEL', 'snake:dashboard:events') dashboard_events_enabled = (self.metrics_backend_normalized == 'redis' and env_bool('DASHBOARD_EVENTS_ENABLED', True)) self.metrics_collector = MetricsCollector( metrics_manager=MetricsStoreBuilder.build( backend=metrics_backend_normalized, redis_url=metrics_redis_url, ttl_seconds=metrics_ttl_sec, key_prefix=os.environ.get('METRICS_REDIS_KEY_PREFIX', 'snake:metrics:worker'), ), game_state_local_cache=self.game_state_local_cache, metrics_backend=metrics_backend_normalized, game_state_backend=game_state_backend, stale_game_timeout_sec=self.stale_game_timeout_sec, game_last_seen_unix=self.game_runtime.game_last_seen_unix, game_move_counts=self.game_runtime.game_move_counts, ) self.game_runtime.attach_metrics_collector(self.metrics_collector) self.clear_worker_metrics_on_startup = env_bool('METRICS_CLEAR_WORKERS_ON_STARTUP', True) self.worker_metrics_startup_lock_ttl_sec = env_int('METRICS_STARTUP_CLEANUP_LOCK_TTL_SEC', 300) self.dashboard_running_game_stale_sec = 600 self._startup_worker_metrics_cleared = False self.logger = build_logger('Battlesnake', debug_env_var='DEBUG_SERVER') self.snake_builder = SnakeBuilder self.snake_version = self._get_snake_version() self.gameplay_database = None if gameplay_db_enabled: db_path = gameplay_db_path or os.path.join(data_path, 'data', 'database', 'gameplay.sqlite3') self.gameplay_database = GameplayDatabase( db_path=db_path, busy_timeout_ms=gameplay_db_busy_timeout_ms, ) self.gameplay_tracking = GameplayTrackingService( gameplay_database=self.gameplay_database, snake_type=self.snake_type, snake_version=self.snake_version, logger=self.logger, ) self.dashboard_query = DashboardQueryService( gameplay_database=self.gameplay_database, ws_hub=self.dashboard_ws_hub, logger=self.logger, dashboard_running_game_stale_sec=self.dashboard_running_game_stale_sec, ) self.dashboard_events_service = DashboardEventsService( enabled=dashboard_events_enabled, redis_url=self.metrics_redis_url, channel=dashboard_events_channel, event_origin=dashboard_event_origin, shutdown_event=self.dashboard_ws_hub.shutdown_event, on_notice=self._on_dashboard_games_update_notice, logger=self.logger, ) self.dashboard_query.set_publish_notice(self.dashboard_events_service.publish_notice) self.app = Quart('Battlesnake', template_folder=os.path.join(data_path, 'server', 'templates')) self.app.register_blueprint(create_battlesnake_blueprint(self)) self.app.register_blueprint(create_metrics_blueprint(self)) self.app.register_blueprint(create_dashboard_blueprint(self)) @self.app.after_request async def identify_server(response): response.headers.set('server', 'battlesnake/gitea/snake-python') return response @self.app.before_serving async def clear_startup_worker_metrics_once(): if self._startup_worker_metrics_cleared: return self._startup_worker_metrics_cleared = True if self.clear_worker_metrics_on_startup: should_clear = await self.metrics_collector.should_clear_worker_metrics_on_startup(self.worker_metrics_startup_lock_ttl_sec) if should_clear: await self.metrics_collector.clear_worker_metrics() await self.dashboard_events_service.start_listener() @self.app.after_serving async def shutdown_state_storage(): await self.dashboard_events_service.stop_listener() await self.game_state_store.close() await self.metrics_collector.close() if self.gameplay_database is not None: await self.gameplay_database.close() async def run(self, host:str='0.0.0.0', port:int=8000, debug:bool=False): logging.getLogger('werkzeug').setLevel(logging.ERROR) loop = asyncio.get_running_loop() installed_signal_handlers:list[signal.Signals] = [] shutdown_event = asyncio.Event() def on_shutdown_signal() -> None: self.dashboard_ws_hub.request_shutdown() shutdown_event.set() async def shutdown_trigger() -> None: await shutdown_event.wait() for shutdown_signal in (signal.SIGINT, signal.SIGTERM): try: loop.add_signal_handler(shutdown_signal, on_shutdown_signal) installed_signal_handlers.append(shutdown_signal) except (NotImplementedError, RuntimeError): continue await await_log(self.logger.info(f'Running Battlesnake at http://{host}:{port} with the {' '.join(re.findall('[A-Z][^A-Z]*', self.snake_type))}')) try: await self.app.run_task(host=host, port=port, debug=debug, shutdown_trigger=shutdown_trigger) finally: self.dashboard_ws_hub.request_shutdown() for shutdown_signal in installed_signal_handlers: try: loop.remove_signal_handler(shutdown_signal) except Exception: continue async def _read_json_config_or_create(self) -> dict[str, str]: snake_config = cast(dict[str, str]|None, await read_file(self.config_file, json.load)) if not snake_config: return await self._override_snake_config_with_environment_variables(self.default_snake_config) return await self._override_snake_config_with_environment_variables(snake_config) async def _override_snake_config_with_environment_variables(self, config:dict[str, str]) -> dict[str, str]: config['version'] = self.snake_version for key in ('author', 'color', 'head', 'tail'): value = os.environ.get(f'SNAKE_{key.upper()}') if value is not None: config[key] = value version_override = os.environ.get('SNAKE_VERSION') if version_override is not None: config['version'] = version_override return config def _get_snake_version(self) -> str: configured_version = SnakeBuilder.get_version(self.snake_type) if configured_version: return configured_version try: snake = SnakeBuilder.build(self.snake_type) except Exception: return self.default_snake_config['version'] version = getattr(snake, 'version', None) if version is None: version = getattr(snake, 'VERSION', None) if not version: return self.default_snake_config['version'] return str(version) def _get_stale_game_timeout_sec(self) -> int: return max(30, env_int('SNAKE_STUCK_GAME_TIMEOUT_SEC', 180)) def enable_store_game_state(self): self.store_game_state = True def _cleanup_database(self): storage = StorageLoader.build(self.storage_type)() return storage.cleanup() async def _on_dashboard_games_update_notice(self, trigger:str) -> None: await self.dashboard_query.on_dashboard_games_update_notice(trigger)