PLBA2-2. Реализация
This commit is contained in:
@@ -0,0 +1,153 @@
|
||||
import asyncio
|
||||
import unittest
|
||||
|
||||
from plba.runtime import (
|
||||
ApplicationLifecycle,
|
||||
ApplicationRuntime,
|
||||
RuntimeContext,
|
||||
)
|
||||
from plba.runtime.worker import (
|
||||
DuplicateWorkerError,
|
||||
WorkerConfig,
|
||||
WorkerDefinition,
|
||||
WorkerLifecycle,
|
||||
WorkerRegistry,
|
||||
WorkerSupervisor,
|
||||
)
|
||||
|
||||
|
||||
class FakeWorkerConfigReader:
|
||||
def __init__(self, configs: dict[str, WorkerConfig]) -> None:
|
||||
self.configs = configs
|
||||
|
||||
def get_worker_config(self, worker_name: str) -> WorkerConfig:
|
||||
return self.configs.get(worker_name, WorkerConfig())
|
||||
|
||||
|
||||
class WorkerRegistryTests(unittest.TestCase):
|
||||
def test_duplicate_names_are_rejected(self) -> None:
|
||||
registry = WorkerRegistry()
|
||||
process = self._process
|
||||
registry.register(WorkerDefinition("sync", process))
|
||||
with self.assertRaises(DuplicateWorkerError):
|
||||
registry.register(WorkerDefinition("sync", process))
|
||||
|
||||
@staticmethod
|
||||
async def _process() -> None:
|
||||
return None
|
||||
|
||||
|
||||
class WorkerRuntimeTests(unittest.IsolatedAsyncioTestCase):
|
||||
async def test_disabled_worker_is_skipped_and_has_no_health_snapshot(self) -> None:
|
||||
calls = 0
|
||||
|
||||
async def process() -> None:
|
||||
nonlocal calls
|
||||
calls += 1
|
||||
|
||||
registry = WorkerRegistry()
|
||||
registry.register(WorkerDefinition("cleanup", process))
|
||||
supervisor = WorkerSupervisor(
|
||||
registry, FakeWorkerConfigReader({"cleanup": WorkerConfig(disabled=True)})
|
||||
)
|
||||
runtime = ApplicationRuntime(RuntimeContext("service-a"), supervisor)
|
||||
|
||||
started = await runtime.start()
|
||||
stopped = await runtime.stop()
|
||||
|
||||
self.assertEqual(started.lifecycle, ApplicationLifecycle.RUNNING)
|
||||
self.assertEqual(started.workers.started, ())
|
||||
self.assertEqual(supervisor.snapshots(), ())
|
||||
self.assertEqual(calls, 0)
|
||||
self.assertEqual(stopped.lifecycle, ApplicationLifecycle.STOPPED)
|
||||
|
||||
async def test_cycles_are_sequential_and_continue_after_failure(self) -> None:
|
||||
second_started = asyncio.Event()
|
||||
release_second = asyncio.Event()
|
||||
calls = 0
|
||||
active = 0
|
||||
max_active = 0
|
||||
|
||||
async def process() -> None:
|
||||
nonlocal calls, active, max_active
|
||||
calls += 1
|
||||
active += 1
|
||||
max_active = max(max_active, active)
|
||||
try:
|
||||
if calls == 1:
|
||||
raise RuntimeError("first cycle failed")
|
||||
if calls == 2:
|
||||
second_started.set()
|
||||
await release_second.wait()
|
||||
finally:
|
||||
active -= 1
|
||||
|
||||
registry = WorkerRegistry()
|
||||
registry.register(WorkerDefinition("sync", process))
|
||||
supervisor = WorkerSupervisor(
|
||||
registry, FakeWorkerConfigReader({"sync": WorkerConfig(pause_seconds=0.001)})
|
||||
)
|
||||
runtime = ApplicationRuntime(RuntimeContext("service-a"), supervisor)
|
||||
await runtime.start()
|
||||
await asyncio.wait_for(second_started.wait(), timeout=1)
|
||||
|
||||
snapshot = supervisor.snapshots()[0]
|
||||
self.assertEqual(snapshot.health.status.value, "unhealthy")
|
||||
self.assertEqual(snapshot.lifecycle, WorkerLifecycle.RUNNING)
|
||||
self.assertEqual(max_active, 1)
|
||||
|
||||
stopping = await runtime.stop(timeout_seconds=0.01)
|
||||
self.assertEqual(stopping.lifecycle, ApplicationLifecycle.STOPPING)
|
||||
self.assertEqual(stopping.workers.stopping, ("sync",))
|
||||
release_second.set()
|
||||
await asyncio.wait_for(self._wait_until_stopped(runtime), timeout=1)
|
||||
self.assertEqual(runtime.lifecycle, ApplicationLifecycle.STOPPED)
|
||||
self.assertEqual(calls, 2)
|
||||
|
||||
@staticmethod
|
||||
async def _wait_until_stopped(runtime: ApplicationRuntime) -> None:
|
||||
while runtime.lifecycle is not ApplicationLifecycle.STOPPED:
|
||||
await asyncio.sleep(0)
|
||||
|
||||
async def test_force_stop_cancels_active_cycle(self) -> None:
|
||||
active = asyncio.Event()
|
||||
cancelled = asyncio.Event()
|
||||
|
||||
async def process() -> None:
|
||||
active.set()
|
||||
try:
|
||||
await asyncio.Event().wait()
|
||||
except asyncio.CancelledError:
|
||||
cancelled.set()
|
||||
raise
|
||||
|
||||
registry = WorkerRegistry()
|
||||
registry.register(WorkerDefinition("blocking", process))
|
||||
supervisor = WorkerSupervisor(
|
||||
registry,
|
||||
FakeWorkerConfigReader({"blocking": WorkerConfig(interval_seconds=60)}),
|
||||
)
|
||||
runtime = ApplicationRuntime(RuntimeContext("service-a"), supervisor)
|
||||
await runtime.start()
|
||||
await asyncio.wait_for(active.wait(), timeout=1)
|
||||
|
||||
result = await runtime.stop(force=True, timeout_seconds=1)
|
||||
|
||||
self.assertEqual(result.lifecycle, ApplicationLifecycle.STOPPED)
|
||||
self.assertTrue(cancelled.is_set())
|
||||
|
||||
async def test_invalid_enabled_schedule_fails_application_start(self) -> None:
|
||||
registry = WorkerRegistry()
|
||||
registry.register(WorkerDefinition("missing_schedule", WorkerRegistryTests._process))
|
||||
supervisor = WorkerSupervisor(registry, FakeWorkerConfigReader({}))
|
||||
runtime = ApplicationRuntime(RuntimeContext("service-a"), supervisor)
|
||||
|
||||
result = await runtime.start()
|
||||
|
||||
self.assertEqual(result.lifecycle, ApplicationLifecycle.FAILED)
|
||||
self.assertIn("missing_schedule", result.workers.failures)
|
||||
self.assertEqual(supervisor.snapshots()[0].lifecycle, WorkerLifecycle.FAILED)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user