python-ddd-framework 0.7.3__py3-none-any.whl → 0.9.0__py3-none-any.whl

python_ddd_framework/settings/refresh.py

@@ -1,140 +0,0 @@
-"""单进程 Settings 刷新 owner：合并读取、串行应用、失败后按周期重试。"""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-from contextlib import suppress
-from dataclasses import dataclass
-from typing import Any, ClassVar
-
-from pydantic import ConfigDict, Field
-
-from ..hosted_services import HostedService, HostedServiceContext
-from ..invocation.runtime import _InvocationRuntime
-from ..lifecycle import ShutdownReason
-from ..observability.context import capture_trace_context, invocation_span
-from ..options import BaseOptions, Options
-from .contracts import SettingDefinition
-from .handlers import SettingApplicationStatus, SettingHandler
-from .provider import SettingProvider
-from .values import SettingSnapshot, SettingValueSource
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class SettingsRefreshOptions(BaseOptions):
-    model_config = ConfigDict(extra="forbid")
-
-    reconciliation_interval_seconds: float = Field(default=30.0, gt=0)
-
-
-@dataclass(slots=True)
-class _ApplicationRecord:
-    handler: SettingHandler[Any]
-    last_applied: SettingSnapshot[Any] | None = None
-    error_type: str | None = None
-
-
-class SettingsRefreshRuntime(HostedService):
-    run_in_background_processes: ClassVar[bool] = True
-
-    def __init__(
-        self,
-        settings: SettingProvider,
-        options: Options[SettingsRefreshOptions],
-        runtime: _InvocationRuntime,
-    ) -> None:
-        self._settings = settings
-        self._options = options.value
-        self._runtime = runtime
-        self._definitions: dict[str, SettingDefinition[Any]] = {}
-        self._records: dict[str, list[_ApplicationRecord]] = {}
-        self._dirty: dict[str, dict[str, str]] = {}
-        self._wakeup = asyncio.Event()
-        self._task: asyncio.Task[None] | None = None
-
-    def _register(self, definition: SettingDefinition[Any], handler: SettingHandler[Any]) -> None:
-        self._definitions[definition.name] = definition
-        self._records.setdefault(definition.name, []).append(_ApplicationRecord(handler))
-
-    def request_refresh(self, name: str | None = None) -> None:
-        if name is None:
-            for key in self._definitions:
-                self._dirty.setdefault(key, {})
-        elif name in self._definitions:
-            self._dirty[name] = capture_trace_context(self._runtime.tracer)
-        if self._dirty:
-            self._wakeup.set()
-
-    @property
-    def statuses(self) -> tuple[SettingApplicationStatus, ...]:
-        return tuple(
-            SettingApplicationStatus(
-                name,
-                f"{type(record.handler).__module__}.{type(record.handler).__qualname__}",
-                record.last_applied,
-                record.error_type,
-            )
-            for name, records in self._records.items()
-            for record in records
-        )
-
-    async def start(self, context: HostedServiceContext) -> None:
-        self.request_refresh()
-        self._task = asyncio.create_task(self._run(), name=context.name)
-
-    async def stop(self, reason: ShutdownReason) -> None:
-        if self._task is not None:
-            self._task.cancel()
-            with suppress(asyncio.CancelledError):
-                await self._task
-
-    async def _run(self) -> None:
-        if not self._definitions:
-            await asyncio.Future[None]()
-        while True:
-            try:
-                await asyncio.wait_for(
-                    self._wakeup.wait(), timeout=self._options.reconciliation_interval_seconds
-                )
-            except TimeoutError:
-                self.request_refresh()
-            # 取走本轮名字后立即清理；await 期间到达的新请求进入下一轮，不能被误清除。
-            requests = tuple(self._dirty.items())
-            self._dirty.clear()
-            self._wakeup.clear()
-            for name, carrier in requests:
-                with invocation_span(
-                    self._runtime.tracer, f"refresh setting {name}", carrier=carrier
-                ):
-                    await self._refresh(name)
-
-    async def _refresh(self, name: str) -> None:
-        try:
-            latest = await self._settings.snapshot(self._definitions[name])
-        except Exception as error:
-            for record in self._records[name]:
-                record.error_type = type(error).__name__
-            _LOGGER.error("Settings refresh failed for %s: %s", name, type(error).__name__)
-            return
-        for record in self._records[name]:
-            previous = record.last_applied
-            if (
-                previous is not None
-                and record.error_type is None
-                and previous.value == latest.value
-                and (previous.source is SettingValueSource.UNSET)
-                == (latest.source is SettingValueSource.UNSET)
-            ):
-                continue
-            try:
-                with invocation_span(self._runtime.tracer, f"apply setting {name}"):
-                    await record.handler.apply(latest)
-            except Exception as error:
-                # 失败不能覆盖成功记录，下一次校对仍会按最后成功应用的值决定重试。
-                record.error_type = type(error).__name__
-                _LOGGER.error("Settings handler failed for %s: %s", name, record.error_type)
-            else:
-                record.last_applied = latest
-                record.error_type = None

python_ddd_framework/settings/refresh_module.py

@@ -1,52 +0,0 @@
-"""只组装正式 handler 与刷新运行时；组件应用规则由 handler 自己拥有。"""
-
-from __future__ import annotations
-
-from dishka import DEFAULT_COMPONENT, DependencyKey
-
-from python_ddd_framework import ConfigureContext
-
-from ..hosted_services.declarations import HostedServices
-from ..lifecycle import PreInitializeContext, ShutdownContext
-from ..modularity import AppModule, ModuleRef
-from .catalog import SettingCatalog
-from .manager import SettingManager
-from .module import SettingsModule
-from .refresh import SettingsRefreshOptions, SettingsRefreshRuntime
-
-
-class SettingsRefreshModule(AppModule):
-    dependencies = (
-        SettingsModule,
-        ModuleRef("python_ddd_framework.hosted_services.module:HostedServicesModule"),
-    )
-
-    def __init__(self) -> None:
-        self._manager: SettingManager | None = None
-
-    def configure(self, context: ConfigureContext) -> None:
-        context.configure(SettingsRefreshOptions, section="settings_refresh")
-
-    hosted_services = HostedServices((SettingsRefreshRuntime,))
-
-    async def pre_initialize(self, context: PreInitializeContext) -> None:
-        catalog = await context.container.get(SettingCatalog)
-        refresh = await context.container.get(SettingsRefreshRuntime)
-        for definition in catalog.handlers:
-            handler = await context.container.get(definition.handler_type)
-            refresh._register(definition.setting, handler)
-        # Manager 固定归 APP；查询最终原生图，含 alias，不构造服务或维护第二清单。
-        # 无存储仍应用只读值；已注册服务由原生 get 解析，构造失败不能降级。
-        if (
-            context.container.registry.get_factory(DependencyKey(SettingManager, DEFAULT_COMPONENT))
-            is not None
-        ):
-            settings = await context.container.get(SettingManager)
-            settings._refresh = refresh
-            self._manager = settings
-
-    async def shutdown(self, context: ShutdownContext) -> None:
-        # 只解除本实例完成的接线；启动部分失败后的关闭不得重新构造依赖。
-        if self._manager is not None:
-            self._manager._refresh = None
-            self._manager = None