From 71998a6b13359d0831f0dd9dc0941a9027e7119a Mon Sep 17 00:00:00 2001 From: zosimovaa Date: Sat, 10 Oct 2026 19:36:32 +0300 Subject: [PATCH] =?UTF-8?q?PLBA2-2.=20=D0=A0=D0=B5=D0=B0=D0=BB=D0=B8=D0=B7?= =?UTF-8?q?=D0=B0=D1=86=D0=B8=D1=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 97 ++++++-- docs/configuration.md | 40 ++++ docs/database-contracts.md | 77 ++++++ docs/integration.md | 52 +++++ pyproject.toml | 7 +- src/plba/__init__.py | 5 + src/plba/__pycache__/__init__.cpython-312.pyc | Bin 0 -> 297 bytes src/plba/config/__init__.py | 18 ++ .../__pycache__/__init__.cpython-312.pyc | Bin 0 -> 586 bytes .../config/__pycache__/loader.cpython-312.pyc | Bin 0 -> 6697 bytes .../__pycache__/manager.cpython-312.pyc | Bin 0 -> 9898 bytes .../config/__pycache__/models.cpython-312.pyc | Bin 0 -> 1611 bytes src/plba/config/loader.py | 106 +++++++++ src/plba/config/manager.py | 161 +++++++++++++ src/plba/config/models.py | 27 +++ src/plba/health/__init__.py | 27 +++ .../__pycache__/__init__.cpython-312.pyc | Bin 0 -> 696 bytes .../__pycache__/aggregator.cpython-312.pyc | Bin 0 -> 9177 bytes .../__pycache__/contributors.cpython-312.pyc | Bin 0 -> 2243 bytes .../health/__pycache__/models.cpython-312.pyc | Bin 0 -> 1824 bytes .../__pycache__/provider.cpython-312.pyc | Bin 0 -> 4097 bytes src/plba/health/aggregator.py | 118 ++++++++++ src/plba/health/contributors.py | 35 +++ src/plba/health/models.py | 37 +++ src/plba/health/provider.py | 65 ++++++ src/plba/http/__init__.py | 3 + .../http/__pycache__/__init__.cpython-312.pyc | Bin 0 -> 208 bytes .../http/__pycache__/asgi.cpython-312.pyc | Bin 0 -> 2714 bytes .../__pycache__/control_api.cpython-312.pyc | Bin 0 -> 6101 bytes .../http/__pycache__/errors.cpython-312.pyc | Bin 0 -> 317 bytes .../http/__pycache__/requests.cpython-312.pyc | Bin 0 -> 2324 bytes .../__pycache__/serialization.cpython-312.pyc | Bin 0 -> 952 bytes src/plba/http/asgi.py | 41 ++++ src/plba/http/control_api.py | 81 +++++++ src/plba/http/errors.py | 2 + src/plba/http/requests.py | 39 ++++ src/plba/http/serialization.py | 21 ++ src/plba/logging/__init__.py | 3 + .../__pycache__/__init__.cpython-312.pyc | Bin 0 -> 267 bytes .../__pycache__/technical.cpython-312.pyc | Bin 0 -> 3467 bytes src/plba/logging/technical.py | 57 +++++ src/plba/runtime/__init__.py | 25 ++ .../__pycache__/__init__.cpython-312.pyc | Bin 0 -> 616 bytes .../__pycache__/application.cpython-312.pyc | Bin 0 -> 4583 bytes .../application_identity.cpython-312.pyc | Bin 0 -> 3120 bytes .../__pycache__/context.cpython-312.pyc | Bin 0 -> 541 bytes .../__pycache__/lifecycle.cpython-312.pyc | Bin 0 -> 1427 bytes .../stop_coordinator.cpython-312.pyc | Bin 0 -> 6356 bytes src/plba/runtime/application.py | 88 +++++++ src/plba/runtime/application_identity.py | 54 +++++ src/plba/runtime/context.py | 8 + src/plba/runtime/lifecycle.py | 32 +++ src/plba/runtime/stop_coordinator.py | 126 ++++++++++ src/plba/runtime/worker/__init__.py | 29 +++ .../__pycache__/__init__.cpython-312.pyc | Bin 0 -> 734 bytes .../worker/__pycache__/config.cpython-312.pyc | Bin 0 -> 2091 bytes .../worker/__pycache__/health.cpython-312.pyc | Bin 0 -> 4916 bytes .../worker/__pycache__/models.cpython-312.pyc | Bin 0 -> 2289 bytes .../__pycache__/registry.cpython-312.pyc | Bin 0 -> 1854 bytes .../worker/__pycache__/runner.cpython-312.pyc | Bin 0 -> 8437 bytes .../__pycache__/schedule.cpython-312.pyc | Bin 0 -> 3934 bytes .../__pycache__/supervisor.cpython-312.pyc | Bin 0 -> 9567 bytes src/plba/runtime/worker/config.py | 33 +++ src/plba/runtime/worker/health.py | 87 +++++++ src/plba/runtime/worker/models.py | 48 ++++ src/plba/runtime/worker/registry.py | 23 ++ src/plba/runtime/worker/runner.py | 153 ++++++++++++ src/plba/runtime/worker/schedule.py | 64 +++++ src/plba/runtime/worker/supervisor.py | 151 ++++++++++++ src/plba/settings/__init__.py | 19 ++ .../__pycache__/__init__.cpython-312.pyc | Bin 0 -> 611 bytes .../__pycache__/models.cpython-312.pyc | Bin 0 -> 2156 bytes .../__pycache__/postgres.cpython-312.pyc | Bin 0 -> 3547 bytes .../__pycache__/reader.cpython-312.pyc | Bin 0 -> 2006 bytes .../__pycache__/repository.cpython-312.pyc | Bin 0 -> 686 bytes src/plba/settings/models.py | 36 +++ src/plba/settings/postgres.py | 43 ++++ src/plba/settings/reader.py | 35 +++ src/plba/settings/repository.py | 7 + src/plba/tracing/__init__.py | 19 ++ .../__pycache__/__init__.cpython-312.pyc | Bin 0 -> 615 bytes .../__pycache__/context.cpython-312.pyc | Bin 0 -> 1296 bytes .../__pycache__/models.cpython-312.pyc | Bin 0 -> 3824 bytes .../__pycache__/postgres.cpython-312.pyc | Bin 0 -> 6032 bytes .../__pycache__/repository.cpython-312.pyc | Bin 0 -> 839 bytes src/plba/tracing/context.py | 23 ++ src/plba/tracing/models.py | 52 +++++ src/plba/tracing/postgres.py | 92 ++++++++ src/plba/tracing/repository.py | 9 + src/plba/workflow/__init__.py | 23 ++ .../__pycache__/__init__.cpython-312.pyc | Bin 0 -> 613 bytes .../__pycache__/engine.cpython-312.pyc | Bin 0 -> 5856 bytes .../failure_recorder.cpython-312.pyc | Bin 0 -> 2985 bytes .../__pycache__/models.cpython-312.pyc | Bin 0 -> 6279 bytes .../__pycache__/persistence.cpython-312.pyc | Bin 0 -> 2023 bytes src/plba/workflow/engine.py | 131 +++++++++++ src/plba/workflow/failure_recorder.py | 64 +++++ src/plba/workflow/models.py | 87 +++++++ src/plba/workflow/persistence.py | 45 ++++ ...configuration.cpython-312-pytest-9.0.2.pyc | Bin 0 -> 12223 bytes .../test_configuration.cpython-312.pyc | Bin 0 -> 12058 bytes ...t_health_http.cpython-312-pytest-9.0.2.pyc | Bin 0 -> 14834 bytes .../test_health_http.cpython-312.pyc | Bin 0 -> 14670 bytes ...test_identity.cpython-312-pytest-9.0.2.pyc | Bin 0 -> 3919 bytes .../__pycache__/test_identity.cpython-312.pyc | Bin 0 -> 3754 bytes ...observability.cpython-312-pytest-9.0.2.pyc | Bin 0 -> 8850 bytes .../test_observability.cpython-312.pyc | Bin 0 -> 8686 bytes .../test_runtime.cpython-312-pytest-9.0.2.pyc | Bin 0 -> 10762 bytes .../__pycache__/test_runtime.cpython-312.pyc | Bin 0 -> 10598 bytes ...test_settings.cpython-312-pytest-9.0.2.pyc | Bin 0 -> 8451 bytes .../__pycache__/test_settings.cpython-312.pyc | Bin 0 -> 8286 bytes ...test_workflow.cpython-312-pytest-9.0.2.pyc | Bin 0 -> 9084 bytes .../__pycache__/test_workflow.cpython-312.pyc | Bin 0 -> 8920 bytes tests/test_configuration.py | 179 ++++++++++++++ tests/test_health_http.py | 219 ++++++++++++++++++ tests/test_identity.py | 54 +++++ tests/test_observability.py | 130 +++++++++++ tests/test_runtime.py | 153 ++++++++++++ tests/test_settings.py | 108 +++++++++ tests/test_workflow.py | 128 ++++++++++ 120 files changed, 3675 insertions(+), 21 deletions(-) create mode 100644 docs/configuration.md create mode 100644 docs/database-contracts.md create mode 100644 docs/integration.md create mode 100644 src/plba/__init__.py create mode 100644 src/plba/__pycache__/__init__.cpython-312.pyc create mode 100644 src/plba/config/__init__.py create mode 100644 src/plba/config/__pycache__/__init__.cpython-312.pyc create mode 100644 src/plba/config/__pycache__/loader.cpython-312.pyc create mode 100644 src/plba/config/__pycache__/manager.cpython-312.pyc create mode 100644 src/plba/config/__pycache__/models.cpython-312.pyc create mode 100644 src/plba/config/loader.py create mode 100644 src/plba/config/manager.py create mode 100644 src/plba/config/models.py create mode 100644 src/plba/health/__init__.py create mode 100644 src/plba/health/__pycache__/__init__.cpython-312.pyc create mode 100644 src/plba/health/__pycache__/aggregator.cpython-312.pyc create mode 100644 src/plba/health/__pycache__/contributors.cpython-312.pyc create mode 100644 src/plba/health/__pycache__/models.cpython-312.pyc create mode 100644 src/plba/health/__pycache__/provider.cpython-312.pyc create mode 100644 src/plba/health/aggregator.py create mode 100644 src/plba/health/contributors.py create mode 100644 src/plba/health/models.py create mode 100644 src/plba/health/provider.py create mode 100644 src/plba/http/__init__.py create mode 100644 src/plba/http/__pycache__/__init__.cpython-312.pyc create mode 100644 src/plba/http/__pycache__/asgi.cpython-312.pyc create mode 100644 src/plba/http/__pycache__/control_api.cpython-312.pyc create mode 100644 src/plba/http/__pycache__/errors.cpython-312.pyc create mode 100644 src/plba/http/__pycache__/requests.cpython-312.pyc create mode 100644 src/plba/http/__pycache__/serialization.cpython-312.pyc create mode 100644 src/plba/http/asgi.py create mode 100644 src/plba/http/control_api.py create mode 100644 src/plba/http/errors.py create mode 100644 src/plba/http/requests.py create mode 100644 src/plba/http/serialization.py create mode 100644 src/plba/logging/__init__.py create mode 100644 src/plba/logging/__pycache__/__init__.cpython-312.pyc create mode 100644 src/plba/logging/__pycache__/technical.cpython-312.pyc create mode 100644 src/plba/logging/technical.py create mode 100644 src/plba/runtime/__init__.py create mode 100644 src/plba/runtime/__pycache__/__init__.cpython-312.pyc create mode 100644 src/plba/runtime/__pycache__/application.cpython-312.pyc create mode 100644 src/plba/runtime/__pycache__/application_identity.cpython-312.pyc create mode 100644 src/plba/runtime/__pycache__/context.cpython-312.pyc create mode 100644 src/plba/runtime/__pycache__/lifecycle.cpython-312.pyc create mode 100644 src/plba/runtime/__pycache__/stop_coordinator.cpython-312.pyc create mode 100644 src/plba/runtime/application.py create mode 100644 src/plba/runtime/application_identity.py create mode 100644 src/plba/runtime/context.py create mode 100644 src/plba/runtime/lifecycle.py create mode 100644 src/plba/runtime/stop_coordinator.py create mode 100644 src/plba/runtime/worker/__init__.py create mode 100644 src/plba/runtime/worker/__pycache__/__init__.cpython-312.pyc create mode 100644 src/plba/runtime/worker/__pycache__/config.cpython-312.pyc create mode 100644 src/plba/runtime/worker/__pycache__/health.cpython-312.pyc create mode 100644 src/plba/runtime/worker/__pycache__/models.cpython-312.pyc create mode 100644 src/plba/runtime/worker/__pycache__/registry.cpython-312.pyc create mode 100644 src/plba/runtime/worker/__pycache__/runner.cpython-312.pyc create mode 100644 src/plba/runtime/worker/__pycache__/schedule.cpython-312.pyc create mode 100644 src/plba/runtime/worker/__pycache__/supervisor.cpython-312.pyc create mode 100644 src/plba/runtime/worker/config.py create mode 100644 src/plba/runtime/worker/health.py create mode 100644 src/plba/runtime/worker/models.py create mode 100644 src/plba/runtime/worker/registry.py create mode 100644 src/plba/runtime/worker/runner.py create mode 100644 src/plba/runtime/worker/schedule.py create mode 100644 src/plba/runtime/worker/supervisor.py create mode 100644 src/plba/settings/__init__.py create mode 100644 src/plba/settings/__pycache__/__init__.cpython-312.pyc create mode 100644 src/plba/settings/__pycache__/models.cpython-312.pyc create mode 100644 src/plba/settings/__pycache__/postgres.cpython-312.pyc create mode 100644 src/plba/settings/__pycache__/reader.cpython-312.pyc create mode 100644 src/plba/settings/__pycache__/repository.cpython-312.pyc create mode 100644 src/plba/settings/models.py create mode 100644 src/plba/settings/postgres.py create mode 100644 src/plba/settings/reader.py create mode 100644 src/plba/settings/repository.py create mode 100644 src/plba/tracing/__init__.py create mode 100644 src/plba/tracing/__pycache__/__init__.cpython-312.pyc create mode 100644 src/plba/tracing/__pycache__/context.cpython-312.pyc create mode 100644 src/plba/tracing/__pycache__/models.cpython-312.pyc create mode 100644 src/plba/tracing/__pycache__/postgres.cpython-312.pyc create mode 100644 src/plba/tracing/__pycache__/repository.cpython-312.pyc create mode 100644 src/plba/tracing/context.py create mode 100644 src/plba/tracing/models.py create mode 100644 src/plba/tracing/postgres.py create mode 100644 src/plba/tracing/repository.py create mode 100644 src/plba/workflow/__init__.py create mode 100644 src/plba/workflow/__pycache__/__init__.cpython-312.pyc create mode 100644 src/plba/workflow/__pycache__/engine.cpython-312.pyc create mode 100644 src/plba/workflow/__pycache__/failure_recorder.cpython-312.pyc create mode 100644 src/plba/workflow/__pycache__/models.cpython-312.pyc create mode 100644 src/plba/workflow/__pycache__/persistence.cpython-312.pyc create mode 100644 src/plba/workflow/engine.py create mode 100644 src/plba/workflow/failure_recorder.py create mode 100644 src/plba/workflow/models.py create mode 100644 src/plba/workflow/persistence.py create mode 100644 tests/__pycache__/test_configuration.cpython-312-pytest-9.0.2.pyc create mode 100644 tests/__pycache__/test_configuration.cpython-312.pyc create mode 100644 tests/__pycache__/test_health_http.cpython-312-pytest-9.0.2.pyc create mode 100644 tests/__pycache__/test_health_http.cpython-312.pyc create mode 100644 tests/__pycache__/test_identity.cpython-312-pytest-9.0.2.pyc create mode 100644 tests/__pycache__/test_identity.cpython-312.pyc create mode 100644 tests/__pycache__/test_observability.cpython-312-pytest-9.0.2.pyc create mode 100644 tests/__pycache__/test_observability.cpython-312.pyc create mode 100644 tests/__pycache__/test_runtime.cpython-312-pytest-9.0.2.pyc create mode 100644 tests/__pycache__/test_runtime.cpython-312.pyc create mode 100644 tests/__pycache__/test_settings.cpython-312-pytest-9.0.2.pyc create mode 100644 tests/__pycache__/test_settings.cpython-312.pyc create mode 100644 tests/__pycache__/test_workflow.cpython-312-pytest-9.0.2.pyc create mode 100644 tests/__pycache__/test_workflow.cpython-312.pyc create mode 100644 tests/test_configuration.py create mode 100644 tests/test_health_http.py create mode 100644 tests/test_identity.py create mode 100644 tests/test_observability.py create mode 100644 tests/test_runtime.py create mode 100644 tests/test_settings.py create mode 100644 tests/test_workflow.py diff --git a/README.md b/README.md index b58ea91..5e43491 100644 --- a/README.md +++ b/README.md @@ -1,35 +1,94 @@ # PLBA v2 -PLBA v2 is a compact, transport-neutral runtime for business microservices. It owns application lifecycle, worker supervision, versioned configuration snapshots, traces, structured logging, health aggregation, workflows and an optional audit port. +PLBA v2 is a transport-neutral Python library for application lifecycle, +workers, health aggregation, configuration snapshots, workflows, business +tracing, and structured technical logs. It is a separate package from PLBA v1. -It deliberately does not own task queues, RabbitMQ clients, gRPC servers, HTTP servers, a database driver, or business logic. A service supplies those as adapters and owns its entrypoint. +The application owns its entrypoint and composition root, business logic, HTTP +host and listener, database schema and migrations, and message queues. PLBA2 +provides components and adapters that the application wires together; it does +not start a service or create a second HTTP port. -## Status +## Capabilities -This repository contains the first executable skeleton and public contracts. It is a breaking, separate package from PLBA v1; no v1 compatibility facade is provided. +- `runtime/application-identity` resolves `application_id` from `config.yaml`, + then `[project].name` in `pyproject.toml`, then UUIDv4. +- `runtime/worker` registers uniquely named workers, applies the `disabled` + flag, runs sequential scheduled cycles, combines application and automatic + health, and supports graceful or force stop. +- `runtime/application-lifecycle` starts and stops all enabled workers and + reports application lifecycle states. +- `health/aggregation` combines worker and contributor states, criticality, + missing components, and application lifecycle into a health report. +- `api/http/control-api` is a mountable ASGI adapter for `GET /health`, + `POST /runtime/start`, `POST /runtime/stop`, and `GET /runtime/status`. +- `configuration/application-config-file` loads an application-typed root + `config.yaml` and atomically reloads valid snapshots without a restart. +- `configuration/application-settings` provides a typed `SettingsReader` and a + PostgreSQL adapter for the application's `settings` table. +- `workflow/orchestration` executes named object-based steps through declared + transitions and persists run and step snapshots through an application port. +- `observability/business-tracing` provides trace contracts and a PostgreSQL + writer for application-owned `trace_contexts` and `trace_messages` tables. +- `observability/technical-logging` formats JSON log records with application + and business trace identifiers for stdout. -## Run checks +## Install ```bash -python -m unittest discover -s tests -v +pip install . ``` -## Configuration-service shape +The PostgreSQL adapters accept the application's pool and schema. PLBA2 does +not install or manage a database driver. The HTTP adapter uses ASGI and does +not install or manage an HTTP server. + +## Composition outline + +The application loads and validates configuration before building dependent +components. It supplies a decoder for its own typed fields: ```python -runtime = Runtime( - configuration=ConfigurationSnapshotManager( - client=configuration_grpc_adapter, - scope="configuration-service", - validator=validate_configuration, - ), - workers=[grpc_server_worker, configuration_changed_consumer], +config_loader = ApplicationConfigLoader( + Path("config.yaml"), application_decoder=ServiceConfig.from_mapping ) +config_manager = ApplicationConfigManager(config_loader) +initial_config = config_manager.load_initial() -await runtime.start() -# The RabbitMQ adapter invokes the registered callback after configuration.changed. -# The manager refetches and atomically swaps the validated snapshot. -await runtime.stop(timeout_seconds=20) +identity = ApplicationIdentityResolver( + TomlProjectNameReader(Path("pyproject.toml")) +) +runtime_context = identity.resolve(initial_config.application_id) + +workers = WorkerRegistry() +workers.register(WorkerDefinition("inventory_sync", sync_inventory)) +supervisor = WorkerSupervisor(workers, config_manager) +runtime = ApplicationRuntime(runtime_context, supervisor) ``` -The adapter authenticates using bootstrap values read by the service from environment/secrets. Business code reads `manager.current()` and never makes a synchronous configuration-service call. +The application creates its HTTP host and mounts `ControlApi` on the same +listener. `RuntimeHealthInputProvider` connects the runtime, worker supervisor, +and registered health contributors to `HealthAggregator`. The application +starts its own server and chooses when to call `runtime.start()` and +`runtime.stop()`. + +For configuration changes, run `config_manager.watch(...)` in an application +task and handle reload errors in the supplied callback. Existing snapshots +remain stable; an invalid update leaves the latest valid snapshot active. + +## Database ownership + +The application creates and seeds `settings` in its migrations. It also creates +`trace_contexts` and `trace_messages` in its migrations. PLBA2 does not create +tables, run application migrations, copy YAML into the database, expose a +business-history API, publish business events to RabbitMQ, or provide shared +worker-message queues. See [database contracts](docs/database-contracts.md) and +[configuration](docs/configuration.md) for the consumer-facing contracts. +See [integration guidance](docs/integration.md) for wiring the HTTP, database, +workflow, trace, and logging adapters into an application. + +## Development + +```bash +python3 -m pytest +``` diff --git a/docs/configuration.md b/docs/configuration.md new file mode 100644 index 0000000..e79efcc --- /dev/null +++ b/docs/configuration.md @@ -0,0 +1,40 @@ +# Application configuration + +PLBA2 reads `config.yaml` from the application root. The application supplies a +typed decoder for its own fields; PLBA2 validates the common identity and worker +fields and keeps the application model in the same snapshot. + +```yaml +application_id: inventory-service +workers: + inventory_sync: + disabled: false + interval_seconds: 60 + cleanup: + pause_seconds: 300 +database_url: "..." +``` + +`application_id` is optional. A non-empty value is used unchanged; otherwise +identity resolution uses `[project].name` from `pyproject.toml`, then a UUIDv4. +The resolved value is passed to `ApplicationRuntime` through `RuntimeContext` +before dependent components start. + +Each worker entry may set `disabled` (default `false`) and one schedule: +`interval_seconds` or `pause_seconds`. Enabled workers need exactly one positive +finite schedule. A disabled worker is skipped at application start and does not +need a schedule. Changing `disabled` takes effect on the next application start; +valid schedule updates are used when the next worker cycle is planned. + +The application defines every other YAML field and its typed model. This file is +for rarely changed technical parameters. Business parameters, feature toggles, +and technical values that must change remotely while the process is running +belong in the application-owned `settings` table, read through `SettingsReader`. + +Load and validate the initial file before starting dependent components. A +missing, malformed, or invalid initial file raises `ApplicationConfigLoadError` +and blocks startup. After startup, `ApplicationConfigManager.watch` checks for +file changes. It swaps in a fully validated snapshot atomically; previously +returned snapshots remain unchanged. If an update is invalid or unreadable, +`reload_if_changed` returns a failure and the manager keeps the last valid +snapshot. The watcher passes that error to the application's callback. diff --git a/docs/database-contracts.md b/docs/database-contracts.md new file mode 100644 index 0000000..e4f2812 --- /dev/null +++ b/docs/database-contracts.md @@ -0,0 +1,77 @@ +# Database contracts + +PLBA2 reads and writes application-owned tables through adapters. The application +owns the schema, migrations, initial values, and retention policy. PLBA2 does not +create tables or run migrations. + +## `settings` + +The application creates `settings` in its own schema and loads initial rows in +its migration. The table has this contract: + +| Field | Type | Constraints | Purpose | +| --- | --- | --- | --- | +| `id` | `BIGINT` | Identity primary key, not null | Row identifier and final ordering key | +| `config_key` | `VARCHAR(128)` | Nullable | Application-defined scope or entity | +| `setting_key` | `VARCHAR(128)` | Not null | Stable setting name | +| `setting_value` | `TEXT` | Not null | Text value decoded by the application | +| `sort_order` | `INT` | Not null, default `0` | Order for repeated keys | +| `is_enabled` | `BOOLEAN` | Not null, default `TRUE` | Includes or excludes a row from reads | +| `description` | `TEXT` | Nullable | Human-readable explanation | + +Indexes should support the adapter's filters and ordering, for example: + +```sql +CREATE INDEX settings_key_enabled_order_idx + ON settings (setting_key, is_enabled, sort_order, id); +CREATE INDEX settings_scope_lookup_order_idx + ON settings (setting_key, config_key, is_enabled, sort_order, id); +``` + +There is no uniqueness constraint on `setting_key`; several enabled rows may +form an ordered list. Reads filter by `setting_key`, an optional `config_key`, +and `is_enabled = TRUE`, then order by `sort_order`, `id`. The value of a feature +toggle belongs in `setting_value`; `is_enabled` only controls whether the row is +read. `config_key` relationships are owned by the application. + +`settings` stores business parameters, feature toggles, and technical values +that must change remotely while the process runs. Rarely changed technical +parameters remain in the root `config.yaml`; PLBA2 does not copy YAML into the +database. + +## `trace_contexts` and `trace_messages` + +The application creates both trace tables in its own schema through its own +migration. Public code calls the context identifier `business_trace_id`; both +tables store it as `trace_id`. + +`trace_contexts` contains: + +| Field | Type | Constraints | Purpose | +| --- | --- | --- | --- | +| `trace_id` | `UUID` | Primary key, not null | Public `business_trace_id` | +| `parent_id` | `UUID` | Nullable | Parent context identifier | +| `alias` | `TEXT` | Not null | Short context name | +| `trace_type` | `TEXT` | Not null | Business operation type | +| `event_time` | `TIMESTAMPTZ` | Not null | Context creation time | +| `attrs_json` | `JSONB` | Not null | Context attributes, including `application_id` | + +Create indexes on `parent_id` and `event_time`. + +`trace_messages` contains: + +| Field | Type | Constraints | Purpose | +| --- | --- | --- | --- | +| `id` | `BIGINT` | Identity primary key, not null | Message identifier | +| `trace_id` | `UUID` | Not null, references `trace_contexts.trace_id` with `ON DELETE CASCADE` | Owning context | +| `event_time` | `TIMESTAMPTZ` | Not null | Message time | +| `step` | `TEXT` | Not null | Business step name | +| `status` | `TEXT` | Not null | Step result | +| `level` | `TEXT` | Not null | Business message level | +| `message` | `TEXT` | Not null | Human-readable business message | +| `attrs_json` | `JSONB` | Not null | Message attributes, including `application_id` | + +Create indexes on `trace_id`, `event_time`, and `status`. The PostgreSQL +adapter only inserts rows, adds the runtime `application_id` to each +`attrs_json`, and passes database failures to the application. It does not +create tables, run migrations, publish RabbitMQ events, or expose a history API. diff --git a/docs/integration.md b/docs/integration.md new file mode 100644 index 0000000..293cdd8 --- /dev/null +++ b/docs/integration.md @@ -0,0 +1,52 @@ +# Integrating PLBA2 + +The application keeps its entrypoint and composes the library before it starts +its own HTTP host. The root `config.yaml` must load successfully before +dependent components are created. + +## HTTP, runtime, and health + +Register `WorkerDefinition` objects in a `WorkerRegistry`, pass the registry and +`ApplicationConfigManager` to `WorkerSupervisor`, resolve an +`ApplicationIdentityResolver` result into `RuntimeContext`, and construct +`ApplicationRuntime`. Register non-worker checks in `HealthContributorRegistry` +and connect it to `HealthAggregator` with `RuntimeHealthInputProvider`. + +Mount `ControlApi(runtime, health_aggregator)` in the application's ASGI host. +The host owns the socket and listener; the adapter contributes `/health`, +`/runtime/start`, `/runtime/stop`, and `/runtime/status` to that same listener. +The application chooses when to start and stop the runtime. + +## Configuration and settings + +Pass an application decoder to `ApplicationConfigLoader`. Its typed model +validates application-specific fields while PLBA2 validates `application_id` +and worker settings. `ApplicationConfigManager` implements +`WorkerConfigReader`; its watcher atomically swaps valid snapshots and passes +reload failures to the application's callback. + +Create `settings` and seed its initial values in an application migration. Pass +the application's pool and schema to `PostgresSettingsRepository`, then expose +it through `SettingsReader` and typed `SettingKey` definitions. The adapter +filters enabled rows and returns values in `sort_order`, `id` order. The full +schema contract is in [database-contracts.md](database-contracts.md). + +## Workflow and business trace + +Define a `WorkflowDefinition` from named `WorkflowNode` objects and explicit +transition maps. Give `WorkflowEngine` an application-owned implementation of +`WorkflowPersistence`; that adapter decides how and where to store snapshots. +PLBA2 does not connect workflow persistence to a database itself. + +Create `trace_contexts` and `trace_messages` in the application's migrations. +Pass the application's pool, schema, and resolved application ID to +`PostgresBusinessTraceWriter`. Bind the public trace ID with +`business_trace_context(trace_id)` around async business work so technical logs +inherit it. + +## Technical logs + +Attach `create_stdout_handler(runtime_context.application_id)` to the +application's logger. It uses the standard library `StreamHandler` and emits +one JSON object per record. The platform remains responsible for log delivery +and retention. diff --git a/pyproject.toml b/pyproject.toml index c275adc..ea40f22 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -5,10 +5,13 @@ build-backend = "setuptools.build_meta" [project] name = "plba-v2" version = "0.1.0" -description = "Portable lifecycle and observability runtime for business microservices" +description = "Portable application lifecycle and observability components" readme = "README.md" requires-python = ">=3.11" -dependencies = [] +dependencies = ["PyYAML>=6.0"] + +[project.optional-dependencies] +test = ["pytest>=8.0"] [tool.setuptools.packages.find] where = ["src"] diff --git a/src/plba/__init__.py b/src/plba/__init__.py new file mode 100644 index 0000000..19a9aab --- /dev/null +++ b/src/plba/__init__.py @@ -0,0 +1,5 @@ +"""Portable lifecycle and observability components for Python applications.""" + +from plba.runtime.context import RuntimeContext + +__all__ = ["RuntimeContext"] diff --git a/src/plba/__pycache__/__init__.cpython-312.pyc b/src/plba/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..39967b4800d0719914fb50d73d13b869a68012e5 GIT binary patch literal 297 zcmYk2u};G<5Qgofs8vx}=mZR2vm`HoSXh{ei{Y3KG9`cmJI}-AVU4nT%1?^To^cW2~R4`BV05RtM2MAc1Nmu*fuSvpT~_ zYqhm%8XuNbctWjEpj&Nu#7-@nh3vguKg)1_S1%j0-f4EiCZ0yw4p)ar(nZcCN?AC?%VHKk8zmA0*? y-tj8o6{X6kKxt{a_2{?-vDEU!r3c^`em|z49Ao^BW?!iK*gbq3AKee#D9$%;gH|K} literal 0 HcmV?d00001 diff --git a/src/plba/config/__init__.py b/src/plba/config/__init__.py new file mode 100644 index 0000000..f7d87b1 --- /dev/null +++ b/src/plba/config/__init__.py @@ -0,0 +1,18 @@ +from plba.config.loader import ApplicationConfigLoadError, ApplicationConfigLoader +from plba.config.manager import ( + ApplicationConfigManager, + ApplicationConfigUnavailable, + ConfigReloadResult, + ConfigReloadStatus, +) +from plba.config.models import ApplicationConfigSnapshot + +__all__ = [ + "ApplicationConfigLoadError", + "ApplicationConfigLoader", + "ApplicationConfigManager", + "ApplicationConfigSnapshot", + "ApplicationConfigUnavailable", + "ConfigReloadResult", + "ConfigReloadStatus", +] diff --git a/src/plba/config/__pycache__/__init__.cpython-312.pyc b/src/plba/config/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..56d01384d21a431146fbfae39cfd8670724dc518 GIT binary patch literal 586 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 literal 0 HcmV?d00001 diff --git a/src/plba/config/__pycache__/manager.cpython-312.pyc b/src/plba/config/__pycache__/manager.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6ac2b23b48b9e4d9710518c977891e59053a5f80 GIT binary patch literal 9898 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�?O`w~qk zivnpY!wsK--_(aG`-rlOX|fuvNxZxae%2~WH)$eG9;bo_kmGhiN4uAXH0G_WFRO%PDHkM4B0nGJ0)Srt@hSRa zW_B?D`Flg->|S-|{( z)u#Wy)uFLXIlGklAr1eQ z7vSUPLHq{?yGFg(t~Pbtnw$>OIEKbj%(wiNAU{x64u2|?GXq?uDd6Y9i>|c*!_S9V zu)x$4k#njCTWmcMQIEEYH`*%N@TiVO#quj3PvfbxShUC6%!O#`1@IWeV;y6>j~e^v z+&()0J8Jxe-gsnGKD&5#=?*@ykXE@rKL~em None: + self._config_path = config_path + self._application_decoder = application_decoder + + @property + def config_path(self) -> Path: + return self._config_path + + def signature(self) -> tuple[int, int, int, int]: + stat = self._config_path.stat() + return stat.st_mtime_ns, stat.st_ctime_ns, stat.st_size, stat.st_ino + + def load(self) -> LoadedApplicationConfig[T]: + try: + with self._config_path.open("r", encoding="utf-8") as config_file: + raw_config = yaml.safe_load(config_file) + except (OSError, UnicodeDecodeError, yaml.YAMLError) as error: + raise ApplicationConfigLoadError("could not read config.yaml") from error + if not isinstance(raw_config, dict): + raise ApplicationConfigLoadError("config.yaml root must be a mapping") + try: + application_id = self._application_id(raw_config) + workers = self._workers(raw_config) + application_config = self._application_decoder(raw_config) + except ApplicationConfigLoadError: + raise + except Exception as error: + raise ApplicationConfigLoadError("config.yaml does not match the application model") from error + return LoadedApplicationConfig(application_id, workers, application_config) + + @staticmethod + def _application_id(raw_config: Mapping[str, Any]) -> str | None: + if "application_id" not in raw_config: + return None + application_id = raw_config["application_id"] + if not isinstance(application_id, str): + raise ApplicationConfigLoadError("application_id must be a string") + return application_id + + @staticmethod + def _workers(raw_config: Mapping[str, Any]) -> dict[str, WorkerConfig]: + raw_workers = raw_config.get("workers", {}) + if not isinstance(raw_workers, dict): + raise ApplicationConfigLoadError("workers must be a mapping") + workers: dict[str, WorkerConfig] = {} + for name, raw_settings in raw_workers.items(): + if not isinstance(name, str) or not name or name.strip() != name: + raise ApplicationConfigLoadError("worker names must be non-empty strings") + if not isinstance(raw_settings, dict): + raise ApplicationConfigLoadError(f"workers.{name} must be a mapping") + unknown = set(raw_settings) - ApplicationConfigLoader._WORKER_FIELDS + if unknown: + raise ApplicationConfigLoadError( + f"workers.{name} contains unsupported fields: {sorted(unknown)}" + ) + workers[name] = ApplicationConfigLoader._worker_config(name, raw_settings) + return workers + + @staticmethod + def _worker_config(name: str, raw: Mapping[str, Any]) -> WorkerConfig: + disabled = raw.get("disabled", False) + if not isinstance(disabled, bool): + raise ApplicationConfigLoadError(f"workers.{name}.disabled must be boolean") + interval = ApplicationConfigLoader._duration(name, "interval_seconds", raw) + pause = ApplicationConfigLoader._duration(name, "pause_seconds", raw) + config = WorkerConfig(disabled, interval, pause) + try: + config.validate_schedule() + except WorkerConfigurationError as error: + raise ApplicationConfigLoadError(f"workers.{name} has an invalid schedule") from error + return config + + @staticmethod + def _duration(name: str, field: str, raw: Mapping[str, Any]) -> float | None: + if field not in raw: + return None + value = raw[field] + if isinstance(value, bool) or not isinstance(value, (int, float)): + raise ApplicationConfigLoadError(f"workers.{name}.{field} must be numeric") + duration = float(value) + if not math.isfinite(duration): + raise ApplicationConfigLoadError(f"workers.{name}.{field} must be finite") + return duration diff --git a/src/plba/config/manager.py b/src/plba/config/manager.py new file mode 100644 index 0000000..4950983 --- /dev/null +++ b/src/plba/config/manager.py @@ -0,0 +1,161 @@ +import asyncio +import math +from collections.abc import Awaitable, Callable +from copy import deepcopy +from dataclasses import dataclass +from enum import StrEnum +import logging +from threading import RLock +from typing import Generic, TypeVar + +from plba.config.loader import ApplicationConfigLoadError, ApplicationConfigLoader +from plba.config.models import ApplicationConfigSnapshot, LoadedApplicationConfig +from plba.runtime.worker.config import WorkerConfig + +T = TypeVar("T") + + +class ConfigReloadStatus(StrEnum): + UNCHANGED = "unchanged" + RELOADED = "reloaded" + FAILED = "failed" + + +@dataclass(frozen=True, slots=True) +class ConfigReloadResult(Generic[T]): + status: ConfigReloadStatus + snapshot: ApplicationConfigSnapshot[T] | None = None + error: Exception | None = None + + +class ApplicationConfigUnavailable(RuntimeError): + pass + + +class ApplicationConfigManager(Generic[T]): + def __init__( + self, loader: ApplicationConfigLoader[T], logger: logging.Logger | None = None + ) -> None: + self._loader = loader + self._logger = logger or logging.getLogger(__name__) + self._lock = RLock() + self._snapshot: ApplicationConfigSnapshot[T] | None = None + self._revision = 0 + self._last_seen_signature: tuple[int, int, int, int] | None = None + + def load_initial(self) -> ApplicationConfigSnapshot[T]: + try: + loaded = self._loader.load() + signature = self._loader.signature() + except Exception as error: + self._logger.error( + "initial application config load failed", + extra={"attributes": {"error_type": type(error).__name__}}, + ) + raise + with self._lock: + self._revision += 1 + self._snapshot = self._snapshot_from(loaded) + self._last_seen_signature = signature + snapshot = self.current() + self._logger.info( + "initial application config loaded", + extra={"attributes": {"revision": snapshot.revision}}, + ) + return snapshot + + def current(self) -> ApplicationConfigSnapshot[T]: + with self._lock: + if self._snapshot is None: + raise ApplicationConfigUnavailable("application config is not loaded") + snapshot = self._snapshot + return ApplicationConfigSnapshot( + application_id=snapshot.application_id, + workers=snapshot.workers, + application_config=deepcopy(snapshot.application_config), + revision=snapshot.revision, + ) + + def get_worker_config(self, worker_name: str) -> WorkerConfig: + with self._lock: + if self._snapshot is None: + raise ApplicationConfigUnavailable("application config is not loaded") + return self._snapshot.workers.get(worker_name, WorkerConfig()) + + def reload_if_changed(self) -> ConfigReloadResult[T]: + try: + signature = self._loader.signature() + except OSError as error: + with self._lock: + if self._last_seen_signature is None: + return ConfigReloadResult(ConfigReloadStatus.UNCHANGED) + return self._failure(error, None) + with self._lock: + if signature == self._last_seen_signature: + return ConfigReloadResult(ConfigReloadStatus.UNCHANGED) + self._last_seen_signature = signature + try: + loaded = self._loader.load() + except ApplicationConfigLoadError as error: + return self._failure(error, signature) + with self._lock: + self._revision += 1 + self._snapshot = self._snapshot_from(loaded) + snapshot = self.current() + self._logger.info( + "application config reloaded", + extra={"attributes": {"revision": snapshot.revision}}, + ) + return ConfigReloadResult(ConfigReloadStatus.RELOADED, snapshot=snapshot) + + async def watch( + self, + stop_event: asyncio.Event, + interval_seconds: float, + on_reload_failed: Callable[[Exception], Awaitable[None]], + sleep: Callable[[float], Awaitable[None]] = asyncio.sleep, + ) -> None: + if ( + isinstance(interval_seconds, bool) + or not isinstance(interval_seconds, (int, float)) + or not math.isfinite(interval_seconds) + or interval_seconds <= 0 + ): + raise ValueError("interval_seconds must be a positive finite number") + while not stop_event.is_set(): + sleep_task = asyncio.ensure_future(sleep(interval_seconds)) + stop_task = asyncio.create_task(stop_event.wait()) + done, pending = await asyncio.wait( + (sleep_task, stop_task), return_when=asyncio.FIRST_COMPLETED + ) + if sleep_task in done: + await sleep_task + for task in pending: + task.cancel() + await asyncio.gather(*pending, return_exceptions=True) + if stop_task in done: + break + result = await asyncio.to_thread(self.reload_if_changed) + if result.status is ConfigReloadStatus.FAILED and result.error is not None: + await on_reload_failed(result.error) + + def _failure( + self, error: Exception, signature: tuple[int, int, int, int] | None + ) -> ConfigReloadResult[T]: + with self._lock: + self._last_seen_signature = signature + self._logger.error( + "application config reload failed", + extra={"attributes": {"error_type": type(error).__name__}}, + ) + return ConfigReloadResult(ConfigReloadStatus.FAILED, error=error) + + def _snapshot_from( + self, loaded: LoadedApplicationConfig[T] + ) -> ApplicationConfigSnapshot[T]: + return ApplicationConfigSnapshot( + application_id=loaded.application_id, + workers=loaded.workers, + application_config=loaded.application_config, + revision=self._revision, + ) diff --git a/src/plba/config/models.py b/src/plba/config/models.py new file mode 100644 index 0000000..33ce95c --- /dev/null +++ b/src/plba/config/models.py @@ -0,0 +1,27 @@ +from collections.abc import Mapping +from dataclasses import dataclass +from types import MappingProxyType +from typing import Generic, TypeVar + +from plba.runtime.worker.config import WorkerConfig + +T = TypeVar("T") + + +@dataclass(frozen=True, slots=True) +class ApplicationConfigSnapshot(Generic[T]): + application_id: str | None + workers: Mapping[str, WorkerConfig] + application_config: T + revision: int + + def __post_init__(self) -> None: + object.__setattr__(self, "workers", MappingProxyType(dict(self.workers))) + + +@dataclass(frozen=True, slots=True) +class LoadedApplicationConfig(Generic[T]): + application_id: str | None + workers: Mapping[str, WorkerConfig] + application_config: T + diff --git a/src/plba/health/__init__.py b/src/plba/health/__init__.py new file mode 100644 index 0000000..bcd3327 --- /dev/null +++ b/src/plba/health/__init__.py @@ -0,0 +1,27 @@ +from plba.health.aggregator import HealthAggregator, HealthInputInvalid, HealthInputReader +from plba.health.contributors import ( + DuplicateHealthContributorError, + HealthContributor, + HealthContributorRegistry, +) +from plba.health.models import ( + HealthComponent, + HealthExpectation, + HealthInput, + HealthReport, +) +from plba.health.provider import RuntimeHealthInputProvider + +__all__ = [ + "DuplicateHealthContributorError", + "HealthAggregator", + "HealthComponent", + "HealthContributor", + "HealthContributorRegistry", + "HealthExpectation", + "HealthInput", + "HealthInputInvalid", + "HealthInputReader", + "HealthReport", + "RuntimeHealthInputProvider", +] diff --git a/src/plba/health/__pycache__/__init__.cpython-312.pyc b/src/plba/health/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..11c37f4910dbb82e32a5735205930ab4c0255de2 GIT binary patch literal 696 zcmZWmJ#X7E5GD0t*_IqTL147akXZ;||A8PtkOpX$An;UhQ5lO+7?6@cQARxGS9I@| zpV76Qx^l^oDaewUXc#1v;L-{kr~X0q|gwRp`8m#aDfN z2Qi2t0~{jAEo5;U+0bwnbGVCK-a;+zA+O?W*5)15;a$|_KJs~hf{J%ok8hzZ2oeyx zKOpMQTcP)8hJ>~nd?A?0tK%dQB*8KhYNuw-(!7*s=?pU(tL+9iAvh*Nm+pTqb4I6F zlKS=}OQoQfrEYR6gzmJgYVhjgf6@s_Xd%TsbX0$J$@45Fsa!QUy~)W`Vo9@9`3)y3 zsFMlFGa*B$K26G0Qoi(4ZEzv788v==(b5|W+d#*FXP|As{0!k6a16Kx0s}n_=ixvN zb9RYGSJg|6@cOChX6qXDp(&egUZbc-uLr7~rjTbbVMXm}ob+@x})yePtq zMbRBtXeD^xE5vkc}vf#=UT>e literal 0 HcmV?d00001 diff --git a/src/plba/health/__pycache__/aggregator.cpython-312.pyc b/src/plba/health/__pycache__/aggregator.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..478d7c815de5a8ba8cf64eda7fd0781b8353a1ed GIT binary patch literal 9177 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 Krvz)d@c#jhoVR!Y literal 0 HcmV?d00001 diff --git a/src/plba/health/__pycache__/contributors.cpython-312.pyc b/src/plba/health/__pycache__/contributors.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a9c3cd4ed91ed8a4966b8f76f011ee1defcaf3b5 GIT binary patch literal 2243 zcmaJ?&u}9+0PQYgEO=s62 zr&NmCRN}}jk*Z1@i_$-Uf1sE4;w4m$R#dH2_0XGJBO!6>d%Ippg6Y`$_RX6&GjHB} z@69ji^dN!u)8{`|7bHUd#7^Agp3vO{VS`x2qBf~foz?_hpx75|u_ozKD2ujSQ*?zA zCR`_sGGzp2EenYHfIygJ!S6?TONdq#$VbFd)`>L`Yqp{RqO0MU3S$YD*b*bPJ{W2T zL7R+c=*ebEOaF}qnh+%3zin1LbIE3bdeO9Plr$P7EYmZ~w&}Xi$y{`5D^8u&y?JKZ z-i@m;Pg&;9Dys*wYdfA>?s*Y@dV7=ZDd=txMs#WsUARV=2&*6boH)||N-w3xiI5REAuLf$FSG-Euv==osPz?i(3?mpc zjGALLY?M=m@kPV5dn2Oj@gQRuX1(rsrdM(5F4{!cQumK?`^K)N84=XsZx zCs*txb28e0vi#CBx3tpaNQMwlaNh*@mi#f8{$^q4P<~s=?_@{T=I>gMr4fEOw%iji z3R-O46u`@XH7Ue7|3PELhBJEXm8g8kxx*JVkq^N%o`eLb;xGw3UCE*oX!m?z^(3dTsENGO7vde-s0NR13pe2Hl zR~){=u2>+5PT>ACZk~n9OL}opfnu`Ni`mz-|BO4Ns_feWy0-{F;w56e zCG?;B9r<3^y?+0-`p*s1muTYRsurb5VOIzXn1F>^!}SVFtWbCA@37j6*IXU%V`|!% z-^~IK*}^!pW(%6kli)m58z>1Y!Qf}6-C!aAc^>p3y)}U!N4W^#;*}L*M#L-qA0uKL zObGWY0ANIBw4KR6%H;3QwTq|y;^}sA#xKrn7v~;+*}ibuzi|0c@$!@5qpf4}+rta3 z)WS~ka66gvletZ=ouBgIpPYI!Jhd}C^Kha)d&!@@)SCIYb>Ne(C>$E<5FtI(QOK#e zyHZ;n_0`eMxpr>C&rLj1PlhBc?MaUp#G41_Hi*}w0f98B?j|UVVynKOOw>n=sTN=H zr-Z)+YE2Ae52_3cV;Ly7Ft{!+z|ii*65(}NJ@)#Xg5eW5S_+zIUyaJNZMom7DUj(@zO#q8f;cENZDBQ+8~dmBVMDWGj?g;hB8dG9%% ztLLJ}>O7wWJG@m_2k3~D(%;GCZ{+x2!U1bK$<@A3f7La>mb`T}%C=5FvSQ qY}0y7i_Zj+j&=w@S0ut%2fI&GlqT+1;ixq6OdX=r{}O=k(EkBnzxBfa literal 0 HcmV?d00001 diff --git a/src/plba/health/__pycache__/models.cpython-312.pyc b/src/plba/health/__pycache__/models.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1137d7a7993985a7b2ba7fd7ab5abed379213151 GIT binary patch literal 1824 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 HealthInput: ... + + +class HealthAggregator: + _LIFECYCLES = {"new", "starting", "running", "stopping", "stopped", "failed"} + + def __init__(self, input_provider: HealthInputReader) -> None: + self._input_provider = input_provider + + async def aggregate(self) -> HealthReport: + health_input = await self._input_provider.read() + self._validate(health_input) + components = self._fill_missing(health_input) + status = self._aggregate_status(health_input.lifecycle, components) + return HealthReport( + application_id=health_input.application_id, + lifecycle=health_input.lifecycle, + status=status, + components=tuple(sorted(components, key=lambda item: item.name)), + ) + + @staticmethod + def _validate(health_input: HealthInput) -> None: + if not isinstance(health_input, HealthInput): + raise HealthInputInvalid("health input has an unsupported type") + if not isinstance(health_input.application_id, str) or not health_input.application_id: + raise HealthInputInvalid("application_id must be a non-empty string") + if not isinstance(health_input.lifecycle, str) or health_input.lifecycle not in HealthAggregator._LIFECYCLES: + raise HealthInputInvalid("lifecycle is not supported") + if any(not isinstance(item, HealthExpectation) for item in health_input.expected_components): + raise HealthInputInvalid("expected component has an unsupported type") + if any(not isinstance(item, HealthComponent) for item in health_input.components): + raise HealthInputInvalid("component has an unsupported type") + expected_names = [item.name for item in health_input.expected_components] + component_names = [item.name for item in health_input.components] + if any(not isinstance(name, str) for name in expected_names + component_names): + raise HealthInputInvalid("component names must be strings") + if any(not isinstance(item.critical, bool) for item in health_input.expected_components): + raise HealthInputInvalid("expected component critical flags must be boolean") + if len(expected_names) != len(set(expected_names)): + raise HealthInputInvalid("expected component names must be unique") + if len(component_names) != len(set(component_names)): + raise HealthInputInvalid("component names must be unique") + if any(not name for name in expected_names + component_names): + raise HealthInputInvalid("component names must be non-empty") + for component in health_input.components: + if not isinstance(component.status, HealthStatus): + raise HealthInputInvalid(f"invalid status for component {component.name}") + if not isinstance(component.critical, bool): + raise HealthInputInvalid(f"invalid critical flag for {component.name}") + if component.detail is not None and not isinstance(component.detail, str): + raise HealthInputInvalid(f"invalid detail for component {component.name}") + if not isinstance(component.meta, Mapping): + raise HealthInputInvalid(f"invalid meta for component {component.name}") + if any(not isinstance(key, str) for key in component.meta): + raise HealthInputInvalid(f"meta keys must be strings for {component.name}") + try: + json.dumps(dict(component.meta), allow_nan=False) + except (TypeError, ValueError) as error: + raise HealthInputInvalid( + f"meta is not JSON serializable for component {component.name}" + ) from error + + @staticmethod + def _fill_missing(health_input: HealthInput) -> list[HealthComponent]: + components = {item.name: item for item in health_input.components} + for expected in health_input.expected_components: + if expected.name not in components: + components[expected.name] = HealthComponent( + name=expected.name, + status=( + HealthStatus.UNHEALTHY + if expected.critical + else HealthStatus.DEGRADED + ), + critical=expected.critical, + detail="component has not reported health", + ) + return list(components.values()) + + @staticmethod + def _aggregate_status(lifecycle: str, components: list[HealthComponent]) -> str: + if lifecycle == "stopped": + return "stopped" + statuses = [HealthStatus.OK] + if lifecycle in {"new", "failed"}: + statuses.append(HealthStatus.UNHEALTHY) + elif lifecycle in {"starting", "stopping"}: + statuses.append(HealthStatus.DEGRADED) + order = { + HealthStatus.OK: 0, + HealthStatus.DEGRADED: 1, + HealthStatus.UNHEALTHY: 2, + } + for component in components: + status = component.status + if status is HealthStatus.UNHEALTHY and not component.critical: + status = HealthStatus.DEGRADED + statuses.append(status) + return max(statuses, key=order.__getitem__).value diff --git a/src/plba/health/contributors.py b/src/plba/health/contributors.py new file mode 100644 index 0000000..6b8e170 --- /dev/null +++ b/src/plba/health/contributors.py @@ -0,0 +1,35 @@ +from collections.abc import Awaitable, Callable +from dataclasses import dataclass + +from plba.runtime.worker.models import ComponentHealth + + +HealthReader = Callable[[], Awaitable[ComponentHealth]] + + +@dataclass(frozen=True, slots=True) +class HealthContributor: + name: str + health_reader: HealthReader + critical: bool = True + + +class DuplicateHealthContributorError(ValueError): + pass + + +class HealthContributorRegistry: + def __init__(self) -> None: + self._contributors: dict[str, HealthContributor] = {} + + def register(self, contributor: HealthContributor) -> None: + if not contributor.name or contributor.name.strip() != contributor.name: + raise ValueError("health contributor name must be non-empty") + if contributor.name in self._contributors: + raise DuplicateHealthContributorError( + f"health contributor already registered: {contributor.name}" + ) + self._contributors[contributor.name] = contributor + + def all(self) -> tuple[HealthContributor, ...]: + return tuple(self._contributors.values()) diff --git a/src/plba/health/models.py b/src/plba/health/models.py new file mode 100644 index 0000000..16e7e86 --- /dev/null +++ b/src/plba/health/models.py @@ -0,0 +1,37 @@ +from collections.abc import Mapping +from dataclasses import dataclass, field +from typing import Any + +from plba.runtime.worker.models import HealthStatus + + +@dataclass(frozen=True, slots=True) +class HealthExpectation: + name: str + critical: bool + + +@dataclass(frozen=True, slots=True) +class HealthComponent: + name: str + status: HealthStatus + critical: bool + detail: str | None = None + meta: Mapping[str, Any] = field(default_factory=dict) + + +@dataclass(frozen=True, slots=True) +class HealthInput: + application_id: str + lifecycle: str + expected_components: tuple[HealthExpectation, ...] + components: tuple[HealthComponent, ...] + + +@dataclass(frozen=True, slots=True) +class HealthReport: + application_id: str + lifecycle: str + status: str + components: tuple[HealthComponent, ...] + diff --git a/src/plba/health/provider.py b/src/plba/health/provider.py new file mode 100644 index 0000000..d6e0fb8 --- /dev/null +++ b/src/plba/health/provider.py @@ -0,0 +1,65 @@ +import asyncio + +from plba.health.contributors import HealthContributorRegistry +from plba.health.models import HealthComponent, HealthExpectation, HealthInput +from plba.runtime.application import ApplicationRuntime +from plba.runtime.worker.models import ComponentHealth +from plba.runtime.worker.supervisor import WorkerSupervisor + + +class RuntimeHealthInputProvider: + def __init__( + self, + runtime: ApplicationRuntime, + worker_supervisor: WorkerSupervisor, + contributors: HealthContributorRegistry, + ) -> None: + self._runtime = runtime + self._worker_supervisor = worker_supervisor + self._contributors = contributors + + async def read(self) -> HealthInput: + worker_expectations = self._worker_supervisor.expected_workers() + contributor_definitions = self._contributors.all() + expected = tuple( + [HealthExpectation(name, critical) for name, critical in worker_expectations] + + [ + HealthExpectation(item.name, item.critical) + for item in contributor_definitions + ] + ) + actual = [ + HealthComponent( + name=snapshot.name, + status=snapshot.health.status, + critical=snapshot.health.critical, + detail=snapshot.health.detail, + meta=snapshot.health.meta, + ) + for snapshot in self._worker_supervisor.snapshots() + ] + contributor_health = await asyncio.gather( + *(item.health_reader() for item in contributor_definitions) + ) + actual.extend( + self._component_from_contributor(item.name, item.critical, health) + for item, health in zip(contributor_definitions, contributor_health) + ) + return HealthInput( + application_id=self._runtime.context.application_id, + lifecycle=self._runtime.lifecycle.value, + expected_components=expected, + components=tuple(actual), + ) + + @staticmethod + def _component_from_contributor( + name: str, critical: bool, health: ComponentHealth + ) -> HealthComponent: + return HealthComponent( + name=name, + status=health.status, + critical=critical, + detail=health.detail, + meta=dict(health.meta), + ) diff --git a/src/plba/http/__init__.py b/src/plba/http/__init__.py new file mode 100644 index 0000000..b8a44f6 --- /dev/null +++ b/src/plba/http/__init__.py @@ -0,0 +1,3 @@ +from plba.http.control_api import ControlApi + +__all__ = ["ControlApi"] diff --git a/src/plba/http/__pycache__/__init__.cpython-312.pyc b/src/plba/http/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dddbe5c4b2c269420c48db7d8015a9d4e1cefbab GIT binary patch literal 208 zcmX@j%ge<81V-{bOz<=M literal 0 HcmV?d00001 diff --git a/src/plba/http/__pycache__/asgi.cpython-312.pyc b/src/plba/http/__pycache__/asgi.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d50edcd3d28ddd6c751d74f9290661f03943cffb GIT binary patch literal 2714 zcmb`JUu+vi8o+1vpZ_F{oj7$u5;$KkBr&B)fr>=U6|%|EQk}>{3kdRnwb>abPMuwM zW=*l1BGfCWl`2YKE(BAC1pw_3iMT~5sijun95n{F|a2R31!113>Fd3 zLs*G1jYME9S_-A3ZmWL!#L1T(r|>E>EMBmgYhm;V+Yku{w!D>SbD`bnfwmw8 zQBI?)mxs~S3;&YO;dEruRh&|RmSeMU%!4GyP1~}l>6D)~^Eqlcsofz;QqweRGn!&P z5-HQ3FXX91Nx9i`-x+t6X`7U`#L{kL9vm{Fe>|JRGr7S+$&D~-5O0lg_a0&f z8Fxb2AMR2I}Sdm393i=Jy3kgod&;i_umI$4P`+l_=Xe^@-PN>dA^{CyF!!& zi2#94gCr;7$AV}|KvEzd8Zi{iW~CX4gghf$sjcA6q@kmB5{a2kYeqi zxe>uhMnroU@{LJh%LOYQ^54c1*UDGQOZ_Xa-HtuC89TZWJGwSpjZIuu?zFVs?L1WL zO5JTgS=--tL%uQbnX-CvwPkbQ*v7!IwVCR`@k;xNx+?dy{TK@EYuS<`vFJ}I5{cGD z^J6<;UFkWz*1M5-vDz}W86MjRkJb0X)V+E;is*Qo_rg9d>fQQLy#6@WpI6qOXcPKj ztdA(`&uBs)!O)tGGz$&_d=K{9p!l%=PU$=W*ui5(bI_mAm!~ zHO$kP36#@{&zHE=K4b~d8tK(1D>iFbBu_IzwDKSKrql;a4u~jcq45*zBXjD=t=Pz& zWY^O1O7Dx6?y+i8-;C=UalO{sx!8TZd+GIRYj0&>^j7QWj@4MDTdyX^H{;`#_;@Xz ztnc%a=e@ge9qRZte+E{)*sKrW53zngx%MPz|HgW+@_8R<>)lxIQ`UPzLhr?*?GtUf z$qi>9XUx+~#*Jn&^EN5M7iZk&Oy+FS$on%)VCbsTC5LjhU+8kqa$JSvOoyeQ&%}2# zLG?co6ZyqEKqmf#c#Sw_{uVTsP+f|u1IxUQK&%wEgs68mt2$nus3RdiOZallxjFG= z;^xa=yzBQXr(WOk4C*~0wPWRU9f4SrJ#ka{zv%f(i&fJadmMzTL4wO!GyVs}#d|sE zWhN^A!g25Y^>=v?tao?59saX_5-+epm=I427YV2?V~oE+P2Zv959shu+5z10KLm~E F`7_MKk`n*` literal 0 HcmV?d00001 diff --git a/src/plba/http/__pycache__/control_api.cpython-312.pyc b/src/plba/http/__pycache__/control_api.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3a6848795b9dfff60034cfbfa47fb4961e9f6f8a GIT binary patch literal 6101 zcmcf_TWlN0agTS$H${;YDcO=O%2XoJjwm~_?D(aadYZ9JDK_oEO5h8_JK0nylG!`i zl`6G?6BJ63AU4oO4q6~`exkrB>i!fe^3lY05GDONnkmR0Y&1YW+Waw5fg~ylbawfW zElW+)0$t#CXJ>b3cjjj2v461H%m~V%=RO_#XB9$!A)RvJO2D!Lz#I~h$RyA>Gr}+g z)+Kb~>3~1#a&0LC(VA#7o_87G&Y!=^y{?hBT_V>oC}^ki>0$sC51I-5fe(L zCzMd~d^8akVY(xDVjy%xQPL3{P0HyMRsiYhNhKAWN*tG7n2=}7N|$iZ zb)TbK2v{P^gmiQ=k&242w=F+MPb8K2xTLvDz+ik-icQ865+xcda!{

