244 lines
9.4 KiB
Python
244 lines
9.4 KiB
Python
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)
|