180 lines
6.9 KiB
Python
180 lines
6.9 KiB
Python
from dataclasses import dataclass
|
|
from pathlib import Path
|
|
from tempfile import TemporaryDirectory
|
|
import asyncio
|
|
import unittest
|
|
|
|
from plba.config import (
|
|
ApplicationConfigLoadError,
|
|
ApplicationConfigLoader,
|
|
ApplicationConfigManager,
|
|
ConfigReloadStatus,
|
|
)
|
|
from plba.runtime import ApplicationLifecycle, ApplicationRuntime, RuntimeContext
|
|
from plba.runtime.worker import (
|
|
WorkerConfig,
|
|
WorkerDefinition,
|
|
WorkerRegistry,
|
|
WorkerSupervisor,
|
|
)
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class ServiceConfig:
|
|
service_name: str
|
|
|
|
|
|
def decode_service_config(raw: dict[str, object]) -> ServiceConfig:
|
|
name = raw.get("service_name")
|
|
if not isinstance(name, str):
|
|
raise ValueError("service_name is required")
|
|
return ServiceConfig(name)
|
|
|
|
|
|
class ApplicationConfigTests(unittest.TestCase):
|
|
def test_loads_common_fields_and_typed_application_config(self) -> None:
|
|
with TemporaryDirectory() as directory:
|
|
path = Path(directory) / "config.yaml"
|
|
path.write_text(
|
|
"application_id: service-a\nservice_name: alpha\n"
|
|
"workers:\n sync:\n pause_seconds: 5\n",
|
|
encoding="utf-8",
|
|
)
|
|
manager = ApplicationConfigManager(
|
|
ApplicationConfigLoader(path, decode_service_config)
|
|
)
|
|
|
|
snapshot = manager.load_initial()
|
|
|
|
self.assertEqual(snapshot.application_id, "service-a")
|
|
self.assertEqual(snapshot.application_config, ServiceConfig("alpha"))
|
|
self.assertEqual(manager.get_worker_config("sync").pause_seconds, 5)
|
|
self.assertFalse(manager.get_worker_config("undeclared").disabled)
|
|
|
|
def test_invalid_initial_file_blocks_startup(self) -> None:
|
|
with TemporaryDirectory() as directory:
|
|
path = Path(directory) / "config.yaml"
|
|
path.write_text("workers: [not-a-mapping]\n", encoding="utf-8")
|
|
manager = ApplicationConfigManager(
|
|
ApplicationConfigLoader(path, decode_service_config)
|
|
)
|
|
|
|
with self.assertRaises(ApplicationConfigLoadError):
|
|
manager.load_initial()
|
|
|
|
def test_reload_is_atomic_and_invalid_update_keeps_last_snapshot(self) -> None:
|
|
with TemporaryDirectory() as directory:
|
|
path = Path(directory) / "config.yaml"
|
|
path.write_text("service_name: alpha\n", encoding="utf-8")
|
|
manager = ApplicationConfigManager(
|
|
ApplicationConfigLoader(path, decode_service_config)
|
|
)
|
|
previous = manager.load_initial()
|
|
path.write_text("service_name: beta\n", encoding="utf-8")
|
|
|
|
reloaded = manager.reload_if_changed()
|
|
|
|
self.assertEqual(reloaded.status, ConfigReloadStatus.RELOADED)
|
|
self.assertEqual(previous.application_config, ServiceConfig("alpha"))
|
|
self.assertEqual(manager.current().application_config, ServiceConfig("beta"))
|
|
revision = manager.current().revision
|
|
path.write_text("service_name: [invalid]\n", encoding="utf-8")
|
|
|
|
failed = manager.reload_if_changed()
|
|
|
|
self.assertEqual(failed.status, ConfigReloadStatus.FAILED)
|
|
self.assertEqual(manager.current().revision, revision)
|
|
self.assertEqual(manager.current().application_config, ServiceConfig("beta"))
|
|
|
|
def test_disabled_worker_does_not_require_a_schedule(self) -> None:
|
|
with TemporaryDirectory() as directory:
|
|
path = Path(directory) / "config.yaml"
|
|
path.write_text("service_name: alpha\nworkers:\n inactive:\n disabled: true\n", encoding="utf-8")
|
|
manager = ApplicationConfigManager(
|
|
ApplicationConfigLoader(path, decode_service_config)
|
|
)
|
|
|
|
manager.load_initial()
|
|
|
|
self.assertTrue(manager.get_worker_config("inactive").disabled)
|
|
|
|
|
|
class ConfigWatcherTests(unittest.IsolatedAsyncioTestCase):
|
|
async def test_watcher_reports_invalid_reload_and_stops_promptly(self) -> None:
|
|
with TemporaryDirectory() as directory:
|
|
path = Path(directory) / "config.yaml"
|
|
path.write_text("service_name: alpha\n", encoding="utf-8")
|
|
manager = ApplicationConfigManager(
|
|
ApplicationConfigLoader(path, decode_service_config)
|
|
)
|
|
manager.load_initial()
|
|
stop_event = asyncio.Event()
|
|
error_reported = asyncio.Event()
|
|
|
|
async def report_error(_: Exception) -> None:
|
|
error_reported.set()
|
|
|
|
async def write_invalid() -> None:
|
|
await asyncio.sleep(0.01)
|
|
path.write_text("workers: []\n", encoding="utf-8")
|
|
|
|
watcher = asyncio.create_task(
|
|
manager.watch(stop_event, 0.02, report_error)
|
|
)
|
|
writer = asyncio.create_task(write_invalid())
|
|
await asyncio.wait_for(error_reported.wait(), timeout=1)
|
|
stop_event.set()
|
|
await asyncio.wait_for(watcher, timeout=1)
|
|
await writer
|
|
|
|
|
|
class ConfigRuntimeIntegrationTests(unittest.IsolatedAsyncioTestCase):
|
|
async def test_disabled_change_waits_until_next_application_start(self) -> None:
|
|
with TemporaryDirectory() as directory:
|
|
path = Path(directory) / "config.yaml"
|
|
path.write_text(
|
|
"service_name: alpha\nworkers:\n sync:\n pause_seconds: 0.01\n",
|
|
encoding="utf-8",
|
|
)
|
|
manager = ApplicationConfigManager(
|
|
ApplicationConfigLoader(path, decode_service_config)
|
|
)
|
|
manager.load_initial()
|
|
first_cycle = asyncio.Event()
|
|
later_cycle = asyncio.Event()
|
|
calls = 0
|
|
|
|
async def process() -> None:
|
|
nonlocal calls
|
|
calls += 1
|
|
first_cycle.set()
|
|
if calls >= 2:
|
|
later_cycle.set()
|
|
|
|
registry = WorkerRegistry()
|
|
registry.register(WorkerDefinition("sync", process))
|
|
supervisor = WorkerSupervisor(registry, manager)
|
|
runtime = ApplicationRuntime(RuntimeContext("service-a"), supervisor)
|
|
await runtime.start()
|
|
await asyncio.wait_for(first_cycle.wait(), timeout=1)
|
|
path.write_text(
|
|
"service_name: alpha\nworkers:\n sync:\n disabled: true\n",
|
|
encoding="utf-8",
|
|
)
|
|
self.assertEqual(manager.reload_if_changed().status, ConfigReloadStatus.RELOADED)
|
|
await asyncio.wait_for(later_cycle.wait(), timeout=1)
|
|
self.assertEqual(runtime.lifecycle, ApplicationLifecycle.RUNNING)
|
|
|
|
await runtime.stop()
|
|
before_restart = calls
|
|
restarted = await runtime.start()
|
|
await asyncio.sleep(0.03)
|
|
|
|
self.assertEqual(restarted.workers.started, ())
|
|
self.assertEqual(calls, before_restart)
|
|
await runtime.stop()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|