python-ddd-framework 0.3.2__py3-none-any.whl → 0.5.1__py3-none-any.whl

python_ddd_framework/application_services/dispatcher.py

@@ -3,54 +3,26 @@
 from __future__ import annotations
 
 import asyncio
-import logging
-import time
 from collections.abc import Awaitable, Callable
 from contextvars import ContextVar
 from dataclasses import dataclass
-from datetime import UTC, datetime
-from typing import TYPE_CHECKING, cast
-from uuid import uuid4
+from typing import cast
 
 from dishka import AsyncContainer
-from dishka.exceptions import NoFactoryError
 
-from ..auditing import ApplicationServiceAuditRecord, AuditSink
-from ..auditing.control import AuditingControl, AuditingOptions
-from ..authorization import PermissionChecker
-from ..authorization.contracts import _AuthorizationRequirement
-from ..authorization.errors import (
-    PermissionCheckerUnavailableError,
-    PermissionDeniedError,
-    UnauthenticatedError,
-)
-from ..observability.context import invocation_span
-from ..options import Options
+from ..invocation.dispatcher import _MethodDispatcher
+from ..invocation.execution import _InterceptorPipeline
+from ..invocation.methods import _CompiledMethod
 from ..settings.provider import SettingProvider
-from ..unit_of_work import UnitOfWorkManager
 from .catalog import (
     _APPLICATION_SERVICE_COMPONENT,
-    ApplicationServiceCatalog,
-    ApplicationServiceRegistration,
     _CompiledApplicationService,
-    _CompiledMethod,
 )
 from .contracts import ApplicationService
 from .errors import (
-    ApplicationServiceValidationError,
-    ApplicationServiceValidationIssue,
     CrossTaskInvocationError,
-    NestedConnectionError,
 )
-from .execution import _InterceptorPipeline
-from .interceptors import InterceptionStage
 from .invocation import _current_task, _InvocationRuntime
-from .validation import _validate_arguments
-
-_LOGGER = logging.getLogger(__name__)
-
-if TYPE_CHECKING:
-    pass
 
 
 @dataclass(slots=True)
@@ -61,7 +33,6 @@ class _HttpInvocationState:
     pipeline: _InterceptorPipeline
     consumed: bool = False
     is_short_circuited: Callable[[], bool] = lambda: False
-    defer_audit: Callable[[Callable[[BaseException | None], Awaitable[None]]], None] | None = None
 
 
 class _ApplicationServiceProxy:
@@ -88,20 +59,17 @@ class _ApplicationServiceProxy:
         return invoke
 
 
-class _ApplicationServiceDispatcher:
-    """所有 caller 共用的 validation、ownership、UoW 与 event 顺序 owner。"""
+class _ApplicationServiceDispatcher(_MethodDispatcher):
+    """应用服务的 HTTP 许可与 REQUEST 到 ACTION 实例桥接。"""
 
-    __slots__ = ("_catalog", "_container", "_http_boundary", "_runtime")
+    __slots__ = ("_http_boundary",)
 
     def __init__(
         self,
         container: AsyncContainer,
         runtime: _InvocationRuntime,
-        catalog: ApplicationServiceCatalog,
     ) -> None:
