python-ddd-framework 0.4.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

python_ddd_framework/application/runtime.py

@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 import asyncio
+from collections.abc import Awaitable, Callable, Iterable
+from functools import partial
 from typing import Never
 from uuid import UUID
 
@@ -155,27 +157,25 @@ class Application:
 
     async def _stop_runtimes(self, reason: ShutdownReason) -> tuple[BaseException, ...]:
         failures: list[BaseException] = []
-        # 先统一关闭外部准入，再逆序排空依赖；一个能力失败不能阻止其余能力释放资源。
-        # stop 只交给触达过 start 的参与者；预启动入口已接受的资源由独立 drain 收口。
+        # 每个阶段都是全局屏障；收尾与排空完成前，不释放任何参与者的依赖资源。
+        # 用户钩子只交给触达过 start 的参与者；预启动请求仍由独立 drain 收口。
         participants = tuple(reversed(self._root.touched_runtimes))
-        for participant in participants:
-            if participant.close_admission is not None:
-                try:
-                    participant.close_admission()
-                except BaseException as error:
-                    failures.append(error)
-        for participant in participants:
-            try:
-                failures.extend(await participant.stop(reason))
-            except BaseException as error:
-                failures.append(error)
+        failures.extend(_call_shutdown_callbacks(item.quiesce for item in participants))
+        failures.extend(
+            await _await_shutdown_callbacks(
+                partial(item.stopping, reason) for item in participants if item.stopping is not None
+            )
+        )
+        failures.extend(_call_shutdown_callbacks(item.close_admission for item in participants))
+        failures.extend(
+            await _await_shutdown_callbacks(
+                item.drain for item in reversed(self._root.runtimes) if item.drain is not None
+            )
+        )
+        failures.extend(
+            await _await_shutdown_callbacks(partial(item.stop, reason) for item in participants)
+        )
         self._root.touched_runtimes.clear()
-        for participant in reversed(self._root.runtimes):
-            if participant.drain is not None:
-                try:
-                    await participant.drain()
-                except BaseException as error:
-                    failures.append(error)
         return tuple(failures)
 
     async def stop(self) -> None:
@@ -352,3 +352,30 @@ class Application:
                 if not watcher.done():
                     watcher.cancel()
             await asyncio.gather(*watchers, return_exceptions=True)
+
+
+def _call_shutdown_callbacks(
+    callbacks: Iterable[Callable[[], None] | None],
+) -> tuple[BaseException, ...]:
+    failures: list[BaseException] = []
+    for callback in callbacks:
+        if callback is not None:
+            try:
+                callback()
+            except BaseException as error:
+                failures.append(error)
+    return tuple(failures)
+
+
+async def _await_shutdown_callbacks(
+    callbacks: Iterable[Callable[[], Awaitable[tuple[BaseException, ...] | None]]],
+) -> tuple[BaseException, ...]:
+    failures: list[BaseException] = []
+    for callback in callbacks:
+        try:
+            result = await callback()
+            if result is not None:
+                failures.extend(result)
+        except BaseException as error:
+            failures.append(error)
+    return tuple(failures)

python_ddd_framework/application_services/bindings.py

@@ -9,15 +9,12 @@ from typing import get_origin
 from dishka import (
     DEFAULT_COMPONENT,
     DependencyKey,
-    Provider,
     Scope,
 )
 
 from ..diagnostics import SourceLocation
 from ..modularity import ModuleRegistry
 from ..services.arbitration import (
-    _ArbitrationResult,
-    _provider_with_active_sources,
     _RegistrationDraft,
 )
 from ..services.native_graph import _NativeServiceGraph
@@ -201,64 +198,3 @@ def _validate_application_service_bindings(
                     "or private implementation binding"
                 ),
             )
-
-
-def _runtime_providers(
-    arbitration: _ArbitrationResult,
-    services: tuple[_BoundApplicationService, ...],
-) -> tuple[Provider, ...]:
-    """仅重定位 Application Service factories；其他 Dishka provider 保持原生形状。"""
-
-    related_draft_ids = frozenset(
-        draft_id for service in services for draft_id in service.related_draft_ids
-    )
-    drafts_by_entry: dict[int, list[_RegistrationDraft]] = {}
-    for draft in arbitration.drafts:
-        drafts_by_entry.setdefault(draft.entry.entry_id, []).append(draft)
-
-    providers: list[Provider] = []
-    for entry in arbitration.ordered_entries:
-        entry_drafts = drafts_by_entry[entry.entry_id]
-        active = tuple(
-            draft
-            for draft in entry_drafts
-            if draft.decision is not RegistrationDecision.BACKED_OFF
-            and id(draft) not in related_draft_ids
-        )
-        if not active:
-            continue
-        if len(active) == len(entry_drafts):
-            providers.append(entry.contribution.provider)
-        else:
-            providers.append(_provider_with_active_sources(entry.contribution.provider, active))
-
-    # default component 只发布 REQUEST proxy；ACTION implementation 统一藏入框架私有 component。
-    implementation_provider = Provider(component=_APPLICATION_SERVICE_COMPONENT)
-    for service in services:
-        winner = service.winner
-        assert winner.factory is not None
-        # internal contributor 被 override 时仍以原声明 key 调度；
-        # winner class 只是实现事实，不能改写契约 key。
-        contract = (
-            service.binding.discovery.definition.contract or service.binding.discovery.service_type
-        )
-        implementation_provider.factories.append(
-            winner.factory.replace(
-                dependencies=tuple(
-                    dependency.with_component(DEFAULT_COMPONENT)
-                    for dependency in winner.factory.dependencies
-                ),
-                kw_dependencies={
-                    name: dependency.with_component(DEFAULT_COMPONENT)
-                    for name, dependency in winner.factory.kw_dependencies.items()
-                },
-                provides=DependencyKey(contract, None),
-                when_override=None,
-                when_component=DEFAULT_COMPONENT,
-            )
-        )
-        # ServiceCatalog 的 accepted row 必须描述 relocated native binding，而非旧 default key。
-        winner.key = DependencyKey(contract, _APPLICATION_SERVICE_COMPONENT)
-    if services:
-        providers.append(implementation_provider)
-    return tuple(providers)

python_ddd_framework/application_services/dispatcher.py

@@ -13,6 +13,7 @@ from dishka import AsyncContainer
 from ..invocation.dispatcher import _MethodDispatcher
 from ..invocation.execution import _InterceptorPipeline
 from ..invocation.methods import _CompiledMethod
+from ..invocation.runtime import _current_task, _InvocationRuntime
 from ..settings.provider import SettingProvider
 from .catalog import (
     _APPLICATION_SERVICE_COMPONENT,
@@ -22,7 +23,6 @@ from .contracts import ApplicationService
 from .errors import (
     CrossTaskInvocationError,
 )
-from .invocation import _current_task, _InvocationRuntime
 
 
 @dataclass(slots=True)