v6(f0?^h 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 literal 0 HcmV?d00001 diff --git a/src/plba/http/__pycache__/errors.cpython-312.pyc b/src/plba/http/__pycache__/errors.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9350e447c25e77866a4393c62b65375c1549aece GIT binary patch literal 317 zcmX@j%ge<81SUzRvJ8OqV-N=hSfPy1Qb5LZ1||k~h7^Vth7`tBhSkgvxhTd;CQasK zm<|xl2<3d{0WzjDq%uS?rZ7Y?RWfQa-4b@r&nqd)&k0H`EKMygaV;v!FY?o5zQqwA zpO=`M8Xtd)D?UCqKczGW#O8^QFDy;Wfyk_6_zW`mmw0hevVK8MQlfrFNlAfzD#(ap zy@JXjkc+?s$N|M5x3@6dVBsj@fQkD79l#Zqm{Xbxwilv-9V81@!U<&k;;@0(Zdb$& dnIgrcI zQqm?QeW*ThK1mak+USE1{s}&{FROP+=@t{4whw(nF==C8I3I==-|563LRDBx5n&N%Kw}J$sBk91kU49x87{#wRL2>7Mo0*r z%o}1RkO(k<1(4GOO?V*QXDiuQFa)%~S3nE;n)}sd62TcJ9{P*UhU1JI(p0P_4HY3W z;ZB<~gf*S9Ol(`mC3rmt5k70%mVG(Sx?;+<^3ZezWLOv_s|h`}{uAfObP+&6fhX88 z@-qnz@=(y&K4Q_hga`u~mk$6ybUf9;peDeOCTbwX6Uh8J(7G8e9(1KqY-OuR23;X# z*-1F;%2>}pD~A;Xla{F=m!Gh-8CSF+&e>+Nx(n;jI3lgxAlgMxV333v&q9dC+^@>> zObB4==Z!S)OEq3#(ggO_p|O4jpU<+m-uEi7c$+W#C$VXL-jAARaHH>8SkFmLRh(q= zqS`VZ;mh+Iatm+BePok;r@uDdeNJ-#-**OzL%AowfWLP5}^Yb{&$E$rLp z85R^kfiDOT>iz7a-~hnum6HzE^7<0?ZZVyu*ch-IXSofP#QC`k+&rs+S?+UgnwbVS zxN$Je#J3IS+Yzbcs9m{K(M%5ED5+hn>Sk1po*Nw*j#?9Gn8bM@hf|%s`S;%LKcyPF z79G1h*xBnv=HLCl?*!bO)~4WXiI9B9ChsZ;6wR3^m(5x>hFUbGLqkJ@`DX9JRnU4F zCoIc=s+oUh%MFYsRnxR^lsK6=!?5W_=8tT3^8VV(leLhJ^(jbJGIdOYG852_vo)A; z*`{s9<teQ#a@|vE+E{7l? zR|z2v!!le>H!*1{BsbAyR6OYhbyPtV7hNuCAUjMk1S-pFt^jE_tbs(Nor9=1UVqX( zhM?!1~!PO1p&Gb){CjR}tYlNe{atHpu3vNNub zRc!?Gjia^x*X5~bLqUg0+nNKv$xSPfgHGE>DRRLHUsz?ikix9&*?;H6?GsDd_t(C= z_OQLwcA~WBqlKYYB4}tSw%_e3%N<_Oxl-i36F$EpZCjZBrmuL+iGAp_9DOPs^{f|4 zk&90F;&MatqI63t4lRw98V)T8%Pp;U4&6TFv>hw8^e)IN^6uinyW7ihn-}zPDbnwR z`&VAn0*3xQ4Y*W_j5_02obZ)@S2?PEjhe}>eH$B)!DD&%z;W(zM|hxzd)y-s zIWDvTD~ea_D%LF%DT;TiY|?CiD|v5e z2I5JJ6wAa6hRALuh9AHhp}>w(67mTZ&?!Q`2G1kSb7vQNN__KjtYdEE=2-FatgH9O zzHV*i~9;gBsuAu7RZ(geh=DUSL~S=M6B9Qr0M zF)^3tf*91uZDM(B<30)NlyQyz(X2rO8;jt+emHnn-Iku;Qy|MN>`1%HA|RYvkC7=am?~ES%O_lmn8g|q&)C#uu5Ec-a|p9s zk1IZCQ{j0l3_b8Lw;rsx4%a<*jo7j65vs$NdDgD`VLc!Li_9z)L!ct_)JaDL67AvY zBg< bytes: + chunks: list[bytes] = [] + while True: + message = await receive() + if message.get("type") == "http.disconnect": + raise ControlRequestError("client disconnected before request completed") + if message.get("type") != "http.request": + continue + chunks.append(message.get("body", b"")) + if not message.get("more_body", False): + return b"".join(chunks) + + async def send_json(self, send: Any, status: int, payload: dict[str, Any]) -> None: + body = json.dumps(payload, allow_nan=False).encode("utf-8") + await send( + { + "type": "http.response.start", + "status": status, + "headers": [ + (b"content-type", b"application/json; charset=utf-8"), + (b"content-length", str(len(body)).encode("ascii")), + ], + } + ) + await send({"type": "http.response.body", "body": body}) + + async def handle_lifespan(self, receive: Any, send: Any) -> None: + while True: + message = await receive() + if message.get("type") == "lifespan.startup": + await send({"type": "lifespan.startup.complete"}) + elif message.get("type") == "lifespan.shutdown": + await send({"type": "lifespan.shutdown.complete"}) + return diff --git a/src/plba/http/control_api.py b/src/plba/http/control_api.py new file mode 100644 index 0000000..c941726 --- /dev/null +++ b/src/plba/http/control_api.py @@ -0,0 +1,81 @@ +from typing import Any + +from plba.health.aggregator import HealthAggregator, HealthInputInvalid +from plba.http.asgi import ASGIHttpTransport +from plba.http.errors import ControlRequestError +from plba.http.requests import StopRequest +from plba.http.serialization import health_report_payload +from plba.runtime.application import ApplicationRuntime, RuntimeLifecycleError + + +class ControlApi: + """ASGI route adapter; it owns no server, socket, or listener.""" + + def __init__( + self, runtime: ApplicationRuntime, health_aggregator: HealthAggregator + ) -> None: + self._runtime = runtime + self._health_aggregator = health_aggregator + self._transport = ASGIHttpTransport() + + async def __call__(self, scope: dict[str, Any], receive: Any, send: Any) -> None: + scope_type = scope.get("type") + if scope_type == "lifespan": + await self._transport.handle_lifespan(receive, send) + return + if scope_type != "http": + return + try: + status, payload = await self._dispatch(scope, receive) + except HealthInputInvalid as error: + status, payload = 500, self._error("HEALTH_INPUT_INVALID", error) + except RuntimeLifecycleError as error: + status, payload = 409, self._error("APPLICATION_CONTROL_CONFLICT", error) + except ControlRequestError as error: + status, payload = 400, self._error("HTTP_CONTROL_REJECTED", error) + except Exception as error: + status, payload = 500, self._error("CONTROL_API_FAILED", error) + await self._transport.send_json(send, status, payload) + + async def _dispatch(self, scope: dict[str, Any], receive: Any) -> tuple[int, dict[str, Any]]: + method = scope.get("method", "").upper() + path = scope.get("path", "") + query = scope.get("query_string", b"") + if path in {"/health", "/runtime/status", "/runtime/start", "/runtime/stop"} and query: + raise ControlRequestError("query parameters are not accepted") + if path == "/health": + if method != "GET": + return 405, self._error("METHOD_NOT_ALLOWED", "GET required") + await self._require_empty_body(receive) + report = await self._health_aggregator.aggregate() + return 200, health_report_payload(report) + if path == "/runtime/start": + if method != "POST": + return 405, self._error("METHOD_NOT_ALLOWED", "POST required") + await self._require_empty_body(receive) + result = await self._runtime.start() + return 200, {"status": result.lifecycle.value} + if path == "/runtime/status": + if method != "GET": + return 405, self._error("METHOD_NOT_ALLOWED", "GET required") + await self._require_empty_body(receive) + return 200, {"status": self._runtime.lifecycle.value} + if path == "/runtime/stop": + if method != "POST": + return 405, self._error("METHOD_NOT_ALLOWED", "POST required") + request = StopRequest.parse(await self._transport.read_body(receive)) + result = await self._runtime.stop( + force=request.force, timeout_seconds=request.timeout_seconds + ) + status_code = 200 if result.lifecycle.value == "stopped" else 202 + return status_code, {"status": result.lifecycle.value} + return 404, self._error("NOT_FOUND", "control route not found") + + async def _require_empty_body(self, receive: Any) -> None: + if await self._transport.read_body(receive): + raise ControlRequestError("request body is not accepted") + + @staticmethod + def _error(code: str, error: Exception | str) -> dict[str, str]: + return {"error": code, "message": str(error)} + diff --git a/src/plba/http/errors.py b/src/plba/http/errors.py new file mode 100644 index 0000000..5db816c --- /dev/null +++ b/src/plba/http/errors.py @@ -0,0 +1,2 @@ +class ControlRequestError(ValueError): + pass diff --git a/src/plba/http/requests.py b/src/plba/http/requests.py new file mode 100644 index 0000000..2dc433d --- /dev/null +++ b/src/plba/http/requests.py @@ -0,0 +1,39 @@ +import json +import math +from dataclasses import dataclass +from typing import Any + +from plba.http.errors import ControlRequestError + + +@dataclass(frozen=True, slots=True) +class StopRequest: + force: bool = False + timeout_seconds: float | None = None + + @classmethod + def parse(cls, body: bytes) -> "StopRequest": + if not body: + raise ControlRequestError("stop request must contain a JSON object") + try: + decoded: Any = json.loads(body.decode("utf-8")) + except (json.JSONDecodeError, UnicodeDecodeError) as error: + raise ControlRequestError("stop request must contain valid UTF-8 JSON") from error + if not isinstance(decoded, dict): + raise ControlRequestError("stop request must be a JSON object") + if set(decoded) - {"force", "timeout_seconds"}: + raise ControlRequestError("stop request contains unsupported fields") + force = decoded.get("force", False) + timeout_seconds = decoded.get("timeout_seconds") + if not isinstance(force, bool): + raise ControlRequestError("force must be a boolean") + if "timeout_seconds" in decoded and timeout_seconds is None: + raise ControlRequestError("timeout_seconds cannot be null") + if timeout_seconds is not None and ( + isinstance(timeout_seconds, bool) + or not isinstance(timeout_seconds, (int, float)) + or not math.isfinite(timeout_seconds) + or timeout_seconds <= 0 + ): + raise ControlRequestError("timeout_seconds must be a positive finite number") + return cls(force=force, timeout_seconds=timeout_seconds) diff --git a/src/plba/http/serialization.py b/src/plba/http/serialization.py new file mode 100644 index 0000000..d9c81ec --- /dev/null +++ b/src/plba/http/serialization.py @@ -0,0 +1,21 @@ +from typing import Any + +from plba.health.models import HealthReport + + +def health_report_payload(report: HealthReport) -> dict[str, Any]: + return { + "application_id": report.application_id, + "lifecycle": report.lifecycle, + "status": report.status, + "components": [ + { + "name": item.name, + "status": item.status.value, + "critical": item.critical, + "detail": item.detail, + "meta": dict(item.meta), + } + for item in report.components + ], + } diff --git a/src/plba/logging/__init__.py b/src/plba/logging/__init__.py new file mode 100644 index 0000000..cfdec34 --- /dev/null +++ b/src/plba/logging/__init__.py @@ -0,0 +1,3 @@ +from plba.logging.technical import TechnicalJsonFormatter, create_stdout_handler + +__all__ = ["TechnicalJsonFormatter", "create_stdout_handler"] diff --git a/src/plba/logging/__pycache__/__init__.cpython-312.pyc b/src/plba/logging/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d9c09b59014093964dfa2fa76ee9636f94d235be GIT binary patch literal 267 zcmX@j%ge<81X3xdvL*oO#~=<2FhLogWq^$73@HpLj5!Rsj8TlaOi@gX3@J=0%;`)~ z%#|#ftS>=IHJNUSg`_5DMCLZ5`LO2x5Nr^k`ncD^3&5Z^V0Q7UaYG R@!3tYC1>_r?vaR6a!M}7bR literal 0 HcmV?d00001 diff --git a/src/plba/logging/__pycache__/technical.cpython-312.pyc b/src/plba/logging/__pycache__/technical.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..65a791217c9e4b07a890e42b1ad91e0122a0d77d GIT binary patch literal 3467 zcmai0U2I!P6`r|&{*9BS`Exc-ou9UGw{g-RN|lYWfp*(%*`|eb3s|7b&AsES-Ro;J z_nOv`gSu5EveF{463{&CLo4ynszvmH7Z4IcTL}a&wj2~Qt<*{g3Et9e5T(3u=Gxau z+g%vTbIzPOcjnAFXTCFkYHJH3X#K_?vmg2q`YRuJ4aRPJ`fDK9k%0_sq8v`)oRAVQ z9}A|K6H{VNN=fcmH06{Ga?w;$ic5VdA5h8k=K`rfE|?0sda@bHg;QaS1auM^$~9#8 zh?4DZ?zfHH5gUV4B!G;t;V11zfCLS3$%l{;gm2>8l$$IGMuAH!M(CQH+EEe{ZU5ji z34!^}XoW(?T4erXnrUhaCIO+}&>Z4qa)kMLzm&Jg9Eim)StX{NCzqX5XA_u3^&+Lj za@2*Qow0~*s}9w4qGk-exvfiDE;C^G18^EaDQuvWK*TgQFp&&_$cqT5dxW&WO*LSY zR#p&b$k*DyaSHKeJGL*|;0=jLY02fW7ORwK2BC9Ip~NXtOK&>a-G%e~|MVNs{RCe}jw|Nf2Vxoh zP)6uZQ-V<$+aU)ejb`9GxWQe;Wn4yTYu&N{BgxY%K`iE$;xC#P&lPPazChwu-Wn&l zf>TP!Oty;!IEi0XGgih?RTjLUnMLvzrFqKQ)fZP_9j%x&PneLHWD_$@!>~1NgN_AM zRW~&VpK5b^;_>*E=P{e=69scYn=tc>i;y1^j_1*2p+t9p-qNnmc5>3QjPGDiK=Ee5z!wi4 zmZh@v{u>UzOKvMmP76ys3u&hl^XB0Sp|W(mmB`*HX~@~t((!xJtJoRxq-DvImPJFE z1~J$>;>~VR?=;JDS$-e>pdH}a0p#rVw6c3VZi|9m5PqS%;XBQE&Z80JjCmT)pvR?! zQABqvE88q?YuTn;6%4ejd|$bQFQLogH_;`Wh|IBYE@PS*8*gf}Avwv!i=<@pMdESFGvj$+dXZSR2f);>jaWD~3WE{*R zMm)ceCA!0Qyizz$B!uU9|8qQ*5LuX5c99ZQv-M1d1)w_RFR7Mhv7k)~8r7UUwU_p_ zU@87NTc4gkJ2!4?X_DxsJPNEWP4l^}aQbwBeuo&80|OI_j?MxZJKt~$^HEYTp{TKd z8+A*Ankcz_aFIA?nxW@+m-#@zk4||uQw~#1)T|Qi3}G|v6QDY^A)s`nb!zUNbf zxhgM3r)r(2E9c&=gx~$ohRCJQ?LP3>Aqeqc6AaVC0_x&h_-m7x3!W*JH_QEV+UB=-#1!xs>u_H@0#CO@WI`v>fH7?1fs) z?~+@KSAhBdwfKFZjIDO3iQrJNTXh&dZ#ECB-RjGI_fm8C!QECyo~}pX;U&x?${{PE z(BnW@+q`S~+nQyV0Mw#gvKbu5$QKa)FN&czty~am2KVj>ZbvK|w zZLFa-b?6-E9EQJr6gqh7D5$+>Ju*^_jND3BlCw8Y+}D4f{av;e`RbLEbt$wi^;M<5 zwdlmXNG?m`uPgLC|#^fYu# zaZ3ChPdPSF{ None: + super().__init__() + if not application_id: + raise ValueError("application_id must be non-empty") + self._application_id = application_id + self._trace_id_reader = trace_id_reader + + def format(self, record: logging.LogRecord) -> str: + timestamp = datetime.fromtimestamp(record.created, timezone.utc) + payload: dict[str, Any] = { + "timestamp": timestamp.isoformat(timespec="milliseconds").replace( + "+00:00", "Z" + ), + "level": record.levelname, + "logger": record.name, + "message": record.getMessage(), + "application_id": self._application_id, + } + attributes = getattr(record, "attributes", None) + if attributes is not None: + if not isinstance(attributes, Mapping) or any( + not isinstance(key, str) for key in attributes + ): + raise ValueError("log attributes must be a string-keyed object") + payload["attributes"] = dict(attributes) + business_trace_id = self._trace_id_reader() + if business_trace_id is not None: + payload["business_trace_id"] = business_trace_id + try: + return json.dumps( + payload, ensure_ascii=False, allow_nan=False, separators=(",", ":") + ) + except (TypeError, ValueError) as error: + raise ValueError("technical log attributes must be JSON-safe") from error + + +def create_stdout_handler( + application_id: str, stream: TextIO | None = None +) -> logging.StreamHandler[TextIO]: + handler = logging.StreamHandler(stream if stream is not None else sys.stdout) + handler.setFormatter(TechnicalJsonFormatter(application_id)) + return handler diff --git a/src/plba/runtime/__init__.py b/src/plba/runtime/__init__.py new file mode 100644 index 0000000..aadda47 --- /dev/null +++ b/src/plba/runtime/__init__.py @@ -0,0 +1,25 @@ +from plba.runtime.application import ( + ApplicationLifecycle, + ApplicationRuntime, + ApplicationStartResult, + ApplicationStopResult, + RuntimeLifecycleError, +) +from plba.runtime.application_identity import ( + ApplicationIdentityResolver, + ProjectNameReader, + TomlProjectNameReader, +) +from plba.runtime.context import RuntimeContext + +__all__ = [ + "ApplicationLifecycle", + "ApplicationIdentityResolver", + "ApplicationRuntime", + "ApplicationStartResult", + "ApplicationStopResult", + "ProjectNameReader", + "RuntimeContext", + "RuntimeLifecycleError", + "TomlProjectNameReader", +] diff --git a/src/plba/runtime/__pycache__/__init__.cpython-312.pyc b/src/plba/runtime/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8d7467d937bf658a10738239d75059d0ee382874 GIT binary patch literal 616 zcmZ`#%Sr<=6iw#QdD%j>6+t&HT+F8R14IxJ6r@OXl}#9DqD)C~6f}(^ zk>=THdPU-XOo?1wVB5V+q>RY*1@2r#T(n8IM}@2}@p&<)XTI;yBhGUknsReNf07Ut zF8a!o(;LEN^^E5o5{p*ENSj27qUskpqkrfS%F3+6VV((cD?*Q(YA5b$ur$~jN*X*3 zfd)r|e(hFRmKz1Vj2e8pU?ci@iD}ZW5N(y)|50lgD zit!^DC?yzgb$Q&>^5$%&CdO%&3XB^?f9&qDJn2!g&)1X~s;|4F;N64}j*JpChCson WVnO2rC>Z(x?tWT+VB9&ps+3<6(y)mD literal 0 HcmV?d00001 diff --git a/src/plba/runtime/__pycache__/application.cpython-312.pyc b/src/plba/runtime/__pycache__/application.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ee7fe51d3a680fa85925380ffc1b65a48bb7546b GIT binary patch literal 4583 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 literal 0 HcmV?d00001 diff --git a/src/plba/runtime/__pycache__/application_identity.cpython-312.pyc b/src/plba/runtime/__pycache__/application_identity.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f6185696011fe5204cb2d04fe61db25c3e8fa3bb GIT binary patch literal 3120 zcmaJ@Piz}i8h>y8*ke16<2p^6x^A7;p`C3=+7eP)rMsnccMDofY0IHLbTsjdi=*)$ z-n`H{IBY>Vgw;w5rvz!yW~Cm2%Atr02M(wwv|JJ;C}C&?2==fyw~kb)d*SOd`#0H=T!B=WBLPw+ z6Cm0;CYsr~X~Lkl8kzPinWns1tYiXpZW-0q+G)YS;w8<3qU5i_1iE0$FodS|X_2ET z?x>0!6Tlr!4K}Tis<^EVv86-Wq(kBui8dWfs!B|#N*Cc|7s&x~l-Tr|K*?o7;rI6o z*Tu`^8a+U`()^M)lZi~AkGG7RkRlAA=`yL1YsC9nmC}yD#vOm7d>jeWTn(}~eC$Z2 zvRQQe9CFOck2{i8(hbM|%Edo2R$@-%(kn0j<*b=48Kx%?ubSKm=IwmZ=6W$}I+Bsk za@GT?RN2j(O^KPyTc)El(~IqcMJx%##+W5>cx8p9Hg$0Ota_rR(TDa&KyHwlAO&`< zM|ZA8Q_IoRT2x(*s*9&t1L$>|N_SvfOuMDRT4yp@CiB#(HZaJRjKy;e_wT&vcQGdd^7VX9{q4 zB>7C(e<$EazN_!dpm^sn1*-a43|6ylBs-B{jM*L}=-6$cXctZ(K@@U#n*o1Nd2qpi z)5(L2ypE5WFC?F)9zbmn$IjZdO`V`qvXGBH?b=`%YiBRLteCPBPQb+FM>5f@2!s zA?jZNK?Hv%&Rf=1DQ}^D3z9;Q;qWm`zDui=iB&o+6rTl{-3BHn0{sni7A9?;95<7C5}I(ncr{sK$#kiR zH=WLQS3%iek+~(}1TIy|9z?MtD0I8`QREOgo3TBHf)OBXv32~+OUbDNzZKucA{9T! zMhfjMlv)ZM`C|8a$G}Z{LljO1H+&?vXKBy*l^w4xb-emxD7Bs#eJ}k(qJJ$hx||qY zOPpIyoLfn}G@Jf5)_=D@wQy-|;P~>u@s)uSEBzCi_tR$&2zf(VmQ>e7!E*%;`-da+Lc0bHi^9!cFJyS^ix_elJEvgf~Kc*95OGxN#@fyYB7 ULQm8C1nI+64?XpO0C8>m1#C{X761SM literal 0 HcmV?d00001 diff --git a/src/plba/runtime/__pycache__/context.cpython-312.pyc b/src/plba/runtime/__pycache__/context.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..936061d4d933a260ddd14df04eb9a72804a0c145 GIT binary patch literal 541 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 I)J$dgKN)|1{r~^~ literal 0 HcmV?d00001 diff --git a/src/plba/runtime/application.py b/src/plba/runtime/application.py new file mode 100644 index 0000000..f151cd2 --- /dev/null +++ b/src/plba/runtime/application.py @@ -0,0 +1,88 @@ +import logging +from plba.runtime.context import RuntimeContext +from plba.runtime.lifecycle import ( + ApplicationLifecycle, + ApplicationStartResult, + ApplicationStopResult, + RuntimeLifecycleError, +) +from plba.runtime.stop_coordinator import ApplicationStopCoordinator +from plba.runtime.worker.supervisor import WorkerSupervisor + + +class ApplicationRuntime: + def __init__( + self, + context: RuntimeContext, + worker_supervisor: WorkerSupervisor, + logger: logging.Logger | None = None, + ) -> None: + self.context = context + self._worker_supervisor = worker_supervisor + self._logger = logger or logging.getLogger(__name__) + self._lifecycle = ApplicationLifecycle.NEW + self._stop_coordinator = ApplicationStopCoordinator( + worker_supervisor, + lambda: self._lifecycle, + self._set_lifecycle, + context.application_id, + self._logger, + ) + + @property + def lifecycle(self) -> ApplicationLifecycle: + return self._lifecycle + + async def start(self) -> ApplicationStartResult: + if self._lifecycle not in { + ApplicationLifecycle.NEW, + ApplicationLifecycle.STOPPED, + }: + raise RuntimeLifecycleError( + f"application cannot start from {self._lifecycle.value}" + ) + self._lifecycle = ApplicationLifecycle.STARTING + self._logger.info( + "application start requested", + extra={"attributes": {"application_id": self.context.application_id}}, + ) + try: + workers = await self._worker_supervisor.start_all() + except Exception as error: + self._lifecycle = ApplicationLifecycle.FAILED + self._logger.error( + "application start failed", + extra={ + "attributes": { + "application_id": self.context.application_id, + "error_type": type(error).__name__, + } + }, + ) + raise + self._lifecycle = ( + ApplicationLifecycle.RUNNING + if workers.successful + else ApplicationLifecycle.FAILED + ) + self._logger.log( + logging.INFO if workers.successful else logging.ERROR, + "application start completed", + extra={ + "attributes": { + "application_id": self.context.application_id, + "lifecycle": self._lifecycle.value, + "started_workers": list(workers.started), + "failed_workers": list(workers.failures), + } + }, + ) + return ApplicationStartResult(self._lifecycle, workers) + + async def stop( + self, force: bool = False, timeout_seconds: float | None = None + ) -> ApplicationStopResult: + return await self._stop_coordinator.stop(force, timeout_seconds) + + def _set_lifecycle(self, lifecycle: ApplicationLifecycle) -> None: + self._lifecycle = lifecycle diff --git a/src/plba/runtime/application_identity.py b/src/plba/runtime/application_identity.py new file mode 100644 index 0000000..9b6f985 --- /dev/null +++ b/src/plba/runtime/application_identity.py @@ -0,0 +1,54 @@ +from collections.abc import Callable +from pathlib import Path +import tomllib +from typing import Protocol +from uuid import UUID, uuid4 + +from plba.runtime.context import RuntimeContext + + +class ProjectNameReader(Protocol): + def read_project_name(self) -> str | None: ... + + +class TomlProjectNameReader: + def __init__(self, metadata_path: Path) -> None: + self._metadata_path = metadata_path + + def read_project_name(self) -> str | None: + try: + with self._metadata_path.open("rb") as metadata_file: + metadata = tomllib.load(metadata_file) + except (OSError, tomllib.TOMLDecodeError): + return None + + project = metadata.get("project") + if not isinstance(project, dict): + return None + name = project.get("name") + return name if isinstance(name, str) and name else None + + +class ApplicationIdentityResolver: + def __init__( + self, + project_name_reader: ProjectNameReader, + uuid_factory: Callable[[], UUID] = uuid4, + ) -> None: + self._project_name_reader = project_name_reader + self._uuid_factory = uuid_factory + + def resolve(self, configured_application_id: str | None = None) -> RuntimeContext: + if configured_application_id is not None and not isinstance( + configured_application_id, str + ): + raise TypeError("configured_application_id must be a string or None") + + if configured_application_id: + application_id = configured_application_id + else: + application_id = self._project_name_reader.read_project_name() + if not application_id: + application_id = str(self._uuid_factory()) + + return RuntimeContext(application_id=application_id) diff --git a/src/plba/runtime/context.py b/src/plba/runtime/context.py new file mode 100644 index 0000000..fd8751c --- /dev/null +++ b/src/plba/runtime/context.py @@ -0,0 +1,8 @@ +from dataclasses import dataclass + + +@dataclass(frozen=True, slots=True) +class RuntimeContext: + """Process-wide identity shared with runtime components.""" + + application_id: str diff --git a/src/plba/runtime/lifecycle.py b/src/plba/runtime/lifecycle.py new file mode 100644 index 0000000..bc9ee94 --- /dev/null +++ b/src/plba/runtime/lifecycle.py @@ -0,0 +1,32 @@ +from dataclasses import dataclass +from enum import StrEnum + +from plba.runtime.worker.supervisor import ( + WorkerGroupStartResult, + WorkerGroupStopResult, +) + + +class ApplicationLifecycle(StrEnum): + NEW = "new" + STARTING = "starting" + RUNNING = "running" + STOPPING = "stopping" + STOPPED = "stopped" + FAILED = "failed" + + +class RuntimeLifecycleError(RuntimeError): + pass + + +@dataclass(frozen=True, slots=True) +class ApplicationStartResult: + lifecycle: ApplicationLifecycle + workers: WorkerGroupStartResult + + +@dataclass(frozen=True, slots=True) +class ApplicationStopResult: + lifecycle: ApplicationLifecycle + workers: WorkerGroupStopResult diff --git a/src/plba/runtime/stop_coordinator.py b/src/plba/runtime/stop_coordinator.py new file mode 100644 index 0000000..f1927fa --- /dev/null +++ b/src/plba/runtime/stop_coordinator.py @@ -0,0 +1,126 @@ +import asyncio +from collections.abc import Callable +import logging +import math + +from plba.runtime.lifecycle import ( + ApplicationLifecycle, + ApplicationStopResult, + RuntimeLifecycleError, +) +from plba.runtime.worker.supervisor import WorkerGroupStopResult, WorkerSupervisor + + +class ApplicationStopCoordinator: + def __init__( + self, + worker_supervisor: WorkerSupervisor, + lifecycle_reader: Callable[[], ApplicationLifecycle], + lifecycle_writer: Callable[[ApplicationLifecycle], None], + application_id: str, + logger: logging.Logger, + ) -> None: + self._worker_supervisor = worker_supervisor + self._lifecycle_reader = lifecycle_reader + self._lifecycle_writer = lifecycle_writer + self._application_id = application_id + self._logger = logger + self._stop_task: asyncio.Task[WorkerGroupStopResult] | None = None + + async def stop( + self, force: bool = False, timeout_seconds: float | None = None + ) -> ApplicationStopResult: + self._validate_options(force, timeout_seconds) + lifecycle = self._lifecycle_reader() + if lifecycle is ApplicationLifecycle.STOPPED: + return ApplicationStopResult(lifecycle, WorkerGroupStopResult((), ())) + if lifecycle is ApplicationLifecycle.STOPPING: + if force: + self._worker_supervisor.request_stop_all(force=True) + else: + self._lifecycle_writer(ApplicationLifecycle.STOPPING) + self._logger.info( + "application stop requested", + extra={"attributes": {"application_id": self._application_id, "force": force}}, + ) + self._stop_task = asyncio.create_task( + self._finish_stop(force), name="application:stop" + ) + + if self._stop_task is None: + raise RuntimeLifecycleError("application stop operation was not created") + if timeout_seconds is None: + workers = await asyncio.shield(self._stop_task) + return ApplicationStopResult(self._lifecycle_reader(), workers) + done, _ = await asyncio.wait({self._stop_task}, timeout=timeout_seconds) + if not done: + return self._stopping_result() + return ApplicationStopResult(self._lifecycle_reader(), self._stop_task.result()) + + async def _finish_stop(self, force: bool) -> WorkerGroupStopResult: + try: + workers = await self._worker_supervisor.stop_all(force=force) + except Exception as error: + self._lifecycle_writer(ApplicationLifecycle.FAILED) + self._logger.error( + "application stop failed", + extra={ + "attributes": { + "application_id": self._application_id, + "error_type": type(error).__name__, + } + }, + ) + raise + lifecycle = ( + ApplicationLifecycle.STOPPED + if workers.complete + else ApplicationLifecycle.STOPPING + ) + self._lifecycle_writer(lifecycle) + self._logger.info( + "application stop completed", + extra={ + "attributes": { + "application_id": self._application_id, + "lifecycle": lifecycle.value, + "stopped_workers": list(workers.stopped), + } + }, + ) + return workers + + def _stopping_result(self) -> ApplicationStopResult: + stopping = tuple( + sorted( + snapshot.name + for snapshot in self._worker_supervisor.snapshots() + if snapshot.lifecycle.value in {"starting", "running", "stopping"} + ) + ) + self._logger.warning( + "application stop is continuing", + extra={ + "attributes": { + "application_id": self._application_id, + "workers_stopping": list(stopping), + } + }, + ) + return ApplicationStopResult( + ApplicationLifecycle.STOPPING, WorkerGroupStopResult((), stopping) + ) + + @staticmethod + def _validate_options(force: bool, timeout_seconds: float | None) -> None: + if not isinstance(force, bool): + raise ValueError("force must be a boolean") + if timeout_seconds is None: + return + if ( + isinstance(timeout_seconds, bool) + or not isinstance(timeout_seconds, (int, float)) + or not math.isfinite(timeout_seconds) + or timeout_seconds <= 0 + ): + raise ValueError("timeout_seconds must be a positive finite number") diff --git a/src/plba/runtime/worker/__init__.py b/src/plba/runtime/worker/__init__.py new file mode 100644 index 0000000..ba99c3c --- /dev/null +++ b/src/plba/runtime/worker/__init__.py @@ -0,0 +1,29 @@ +from plba.runtime.worker.config import WorkerConfig, WorkerConfigReader +from plba.runtime.worker.models import ( + ComponentHealth, + HealthStatus, + WorkerDefinition, + WorkerLifecycle, + WorkerSnapshot, +) +from plba.runtime.worker.registry import DuplicateWorkerError, WorkerRegistry +from plba.runtime.worker.supervisor import ( + WorkerGroupStartResult, + WorkerGroupStopResult, + WorkerSupervisor, +) + +__all__ = [ + "ComponentHealth", + "DuplicateWorkerError", + "HealthStatus", + "WorkerConfig", + "WorkerConfigReader", + "WorkerDefinition", + "WorkerGroupStartResult", + "WorkerGroupStopResult", + "WorkerLifecycle", + "WorkerRegistry", + "WorkerSnapshot", + "WorkerSupervisor", +] diff --git a/src/plba/runtime/worker/__pycache__/__init__.cpython-312.pyc b/src/plba/runtime/worker/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..12e7dd3b9a3a97512c2ce46c72e796a4f6d70d0e GIT binary patch literal 734 zcmZvZzi-qq6vu7n*Yz&Rm5LS#Ar_`AcmDwD(pF_a9qtAs3pEOf?;5b<=*0ou$X~(U zjhX)fW)?3UnAm^{ozw|Cxk8c7Qa;xE;rD&-463O}Ham>I#o~!l%9nXdni3(8V0SBZhP+Ms(EKE)PXSBN5YBjOiGo zB`Um2Om|m)5`4Ep3DMyT32zu2$!bw9_1;};#z}30W}S^bK^{onohBCG?|hrC~FC z-?HsTKi-zt{GIX647O<7-uW44#^9 wTh0#Qfq8??*CYl%9E|Z5I$aYVli$c-9V2{(*Tlu-Co=dIMkDe*fPItw2dC51D*ylh literal 0 HcmV?d00001 diff --git a/src/plba/runtime/worker/__pycache__/config.cpython-312.pyc b/src/plba/runtime/worker/__pycache__/config.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c754d876da2620608f06259944ca8fa30e18aea0 GIT binary patch literal 2091 zcmZ`)O-$TI6rQoiix)3}011>-tG@=siCFI0jEA^0;9608fLr-lF5Rh0+6RA>9y%8-{rJOoruVLAwBl*pn_ujmj z_ueB0q~bxBtvU5jjsf=0x-bP14WpFQ1XhW18qlnza^1Flr$}s@ciMI_z$H)e8QZ>9a=cjc6KF{9&yO>jAD{E4opD<7L$^rA zzla=<=OfQ&=gKrC>>?r=CbPK+>PV+XBL7(2Csm+9h4@@!UJ$YaVKj3H8Xt%a`(b<{ z>X1_jA{tgEga)g*6zRZfr2_yVLrt09BGV#S2Tm=bT)M1UI?uGGVT$Y6WzMumaF+MD zen{wT$Fms`v0%o#=A05E$ugg0R~!vwQ1Y6M>q5E$s^F%Swhao)QqwGds}h3}oQFau zpw~Vkol=EWWp-5L(FjF&@xXAkd51f&3Tfu$zJ256e&^LNop`FMVFZ7Oq1njh=jCREV0m>CZ=QhrQ$T9RF>xd&E^8; zhVE@*by67@l_AkSNhGj&r^{TQg^r&m98Cv-$5nAZt`)q%2{|e{;SASZR&aecBo^X` z5wE~AGY+$pICxsFq6h>Oo3D~dP?%y+Sp$ApK++YDUjVTgN9DCv5TAWP-y^oM9|Tzd zb))<4rSC7*GrjeJW7`8`8v|o&@2n48SjyD<2ec5=( zU3)aPb>^zry?*-2W^Z;qlYP?NcX$4~`Pye&-6Qu$*PNfvv}$)$aQZ^j5@a)=BrH)s zD>5z7PIXBnTI0kY6&&xjZO8Y6FzQ^)w&QXPN~5SIuS-s%I_@(vcT{E~B2v!A1^E{I zd1Pqey(PSfhUzD+b=1F1YWSYFiLCk?BMVoS->RLzH?fIEc2Sph6~?}#n*$vxdA5yL zg=W7)VMtW05L7@|6&*(_BTM7Gt;PC~IG9jw#K?@AE;Xh1_9hWE7kSJI5KjSSqsT0U z9up!uEC`c3_AqjTgm%+s+=nZ}FCKgL1*_wUqi^D@Wvx_O0l3OS8s~9D9^IDU6H+FL zDL&RMh-~#!_di-kQ){1Zp{Y25(!xq}WA7hE7?lyyR|MgyusrAbH>eDkcV2hA5{dpy z@sA{`VRX*Hv!Ck|@tpMv9m0OKh*wwr=5U90Q@F+J0PVk{5W k@D@DruhI*z!W|%KLj}t4P9)ep1>t2_8~jJuUyiH)AGcTIK>z>% literal 0 HcmV?d00001 diff --git a/src/plba/runtime/worker/__pycache__/health.cpython-312.pyc b/src/plba/runtime/worker/__pycache__/health.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0f4c6224e5e40974d98c38d2937c2e80f2bc2f5a GIT binary patch literal 4916 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 U;r(UUmk$4@CFtV61R#juf3TT<(f|Me literal 0 HcmV?d00001 diff --git a/src/plba/runtime/worker/__pycache__/runner.cpython-312.pyc b/src/plba/runtime/worker/__pycache__/runner.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cf9a12dff100ee76fe483fe7543f21a82a61aadc GIT binary patch literal 8437 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 literal 0 HcmV?d00001 diff --git a/src/plba/runtime/worker/__pycache__/schedule.cpython-312.pyc b/src/plba/runtime/worker/__pycache__/schedule.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c42381cf95831c470da771c84af6fcbf07e5d7f6 GIT binary patch literal 3934 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 blGPEqHG|oQuJ5k@%JmvWbw46Vm681~+WiLV literal 0 HcmV?d00001 diff --git a/src/plba/runtime/worker/config.py b/src/plba/runtime/worker/config.py new file mode 100644 index 0000000..c28fa51 --- /dev/null +++ b/src/plba/runtime/worker/config.py @@ -0,0 +1,33 @@ +from dataclasses import dataclass +import math +from typing import Protocol + + +class WorkerConfigurationError(ValueError): + pass + + +@dataclass(frozen=True, slots=True) +class WorkerConfig: + disabled: bool = False + interval_seconds: float | None = None + pause_seconds: float | None = None + + def validate_schedule(self) -> None: + if self.disabled: + return + has_interval = self.interval_seconds is not None + has_pause = self.pause_seconds is not None + if has_interval == has_pause: + raise WorkerConfigurationError( + "exactly one of interval_seconds or pause_seconds is required" + ) + duration = self.interval_seconds if has_interval else self.pause_seconds + if isinstance(duration, bool) or not isinstance(duration, (int, float)): + raise WorkerConfigurationError("worker schedule must be a number") + if not math.isfinite(duration) or duration <= 0: + raise WorkerConfigurationError("worker schedule must be positive") + + +class WorkerConfigReader(Protocol): + def get_worker_config(self, worker_name: str) -> WorkerConfig: ... diff --git a/src/plba/runtime/worker/health.py b/src/plba/runtime/worker/health.py new file mode 100644 index 0000000..e8c12f3 --- /dev/null +++ b/src/plba/runtime/worker/health.py @@ -0,0 +1,87 @@ +from plba.runtime.worker.models import ( + ComponentHealth, + HealthStatus, + WorkerDefinition, +) + + +class WorkerHealthTracker: + def __init__(self, definition: WorkerDefinition) -> None: + self._critical = definition.critical + self._health_check = definition.health_check + self._automatic_status = HealthStatus.OK + self._application_status = HealthStatus.OK + self._application_detail: str | None = None + self._application_meta: dict[str, object] = {} + self._last_error: BaseException | None = None + + @property + def last_error(self) -> BaseException | None: + return self._last_error + + def cycle_succeeded(self) -> None: + self._last_error = None + self._automatic_status = HealthStatus.OK + + def cycle_failed(self, error: BaseException) -> None: + self._last_error = error + self._automatic_status = HealthStatus.UNHEALTHY + + def runtime_failed(self, error: BaseException) -> None: + self._last_error = error + self._automatic_status = HealthStatus.UNHEALTHY + + def cycle_exceeded_interval(self) -> None: + self._automatic_status = HealthStatus.DEGRADED + + async def refresh_application_health(self) -> None: + if self._health_check is None: + self._application_status = HealthStatus.OK + self._application_detail = None + self._application_meta = {} + return + try: + health = await self._health_check() + except Exception as error: + self._application_status = HealthStatus.UNHEALTHY + self._application_detail = f"health check failed: {error}" + self._application_meta = {} + return + if not isinstance(health, ComponentHealth) or not isinstance( + health.status, HealthStatus + ): + self._application_status = HealthStatus.UNHEALTHY + self._application_detail = "health check returned an invalid status" + self._application_meta = {} + return + self._application_status = health.status + self._application_detail = health.detail + self._application_meta = dict(health.meta) + + def snapshot(self) -> ComponentHealth: + status_order = { + HealthStatus.OK: 0, + HealthStatus.DEGRADED: 1, + HealthStatus.UNHEALTHY: 2, + } + status = max( + (self._automatic_status, self._application_status), + key=status_order.__getitem__, + ) + details = self._details() + return ComponentHealth( + status=status, + critical=self._critical, + detail="; ".join(details) or None, + meta=self._application_meta, + ) + + def _details(self) -> list[str]: + details: list[str] = [] + if self._automatic_status is HealthStatus.UNHEALTHY and self._last_error: + details.append(f"worker cycle failed: {self._last_error}") + elif self._automatic_status is HealthStatus.DEGRADED: + details.append("worker cycle exceeded interval_seconds") + if self._application_detail: + details.append(self._application_detail) + return details diff --git a/src/plba/runtime/worker/models.py b/src/plba/runtime/worker/models.py new file mode 100644 index 0000000..fe734bf --- /dev/null +++ b/src/plba/runtime/worker/models.py @@ -0,0 +1,48 @@ +from collections.abc import Awaitable, Callable, Mapping +from dataclasses import dataclass, field +from enum import StrEnum +from typing import Any + + +class HealthStatus(StrEnum): + OK = "ok" + DEGRADED = "degraded" + UNHEALTHY = "unhealthy" + + +class WorkerLifecycle(StrEnum): + NEW = "new" + STARTING = "starting" + RUNNING = "running" + STOPPING = "stopping" + STOPPED = "stopped" + FAILED = "failed" + + +@dataclass(frozen=True, slots=True) +class ComponentHealth: + status: HealthStatus = HealthStatus.OK + critical: bool = True + detail: str | None = None + meta: Mapping[str, Any] = field(default_factory=dict) + + +HealthCheck = Callable[[], Awaitable[ComponentHealth]] +WorkerProcess = Callable[[], Awaitable[None]] + + +@dataclass(frozen=True, slots=True) +class WorkerDefinition: + name: str + process: WorkerProcess + critical: bool = True + health_check: HealthCheck | None = None + + +@dataclass(frozen=True, slots=True) +class WorkerSnapshot: + name: str + lifecycle: WorkerLifecycle + health: ComponentHealth + last_error: BaseException | None = None + diff --git a/src/plba/runtime/worker/registry.py b/src/plba/runtime/worker/registry.py new file mode 100644 index 0000000..3f704b8 --- /dev/null +++ b/src/plba/runtime/worker/registry.py @@ -0,0 +1,23 @@ +from plba.runtime.worker.models import WorkerDefinition + + +class DuplicateWorkerError(ValueError): + pass + + +class WorkerRegistry: + def __init__(self) -> None: + self._definitions: dict[str, WorkerDefinition] = {} + + def register(self, definition: WorkerDefinition) -> None: + if not definition.name or definition.name.strip() != definition.name: + raise ValueError("worker name must be non-empty and have no outer spaces") + if definition.name in self._definitions: + raise DuplicateWorkerError(f"worker already registered: {definition.name}") + self._definitions[definition.name] = definition + + def get(self, name: str) -> WorkerDefinition: + return self._definitions[name] + + def all(self) -> tuple[WorkerDefinition, ...]: + return tuple(self._definitions.values()) diff --git a/src/plba/runtime/worker/runner.py b/src/plba/runtime/worker/runner.py new file mode 100644 index 0000000..f3cc585 --- /dev/null +++ b/src/plba/runtime/worker/runner.py @@ -0,0 +1,153 @@ +import asyncio +import logging +import time +from collections.abc import Awaitable, Callable + +from plba.runtime.worker.config import WorkerConfig, WorkerConfigReader +from plba.runtime.worker.health import WorkerHealthTracker +from plba.runtime.worker.models import ( + WorkerDefinition, + WorkerLifecycle, + WorkerSnapshot, +) +from plba.runtime.worker.schedule import WorkerScheduleController + +AsyncSleep = Callable[[float], Awaitable[None]] +Clock = Callable[[], float] + + +class WorkerRunner: + def __init__( + self, + definition: WorkerDefinition, + config_reader: WorkerConfigReader, + sleep: AsyncSleep = asyncio.sleep, + clock: Clock = time.monotonic, + logger: logging.Logger | None = None, + ) -> None: + self._definition = definition + self._config_reader = config_reader + self._sleep = sleep + self._clock = clock + self._logger = logger or logging.getLogger(__name__) + self._schedule = WorkerScheduleController(definition.name, config_reader, sleep) + self._lifecycle = WorkerLifecycle.NEW + self._health = WorkerHealthTracker(definition) + self._task: asyncio.Task[None] | None = None + self._stop_requested = asyncio.Event() + + @property + def name(self) -> str: + return self._definition.name + + @property + def task(self) -> asyncio.Task[None] | None: + return self._task + + def start(self, config: WorkerConfig) -> None: + self._schedule.start(config) + self._lifecycle = WorkerLifecycle.STARTING + self._task = asyncio.create_task(self._run(), name=f"worker:{self.name}") + self._logger.info( + "worker started", extra={"attributes": {"worker": self.name}} + ) + + def request_stop(self, force: bool = False) -> None: + if self._task is None or self._task.done(): + if self._lifecycle is not WorkerLifecycle.FAILED: + self._lifecycle = WorkerLifecycle.STOPPED + return + self._lifecycle = WorkerLifecycle.STOPPING + self._stop_requested.set() + if force: + self._task.cancel() + + async def wait_stopped(self) -> None: + if self._task is None: + self._lifecycle = WorkerLifecycle.STOPPED + return + try: + await self._task + except asyncio.CancelledError: + self._lifecycle = WorkerLifecycle.STOPPED + self._logger.info( + "worker force-stopped", extra={"attributes": {"worker": self.name}} + ) + except Exception as error: + self._health.runtime_failed(error) + self._lifecycle = WorkerLifecycle.FAILED + else: + if self._lifecycle is not WorkerLifecycle.FAILED: + self._lifecycle = WorkerLifecycle.STOPPED + + def snapshot(self) -> WorkerSnapshot: + return WorkerSnapshot( + name=self.name, + lifecycle=self._lifecycle, + health=self._health.snapshot(), + last_error=self._health.last_error, + ) + + async def _run(self) -> None: + self._lifecycle = WorkerLifecycle.RUNNING + try: + while not self._stop_requested.is_set(): + cycle_config = self._schedule.current + started_at = self._clock() + self._logger.debug( + "worker cycle started", extra={"attributes": {"worker": self.name}} + ) + try: + await self._definition.process() + self._health.cycle_succeeded() + self._logger.debug( + "worker cycle completed", + extra={"attributes": {"worker": self.name}}, + ) + except Exception as error: + self._health.cycle_failed(error) + self._logger.error( + "worker cycle failed", + extra={ + "attributes": { + "worker": self.name, + "error_type": type(error).__name__, + } + }, + ) + + elapsed = max(0.0, self._clock() - started_at) + await self._health.refresh_application_health() + config = self._schedule.next_schedule() + if self._health.last_error is None: + if ( + cycle_config.interval_seconds is not None + and elapsed > cycle_config.interval_seconds + ): + self._health.cycle_exceeded_interval() + if self._stop_requested.is_set(): + break + await self._schedule.wait_for_next_cycle( + config, elapsed, self._stop_requested + ) + except asyncio.CancelledError: + raise + except Exception as error: + self._health.runtime_failed(error) + self._lifecycle = WorkerLifecycle.FAILED + self._logger.error( + "worker runtime failed", + extra={ + "attributes": { + "worker": self.name, + "error_type": type(error).__name__, + } + }, + ) + return + self._lifecycle = WorkerLifecycle.STOPPED + self._logger.info( + "worker stopped", extra={"attributes": {"worker": self.name}} + ) + + diff --git a/src/plba/runtime/worker/schedule.py b/src/plba/runtime/worker/schedule.py new file mode 100644 index 0000000..00460ab --- /dev/null +++ b/src/plba/runtime/worker/schedule.py @@ -0,0 +1,64 @@ +import asyncio +from collections.abc import Awaitable, Callable +from dataclasses import replace + +from plba.runtime.worker.config import WorkerConfig, WorkerConfigReader + +AsyncSleep = Callable[[float], Awaitable[None]] + + +class WorkerScheduleController: + def __init__( + self, + worker_name: str, + config_reader: WorkerConfigReader, + sleep: AsyncSleep, + ) -> None: + self._worker_name = worker_name + self._config_reader = config_reader + self._sleep = sleep + self._current: WorkerConfig | None = None + + @property + def current(self) -> WorkerConfig: + if self._current is None: + raise RuntimeError("worker schedule has not started") + return self._current + + def start(self, config: WorkerConfig) -> None: + if config.disabled: + raise ValueError(f"worker is disabled: {self._worker_name}") + config.validate_schedule() + self._current = config + + def next_schedule(self) -> WorkerConfig: + config = self._config_reader.get_worker_config(self._worker_name) + if config.disabled and config.interval_seconds is None and config.pause_seconds is None: + return self.current + config = replace(config, disabled=False) + config.validate_schedule() + self._current = config + return config + + async def wait_for_next_cycle( + self, config: WorkerConfig, elapsed: float, stop_requested: asyncio.Event + ) -> None: + delay = self._delay(config, elapsed) + if not delay or stop_requested.is_set(): + return + sleep_task = asyncio.ensure_future(self._sleep(delay)) + stop_task = asyncio.create_task(stop_requested.wait()) + done, pending = await asyncio.wait( + (sleep_task, stop_task), return_when=asyncio.FIRST_COMPLETED + ) + if sleep_task in done: + await sleep_task + for task in pending: + task.cancel() + await asyncio.gather(*pending, return_exceptions=True) + + @staticmethod + def _delay(config: WorkerConfig, elapsed: float) -> float: + if config.pause_seconds is not None: + return config.pause_seconds + return max(0.0, (config.interval_seconds or 0.0) - elapsed) diff --git a/src/plba/runtime/worker/supervisor.py b/src/plba/runtime/worker/supervisor.py new file mode 100644 index 0000000..9e01912 --- /dev/null +++ b/src/plba/runtime/worker/supervisor.py @@ -0,0 +1,151 @@ +import asyncio +import logging +from dataclasses import dataclass, field +from types import MappingProxyType +from typing import Mapping + +from plba.runtime.worker.config import WorkerConfigReader +from plba.runtime.worker.models import ( + ComponentHealth, + HealthStatus, + WorkerLifecycle, + WorkerSnapshot, +) +from plba.runtime.worker.registry import WorkerRegistry +from plba.runtime.worker.runner import AsyncSleep, Clock, WorkerRunner + + +@dataclass(frozen=True, slots=True) +class WorkerGroupStartResult: + started: tuple[str, ...] + failures: Mapping[str, BaseException] = field(default_factory=dict) + + @property + def successful(self) -> bool: + return not self.failures + + +@dataclass(frozen=True, slots=True) +class WorkerGroupStopResult: + stopped: tuple[str, ...] + stopping: tuple[str, ...] + + @property + def complete(self) -> bool: + return not self.stopping + + +class WorkerSupervisor: + def __init__( + self, + registry: WorkerRegistry, + config_reader: WorkerConfigReader, + sleep: AsyncSleep = asyncio.sleep, + clock: Clock | None = None, + logger: logging.Logger | None = None, + ) -> None: + self._registry = registry + self._config_reader = config_reader + self._sleep = sleep + self._clock = clock + self._logger = logger or logging.getLogger(__name__) + self._runners: dict[str, WorkerRunner] = {} + self._start_failures: dict[str, BaseException] = {} + self._expected_names: set[str] = set() + self._started_once = False + + async def start_all(self) -> WorkerGroupStartResult: + started: list[str] = [] + self._start_failures = {} + self._expected_names = set() + self._started_once = True + for definition in self._registry.all(): + try: + config = self._config_reader.get_worker_config(definition.name) + if config.disabled: + self._runners.pop(definition.name, None) + self._logger.info( + "worker disabled for application start", + extra={"attributes": {"worker": definition.name}}, + ) + continue + self._expected_names.add(definition.name) + runner = WorkerRunner( + definition, + self._config_reader, + sleep=self._sleep, + **({"clock": self._clock} if self._clock is not None else {}), + logger=self._logger, + ) + runner.start(config) + self._runners[definition.name] = runner + started.append(definition.name) + except Exception as error: + self._expected_names.add(definition.name) + self._start_failures[definition.name] = error + self._logger.error( + "worker start failed", + extra={ + "attributes": { + "worker": definition.name, + "error_type": type(error).__name__, + } + }, + ) + return WorkerGroupStartResult( + started=tuple(started), + failures=MappingProxyType(dict(self._start_failures)), + ) + + def snapshots(self) -> tuple[WorkerSnapshot, ...]: + snapshots = {name: runner.snapshot() for name, runner in self._runners.items()} + for name, error in self._start_failures.items(): + definition = self._registry.get(name) + snapshots[name] = WorkerSnapshot( + name=name, + lifecycle=WorkerLifecycle.FAILED, + health=ComponentHealth( + HealthStatus.UNHEALTHY, critical=definition.critical + ), + last_error=error, + ) + return tuple(snapshots[name] for name in sorted(snapshots)) + + def expected_workers(self) -> tuple[tuple[str, bool], ...]: + if self._started_once: + names = self._expected_names + else: + names = { + definition.name + for definition in self._registry.all() + if not self._config_reader.get_worker_config(definition.name).disabled + } + return tuple( + (name, self._registry.get(name).critical) for name in sorted(names) + ) + + async def stop_all( + self, force: bool = False, timeout_seconds: float | None = None + ) -> WorkerGroupStopResult: + if timeout_seconds is not None and timeout_seconds <= 0: + raise ValueError("timeout_seconds must be positive") + runners = tuple(self._runners.values()) + self.request_stop_all(force=force) + + tasks = {runner.task: runner for runner in runners if runner.task is not None} + if not tasks: + return WorkerGroupStopResult((), ()) + done, pending = await asyncio.wait( + tasks, + timeout=timeout_seconds, + return_when=asyncio.ALL_COMPLETED, + ) + for task in done: + await tasks[task].wait_stopped() + stopped = tuple(sorted(tasks[task].name for task in done)) + stopping = tuple(sorted(tasks[task].name for task in pending)) + return WorkerGroupStopResult(stopped, stopping) + + def request_stop_all(self, force: bool = False) -> None: + for runner in tuple(self._runners.values()): + runner.request_stop(force=force) diff --git a/src/plba/settings/__init__.py b/src/plba/settings/__init__.py new file mode 100644 index 0000000..8abb975 --- /dev/null +++ b/src/plba/settings/__init__.py @@ -0,0 +1,19 @@ +from plba.settings.models import ( + SettingInvalidError, + SettingKey, + SettingNotFoundError, + SettingsDatabaseUnavailableError, +) +from plba.settings.postgres import PostgresSettingsRepository +from plba.settings.reader import SettingsReader +from plba.settings.repository import SettingsRepository + +__all__ = [ + "PostgresSettingsRepository", + "SettingInvalidError", + "SettingKey", + "SettingNotFoundError", + "SettingsDatabaseUnavailableError", + "SettingsReader", + "SettingsRepository", +] diff --git a/src/plba/settings/__pycache__/__init__.cpython-312.pyc b/src/plba/settings/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..26b556c7a4043e3d00619e1d1e4183b36ab7f7c7 GIT binary patch literal 611 zcmZusyGjE=6rI`K>~3BnF^E`cnI;Q1Hj*leB7~r%*=Cqzhqz((!OSGMc7BDuoqu7i zf3T3s%1#U-q;h7=gNPUA%)MvM+hEoOjidC(u9X1VVQj0TC+GHOft1Kv(h=tkv^HJz*109U@LGH6eV;TmAszPK5p{gU3fD} z0z&zJ-}2o}rJSTa>N$VgFruvKN%`L9KepOMd&nJxFr^4Rftj=f=3TGH3F987EH%)5oTDGsvq{V7-0F;Lx iO877#gx^L18Z#i_s{&wa3cM*e{ERg6rQoYUhiL)gr5=!u!X2(`HR#ZN-0$0r%hIcrELNS3(4}XCu9?^y^Ot4 z9pw;}R7&ZA^u%(ahh9)Pv{I!Wd+VXSgoZGmLgChBg9HB5KCh!)A|8i25)d|?#c+A z6zHT`wzI0|1eyUf%X&7^yg+k+_ONZ6Xm5}&Zu=XJ7HO!RH*MRj*bMlTW%_2-Ha)K> zhw@n`2$LhsVZ2riljA{yT{U?~$H$9Os7`QqmN{X#iFMHWeFx3eHIt!B)tGX8B=Xt>SHeA$+iwTAg4Tt5rMsnj zm+xL)9XS5&jvxBJ>;HA&)bD)*EBnr__MKbFo?FZ0Z=bn!rZs-=+TCm4?|!)N9kDvH z+BdqA9bK2n{!@!*+F+Ax=_tI{qNCmb=Kng%k8eL#ZwxMFxhRRm@tv@V?*bAfjPC|E z%s^I*IQ_G`o{RB0TtKV=szIhf2kD?Z{)yFUPLtc)vpp%GzMu z5BLCx_la;p#KN=)#`{zd&tyQIe zZTsH&k;So9Wp7(i5+%BxC2G&QL=(qa8QWo<8Q$RYyxi@$hu4^ zeM|-)lh^+sLl4Q&pGs!&{LPE=^tVj!mnY}7rz(*$OM@-z5k0ga_0VHWueEx=+S4Y$ hLa#}K>j-Wfq%_rfcZ0yRp&@^y%YQxhFXEy;{{eVH;z9rb literal 0 HcmV?d00001 diff --git a/src/plba/settings/__pycache__/postgres.cpython-312.pyc b/src/plba/settings/__pycache__/postgres.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6d1f515c39571d13e4c67f88670ad914e45f4d6d GIT binary patch literal 3547 zcma(UYiv|m`JDTjM>{P{Dbt}Au25hHXv^|i7ZB~VQ+Abhu?3M?;d*=TZJ9bR&b_6b zajGm3EfE8oY$%D@gdfI0&`2~f{9L+!Hu|TvjWk!1B^nb={L!@}Anp&p@7%fF79a6U z?svZPo#*%d=C_eZm_Ylf@tcv83L$^Of#2jRvQzTtiFWkikv!^8$B4R4wiNUGDR$srY1=X zCbdLUuq0EoWJ|F`D=;L)VFi9eiYZ-@(!r9PP~7P8g6#}5%Z3-_EyKwa@~#X|W+gXV z)R~^M9E;hm!YpT$<&7%0{8Ge!0N+wAfUgn?*O$o8#W8x9_T44GuVh=`99Pc=3!=W8|)*A2Vwk~KzRv3Z1ZSBIIjg zj%E?B)wJ`YdbTsFrH zUZvvUHX6Y@gg?D6p|Eu@WQ_>cBS4XR!e~JZrQ~tRrPPc=1l&6Ca+FePCcbN??Mt)q zFV9OUZ#Ax2B@+}Ywxx3bK9h++EOEr2;|n}s(tA}Qq-F351-v3)N~R2+pr9v&z>&=W z(7?$}xf~$Gl&p{ysCrB2ikuFEx74^Bd^z|&+HVyLcE%~NQn~5u+nsG`y{)XBsUo}E zUf0g-XmzC`=)zTO`#eAzXQ9|j@( z`P56aLMudD-f0RI;l~gL-xq<37QkDHB&5FbHt%_AZq#QkJ-!&=ysD@jYTT^95`?du^&nV=FGQ)_k z(h=AMxeVXZPr#DAU}u7C|C6Rb!ovIFgcw3it_+y49oxvVro1u2dsTEFxeW39JD{N2D`zDug^k|Eu}&reU6h1I80@;$kmTvrTXm>9wt zIDbN^fM1}+zbjk|Nn|20p*Vha0e`qcDuM3hcls8_Y8;I3yqU631-lCjkk`nyZ^3sI zzSp;qR|$UuSlvzj#@C1pv1SYs^l3;Plw5mrTs%$2r~wp1m{7*Z7UE!F;H{OgwG%-H zgB5S4;@?#XUIN}Gg5M2}(J|tkfk`M4=qqm+NF7Ucolt!RUqGu=d-~t%Rm#J&KU$^>7>mK#Z0k!Ysv1966{px2nflKxz_?nEZS$Q;R6No4JPo`jH zcdB1ao>uJwbF>08Ev9x3bnOE7!QPFmddI4`j3%)czNI4oJoBoMGZ088s8bDHgjA@r zY)-ynYspPIML~QqshWLxM28wAoUt=`+tH!;U@#i&S2as6$W%S!N>0UV&TKb_6`FU>I;k9g3^a ziBho|c0#Ff!zyAu!!RQxLSEe2fxC7hK)dDc?w36hD~#E$2+&nLE?wEeg3CrXfWpOV zUZAR7DUI^>|5I$}UiRMra2YKINqyqZx?eQkZN3v(B*KAi3NQjtB%!*+a5xlSh&4}@ z-z`6iC1zuZx!BHUghu*c6~a5^g_iA)TH0n?+U{8Q-~M37TubkxSnmz#nTXTg(kBNF z{=V_h9s7oHt7C5cj+w?olRW?)*GEAi4-U*nlk@e-$LlxEsHwU2Ju_>178>G{y^A$? z!t;e#@AE}|*mLhR4}QY0|MZWIhn_zTk~Q(a6EPHj9Nn|9X8V#TG}Jw5Xj+toNc^9R zB20X0{}33yw6<#veQ#rOFZm@+HYmRm0sD0<85bW$XtGgxSSKMKtpW1G7MhGn4>tx8 z-&UJ!mmcm>0iTXiIAgkjBHl=0{dA1uaV5DkFujQ;H`h+90mQf0;+nmou825&xV9@O zei)Pi|1cuL37&)0yi}{W0<+wJQOFg+$XF{pnU^Nqbyxz1u9VF{8F&b1UMgfZAq@f2 z?Nb1tkg02$9K1eqbz~;KZ?10t#iNUoB)8rA<|2Xa{$Aca*tdkE#X55E$R}b{jxRKC zT;%<(j{B{5zryh+p~$3hHU3nFd9NJ8n-USX9{w+6y^`H-*9Q%+CdIVQ4g+u%r-c7O zyegGfVwgtUby!mSZfCbc#cO44?jv5M#;Y>U(P}PV1P^=F@e!7Ub1*8|2LXVAQ2H@x t`vVDmO!m)`{eLE%PZdfvdaLOv!TxEG(jI!_3pnbb&w|YqOa=hw=3iQhRMh|g literal 0 HcmV?d00001 diff --git a/src/plba/settings/__pycache__/reader.cpython-312.pyc b/src/plba/settings/__pycache__/reader.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..339335aa13fef31d186d5db7c8d867c3ffab847b GIT binary patch literal 2006 zcmZ`)U2GFa5T3nX|Bzsu#5OoCr}CpXp|L=X8X@{e2o(ak5($-RwK^TXb+GF{_Rb`B z?1CVw3_>crG$4fNVx$MlH`UTFJJqX^-iQi-ZB?VG_=w6qW1J^PvRn_PEUrlC*Km z=v=Z9BbfO-S}a>GRZZv9rm9wgF9tN~O!TtTS-zZsW_U+kc;E`PsRS1P5q%d=vXD=u zXH<%lEIMbnDL6;J_A*U}!+==Cka1?$@yz;FU40d0oHSf#S>>EGI!9A+p04|hTjW0x zMX2#r-guL)lGd4bA?cxdCk56`&!8##1{u2$)~P8ZA+yKP=;*(FxdzucC(+NM8JL0@ zs0rpqXI+(dW)HxJI{`kR&sP&`k{hZ*W|L#J#_1`2Ym$SilCz7$5nLP+=pIw>8eFVx z1GC?;-45jCnrsFgS?B)GbDgh>*FYDpi_Wf9`7EbHP5xM(MYAx+zYnwM7C(!kV!Sd) z@X1n|U|s2EkCHE#N{ZFsUZvu4log*sE4PFd%~aBP9nUEhuaY(>whKDCfv~%=Hl(nb zJfYgAh9%^+9JahPWmO%gv{KfzWCysMa|wG?%Z>A;944BHElDdDab9Pp$pR}q_vBm> z7tM4bPgvSSUBpKjVOK*2*kTXSW}P#;t8`1W-Lyp87fZyfbiN z9I4BzgF8OYtPJjc0+Ks&{z!fD(pZZVdm>F=aIyDt?-k?5{MGp{##XlOe&E~F5~)$E z7kt5bZ)+FZ-*$nBPsiLad&o#4DWJJ1jRdJkqN(e*Dq3h zH^@^xVSOX&VGV}8vZ`7hRm~OjQkLNjs(P}dWjiy3c3B{-EfSFt_6Qbln8XsYY07p` zc?k$B5c^FCD_WbdIyELKS%4OY#GQ?8V=bV3d3&3&mJ9a1g&y;MG1%;jT+uGS-m>xN z?yn9kWo-P&-BZ`j2cL@6rgH+@JWd^#%yNLQ(%tQ@2PwLxpnDJ@B8_+x)RQ16EK>23%aCSf+tlnPotfP>dlKD) z{sr}4SVZvP-Mjt+5)c-==&iC9v?t#rsR$0t_r5RhXXbtCbXtJt!}iC$_h`Qwadw=V zEUzLt0uG!cFeCvXV8MOh)(kimNRB{2 zKsW?e6S&JQL9ra=WV!;tZD9+#j!^@bJ2NM6a^kHN=N}8LAqlK+RGLSBMCC&lL zB=>r~(=Gpr5>okLA`bm~V!|?+?uke%Ho56f!z|hjm5%e!$Sm0|t&&m6{dz*>%fEAP zW_i&b2p#RRNtld{P%u`s z7#pU1oEY9_Y=0akwTCJ#3pDZ$iM*AQl~xOL|TwVdwfjZ4R+ zz3#ueGJjC=MYHoVdbNJypkJ None: + if not self.name or self.name.strip() != self.name: + raise ValueError("setting key name must be non-empty") + if self.required and self.default is not _MISSING: + raise ValueError("a required setting cannot have a default") + + @property + def has_default(self) -> bool: + return self.default is not _MISSING + + +class SettingNotFoundError(LookupError): + pass + + +class SettingInvalidError(ValueError): + pass + + +class SettingsDatabaseUnavailableError(RuntimeError): + pass diff --git a/src/plba/settings/postgres.py b/src/plba/settings/postgres.py new file mode 100644 index 0000000..e60a1f8 --- /dev/null +++ b/src/plba/settings/postgres.py @@ -0,0 +1,43 @@ +from collections.abc import Mapping, Sequence +import re +from typing import Any, AsyncContextManager, Protocol + +from plba.settings.models import SettingsDatabaseUnavailableError + + +class PostgresConnection(Protocol): + async def fetch(self, query: str, *parameters: object) -> Sequence[Mapping[str, Any]]: ... + + +class PostgresPool(Protocol): + def acquire(self) -> AsyncContextManager[PostgresConnection]: ... + + +class PostgresSettingsRepository: + _SCHEMA = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$") + + def __init__(self, pool: PostgresPool, schema: str) -> None: + if not self._SCHEMA.fullmatch(schema): + raise ValueError("schema must be a PostgreSQL identifier") + self._pool = pool + self._table = f'"{schema}".settings' + + async def fetch_values( + self, setting_key: str, config_key: str | None = None + ) -> list[str]: + query = ( + f"SELECT setting_value FROM {self._table} " + "WHERE setting_key = $1 AND ($2 IS NULL OR config_key = $2) " + "AND is_enabled = TRUE ORDER BY sort_order ASC, id ASC" + ) + try: + async with self._pool.acquire() as connection: + rows = await connection.fetch(query, setting_key, config_key) + values = [row["setting_value"] for row in rows] + if any(not isinstance(value, str) for value in values): + raise TypeError("settings.setting_value must be text") + return values + except Exception as error: + raise SettingsDatabaseUnavailableError( + "settings query failed" + ) from error diff --git a/src/plba/settings/reader.py b/src/plba/settings/reader.py new file mode 100644 index 0000000..4e1f549 --- /dev/null +++ b/src/plba/settings/reader.py @@ -0,0 +1,35 @@ +from typing import TypeVar + +from plba.settings.models import ( + SettingInvalidError, + SettingKey, + SettingNotFoundError, +) +from plba.settings.repository import SettingsRepository + +T = TypeVar("T") + + +class SettingsReader: + def __init__(self, repository: SettingsRepository) -> None: + self._repository = repository + + async def read( + self, key: SettingKey[T], config_key: str | None = None + ) -> list[T]: + raw_values = await self._repository.fetch_values(key.name, config_key) + if not raw_values: + if key.has_default: + return [key.default] + if key.required: + raise SettingNotFoundError(f"required setting not found: {key.name}") + return [] + decoded: list[T] = [] + for index, value in enumerate(raw_values): + try: + decoded.append(key.decoder(value)) + except Exception as error: + raise SettingInvalidError( + f"setting {key.name} value at index {index} is invalid" + ) from error + return decoded diff --git a/src/plba/settings/repository.py b/src/plba/settings/repository.py new file mode 100644 index 0000000..ae2a9bf --- /dev/null +++ b/src/plba/settings/repository.py @@ -0,0 +1,7 @@ +from typing import Protocol + + +class SettingsRepository(Protocol): + async def fetch_values( + self, setting_key: str, config_key: str | None = None + ) -> list[str]: ... diff --git a/src/plba/tracing/__init__.py b/src/plba/tracing/__init__.py new file mode 100644 index 0000000..bf39037 --- /dev/null +++ b/src/plba/tracing/__init__.py @@ -0,0 +1,19 @@ +from plba.tracing.context import business_trace_context, current_business_trace_id +from plba.tracing.models import BusinessTraceContext, BusinessTraceMessage +from plba.tracing.postgres import ( + BusinessTraceContractError, + BusinessTraceWriteError, + PostgresBusinessTraceWriter, +) +from plba.tracing.repository import BusinessTraceWriter + +__all__ = [ + "BusinessTraceContext", + "BusinessTraceContractError", + "BusinessTraceMessage", + "BusinessTraceWriteError", + "BusinessTraceWriter", + "PostgresBusinessTraceWriter", + "business_trace_context", + "current_business_trace_id", +] diff --git a/src/plba/tracing/__pycache__/__init__.cpython-312.pyc b/src/plba/tracing/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3eabedb2827c665a613b43e20865738f5d398e1d GIT binary patch literal 615 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 literal 0 HcmV?d00001 diff --git a/src/plba/tracing/context.py b/src/plba/tracing/context.py new file mode 100644 index 0000000..81a7fc8 --- /dev/null +++ b/src/plba/tracing/context.py @@ -0,0 +1,23 @@ +from contextlib import contextmanager +from contextvars import ContextVar, Token +from collections.abc import Iterator +from uuid import UUID + +_BUSINESS_TRACE_ID: ContextVar[str | None] = ContextVar( + "plba_business_trace_id", default=None +) + + +def current_business_trace_id() -> str | None: + return _BUSINESS_TRACE_ID.get() + + +@contextmanager +def business_trace_context(business_trace_id: UUID | str) -> Iterator[None]: + if not str(business_trace_id): + raise ValueError("business_trace_id must be non-empty") + token: Token[str | None] = _BUSINESS_TRACE_ID.set(str(business_trace_id)) + try: + yield + finally: + _BUSINESS_TRACE_ID.reset(token) diff --git a/src/plba/tracing/models.py b/src/plba/tracing/models.py new file mode 100644 index 0000000..421bf02 --- /dev/null +++ b/src/plba/tracing/models.py @@ -0,0 +1,52 @@ +from collections.abc import Mapping +from dataclasses import dataclass, field +from datetime import datetime +from types import MappingProxyType +from typing import Any +from uuid import UUID + + +def _validate_event_time(value: datetime) -> None: + if value.tzinfo is None or value.utcoffset() is None: + raise ValueError("event_time must include a timezone") + + +@dataclass(frozen=True, slots=True) +class BusinessTraceContext: + business_trace_id: UUID + alias: str + trace_type: str + event_time: datetime + attributes: Mapping[str, Any] = field(default_factory=dict) + parent_id: UUID | None = None + + def __post_init__(self) -> None: + if not isinstance(self.business_trace_id, UUID): + raise ValueError("business_trace_id must be a UUID") + if self.parent_id is not None and not isinstance(self.parent_id, UUID): + raise ValueError("parent_id must be a UUID or None") + if not isinstance(self.alias, str) or not isinstance(self.trace_type, str): + raise ValueError("alias and trace_type must be strings") + if not self.alias or not self.trace_type: + raise ValueError("alias and trace_type must be non-empty") + _validate_event_time(self.event_time) + object.__setattr__(self, "attributes", MappingProxyType(dict(self.attributes))) + + +@dataclass(frozen=True, slots=True) +class BusinessTraceMessage: + business_trace_id: UUID + event_time: datetime + step: str + status: str + level: str + message: str + attributes: Mapping[str, Any] = field(default_factory=dict) + + def __post_init__(self) -> None: + if not isinstance(self.business_trace_id, UUID): + raise ValueError("business_trace_id must be a UUID") + _validate_event_time(self.event_time) + if any(not isinstance(value, str) for value in (self.step, self.status, self.level, self.message)): + raise ValueError("step, status, level and message must be strings") + object.__setattr__(self, "attributes", MappingProxyType(dict(self.attributes))) diff --git a/src/plba/tracing/postgres.py b/src/plba/tracing/postgres.py new file mode 100644 index 0000000..2bc0b6e --- /dev/null +++ b/src/plba/tracing/postgres.py @@ -0,0 +1,92 @@ +from typing import AsyncContextManager +import json +import re +from typing import Any, Protocol + +from plba.tracing.models import BusinessTraceContext, BusinessTraceMessage + + +class BusinessTraceContractError(ValueError): + pass + + +class BusinessTraceWriteError(RuntimeError): + pass + + +class TraceConnection(Protocol): + async def execute(self, query: str, *parameters: object) -> str: ... + + +class TracePool(Protocol): + def acquire(self) -> AsyncContextManager[TraceConnection]: ... + + +class PostgresBusinessTraceWriter: + _SCHEMA = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$") + + def __init__(self, pool: TracePool, schema: str, application_id: str) -> None: + if not self._SCHEMA.fullmatch(schema): + raise ValueError("schema must be a PostgreSQL identifier") + if not isinstance(application_id, str) or not application_id: + raise ValueError("application_id must be non-empty") + self._pool = pool + self._application_id = application_id + self._contexts = f'"{schema}".trace_contexts' + self._messages = f'"{schema}".trace_messages' + + async def write_context(self, context: BusinessTraceContext) -> None: + attributes = self._json_attributes(context.attributes) + query = ( + f"INSERT INTO {self._contexts} " + "(trace_id, parent_id, alias, trace_type, event_time, attrs_json) " + "VALUES ($1, $2, $3, $4, $5, $6::jsonb)" + ) + await self._execute( + query, + context.business_trace_id, + context.parent_id, + context.alias, + context.trace_type, + context.event_time, + attributes, + ) + + async def write_message(self, message: BusinessTraceMessage) -> None: + attributes = self._json_attributes(message.attributes) + query = ( + f"INSERT INTO {self._messages} " + "(trace_id, event_time, step, status, level, message, attrs_json) " + "VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb)" + ) + await self._execute( + query, + message.business_trace_id, + message.event_time, + message.step, + message.status, + message.level, + message.message, + attributes, + ) + + async def _execute(self, query: str, *parameters: object) -> None: + try: + async with self._pool.acquire() as connection: + await connection.execute(query, *parameters) + except Exception as error: + raise BusinessTraceWriteError("business trace write failed") from error + + def _json_attributes(self, attributes: Any) -> str: + if not hasattr(attributes, "items"): + raise BusinessTraceContractError("attributes must be a JSON object") + values = dict(attributes) + if any(not isinstance(key, str) for key in values): + raise BusinessTraceContractError("attribute keys must be strings") + payload = {**values, "application_id": self._application_id} + try: + return json.dumps(payload, allow_nan=False) + except (TypeError, ValueError) as error: + raise BusinessTraceContractError( + "attributes must contain JSON-safe values" + ) from error diff --git a/src/plba/tracing/repository.py b/src/plba/tracing/repository.py new file mode 100644 index 0000000..e961d6e --- /dev/null +++ b/src/plba/tracing/repository.py @@ -0,0 +1,9 @@ +from typing import Protocol + +from plba.tracing.models import BusinessTraceContext, BusinessTraceMessage + + +class BusinessTraceWriter(Protocol): + async def write_context(self, context: BusinessTraceContext) -> None: ... + + async def write_message(self, message: BusinessTraceMessage) -> None: ... diff --git a/src/plba/workflow/__init__.py b/src/plba/workflow/__init__.py new file mode 100644 index 0000000..dc93c63 --- /dev/null +++ b/src/plba/workflow/__init__.py @@ -0,0 +1,23 @@ +from plba.workflow.engine import WorkflowEngine +from plba.workflow.failure_recorder import WorkflowFailureRecorder +from plba.workflow.models import ( + StepResult, + WorkflowContext, + WorkflowDefinition, + WorkflowNode, + WorkflowRunResult, + WorkflowTransitionError, +) +from plba.workflow.persistence import WorkflowPersistence + +__all__ = [ + "StepResult", + "WorkflowContext", + "WorkflowDefinition", + "WorkflowEngine", + "WorkflowFailureRecorder", + "WorkflowNode", + "WorkflowPersistence", + "WorkflowRunResult", + "WorkflowTransitionError", +] diff --git a/src/plba/workflow/__pycache__/__init__.cpython-312.pyc b/src/plba/workflow/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8d3cc86210a6ba2d42d3c8ad795336bb9a00ff87 GIT binary patch literal 613 zcmZ8dO;5rw7;d+*vGJiIiSeL`$6erVj0X{qgrJE@FAcJS({>}>2y*mSc=x1#MgKt) zPM*9Oi6P-+TNwu4q)+>PKTqFFB@ak@xqZ897yx`ICo}15o3-Wj1OgC13K&EXs<%N6 zW+GF+O=__m$}t<+%s~#zqdaqw%RJ=iyhRJFh>8#lK#+Tes5G&C=Ti;$p(tO+{Ju}) zaWfi(5s{I-EOOBe>4=jK>BT%C+_!~ynUZ0LBqN%Nt*opOM=5zoMI{TIlYSV5X&6VM zn8jLgK*Ubwbw<&0%4*pa??#DkYH}WP$zwOGZWEq_NlKy~@m-#iyt%EwQD7>t6yy~Y z6u1i1&$j%ss1E5(w>Dm?tPw3!w~52`RR2#e=1akP>}EfcLTIwdLhoL!75nRhhyMaJ zLE&KBr4-{=Fq167;vnI@y6UNCJnI;%Kg75;oGkJua_fkaQ(l$TP@d#S!j}mloPzok ZoXrgf8gn4wXB)udZ_6tfj}EWMs$T_quU7y7 literal 0 HcmV?d00001 diff --git a/src/plba/workflow/__pycache__/engine.cpython-312.pyc b/src/plba/workflow/__pycache__/engine.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e97c7a09b7b935bfa73f25b824683ff787df52c6 GIT binary patch literal 5856 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 literal 0 HcmV?d00001 diff --git a/src/plba/workflow/__pycache__/failure_recorder.cpython-312.pyc b/src/plba/workflow/__pycache__/failure_recorder.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dd985d80007a5b75c50b344ba998b146875e3b19 GIT binary patch literal 2985 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 HQylmMnzG^5 literal 0 HcmV?d00001 diff --git a/src/plba/workflow/engine.py b/src/plba/workflow/engine.py new file mode 100644 index 0000000..ba09427 --- /dev/null +++ b/src/plba/workflow/engine.py @@ -0,0 +1,131 @@ +from collections.abc import Callable, Mapping +import logging +from uuid import UUID, uuid4 + +from plba.workflow.models import ( + StepResult, + WorkflowContext, + WorkflowDefinition, + WorkflowRunResult, + WorkflowTransitionError, +) +from plba.workflow.persistence import WorkflowPersistence +from plba.workflow.failure_recorder import WorkflowFailureRecorder + + +class WorkflowEngine: + def __init__( + self, + persistence: WorkflowPersistence, + id_factory: Callable[[], UUID] = uuid4, + logger: logging.Logger | None = None, + ) -> None: + self._persistence = persistence + self._id_factory = id_factory + self._logger = logger or logging.getLogger(__name__) + self._failure_recorder = WorkflowFailureRecorder( + persistence, self._logger + ) + + async def run( + self, definition: WorkflowDefinition, context: WorkflowContext + ) -> WorkflowRunResult: + definition.validate() + run_id = str(self._id_factory()) + current_name = definition.initial_step + current_context = context + await self._persistence.record_run_started( + run_id, definition.name, self._snapshot(current_context) + ) + self._logger.info( + "workflow run started", + extra={ + "attributes": {"workflow": definition.name, "run_id": run_id} + }, + ) + try: + while current_name is not None: + node = definition.nodes[current_name] + self._logger.debug( + "workflow step started", + extra={ + "attributes": { + "workflow": definition.name, + "run_id": run_id, + "step": current_name, + } + }, + ) + await self._persistence.record_step_started( + run_id, current_name, self._snapshot(current_context) + ) + try: + result = await node.step(current_context) + next_name = self._next_node(node.transitions, result) + except Exception as error: + await self._failure_recorder.record_step_failure( + run_id, current_name, current_context, error + ) + raise + + next_context = current_context.with_updates(result.updates) + await self._persistence.record_step_completed( + run_id, current_name, self._snapshot(next_context), result + ) + self._logger.debug( + "workflow step completed", + extra={ + "attributes": { + "workflow": definition.name, + "run_id": run_id, + "step": current_name, + "status": result.status, + } + }, + ) + current_name = next_name + current_context = next_context + await self._persistence.record_run_completed( + run_id, definition.name, self._snapshot(current_context), "completed" + ) + self._logger.info( + "workflow run completed", + extra={ + "attributes": { + "workflow": definition.name, + "run_id": run_id, + "status": "completed", + } + }, + ) + return WorkflowRunResult(run_id, current_context, "completed") + except Exception as error: + await self._failure_recorder.record_run_failure( + run_id, definition.name, self._snapshot(current_context), error + ) + raise + + @staticmethod + def _next_node( + transitions: Mapping[str, str], result: StepResult + ) -> str | None: + if not isinstance(result, StepResult): + raise TypeError("workflow step must return StepResult") + if not isinstance(result.updates, Mapping) or not isinstance(result.status, str): + raise TypeError("workflow step returned an invalid StepResult") + if result.transition is None: + if transitions: + raise WorkflowTransitionError( + "step must select one of its declared transitions" + ) + return None + if result.transition not in transitions: + raise WorkflowTransitionError( + f"transition is not declared: {result.transition}" + ) + return transitions[result.transition] + + @staticmethod + def _snapshot(context: WorkflowContext) -> WorkflowContext: + return WorkflowContext(context.state) + diff --git a/src/plba/workflow/failure_recorder.py b/src/plba/workflow/failure_recorder.py new file mode 100644 index 0000000..761539c --- /dev/null +++ b/src/plba/workflow/failure_recorder.py @@ -0,0 +1,64 @@ +import logging + +from plba.workflow.models import WorkflowContext +from plba.workflow.persistence import WorkflowPersistence + + +class WorkflowFailureRecorder: + def __init__( + self, persistence: WorkflowPersistence, logger: logging.Logger + ) -> None: + self._persistence = persistence + self._logger = logger + + async def record_step_failure( + self, + run_id: str, + step_name: str, + context: WorkflowContext, + error: Exception, + ) -> None: + try: + await self._persistence.record_step_failed( + run_id, step_name, self._snapshot(context), error + ) + except Exception as persistence_error: + error.add_note(f"could not persist workflow step failure: {persistence_error}") + self._logger.error( + "workflow step failed", + extra={ + "attributes": { + "run_id": run_id, + "step": step_name, + "error_type": type(error).__name__, + } + }, + ) + + async def record_run_failure( + self, + run_id: str, + workflow_name: str, + context: WorkflowContext, + error: Exception, + ) -> None: + try: + await self._persistence.record_run_failed( + run_id, workflow_name, self._snapshot(context), error + ) + except Exception as persistence_error: + error.add_note(f"could not persist workflow failure: {persistence_error}") + self._logger.error( + "workflow run failed", + extra={ + "attributes": { + "workflow": workflow_name, + "run_id": run_id, + "error_type": type(error).__name__, + } + }, + ) + + @staticmethod + def _snapshot(context: WorkflowContext) -> WorkflowContext: + return WorkflowContext(context.state) diff --git a/src/plba/workflow/models.py b/src/plba/workflow/models.py new file mode 100644 index 0000000..f59fa51 --- /dev/null +++ b/src/plba/workflow/models.py @@ -0,0 +1,87 @@ +from collections.abc import Awaitable, Callable, Mapping +from dataclasses import dataclass, field +from copy import deepcopy +from types import MappingProxyType +from typing import Any + + +@dataclass(frozen=True, slots=True) +class WorkflowContext: + state: Mapping[str, Any] = field(default_factory=dict) + + def __post_init__(self) -> None: + state = deepcopy(dict(self.state)) + if any(not isinstance(key, str) for key in state): + raise ValueError("workflow context keys must be strings") + object.__setattr__(self, "state", MappingProxyType(state)) + + def with_updates(self, updates: Mapping[str, Any]) -> "WorkflowContext": + return WorkflowContext({**self.state, **updates}) + + +@dataclass(frozen=True, slots=True) +class StepResult: + transition: str | None = None + updates: Mapping[str, Any] = field(default_factory=dict) + status: str = "completed" + + def __post_init__(self) -> None: + object.__setattr__(self, "updates", MappingProxyType(deepcopy(dict(self.updates))) + ) + if not isinstance(self.status, str) or not self.status: + raise ValueError("step status must be a non-empty string") + if self.transition is not None and not isinstance(self.transition, str): + raise ValueError("step transition must be a string or None") + if any(not isinstance(key, str) for key in self.updates): + raise ValueError("step update keys must be strings") + + +WorkflowStep = Callable[[WorkflowContext], Awaitable[StepResult]] + + +@dataclass(frozen=True, slots=True) +class WorkflowNode: + step: WorkflowStep + transitions: Mapping[str, str] = field(default_factory=dict) + + def __post_init__(self) -> None: + object.__setattr__(self, "transitions", MappingProxyType(dict(self.transitions))) + + +@dataclass(frozen=True, slots=True) +class WorkflowDefinition: + name: str + initial_step: str + nodes: Mapping[str, WorkflowNode] + + def __post_init__(self) -> None: + object.__setattr__(self, "nodes", MappingProxyType(dict(self.nodes))) + self.validate() + + def validate(self) -> None: + if not self.name or self.name.strip() != self.name: + raise ValueError("workflow name must be non-empty") + if not self.nodes or self.initial_step not in self.nodes: + raise ValueError("workflow initial_step must name a declared node") + for node_name, node in self.nodes.items(): + if not node_name or node_name.strip() != node_name: + raise ValueError("workflow node names must be non-empty") + for transition, target in node.transitions.items(): + if ( + not isinstance(transition, str) + or not transition + or not isinstance(target, str) + or target not in self.nodes + ): + raise ValueError(f"invalid transition declared by node {node_name}") + + +@dataclass(frozen=True, slots=True) +class WorkflowRunResult: + run_id: str + context: WorkflowContext + status: str + + +class WorkflowTransitionError(ValueError): + pass diff --git a/src/plba/workflow/persistence.py b/src/plba/workflow/persistence.py new file mode 100644 index 0000000..614e668 --- /dev/null +++ b/src/plba/workflow/persistence.py @@ -0,0 +1,45 @@ +from typing import Protocol + +from plba.workflow.models import StepResult, WorkflowContext + + +class WorkflowPersistence(Protocol): + async def record_run_started( + self, run_id: str, workflow_name: str, context: WorkflowContext + ) -> None: ... + + async def record_step_started( + self, run_id: str, step_name: str, context: WorkflowContext + ) -> None: ... + + async def record_step_completed( + self, + run_id: str, + step_name: str, + context: WorkflowContext, + result: StepResult, + ) -> None: ... + + async def record_step_failed( + self, + run_id: str, + step_name: str, + context: WorkflowContext, + error: BaseException, + ) -> None: ... + + async def record_run_completed( + self, + run_id: str, + workflow_name: str, + context: WorkflowContext, + status: str, + ) -> None: ... + + async def record_run_failed( + self, + run_id: str, + workflow_name: str, + context: WorkflowContext, + error: BaseException, + ) -> None: ... diff --git a/tests/__pycache__/test_configuration.cpython-312-pytest-9.0.2.pyc b/tests/__pycache__/test_configuration.cpython-312-pytest-9.0.2.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a3762e5efee35dafc7b38fdc8a482754e152eac3 GIT binary patch literal 12223 zcmd5?TW}OtdhVY4rAHbKl12iJ7zqgwMuPwgVa&yYBtW(hHkV}?8@HS3mOR7U+}#38 zE7g)12Z?o+A>Iv8cGf)P0hgT=l_wsOD(@QKk{3;8T%+pMR!H&^S6<|jwuGsD$p4@2 zo{Kb+z?-f3OwHftoId@Z>;Iqc|IhhXm&-vx_~)U2iT-jOMg12h^kCK^a}zX0-Jp1i zr(;xzCQn1$7&g#U+!Qj?_{I>k#H}GKi5p|KxIJViaZ}6@cZQrKPRE!KL%w!}T<|o< zD&m!)%D6k^j#q`M;+~L)l(WRv#H&Nq@tROgyf#!z@~km$ye?E1uMgG7*M`={*M-*6 zlz|egyzLYF$Iw0u2I?@yJ1$ea^J9aW^RfD%LJd44_=HAb{h*;9@_3ifFlgc{E}KGr z@>L~#y`O6+6$#TsX!_5+qD7a`Nl&^qdspsieq>BRvsO2+K)v zq|KzP4W?4DNSKo&$wYTDF&G)@PjY;(C?-Y4TlSqGDs@X<9OV++5WMlIJdO)7;BrFd zOWR%|SZvaI4@*?5v4jtLNFSoV!!E{265 zWrU_Fl`P985=j^oXt%_&A5nAIo<{@QP61D88y6Ga+}0ypU{hi;3KJx;7j|qLO zE-DsLkcY)YSd$WXNl_;F0XGf_vf_wHk%T03iLfBz z1S*c7aIs;5EL_t0HiPKHd=pNAgi`PKiw&4l!wcagFR*$Q>Hvx@@D9gE+79FrHSMf; zw`;QN+Ww5Q`BKk}v*sHAL3h^apQ)&us^6KZczVkA^o+CaW_8BdIAv-iLtC=GG(|(r zZ3TXX^~GCw11J|GJdN-)!P5j!Gd#`kw16O6mD(cFP}ki_obZ8?nZj`;Gi89PZcuW5 zo^;*TNtMoyKKeX8>ZGV~!c!(C@!=`fwz@##Raq|z-W}?n%|qExF{C|y+*Rb!7f^;V}#m3ZKovqBJ8neC>nkv z)SJdL)J3|@G4RN#uI0c87mtme!Nr9BS6 zUm8h-@#*)cxM2w;1^DvP9)G9fk$G4iY~TG6t=K@HCizHW=#f3oSTPe`iU~P*dxN8-DV9#6kFoI*)ESQ_6YO9_h(U@=@T@$N5_ooLdq?|&g?TCx z_P`I~wgH+X{U?x1)QoF=#?>@Sx$Vd3+h=ChcyHR@J8=7Kdd-fBo@vJY?y<>Zvj)0q z?}K{(td(*#%u^;;#k_;^Zkus$x?{=)x-;&cIitZ_F>!d-M%As)d7nyqpUQaKCyqQ| z+&QKp%{1KnY0md_+V}L`^I7H~a4qESPWyKMQ~Oue%$^ss%u9t=r*pntY2U897c##6 zIbVO;*Z&olWnNrbU@YV7$@z|^eMhs*z(NytV}W$$J3=2x40Q7s-A&z{#?Ly<-TSTO zwc{4hi$5yuNR`u$as_mT1YPz!LAF76RO$JJr>;qtY6l(>_lnx$9gnIlmenHW0TDna zHCnIh1OLl_S=zbwI4oU|_OlML4c?1efV9~Q0xjaUxkQpx**(rhBta4_SYii|k4)ko zj6aJ6ftI)rh=h8fAWfUe`i~?oaIr{U8-PFoygC<4hR;hZZ2zJ>oEkl_k^nshgI!qp zRUieKvDr5*BQjGByFcxkIF@Bzn5hkv6% zCF|a}V1$f?N~mF$0J)S!?+pnK^bWoGe^te1B96*L=h%0 z3Wfc48J?zcSU}G2{>xyFa;-B)5vDE*dY@LQC67#s+PgBp#zhrDa@?{E4zxYd=v$W= zDeEeu?_b)YqTZCB(I@WXnB`C8SqAwP&32i2SX~q6ahqM$xR0vKp|XOq9bHrU{+u9l z4zV4EPcdP<)Mnb_e_7LfXB}--E30Xula(rw80~CikOhk~F(mNfPGoKYH4A3Ehz6Tt zJKo!WEZEcABX&ZP7+Q)oJS>VrLRM^|02VhI<(5OizW&~xHd{G8uh>#pFgYyY7YLW2 zsuxIAgB+-Lp4hCo5nxblw!LIC&|3(AN>0WjVS=l41wWhuuZO^%7lf3=g6~6Sb(}VO zVxl7bv9P5vn1+Lr)*J8Nald4_7U- z`~Bz;--^56vUY7*><9L+X6KjFtNOd8$Z!R_(V`)~y`}nPiB%X$aA7%eK~OD2-C)|| zm&IYB2ox$dy4^o#}?oyU|QTFxT*Wy5V_%mf?f?&IYiHQIL!UD z`W2Q9!#^Lu_e8=R0;(c6mr-?dfji5jdxcMPGR%y4a;Yl|9RN7KbN>kJuGp^FUjXCh z$pP$D`=tGcy0j+kE4Z}KRkngl3!G$mU|Pqzi}>XMEtw8Npw(quPh&>jK4#L7By^QAZdsX^ff_UG{m6e~E&8Sm zM4Gfk^N_gEDxC}O_#}TE^A?z`KQmI)-xzNg|H^DuP2UxOamk36sd>z@3U}+$8ka)0 zF6x~_@UMq|)p7>&-y6a8=2BIt*bBWZAU1_&iD;JiB~V`8ga2Fr$ggO1p-nIJZ$JDHQ@9)PU-PgB=-w6EgQ-QXvzg=CY*7D64vwibYU$FkMuI zQsW_k+f6mNHCTk6D@jfQq=Hk4cuJ0q1ondU4NkNDf#M28s98eK+r$5+9)kDW-I#MX zr`^rpxLdv_di*U<4PBx*P`Q(Vz)$soC^)gBx?+L1dMF$_Z>BbQ zqp$rLM!TejVW?Wd6{HULOs(%m{CfO$Po}ml=Wd&Fw@tgNZ&Y5dyj^*3)3wTP+y`fk zRMi%B^LVSii~fM_H2p0+wITTBfp4)hu)3^x43`|1#Z!zS0x}d| zg$(f==32Fts#wTKh~im%h2A3x&mxGi0OYyn)aAd6poJ%1-J^Z~XHz$XO>2R1{ho+~ z?vAaq*Dvc@TFpo(!VNR^{ttb(eDANHcz(v$g5djoc4A=GM7vu5E`t7~*1J7_z{ejf z23I#dZ==A3sBKHv!qV{Ga9wxZjNWOv%Vga9G#Br@g{t-CYBr~9Hh<*%czveknTbO) zp8A}pIqhk_y+5~MS9-&)%!b{cHf23MIi_cd0WWgxy91L0S*D>-u)DlKc10Yzt zvjYK$-*2aTt(N-%JI1@{Uc2S~ZWG4$+M)dCW*Xw3TM4xj>NNLOTR(SO;jOxkO^cyX z5^7tFg-&B0l0o=OcpPz=nm5#&>s91~Z%P!HuAo*zK0b9dX{XwKaHu_`9@LfrL0BUJ zK@^-TTyb1+USWP14Ep~%*(=$U%bexu``J}z5o}ng9K)NhI{1nS$Aoi&8H6KKgg-Lw zG9>8y!1HI0BKBPr7wcOmpkC)udrH^seD| zxZQ#+_!gTYz6=De7nuP|$0Wr$7!mO@54joTi~(>G)r4e(a+fY?IMWI!JS<4k=-`SQ ziwf=Y9uC!?%Od2GSiET!V-s-hUUC>s4$}(QUaJSkM?&#YapnVe&CROoj%(&=_d0}^ zS$EU)n!208zuq%lz5d3r>&L#SZUv-S-Kb&y_6}M^ffP|okiLsJ*rU52ds6j2Xl|yV zdyQ}Z&rA1yeL&s32}o^x3@;M_sUmLdB3kO`c*gr;U>j9n9&SRS6A7Lv1J=irMKOvQ z=aKA0au~@GBf;Hy{ARiX6$)j0?p|*uotHR}tbx z085TP#W%6A)-brp=8*DN*c7X%-;X;d0D2a{S|hv^yA}Zt`YD_Dws zY%^<{K5W0${{FU!7mA|O)io2n3nsH`<9r2Gw=v`0gzj$e%=yxcFWVTnbK&mAOyhwp z^W02*+nvpK4`=H40@$wI{7K_IXQr*^(`cslrHRASp86Z@*W2IQmSdWxn5F^}em1vZ zXL`fV%!bZ;Z)82e921;kf|@^l+C5Ox4Y*(7s?zRGXcr_hzTG+Bfwb>HHh3Zzd?g)x zCCi*$oqK^vAngleJ9=^*{ppVWEOYb$G<56rt?vcE_c+D)r+v*61JjMIAI5LR-%sZ1 z+9&#eJ9g!^DdTC)F|AWfYr(&NCg($j>gA1lhAi`J!NGs(HrN0=aUhELFPx%b8fPga zJ1AH4_tQ-9`&ou^9i$)5!t^vfd{Ea8W(P`?gxX+}r^1 zuS|4b!19$jSP6-*tLeTD%hxp~jMv+tim#jTQ}q@H+A8X04{|KXkOG>LBAT#Bo31H-8Bmp> zi0Vnzy{L~>1&qL6G4YYGtX}D~B+ubJSoKnv?Ig6Mn}dx5UC@fRPfFr0$p=;cO#UsJ zX=Jd8$)}ibR2NOiBiml}p6-6}7L-O@FMR=I)=1OzzoXgr4b}8}s_ysHrr%K&zoRNa zNzjHl3djOO(Z}gD_0obt&-%_y8JyQzvb1->K-0BgdegOYM#@kJm#ZLYGtujB%D21k z)ZTs}y}o0Xg7n?9bNHCA2-0*vjaR5pwB{+2oIhe%OV{75%hf-Vu775pg2eout#s4v sBe|BIbW6`X1&P^LY0AV*jQ*Rke%e%Z>ByC%e{uBfW3cs_){;f_zf6#ihX4Qo literal 0 HcmV?d00001 diff --git a/tests/__pycache__/test_configuration.cpython-312.pyc b/tests/__pycache__/test_configuration.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e7a3192614e52666b44c2a8c9ef4f43d7ba9e75b GIT binary patch literal 12058 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 literal 0 HcmV?d00001 diff --git a/tests/__pycache__/test_health_http.cpython-312-pytest-9.0.2.pyc b/tests/__pycache__/test_health_http.cpython-312-pytest-9.0.2.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6386a3647d32cc5193690c9fc40c9a5906950fd7 GIT binary patch literal 14834 zcmc&*e{d7oecvaoq?NpqY#ICu@NWYGV;e9W$6*fRA8-d44x9U-aHk0G+LqA|XIF-^ z&rS%Co_!$$^qOF|nc_4z6O*G8calH&qwO5rU4|x|R*HO;yKyHs(@fj@&li!xF`a3@ z-?zJxEDMfY()Nw^yKmpV-}}D5KJV%0cDs#%aBARZgHsg@^RM`z2a^^_9wQ8MjS(1u z1Q-vYcSF$FYamRJ^_YnI#_TcEHx`eD-Z>8kcSFD$w0Ueak1>!J-3$F3339j|5 z4X*R73zmDzgB6|%!WftXj9|IQ2;92{weOxvnr4MGTPm%JrsY8zFLHzJ`f$_tca2)< z8k*A%IUS#qvsSDVoToQ3jN~#fkoR!9Ha+&P79q?C86occPw=_RO%!8mXvA$%@(+r> zKxCk`zh4sjeUY%FIMtN4aBwIb5>AWPwir#Kjf!Fbf_t*ZfiNZhlfPzj9(5*z4{d6oz)(a@G)T3igd+#3<432 zfyOM^{|3LH1-(;6U0p;M(E@!?2W%y?U_Ce3O_(Uiq}u)*DQ&VVJXzrt1U0u z6vlDEBwe(@F*3$@=?f$y%nj0YgGj{?cN-K|76X0sLB?X0l@AX$o{&XJZuAAj*Bjf# zGu|O7JP2P`_MX|+IO-ef9q`E!|A-GChXSYQJtE2xxe=*X>)t>lGSo0MqHtd5sXyZN zj;_l!oCf{%T4-EG&OgU2tlc=le#Dg~;fd)5PEQ5w;RU#o)j$q01ZH!L8BD!SN4lB6 zG@d0=8Kg*SfWUZZ16Wz5v<|4kN}^8~EzQ{}dl`&^!l&kzq z#xHu_?j-P$V0)hJ69`jbwrBQaKXr_YFqEx@j+@B8(xy zUdmNKE;367Vsg)XX^DZ`Tu%~jOJ-uKnmTk3;#F#CER%bc;Xt!jnaIK_Gt!mCx=l)P zM{p=IlDWu_!-z#m$vaCIJ{^)&f=%F*>jC3*U18(bm`Li==z^r1p;HdCT>v?580e%+ zZis7(OP%_HelgzodN070oPnm)wVs}Efe40( z5#G`u7zI|>B^jyEsGizqi0HZ#^ijmDmmK8uSo#iiX*Fk*;WEll{hZE^F=$CE(`R@W zxdXyDiP+T`!$h2VY>d3CEgStlh-)P)=nLusX!19p=IF?b<|*dVZM3j(Y-fS$F_g4!Th~J?XpJ-eUU7?0u}H(AkU!L~ zaFY0yVZS5_Jqi~dLfz>LbSj)6_Ddjdgi&5k+;Yk%DAwVSsy#;Bc2#KNLX~jkO8Gz( zuD#>H@z(Z^cEx(4>tILg;hux9NVwdn2vw{;%~BDSJf95RiFBY8R?M=h)@{AI-6AV2 z%4RpKN+{HY3aHYduoO{Pe?$yY5nl;Gl~~VG)fV*2GK|XGD}fo%>kD{&A;B98hf>e! z`n^6dPDVg=`ooZUWc0<{EZ^{Z)=Nce888%8Qj5ja3w-eczxvntRWqArg?Rqr_jIX|DGFoj* z9AmYsH9mRisu*AOTUy%5xLzg?f5S2MHu9NvlbhhX*ClO-+N5SAsH_!JudjDN?3A9u6x6tGn<^JlB0<`XuTmmFdIlf&AZbCe z7l_-KW^!pCB*>_$QmoxXSum4}Q&Pz5m%Y8f$fDr&MZ77Yb>MNl{5w?ChJE=Kkmby~ zz&jT0Yo}g%Cy-dbC$@giEirCykMf;KtBEqC<9A_5+dQ{D#gJ1)iPBB6(oM5lW2IXX zrOmO@=AQ%-I}gWp9{z|svSgv$Bcqx;-|E=EncU7N``zsAg4R-aSjG}5<776)5&~&w zUVVvSPQrH@C*y{+v65zv41>ZjM!;+_>MWoe1NwasZRV`-$fa%s<(^`obRkgCIZTx? zLwfODdWB^&`y_yooHkknwAw5=*p-F$aK#xL6!42KtVfen5~RV&Vq7&1=*PY~xoHA)ds zYLv&+gz(T%MuNG|=MRX2Uce$p;5|Gaf(lfAMOLLus~Ay>TZTiYL*cWb9=A1vF{uxf z#hu8-3a@JF<37JE$`aZjZWCo##TrO?^_)ln255F4ma+I%C_%;=fRlAK{S4*hR533& z7l;?g-cvqV)IC#F+FE(liI%-M#L?rAW9u(g=P~G>oB%>Oe92(0wf%;%S$D?xiizj0 zynfHYtgTCFC{6}MKuXT94TcOQ#xJP!2~+9oVe z*5OLn%VYNP`HHP^`?gORV(lV}uIl-kr*2u|HT&YO)`aU&%ylU4I+EazMEN84jhF@e zAfyG*g$GM6#@8Kv*}-EA)N*QCv0{+reUh~9CmZ!;V3G?O;gd}jxX@uzK& z{ys|}{=V7N=Cr(@XMvPuA_W%+)v|w)5-Dlc(OG|-2sVLSWWf(0gDA$cLMAhh0k(28 z<;&=dreSg>K+sa&(YP^^5;tSSz>FF7_H-5-XCo;Alh)869H6flfT1;qaNLv@AY-O6 zHtqSO>eTu@ZjPippE0vuQ!Xz>FS)`SvVb5$$2BXASq5`>HE9fz>iFE{a`-u!UKABH zEmWA~b@gU8i^G2#t|SjcHIha$Ko}|`C`mcsiUokBUQw1uHMlR^A6AWH!7uwxfdJA0 z1JKE#aKx(%1n()aFD!}F-qyfCFO_Kxdjesw(dE4jS~GpnF&V$23g{FTYdDU9CE$^0 zt@HrQ$m#a{vH|K=UGnqsm4}0m6D4|6Uwl9+E~!E`6kS;f)!-UKMV>?mEEB2`$W4R3 z*1Ewq>VgqVFG411GZI8IGO-$poQ#hB-;HM_;1j?uq2+sySuC!Z?U^s$7R}$LVm?v> zb~}HAmf?s@Sx8q!H-^zQUFjo16lVsr!s5 zxWd8GrQo+}x1w^S+AgK=TBySNqAO~&=YQk7BG<@20-~C=g;nvwnh7q+5^D))B5Of{ zD~)lb^JSZ6ch8-@yK26yYo0rLpEX#wf64&4$1z3gX9oU?|FI*!`q>HFqO10u*X9nz z>-N333DnbsWwCI}Z2#QoeA~%*+iUSc?*#Yj;tjK0ym)J(_?cMoGx6ed_d;Ac2}5yPvam&IKcq?>NRA^p zg=G0Ul(u3Tl8tc5xRNe1NkfUrmTb;5b&+IQ0nmHv3r#!J6^L1vi5%U=Ob)=C42;oE zu|=a`*ESC9>ZSoan-OD#y9MqRD{K-8oX81QxNM?T$b*ZBHZf0xZ6?v)XF%soqc(xR zX!1Bl3~ndxj_CU=JqS#yT(C@Ao1x?dxRS>oqpe}vLDP?bgQ2NL1L!PGSL!KvPitUZ z+vyq=YSCpclh(ayEi0rDMW`8BBr9aplhX1TnwJ?w?#&9hYl@&0pdr;ql(P^3>rClW zD4V0k2x3e$Wcc;kJirK1Yto=9O}C-zA+O_UxRs)bAn7&8qzWEfRFW4-S_FL=AJcLu z4al4YFL;B)X``B58D;T29(G*K5W*I<->o@Yg05aG_%0$8(8*caGCq&dxk?FsrqguF-g1s&^LeF4Y)3HxHy`oh!v zcDWtO_Sn(xo>50;eknp- z7OP*7`mmrOeEOk1qgZ%|a_Sr7)ZM;e0Mh^fb&$yvex(2bn_lvF=wdY88Tfu(>Bj-%uaiGb~swQW1idjamm{2{4_uFVsuMOyku{}wRggj z&RjfGFkLp&JjjLiq&?wkU*5Ovvn6v+M>n=atM`7yJ-f6Htc=e9;Vyjk0Z`Y@ z2TL}lu!B6555kn4FKTy_DbilaPPdvMdb^yo*RZ!M=);{_(q6~jscWr(Hy^O1eFOV} zX)VTU2+}%AHy~Z6rBUbN_elOJe2?EtI_Ba%kf;FQY5cW<_fU>Ks#MA=Ur`Dr&ZA1D zknwQGQ00gv&E=1f2!{S2m5ySa+^hq2WMaoXRHu6_`rtE09lz z)GXQ-mSPS10^m0XL0&j@FidMj;jsp<_LMC_>Zlyhi>MMq6-kJeqp9L;ZfY9ckyCtp zUa>!cuFC%aM3o&n>(6@QB`pb83vgFi`Stqg`k6DcUwbbvUUoRK>hOehp|bV|{P*|; z-gV_@v~DjL6IHhRjA4y!!U+yXdG+;^(^BhPc2 z(;}c^wjfrzc@`wj)^y_98Q*lpY|Tep!%`_zxc9-rs>2VK4A6lGOJ->4q1+BbI$zY5 z2Mpe3WT(p@_G8j!Vt<0M+YZuZVQ)KW+)di7?Cnjh`0&1oAhl3xMY@c+Q`=JKfCb-V z-!x@!P31DPb;I>7HVv*lHlInzpI|3Ua4?Bnkj1ME|1f-s|Jx<`n|8FG{!tkO%T?|L7y zg=Xf?#9(zgzaE=p2kZ2B`mWa|a5o=m!cyaIL%NI}1L!tS;Pvm9-5)q+!3?_fyy^QG z`ne9lx!hQrG!1S}=h0(&?>=vA(9#yYO!}^ue*D;|2%iDbJq*`Lxbmn7FIWzT;s<{l zuH-2o-!`bMIhj+p>CF;mGAE|3zt5g9)ndJ5!sh9*E8N_EtI|6nznh*4!|amj#yHu51I(}jldRN0kr-A zs+JMveV~eQ-gWu;$>%Q}UT~FOtG`Vk1ykJg9U&AUTByYhBsKYf@BPT$DGfrxYt3x6F5 z_4pC(+_z6XgVRhckKb`|j<)|HKHvATKVJrM{F#b<6qH z_v`}ayqq_g2dGf0?nt8IsaVBR@rtM4+dA*)NN^o7u4Ac?vDQ3T;C4M&VxiIpOFU!k z1Xl#xjhrBb~e156fF!@bJ?n(z%EI=~gqw zcM+t!Dcyr~nYn~A;{sgCe*=>8g&>|Ca+yPqKg}{sq>i+?lk3ny8lzk(#X%WmcLAQi zP%p@(_7RF>T-rjFlA%jIHDi{(3{^@;k)Y63EZsdvj~(l1m%fQlCOIIALlPPfGAwfK zgtT-8qN6q0{F8&5Z(~8MT$T6wTC0sYYUk_sCF&2x;O97~@yZN|yQ<;LSCp?_GBVCW zbzv^cJnuNTz*j$%5i>piZ0lBXn~>H<_O@XY#MC##q7nT^6>DQ^#pnE|{FyD#&f>q}iYw{)i(O{X{*e?`GA7N?RRu(!Ri^7MK_z z_~QZoA!R5$ggdkT5FD`t`+zP})sjK;rdI?zXLMusQq_i&Hc+&jKZnlBX!5EC%0I7f zxU%coo~wIi$lK3G`J;0$Mq9d~%|{`sZV_K7Swj>HSO~JOUtA$n==hs5$4_!W7-Olg zfreY!XoHoEN6bP3;PW$33mlXkj`W9dkhlsfwNb+VG(y5?-RBMwv!Mq~k8$Y+*s9A% zCy!1Y_=vC722@x?6qfEQurYAyCv3bm5c#hCr7A6(s5|rdeSHe{V!; z#4@-7RAYcez(O$v!ahNUb9%TzKy0>qy=Kg8Qj5{ErCsIsP2ez7K?+?AP}= zHO)^AiqYan4E;ka^+O=4Zbpy4ey-=PDYmLBT6lDVTX1il;Fe(b@fi7TjK=`FjpL?NT?_jPL588jwr_lLHH@*UX%mi`+dCMfuCzR0-hTbf`q~C~IWz?L;s#PaIz!;JdxMYmr4yDC(kR)AB(>{`{ zwwoH0IRXEi< zRdTf}>a31gYwnq#q&h%s4gWn8^!Y})|!u` z00}j}(Unm*^$_l(|4C7bpOeD@AK>||xH;z!_dws0Lm2vXu+E7@WzpR~S@Ltq^ zBJGv_7BZqrm#+d@G7>_5g&+BXsn&#TJACUbnlemH9{J%3?zzn#)@{{ lWAJHdzmZ}2iP2veOBdLJa|ho%^7SL%I0~wtEu$;pe*mPZ?Fj$? literal 0 HcmV?d00001 diff --git a/tests/__pycache__/test_health_http.cpython-312.pyc b/tests/__pycache__/test_health_http.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..87791893b899db3d7e09371f381dadbeef1692c8 GIT binary patch literal 14670 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 ano1YBg0qL-I`Z`+-#7|7nk%E9?0*2juCKrV literal 0 HcmV?d00001 diff --git a/tests/__pycache__/test_identity.cpython-312-pytest-9.0.2.pyc b/tests/__pycache__/test_identity.cpython-312-pytest-9.0.2.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bf1e918fe660376b84d0a8ac8f5899103d3f410f GIT binary patch literal 3919 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 literal 0 HcmV?d00001 diff --git a/tests/__pycache__/test_observability.cpython-312-pytest-9.0.2.pyc b/tests/__pycache__/test_observability.cpython-312-pytest-9.0.2.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cc7b3ed8355e757edf752e1fec8cbbfd20c89984 GIT binary patch literal 8850 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 literal 0 HcmV?d00001 diff --git a/tests/__pycache__/test_observability.cpython-312.pyc b/tests/__pycache__/test_observability.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cfe0c8eae0be1c436e002dc04cc0bf55cc99788c GIT binary patch literal 8686 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 literal 0 HcmV?d00001 diff --git a/tests/__pycache__/test_settings.cpython-312-pytest-9.0.2.pyc b/tests/__pycache__/test_settings.cpython-312-pytest-9.0.2.pyc new file mode 100644 index 0000000000000000000000000000000000000000..55cd9aa6b4b55e0ddd7dbadee2c4ac16952ad9e2 GIT binary patch literal 8451 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 literal 0 HcmV?d00001 diff --git a/tests/__pycache__/test_workflow.cpython-312-pytest-9.0.2.pyc b/tests/__pycache__/test_workflow.cpython-312-pytest-9.0.2.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5428c57cf0774720a8cdb0e95fb271b7d7b7fa12 GIT binary patch literal 9084 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

R{Y@`~Nj>$8E~X+knkuq6 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 E1>Z#J^#A|> literal 0 HcmV?d00001 diff --git a/tests/test_configuration.py b/tests/test_configuration.py new file mode 100644 index 0000000..80fe5ae --- /dev/null +++ b/tests/test_configuration.py @@ -0,0 +1,179 @@ +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() diff --git a/tests/test_health_http.py b/tests/test_health_http.py new file mode 100644 index 0000000..7c35f76 --- /dev/null +++ b/tests/test_health_http.py @@ -0,0 +1,219 @@ +import asyncio +import json +import unittest +from typing import Any + +from plba.health import ( + HealthAggregator, + HealthComponent, + HealthExpectation, + HealthInput, + HealthInputInvalid, + HealthContributorRegistry, + RuntimeHealthInputProvider, +) +from plba.http import ControlApi +from plba.runtime import ApplicationLifecycle, ApplicationRuntime, RuntimeContext +from plba.runtime.worker import ( + ComponentHealth, + HealthStatus, + WorkerConfig, + WorkerDefinition, + WorkerRegistry, + WorkerSupervisor, +) + + +class StaticHealthProvider: + def __init__(self, health_input: HealthInput) -> None: + self.health_input = health_input + + async def read(self) -> HealthInput: + return self.health_input + + +class EmptyWorkerConfigReader: + def get_worker_config(self, worker_name: str) -> WorkerConfig: + return WorkerConfig() + + +class HealthAggregationTests(unittest.IsolatedAsyncioTestCase): + async def test_missing_critical_and_noncritical_components_apply_priority(self) -> None: + health_input = HealthInput( + "service-a", + "running", + ( + HealthExpectation("required", True), + HealthExpectation("optional", False), + ), + ( + HealthComponent("degraded", HealthStatus.DEGRADED, True), + HealthComponent("optional-bad", HealthStatus.UNHEALTHY, False), + ), + ) + + report = await HealthAggregator(StaticHealthProvider(health_input)).aggregate() + + self.assertEqual(report.status, "unhealthy") + self.assertEqual( + {item.name: item.status for item in report.components}["required"], + HealthStatus.UNHEALTHY, + ) + self.assertEqual( + {item.name: item.status for item in report.components}["optional"], + HealthStatus.DEGRADED, + ) + + async def test_noncritical_unhealthy_is_capped_at_degraded(self) -> None: + health_input = HealthInput( + "service-a", + "running", + (), + (HealthComponent("cache", HealthStatus.UNHEALTHY, False),), + ) + + report = await HealthAggregator(StaticHealthProvider(health_input)).aggregate() + + self.assertEqual(report.status, "degraded") + self.assertEqual(report.components[0].status, HealthStatus.UNHEALTHY) + + async def test_lifecycle_controls_base_health_and_invalid_inputs_fail(self) -> None: + for lifecycle, expected in ( + ("new", "unhealthy"), + ("starting", "degraded"), + ("stopping", "degraded"), + ("failed", "unhealthy"), + ("stopped", "stopped"), + ): + report = await HealthAggregator( + StaticHealthProvider(HealthInput("service-a", lifecycle, (), ())) + ).aggregate() + self.assertEqual(report.status, expected) + + invalid = HealthInput( + "service-a", "running", (), (HealthComponent("bad", "unknown", True),) # type: ignore[arg-type] + ) + with self.assertRaises(HealthInputInvalid): + await HealthAggregator(StaticHealthProvider(invalid)).aggregate() + + async def test_disabled_worker_is_not_expected_before_application_start(self) -> None: + registry = WorkerRegistry() + + async def process() -> None: + return None + + registry.register(WorkerDefinition("disabled", process, critical=True)) + + class ConfigReader: + def get_worker_config(self, worker_name: str) -> WorkerConfig: + return WorkerConfig(disabled=True) + + supervisor = WorkerSupervisor(registry, ConfigReader()) + runtime = ApplicationRuntime(RuntimeContext("service-a"), supervisor) + provider = RuntimeHealthInputProvider(runtime, supervisor, HealthContributorRegistry()) + + report = await HealthAggregator(provider).aggregate() + + self.assertEqual(report.components, ()) + self.assertEqual(report.status, "unhealthy") + + +class ControlApiTests(unittest.IsolatedAsyncioTestCase): + async def asyncSetUp(self) -> None: + self.registry = WorkerRegistry() + self.supervisor = WorkerSupervisor(self.registry, EmptyWorkerConfigReader()) + self.runtime = ApplicationRuntime(RuntimeContext("service-http"), self.supervisor) + provider = RuntimeHealthInputProvider( + self.runtime, self.supervisor, HealthContributorRegistry() + ) + self.api = ControlApi(self.runtime, HealthAggregator(provider)) + + async def test_status_start_health_and_stop_routes(self) -> None: + status = await self.request("GET", "/runtime/status") + self.assertEqual(status[0], 200) + self.assertEqual(status[1], {"status": "new"}) + + started = await self.request("POST", "/runtime/start") + self.assertEqual(started[0], 200) + self.assertEqual(started[1], {"status": "running"}) + + health = await self.request("GET", "/health") + self.assertEqual(health[0], 200) + self.assertEqual(health[1]["application_id"], "service-http") + self.assertEqual(health[1]["status"], "ok") + + stopped = await self.request("POST", "/runtime/stop", b"{}") + self.assertEqual(stopped, (200, {"status": "stopped"})) + + async def test_invalid_stop_request_is_http_400(self) -> None: + missing = await self.request("POST", "/runtime/stop") + malformed = await self.request("POST", "/runtime/stop", b"not-json") + invalid_timeout = await self.request( + "POST", "/runtime/stop", b'{"timeout_seconds": 0}' + ) + null_timeout = await self.request( + "POST", "/runtime/stop", b'{"timeout_seconds": null}' + ) + + self.assertEqual(missing[0], 400) + self.assertEqual(malformed[0], 400) + self.assertEqual(invalid_timeout[0], 400) + self.assertEqual(null_timeout[0], 400) + + async def test_timeout_returns_202_while_worker_stop_continues(self) -> None: + active = asyncio.Event() + release = asyncio.Event() + + async def process() -> None: + active.set() + await release.wait() + + self.registry.register(WorkerDefinition("blocking", process)) + # A fresh supervisor/runtime picks up the worker registered above. + self.supervisor = WorkerSupervisor( + self.registry, + type("Reader", (), {"get_worker_config": lambda _self, _name: WorkerConfig(pause_seconds=1)})(), + ) + self.runtime = ApplicationRuntime(RuntimeContext("service-http"), self.supervisor) + provider = RuntimeHealthInputProvider( + self.runtime, self.supervisor, HealthContributorRegistry() + ) + self.api = ControlApi(self.runtime, HealthAggregator(provider)) + await self.runtime.start() + await asyncio.wait_for(active.wait(), timeout=1) + + result = await self.request( + "POST", "/runtime/stop", b'{"timeout_seconds": 0.01}' + ) + + self.assertEqual(result, (202, {"status": "stopping"})) + release.set() + await asyncio.wait_for(self._wait_until_stopped(), timeout=1) + + async def _wait_until_stopped(self) -> None: + while self.runtime.lifecycle is not ApplicationLifecycle.STOPPED: + await asyncio.sleep(0) + + async def request( + self, method: str, path: str, body: bytes = b"", query: bytes = b"" + ) -> tuple[int, dict[str, Any]]: + incoming = [{"type": "http.request", "body": body, "more_body": False}] + outgoing: list[dict[str, Any]] = [] + + async def receive() -> dict[str, Any]: + return incoming.pop(0) if incoming else {"type": "http.disconnect"} + + async def send(message: dict[str, Any]) -> None: + outgoing.append(message) + + await self.api( + {"type": "http", "method": method, "path": path, "query_string": query}, + receive, + send, + ) + response = json.loads(outgoing[-1]["body"]) + return outgoing[0]["status"], response + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_identity.py b/tests/test_identity.py new file mode 100644 index 0000000..754a568 --- /dev/null +++ b/tests/test_identity.py @@ -0,0 +1,54 @@ +from pathlib import Path +from tempfile import TemporaryDirectory +import unittest +from uuid import UUID + +from plba.runtime.application_identity import ( + ApplicationIdentityResolver, + TomlProjectNameReader, +) + + +class FixedProjectNameReader: + def __init__(self, name: str | None) -> None: + self.name = name + self.calls = 0 + + def read_project_name(self) -> str | None: + self.calls += 1 + return self.name + + +class ApplicationIdentityTests(unittest.TestCase): + def test_configured_identity_has_priority_and_is_unchanged(self) -> None: + reader = FixedProjectNameReader("project-name") + resolver = ApplicationIdentityResolver(reader) + + context = resolver.resolve(" custom-id ") + + self.assertEqual(context.application_id, " custom-id ") + self.assertEqual(reader.calls, 0) + + def test_project_name_is_fallback(self) -> None: + resolver = ApplicationIdentityResolver(FixedProjectNameReader("project-name")) + + self.assertEqual(resolver.resolve("").application_id, "project-name") + + def test_missing_project_metadata_uses_uuidv4(self) -> None: + expected = UUID("12345678-1234-4234-8234-123456789abc") + resolver = ApplicationIdentityResolver( + FixedProjectNameReader(None), uuid_factory=lambda: expected + ) + + self.assertEqual(resolver.resolve().application_id, str(expected)) + + def test_toml_reader_uses_project_name(self) -> None: + with TemporaryDirectory() as directory: + path = Path(directory) / "pyproject.toml" + path.write_text('[project]\nname = "demo-app"\n', encoding="utf-8") + + self.assertEqual(TomlProjectNameReader(path).read_project_name(), "demo-app") + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_observability.py b/tests/test_observability.py new file mode 100644 index 0000000..b1d246a --- /dev/null +++ b/tests/test_observability.py @@ -0,0 +1,130 @@ +import json +import logging +from datetime import datetime, timezone +from io import StringIO +import unittest +from uuid import UUID +from typing import Any + +from plba.logging import TechnicalJsonFormatter, create_stdout_handler +from plba.tracing import ( + BusinessTraceContext, + BusinessTraceMessage, + BusinessTraceWriteError, + PostgresBusinessTraceWriter, + business_trace_context, +) + + +class FakeTraceConnection: + def __init__(self, error: Exception | None = None) -> None: + self.calls: list[tuple[str, tuple[object, ...]]] = [] + self.error = error + + async def execute(self, query: str, *parameters: object) -> str: + self.calls.append((query, parameters)) + if self.error: + raise self.error + return "INSERT 0 1" + + +class FakeAcquire: + def __init__(self, connection: FakeTraceConnection) -> None: + self.connection = connection + + async def __aenter__(self) -> FakeTraceConnection: + return self.connection + + async def __aexit__(self, *_: object) -> None: + return None + + +class FakeTracePool: + def __init__(self, connection: FakeTraceConnection) -> None: + self.connection = connection + + def acquire(self) -> FakeAcquire: + return FakeAcquire(self.connection) + + +class BusinessTraceAdapterTests(unittest.IsolatedAsyncioTestCase): + async def test_adapter_adds_application_id_to_context_and_message(self) -> None: + connection = FakeTraceConnection() + writer = PostgresBusinessTraceWriter(FakeTracePool(connection), "orders", "app-42") + trace_id = UUID("12345678-1234-4234-8234-123456789abc") + event_time = datetime.now(timezone.utc) + + await writer.write_context( + BusinessTraceContext( + trace_id, "order", "create", event_time, {"application_id": "spoofed"} + ) + ) + await writer.write_message( + BusinessTraceMessage(trace_id, event_time, "reserve", "ok", "info", "stock reserved") + ) + + self.assertEqual(len(connection.calls), 2) + context_query, context_params = connection.calls[0] + message_query, message_params = connection.calls[1] + self.assertIn('"orders".trace_contexts', context_query) + self.assertIn('"orders".trace_messages', message_query) + self.assertEqual(json.loads(context_params[-1]), {"application_id": "app-42"}) + self.assertEqual(json.loads(message_params[-1]), {"application_id": "app-42"}) + + async def test_database_failure_is_passed_without_retry(self) -> None: + connection = FakeTraceConnection(RuntimeError("database unavailable")) + writer = PostgresBusinessTraceWriter(FakeTracePool(connection), "orders", "app-42") + trace_id = UUID("12345678-1234-4234-8234-123456789abc") + message = BusinessTraceMessage( + trace_id, datetime.now(timezone.utc), "step", "failed", "error", "failed" + ) + + with self.assertRaises(BusinessTraceWriteError): + await writer.write_message(message) + self.assertEqual(len(connection.calls), 1) + + +class TechnicalLoggingTests(unittest.TestCase): + def test_formatter_emits_contract_and_async_context_trace_id(self) -> None: + trace_id = UUID("12345678-1234-4234-8234-123456789abc") + stream = StringIO() + logger = logging.getLogger("plba.test.structured") + logger.handlers.clear() + logger.propagate = False + logger.setLevel(logging.INFO) + handler = logging.StreamHandler(stream) + handler.setFormatter(TechnicalJsonFormatter("app-42")) + logger.addHandler(handler) + try: + with business_trace_context(trace_id): + logger.info("reservation completed", extra={"attributes": {"order_id": 81}}) + logger.info("outside trace") + finally: + logger.removeHandler(handler) + + records = [json.loads(line) for line in stream.getvalue().splitlines()] + self.assertEqual( + set(records[0]), + { + "timestamp", + "level", + "logger", + "message", + "application_id", + "attributes", + "business_trace_id", + }, + ) + self.assertTrue(records[0]["timestamp"].endswith("Z")) + self.assertEqual(records[0]["application_id"], "app-42") + self.assertEqual(records[0]["business_trace_id"], str(trace_id)) + self.assertNotIn("business_trace_id", records[1]) + + def test_stdout_helper_uses_a_standard_stream_handler(self) -> None: + handler = create_stdout_handler("app-42", StringIO()) + self.assertIsInstance(handler, logging.StreamHandler) + self.assertIsInstance(handler.formatter, TechnicalJsonFormatter) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_runtime.py b/tests/test_runtime.py new file mode 100644 index 0000000..557fca5 --- /dev/null +++ b/tests/test_runtime.py @@ -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() diff --git a/tests/test_settings.py b/tests/test_settings.py new file mode 100644 index 0000000..66419ec --- /dev/null +++ b/tests/test_settings.py @@ -0,0 +1,108 @@ +from collections.abc import Mapping +from typing import Any +import unittest + +from plba.settings import ( + PostgresSettingsRepository, + SettingInvalidError, + SettingKey, + SettingNotFoundError, + SettingsDatabaseUnavailableError, + SettingsReader, +) + + +class FakeSettingsRepository: + def __init__(self, values: list[str]) -> None: + self.values = values + self.calls: list[tuple[str, str | None]] = [] + + async def fetch_values(self, setting_key: str, config_key: str | None = None) -> list[str]: + self.calls.append((setting_key, config_key)) + return list(self.values) + + +class FakeConnection: + def __init__(self, rows: list[Mapping[str, Any]] | None = None, error: Exception | None = None) -> None: + self.rows = rows or [] + self.error = error + self.query: str | None = None + self.parameters: tuple[object, ...] = () + + async def fetch(self, query: str, *parameters: object) -> list[Mapping[str, Any]]: + self.query = query + self.parameters = parameters + if self.error: + raise self.error + return self.rows + + +class FakeAcquire: + def __init__(self, connection: FakeConnection) -> None: + self.connection = connection + + async def __aenter__(self) -> FakeConnection: + return self.connection + + async def __aexit__(self, *_: object) -> None: + return None + + +class FakePool: + def __init__(self, connection: FakeConnection) -> None: + self.connection = connection + + def acquire(self) -> FakeAcquire: + return FakeAcquire(self.connection) + + +class SettingsReaderTests(unittest.IsolatedAsyncioTestCase): + async def test_reader_decodes_all_values_in_repository_order(self) -> None: + repository = FakeSettingsRepository(["4", "9"]) + reader = SettingsReader(repository) + key: SettingKey[int] = SettingKey("retry_count", int) + + values = await reader.read(key, config_key="orders") + + self.assertEqual(values, [4, 9]) + self.assertEqual(repository.calls, [("retry_count", "orders")]) + + async def test_reader_uses_optional_default_and_reports_missing_required(self) -> None: + reader = SettingsReader(FakeSettingsRepository([])) + optional: SettingKey[int] = SettingKey("limit", int, required=False, default=20) + + self.assertEqual(await reader.read(optional), [20]) + with self.assertRaises(SettingNotFoundError): + await reader.read(SettingKey("required", int)) + + async def test_reader_exposes_decoder_failure(self) -> None: + reader = SettingsReader(FakeSettingsRepository(["bad-value"])) + with self.assertRaises(SettingInvalidError) as raised: + await reader.read(SettingKey("limit", int)) + self.assertIsInstance(raised.exception.__cause__, ValueError) + + async def test_postgres_adapter_parameterizes_filters_and_orders(self) -> None: + connection = FakeConnection([{"setting_value": "first"}, {"setting_value": "second"}]) + repository = PostgresSettingsRepository(FakePool(connection), "app_data") + + values = await repository.fetch_values("theme", "north") + + self.assertEqual(values, ["first", "second"]) + self.assertIn('"app_data".settings', connection.query or "") + self.assertIn("ORDER BY sort_order ASC, id ASC", connection.query or "") + self.assertEqual(connection.parameters, ("theme", "north")) + self.assertNotIn("theme", connection.query or "") + + async def test_postgres_adapter_rejects_unsafe_schema_and_wraps_db_errors(self) -> None: + with self.assertRaises(ValueError): + PostgresSettingsRepository(FakePool(FakeConnection()), 'data"; DROP TABLE settings;--') + repository = PostgresSettingsRepository( + FakePool(FakeConnection(error=RuntimeError("connection failed"))), "app_data" + ) + with self.assertRaises(SettingsDatabaseUnavailableError) as raised: + await repository.fetch_values("theme") + self.assertIsInstance(raised.exception.__cause__, RuntimeError) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_workflow.py b/tests/test_workflow.py new file mode 100644 index 0000000..f90f460 --- /dev/null +++ b/tests/test_workflow.py @@ -0,0 +1,128 @@ +import unittest +from typing import Any + +from plba.workflow import ( + StepResult, + WorkflowContext, + WorkflowDefinition, + WorkflowEngine, + WorkflowNode, + WorkflowTransitionError, +) + + +class MemoryPersistence: + def __init__(self) -> None: + self.events: list[tuple[str, str, dict[str, Any]]] = [] + + async def record_run_started(self, run_id: str, workflow_name: str, context: WorkflowContext) -> None: + self.events.append(("run_started", workflow_name, dict(context.state))) + + async def record_step_started(self, run_id: str, step_name: str, context: WorkflowContext) -> None: + self.events.append(("step_started", step_name, dict(context.state))) + + async def record_step_completed( + self, run_id: str, step_name: str, context: WorkflowContext, result: StepResult + ) -> None: + self.events.append(("step_completed", step_name, dict(context.state))) + + async def record_step_failed( + self, run_id: str, step_name: str, context: WorkflowContext, error: BaseException + ) -> None: + self.events.append(("step_failed", step_name, dict(context.state))) + + async def record_run_completed( + self, run_id: str, workflow_name: str, context: WorkflowContext, status: str + ) -> None: + self.events.append(("run_completed", workflow_name, dict(context.state))) + + async def record_run_failed( + self, run_id: str, workflow_name: str, context: WorkflowContext, error: BaseException + ) -> None: + self.events.append(("run_failed", workflow_name, dict(context.state))) + + +class WorkflowEngineTests(unittest.IsolatedAsyncioTestCase): + async def test_named_steps_follow_only_declared_transitions(self) -> None: + persistence = MemoryPersistence() + + async def first(context: WorkflowContext) -> StepResult: + self.assertEqual(dict(context.state), {}) + return StepResult(transition="continue", updates={"count": 1}) + + async def second(context: WorkflowContext) -> StepResult: + self.assertEqual(context.state["count"], 1) + return StepResult(updates={"done": True}) + + definition = WorkflowDefinition( + name="inventory_sync", + initial_step="load", + nodes={ + "load": WorkflowNode(first, {"continue": "save"}), + "save": WorkflowNode(second), + }, + ) + + result = await WorkflowEngine(persistence).run(definition, WorkflowContext()) + + self.assertEqual(result.status, "completed") + self.assertEqual(dict(result.context.state), {"count": 1, "done": True}) + self.assertEqual( + [event[0] for event in persistence.events], + [ + "run_started", + "step_started", + "step_completed", + "step_started", + "step_completed", + "run_completed", + ], + ) + self.assertEqual(persistence.events[0][2], {}) + self.assertEqual(persistence.events[-1][2], {"count": 1, "done": True}) + + async def test_step_error_is_persisted_and_original_exception_propagates(self) -> None: + persistence = MemoryPersistence() + error = RuntimeError("step failed") + later_called = False + + async def fail(_: WorkflowContext) -> StepResult: + raise error + + async def later(_: WorkflowContext) -> StepResult: + nonlocal later_called + later_called = True + return StepResult() + + definition = WorkflowDefinition( + "failure_case", + "first", + {"first": WorkflowNode(fail, {"next": "later"}), "later": WorkflowNode(later)}, + ) + + with self.assertRaises(RuntimeError) as raised: + await WorkflowEngine(persistence).run(definition, WorkflowContext()) + + self.assertIs(raised.exception, error) + self.assertFalse(later_called) + self.assertEqual([event[0] for event in persistence.events][-2:], ["step_failed", "run_failed"]) + + async def test_undeclared_transition_fails_without_running_target(self) -> None: + persistence = MemoryPersistence() + + async def choose_unknown(_: WorkflowContext) -> StepResult: + return StepResult(transition="unknown") + + definition = WorkflowDefinition( + "invalid_transition", + "first", + {"first": WorkflowNode(choose_unknown), "later": WorkflowNode(choose_unknown)}, + ) + + with self.assertRaises(WorkflowTransitionError): + await WorkflowEngine(persistence).run(definition, WorkflowContext()) + self.assertEqual([event[0] for event in persistence.events][-2:], ["step_failed", "run_failed"]) + + +if __name__ == "__main__": + unittest.main()