-        self._container = container
-        self._runtime = runtime
-        self._catalog = catalog
+        super().__init__(container, runtime)
         self._http_boundary: ContextVar[_HttpInvocationState | None] = ContextVar(
             f"python_ddd_framework_http_invocation_{runtime.application_id}_{id(self)}",
             default=None,
@@ -117,62 +85,11 @@ class _ApplicationServiceDispatcher:
         pipeline = _InterceptorPipeline(method.descriptor, method.interceptor_steps, args, kwargs)
         async with self._runtime.outer_lease():
             return await self._invoke_entry(
-                service,
                 method,
                 pipeline,
                 lambda: self._invoke_after_authorization(service, method, pipeline),
             )
 
-    async def _invoke_entry(
-        self,
-        service: _CompiledApplicationService,
-        method: _CompiledMethod,
-        pipeline: _InterceptorPipeline,
-        callback: Callable[[], Awaitable[object]],
-    ) -> object:
-        async def authorize() -> object:
-            if not service.registration.is_integration_service:
-                await self._authorize(method.authorization)
-            return await callback()
-
-        async def audit() -> object:
-            occurred_at = datetime.now(UTC)
-            started_ns = time.perf_counter_ns()
-            failure: BaseException | None = None
-            try:
-                return await pipeline.run(
-                    InterceptionStage.AUTHORIZATION, self._container, authorize
-                )
-            except BaseException as error:
-                failure = error
-                raise
-            finally:
-
-                async def write(final_failure: BaseException | None) -> None:
-                    await self._write_audit(
-                        service.registration,
-                        method,
-                        occurred_at=occurred_at,
-                        duration_ns=time.perf_counter_ns() - started_ns,
-                        failure=final_failure,
-                    )
-
-                boundary = self._http_boundary.get()
-                if (
-                    boundary is not None
-                    and boundary.pipeline is pipeline
-                    and boundary.defer_audit is not None
-                ):
-                    boundary.defer_audit(write)
-                else:
-                    await write(failure)
-
-        async def trace() -> object:
-            with invocation_span(self._runtime.tracer, method.contract_method.__qualname__):
-                return await pipeline.run(InterceptionStage.AUDITING, self._container, audit)
-
-        return await pipeline.run(InterceptionStage.TRACING, self._container, trace)
-
     async def invoke_http_request(
         self,
         service: _CompiledApplicationService,
@@ -190,7 +107,6 @@ class _ApplicationServiceDispatcher:
             pipeline = _InterceptorPipeline(method.descriptor, method.interceptor_steps, (), {})
             state = _HttpInvocationState(service, method, _current_task(), pipeline)
             state.is_short_circuited = is_short_circuited
-            state.defer_audit = defer_audit
             token = self._http_boundary.set(state)
 
             async def invoke_endpoint() -> object:
@@ -201,7 +117,9 @@ class _ApplicationServiceDispatcher:
                 return result
 
             try:
-                return await self._invoke_entry(service, method, pipeline, invoke_endpoint)
+                return await self._invoke_entry(
+                    method, pipeline, invoke_endpoint, defer_audit=defer_audit
+                )
             finally:
                 self._http_boundary.reset(token)
 
@@ -230,188 +148,20 @@ class _ApplicationServiceDispatcher:
         method: _CompiledMethod,
         pipeline: _InterceptorPipeline,
     ) -> object:
-        async def validate() -> object:
-            await self._validate_pipeline(service.registration, method, pipeline)
-            return await pipeline.run(
-                InterceptionStage.UNIT_OF_WORK,
-                self._container,
-                lambda: self._invoke_work(service.registration, method, pipeline),
-            )
-
-        return await pipeline.run(InterceptionStage.VALIDATION, self._container, validate)
-
-    @staticmethod
-    async def _validate_pipeline(
-        registration: ApplicationServiceRegistration,
-        method: _CompiledMethod,
-        pipeline: _InterceptorPipeline,
-    ) -> None:
-        arguments = pipeline.arguments
-        if not arguments.needs_validation:
-            return
-        if method.descriptor.validation_enabled:
-            arguments.args, arguments.kwargs = await _validate_arguments(
-                method, registration, arguments.args, arguments.kwargs
-            )
-        else:
-            # 可选类型验证关闭后，必需参数与参数名仍属于公开调用契约。
-            try:
-                method.signature.bind(None, *arguments.args, **arguments.kwargs)
-            except TypeError:
-                raise ApplicationServiceValidationError(
-                    service=registration.contract,
-                    method_name=method.name,
-                    issues=(
-                        ApplicationServiceValidationIssue(
-                            location=(), error_type="arguments", message="Invalid method arguments"
-                        ),
-                    ),
-                ) from None
-        arguments.mark_validated()
-
-    async def _invoke_work(
-        self,
-        registration: ApplicationServiceRegistration,
-        method: _CompiledMethod,
-        pipeline: _InterceptorPipeline,
-    ) -> object:
-        ambient = self._runtime.current()
-        if ambient is not None:
-            if _current_task() is not ambient.owner_task:
-                raise CrossTaskInvocationError
-            if registration.connection_name != ambient.context.connection_name:
-                raise NestedConnectionError(
-                    outer=ambient.context.connection_name, requested=registration.connection_name
-                )
-            manager = await self._container.get(UnitOfWorkManager)
-
-            async def nested() -> object:
-                return await self._invoke_target(
-                    ambient.action_container, registration, method, pipeline
-                )
-
-            if method.descriptor.unit_of_work.disabled:
-                manager._check_current(registration.connection_name)
-                return await nested()
-            options = manager._resolve_options(
-                registration.connection_name, method.descriptor.unit_of_work, method.name
-            )
-            async with manager._begin(options) as work:
-                result = await nested()
-                await work.complete()
-                return result
-
-        async def invoke(action: AsyncContainer) -> object:
-            return await self._invoke_target(action, registration, method, pipeline)
-
-        return await self._runtime.run_action(
-            self._container,
-            connection_name=registration.connection_name,
-            callback=invoke,
-            declaration=method.descriptor.unit_of_work,
-            method_name=method.name,
-        )
-
-    async def _invoke_target(
-        self,
-        container: AsyncContainer,
-        registration: ApplicationServiceRegistration,
-        method: _CompiledMethod,
-        pipeline: _InterceptorPipeline,
-    ) -> object:
-        async def invoke() -> object:
-            # 位于验证之后的扩展可以改参数；目标调用不能使用修改前的验证结果。
-            await self._validate_pipeline(registration, method, pipeline)
+        async def target(
+            container: AsyncContainer, args: tuple[object, ...], kwargs: dict[str, object]
+        ) -> object:
             implementation = await container.get(
-                registration.contract, component=_APPLICATION_SERVICE_COMPONENT
+                service.registration.contract, component=_APPLICATION_SERVICE_COMPONENT
             )
-            # 实例已由当前 ACTION 容器取得，绑定只属于本 Application 的读取服务。
             cast(ApplicationService, implementation)._setting_provider = await container.get(
                 SettingProvider
             )
-            return await method.implementation_method(
-                implementation, *pipeline.arguments.args, **pipeline.arguments.kwargs
-            )
-
-        return await pipeline.run(InterceptionStage.METHOD, container, invoke)
-
-    async def _write_audit(
-        self,
-        registration: ApplicationServiceRegistration,
-        method: _CompiledMethod,
-        *,
-        occurred_at: datetime,
-        duration_ns: int,
-        failure: BaseException | None,
-    ) -> None:
-        options = (await self._container.get(Options[AuditingOptions])).value
-        control = await self._container.get(AuditingControl)
-        if (
-            not method.descriptor.auditing_enabled
-            or not options.is_enabled
-            or not control.is_enabled
-        ):
-            return
-        try:
-            sink = await self._container.get(AuditSink)
-        except NoFactoryError:
-            return
-        except Exception as audit_error:
-            _LOGGER.error(
-                "application service audit write failed",
-                exc_info=audit_error,
-                extra={
-                    "audit_exception_type": type(audit_error).__name__,
-                    "audit_contract": registration.contract.__qualname__,
-                    "audit_method": method.name,
-                },
-            )
-            return
-        try:
-            current_user = self._runtime.current_user()
-            correlation_id = self._runtime.correlation_id() or str(uuid4())
-            await sink.write_application_service(
-                ApplicationServiceAuditRecord(
-                    occurred_at=occurred_at,
-                    user_id=current_user.user_id,
-                    session_id=current_user.session_id,
-                    correlation_id=correlation_id,
-                    contract=(
-                        f"{registration.contract.__module__}.{registration.contract.__qualname__}"
-                    ),
-                    method=method.name,
-                    succeeded=failure is None,
-                    duration_ns=duration_ns,
-                    exception_type=None if failure is None else type(failure).__name__,
-                )
-            )
-        except Exception as audit_error:
-            # sink resolution/context/write 都属于独立观测边界；失败不能覆盖业务结果。
-            _LOGGER.error(
-                "application service audit write failed",
-                exc_info=audit_error,
-                extra={
-                    "audit_exception_type": type(audit_error).__name__,
-                    "audit_contract": registration.contract.__qualname__,
-                    "audit_method": method.name,
-                },
-            )
+            return await method.implementation_method(implementation, *args, **kwargs)
 
-    async def _authorize(self, requirement: _AuthorizationRequirement) -> None:
-        if requirement.allows_anonymous or not requirement.requires_authenticated_user:
-            return
-        current_user = self._runtime.current_user()
-        if not current_user.is_authenticated:
-            raise UnauthenticatedError
-        if not requirement.permissions:
-            return
-        try:
-            checker = await self._container.get(PermissionChecker)
-        except NoFactoryError:
-            raise PermissionCheckerUnavailableError from None
-        for permission in requirement.permissions:
-            if not await checker.is_granted(current_user, permission):
-                raise PermissionDeniedError(permission=str(permission))
+        return await self._invoke_validated(
+            method, pipeline, target, service.registration.connection_name
+        )
 
 
 def _proxy_factory(

python_ddd_framework/application_services/invocation.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import threading
 from collections.abc import AsyncIterator, Awaitable, Callable, Iterator
 from contextlib import asynccontextmanager, contextmanager
 from contextvars import ContextVar, Token
@@ -16,9 +17,9 @@ from dishka import AsyncContainer, Scope
 from ..authorization import CurrentUser
 from ..invocation import ApplicationInvocationContext
 from ..invocation.contracts import _is_safe_correlation_id
-from ..lifecycle import ApplicationState
+from ..lifecycle import ApplicationState, RuntimeParticipant, ShutdownReason
 from ..unit_of_work import UnitOfWork, UnitOfWorkManager
-from ..unit_of_work.options import UnitOfWorkDeclaration
+from ..unit_of_work.options import _DEFAULT_CONNECTION_NAME, UnitOfWorkDeclaration
 from .catalog import (
     ApplicationServiceCatalog,
 )
@@ -26,6 +27,7 @@ from .errors import (
     ApplicationInvocationCleanupError,
     ApplicationInvocationRejectedError,
     CrossTaskInvocationError,
+    NestedConnectionError,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -61,20 +63,40 @@ class _CallScope:
     owner_task: asyncio.Task[object]
 
 
+@dataclass(eq=False, slots=True)
+class _InvocationReservation:
+    """只携带准入事实，不携带 caller、DI scope 或事务；由接受工作的 owner 收口。"""
+
+    runtime: _InvocationRuntime
+    executing: bool = False
+
+
+@dataclass(eq=False, frozen=True, slots=True)
+class _StoppingPermission:
+    """单 Application、服务 owner 与单次收尾钩子的准入身份，不携带业务 scope。"""
+
+    runtime: _InvocationRuntime
+    owner: type[object]
+
+
 class _InvocationRuntime:
     """每个 Application 独占 admission 与 ContextVar，禁止进程级 current app。"""
 
     __slots__ = (
         "_active",
+        "_admission_lock",
         "_ambient",
         "_application_id",
         "_authenticating",
         "_call_scope",
         "_caller",
-        "_condition",
+        "_changed",
         "_http_method",
         "_is_accepting",
         "_lease",
+        "_loop",
+        "_permissions",
+        "_reservations",
         "_state_getter",
         "tracer",
     )
@@ -106,9 +128,13 @@ class _InvocationRuntime:
             f"python_ddd_framework_invocation_lease_{application_id}",
             default=None,
         )
-        self._condition = asyncio.Condition()
+        self._admission_lock = threading.RLock()
+        self._changed = asyncio.Event()
+        self._loop: asyncio.AbstractEventLoop | None = None
+        self._permissions: set[_StoppingPermission] = set()
         self._is_accepting = False
         self._active = 0
+        self._reservations: set[_InvocationReservation] = set()
         self._call_scope: ContextVar[_CallScope | None] = ContextVar(
             f"python_ddd_framework_call_scope_{application_id}",
             default=None,
@@ -155,12 +181,115 @@ class _InvocationRuntime:
         return self._application_id
 
     def start_accepting(self) -> None:
+        self._loop = asyncio.get_running_loop()
         self._is_accepting = True
 
-    async def stop_accepting_and_wait(self) -> None:
-        async with self._condition:
+    def runtime_participant(self) -> RuntimeParticipant:
+        async def start() -> None:
+            self.start_accepting()
+
+        async def stop(reason: ShutdownReason) -> tuple[BaseException, ...]:
+            self.close_admission()
+            return ()
+
+        return RuntimeParticipant(
+            start=start,
+            stop=stop,
+            quiesce=self.quiesce,
+            close_admission=self.close_admission,
+            drain=self.stop_accepting_and_wait,
+        )
+
+    def quiesce(self) -> None:
+        with self._admission_lock:
+            self._is_accepting = False
+
+    def close_admission(self) -> None:
+        with self._admission_lock:
             self._is_accepting = False
-            await self._condition.wait_for(lambda: self._active == 0)
+            self._permissions.clear()
+
+    def grant_stopping(self, owner: type[object]) -> _StoppingPermission:
+        with self._admission_lock:
+            if self._state_getter() not in (
+                ApplicationState.STOPPING,
+                ApplicationState.ROLLING_BACK,
+            ):
+                raise ApplicationInvocationRejectedError(reason="Not in the stopping phase")
+            permission = _StoppingPermission(self, owner)
+            self._permissions.add(permission)
+            return permission
+
+    def revoke_stopping(self, permission: _StoppingPermission) -> None:
+        with self._admission_lock:
+            self._permissions.discard(permission)
+
+    def require_stopping(self, permission: _StoppingPermission) -> None:
+        with self._admission_lock:
+            if permission.runtime is not self or permission not in self._permissions:
+                raise ApplicationInvocationRejectedError(reason="Invalid stopping permission")
+
+    async def stop_accepting_and_wait(self) -> None:
+        self.close_admission()
+        while True:
+            self._changed.clear()
+            with self._admission_lock:
+                if self._active == 0 and not self._reservations:
+                    return
+            await self._changed.wait()
+
+    def reserve(self, permission: _StoppingPermission | None = None) -> _InvocationReservation:
+        # SDK thread 与权限撤销在同一锁下线性化；已接受许可独立于钩子权限的寿命。
+        with self._admission_lock:
+            if permission is None:
+                self.require_accepting_work()
+            else:
+                self.require_stopping(permission)
+            reservation = _InvocationReservation(self)
+            self._reservations.add(reservation)
+            return reservation
+
+    def require_accepting_work(self) -> None:
+        if not self._is_accepting or self._state_getter() not in (
+            ApplicationState.STARTING,
+            ApplicationState.RUNNING,
+        ):
+            raise ApplicationInvocationRejectedError(reason="Application is not accepting work")
+
+    async def discard(self, reservation: _InvocationReservation) -> None:
+        self.release_reservation(reservation)
+
+    def release_reservation(self, reservation: _InvocationReservation) -> None:
+        with self._admission_lock:
+            if reservation.runtime is not self or reservation not in self._reservations:
+                raise ApplicationInvocationRejectedError(reason="Invalid or released reservation")
+            self._reservations.remove(reservation)
+        if self._loop is not None and not self._loop.is_closed():
+            try:
+                self._loop.call_soon_threadsafe(self._changed.set)
+            except RuntimeError:
+                # 外部 submit 可能在 loop 关闭竞争中退回许可；此时已无 loop 排空等待者。
+                if not self._loop.is_closed():
+                    raise
+
+    @asynccontextmanager
+    async def reserved_lease(self, reservation: _InvocationReservation) -> AsyncIterator[None]:
+        if (
+            reservation.runtime is not self
+            or reservation not in self._reservations
+            or reservation.executing
+            or self._lease.get() is not None
+            or self.current() is not None
+            or self.current_call_scope() is not None
+        ):
+            raise ApplicationInvocationRejectedError(reason="Invalid reservation execution owner")
+        reservation.executing = True
+        token = self._lease.set(_OuterInvocationLease(_current_task(), True))
+        try:
+            yield
+        finally:
+            self._lease.reset(token)
+            await self.discard(reservation)
 
     @asynccontextmanager
     async def outer_lease(self, *, allow_composed_request: bool = False) -> AsyncIterator[None]:
@@ -180,7 +309,7 @@ class _InvocationRuntime:
             yield
             return
 
-        async with self._condition:
+        with self._admission_lock:
             state = self._state_getter()
             # HostedService.start 可调用业务入口，但全部后台启动成功前 readiness 仍为 false。
             allows_invocation = self._is_accepting and state in (
@@ -200,11 +329,11 @@ class _InvocationRuntime:
             yield
         finally:
             self._lease.reset(token)
-            async with self._condition:
+            with self._admission_lock:
                 assert self._active > 0
                 self._active -= 1
                 if self._active == 0:
-                    self._condition.notify_all()
+                    self._changed.set()
 
     def current(self) -> _InvocationState | None:
         return self._ambient.get()
@@ -286,6 +415,30 @@ class _InvocationRuntime:
             self._caller.reset(caller_token)
             self._lease.reset(lease_token)
 
+    def context_for_action(self, container: AsyncContainer) -> ApplicationInvocationContext:
+        """由原生 ACTION factory 缓存上下文，DI 与调用管线共享同一身份。"""
+        # Dishka 1.10 的公开 context 属性已弃用；这里只读取原生 scope 的输入，
+        # 不写 context/cache，也不复制容器的解析或缓存。第三方字段访问集中于此。
+        native_context = container._context
+        if native_context is None or ApplicationInvocationContext not in native_context:
+            return self._new_context(_DEFAULT_CONNECTION_NAME)
+        supplied: object = native_context[ApplicationInvocationContext]
+        if not isinstance(supplied, ApplicationInvocationContext):
+            raise ApplicationInvocationRejectedError(reason="invalid ACTION invocation context")
+        if supplied.application_id != self.application_id:
+            raise ApplicationInvocationRejectedError(
+                reason="ACTION invocation context belongs to another Application"
+            )
+        return supplied
+
+    def _new_context(self, connection_name: str) -> ApplicationInvocationContext:
+        return ApplicationInvocationContext(
+            application_id=self.application_id,
+            invocation_id=uuid4(),
+            parent_invocation_id=None,
+            connection_name=connection_name,
+        )
+
     async def run_action(
         self,
         container: AsyncContainer,
@@ -294,14 +447,16 @@ class _InvocationRuntime:
         callback: Callable[[AsyncContainer], Awaitable[object]],
         declaration: UnitOfWorkDeclaration,
         method_name: str = "execute",
+        unit_of_work_enabled: bool = True,
     ) -> object:
         """执行 scope 独立于数据库 UoW；自动边界只完成自己创建或加入的工作。"""
-        context = ApplicationInvocationContext(
-            application_id=self.application_id,
-            invocation_id=uuid4(),
-            parent_invocation_id=None,
-            connection_name=connection_name,
+        context = (
+            await container.get(ApplicationInvocationContext)
+            if container.scope is Scope.ACTION
+            else self._new_context(connection_name)
         )
+        if context.connection_name != connection_name:
+            raise NestedConnectionError(outer=context.connection_name, requested=connection_name)
         work: UnitOfWork | None = None
         async with _managed_action(
             container, context, committed=lambda: work is not None and work.committed
@@ -309,6 +464,8 @@ class _InvocationRuntime:
             state = _InvocationState(context, _current_task(), action)
             token = self.bind(state)
             try:
+                if not unit_of_work_enabled:
+                    return await callback(action)
                 manager = await action.get(UnitOfWorkManager)
                 if declaration.disabled:
                     manager._check_current(connection_name)
@@ -322,6 +479,27 @@ class _InvocationRuntime:
                 self.reset(token)
 
 
+@asynccontextmanager
+async def _managed_request(parent: AsyncContainer) -> AsyncIterator[AsyncContainer]:
+    """排空入口自己创建的 REQUEST；不推断业务事务是否已经提交。"""
+    request = parent(scope=Scope.REQUEST)
+    primary: BaseException | None = None
+    try:
+        yield request
+    except BaseException as error:
+        primary = error
+    primary, failures = await _close_action(request, primary)
+    if failures:
+        # REQUEST 无事务 owner；保留业务原异常及已有 cause，不伪造 committed=False。
+        inherited = (primary.__cause__,) if primary is not None and primary.__cause__ else ()
+        cleanup = BaseExceptionGroup("REQUEST cleanup failed", (*inherited, *failures))
+        if primary is not None:
+            raise primary from cleanup
+        raise cleanup
+    if primary is not None:
+        raise primary
+
+
 @asynccontextmanager
 async def _managed_action(
     parent: AsyncContainer,
@@ -329,6 +507,10 @@ async def _managed_action(
     *,
     committed: Callable[[], bool],
 ) -> AsyncIterator[AsyncContainer]:
+    if parent.scope is Scope.ACTION:
+        # 普通服务可能已经由调用方的 ACTION 解析；资源仍由该 scope 的 owner 关闭。
+        yield parent
+        return
     action = parent(context={ApplicationInvocationContext: context}, scope=Scope.ACTION)
     primary: BaseException | None = None
     try: