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

python_ddd_framework/application/runtime.py

@@ -1,67 +1,31 @@
-"""公开 Application 状态机、生命周期与非 DI 调用入口。"""
+"""Application 状态、通用生命周期和容器所有权。"""
 
 from __future__ import annotations
 
 import asyncio
-from collections.abc import AsyncIterator, Awaitable, Callable, Iterator
-from contextlib import asynccontextmanager, contextmanager
-from typing import Concatenate, Never, ParamSpec, TypeAlias, TypeVar, cast
-from uuid import UUID, uuid4
-
-from dishka import AsyncContainer, Scope
-
-from ..application_services import (
-    ApplicationInvocationRejectedError,
-    ApplicationServiceCatalog,
-    ApplicationServiceContract,
-    ApplicationServiceRegistration,
-)
-from ..application_services.dispatcher import _ApplicationServiceDispatcher
-from ..application_services.invocation import (
-    _ScopedApplicationServiceInvoker,
-)
-from ..authorization import CurrentUser, PermissionCatalog
-from ..background_jobs import BackgroundJobCatalog
-from ..background_workers import BackgroundWorkerCatalog
-from ..caching import CacheCatalog
+from collections.abc import Awaitable, Callable, Iterable
+from functools import partial
+from typing import Never
+from uuid import UUID
+
+from dishka import AsyncContainer
+
 from ..configuration import ConfigurationRoot
 from ..diagnostics import DiagnosticSnapshot
 from ..errors import (
     ApplicationRuntimeError,
     ApplicationStartError,
-    ContainerCleanupError,
     InvalidApplicationStateError,
     LifecycleInvocationError,
 )
-from ..errors.lifecycle import (
-    _BackgroundExecutionStartFailure,
-    _exclude_runtime_failure,
-)
-from ..events import LocalEventCatalog
-from ..hosted_services import (
-    ApplicationReadinessSnapshot,
-    HostedServiceCatalog,
-    HostedServiceLifecycleError,
-)
-from ..invocation.function_runtime import _invoke_callable
+from ..errors.lifecycle import _exclude_runtime_failure
 from ..lifecycle import ApplicationState, ShutdownReason
 from ..modularity import ModuleRegistry
 from ..options import OptionsSnapshot
 from ..services import ServiceCatalog
-from ..settings import SettingCatalog
 from .runtime_hooks import _RuntimeLifecycle
 from .state import _ApplicationStateRoot
 
-_P = ParamSpec("_P")
-_R = TypeVar("_R")
-_TContract = TypeVar("_TContract", bound=ApplicationServiceContract)
-_StartCleanupFailure: TypeAlias = (
-    LifecycleInvocationError
-    | ContainerCleanupError
-    | _BackgroundExecutionStartFailure
-    | HostedServiceLifecycleError
-)
-
 
 class Application:
     """拥有单次 build 的 Module instances、状态、transition 与 diagnostics。"""
@@ -96,40 +60,10 @@ class Application:
         return self._root.require_service_catalog()
 
     @property
-    def application_service_catalog(self) -> ApplicationServiceCatalog:
-        return self._root.require_application_service_catalog()
-
-    @property
-    def event_catalog(self) -> LocalEventCatalog:
-        return self._root.require_event_catalog()
-
-    @property
-    def permission_catalog(self) -> PermissionCatalog:
-        return self._root.require_permission_catalog()
-
-    @property
-    def cache_catalog(self) -> CacheCatalog:
-        return self._root.require_cache_catalog()
-
-    @property
-    def setting_catalog(self) -> SettingCatalog:
-        return self._root.require_setting_catalog()
-
-    @property
-    def background_worker_catalog(self) -> BackgroundWorkerCatalog:
-        return self._root.require_background_worker_catalog()
-
-    @property
-    def background_job_catalog(self) -> BackgroundJobCatalog:
-        return self._root.require_background_job_catalog()
-
-    @property
-    def hosted_service_catalog(self) -> HostedServiceCatalog:
-        return self._root.require_hosted_service_catalog()
-
-    @property
-    def readiness(self) -> ApplicationReadinessSnapshot:
-        return self._root.readiness()
+    def is_ready(self) -> bool:
+        return self.state is ApplicationState.RUNNING and all(
+            participant.ready is None or participant.ready() for participant in self._root.runtimes
+        )
 
     @property
     def diagnostics(self) -> DiagnosticSnapshot:
@@ -148,41 +82,27 @@ class Application:
             allowed=(ApplicationState.COMPOSED,),
         )
         self._root.state = ApplicationState.STARTING
-        if not run_services:
-            # 数据库 CLI 只需要 Module 初始化及正式 invocation；不打开后台生产者或外部 SDK。
-            self._root.require_background_coordinator().disable_for_database()
         lifecycle = _RuntimeLifecycle(self._root)
         started = False
         try:
             try:
+                self._root.registry.assert_declarations_unchanged()
+                for participant in self._root.runtimes:
+                    if participant.prepare is not None:
+                        participant.prepare(run_services)
                 await lifecycle.start_modules()
-            except LifecycleInvocationError as primary:
+                self._root.registry.assert_declarations_unchanged()
+                # 全部 Module 初始化屏障完成后才开放运行入口；部分启动也必须逆序清理。
+                for participant in self._root.runtimes:
+                    self._root.touched_runtimes.append(participant)
+                    await participant.start()
+            except BaseException as primary:
                 await self._fail_start(lifecycle, primary=primary)
-            self._root.require_invocation_runtime().start_accepting()
-            try:
-                if run_services:
-                    await self._root.require_hosted_service_coordinator().start()
-            except BaseException as original_error:
-                hosted_failure = (
-                    original_error
-                    if isinstance(original_error, HostedServiceLifecycleError)
-                    else HostedServiceLifecycleError(
-                        service="hosted-service-coordinator",
-                        operation="start",
-                        error_type=type(original_error).__name__,
-                    )
-                )
-                await self._fail_start(lifecycle, primary=hosted_failure)
-            try:
-                await self._root.require_background_coordinator().start()
-            except BaseException as original_error:
-                background_failure = _BackgroundExecutionStartFailure(original_error=original_error)
-                await self._fail_start(lifecycle, primary=background_failure)
             self._root.state = ApplicationState.RUNNING
             started = True
         finally:
             self._root.release_transition(token)
-        if started and (self._root.require_background_coordinator().has_runtime_failure_source):
+        if started and any(item.failure is not None for item in self._root.runtimes):
             self._root.runtime_monitor_task = asyncio.create_task(
                 self._monitor_runtime_failure(),
                 name=f"python-ddd-framework-runtime-monitor:{self.id}",
@@ -192,9 +112,7 @@ class Application:
         self,
         lifecycle: _RuntimeLifecycle,
         *,
-        primary: LifecycleInvocationError
-        | HostedServiceLifecycleError
-        | _BackgroundExecutionStartFailure,
+        primary: BaseException,
     ) -> Never:
         self._root.state = ApplicationState.ROLLING_BACK
         # 回滚 task 由本次 start 强持有；重复取消只能在所有资源实际退出后返回。
@@ -217,64 +135,48 @@ class Application:
         self,
         lifecycle: _RuntimeLifecycle,
         *,
-        primary: LifecycleInvocationError
-        | HostedServiceLifecycleError
-        | _BackgroundExecutionStartFailure,
+        primary: BaseException,
     ) -> ApplicationStartError:
+        runtime_failures = await self._stop_runtimes(ShutdownReason.START_FAILURE)
+        module_failures = await lifecycle.shutdown_touched(reason=ShutdownReason.START_FAILURE)
+        container_failures = await lifecycle.close_container(
+            exception=primary.original_error
+            if isinstance(primary, LifecycleInvocationError)
+            else primary
+        )
         if isinstance(primary, LifecycleInvocationError):
-            module_failures = await lifecycle.shutdown_touched(reason=ShutdownReason.START_FAILURE)
-            container_failures = await lifecycle.close_container(exception=primary.original_error)
-            cleanup_failures: tuple[LifecycleInvocationError | ContainerCleanupError, ...] = (
-                *module_failures,
-                *container_failures,
-            )
             self._root.journal.complete_failure(
                 primary.failure_id,
-                cleanup_failure_ids=tuple(failure.failure_id for failure in cleanup_failures),
-            )
-            return ApplicationStartError(
-                primary=primary,
-                cleanup_failures=cleanup_failures,
+                cleanup_failure_ids=tuple(failure.failure_id for failure in module_failures)
+                + tuple(failure.failure_id for failure in container_failures),
             )
         return ApplicationStartError(
             primary=primary,
-            cleanup_failures=await self._rollback_runtime_start(lifecycle, primary=primary),
+            cleanup_failures=(*runtime_failures, *module_failures, *container_failures),
         )
 
-    async def _rollback_runtime_start(
-        self,
-        lifecycle: _RuntimeLifecycle,
-        *,
-        primary: BaseException,
-    ) -> tuple[_StartCleanupFailure, ...]:
-        hosted = self._root.require_hosted_service_coordinator()
-        hosted.close_admission()
-        cleanup_failures: list[_StartCleanupFailure] = []
-        # 消费者必须先实际退出，才可释放它们依赖的 HostedService。
-        try:
-            await self._root.require_background_coordinator().stop()
-        except BaseException as background_error:
-            cleanup_failures.append(
-                _BackgroundExecutionStartFailure(original_error=background_error)
+    async def _stop_runtimes(self, reason: ShutdownReason) -> tuple[BaseException, ...]:
+        failures: list[BaseException] = []
+        # 每个阶段都是全局屏障；收尾与排空完成前，不释放任何参与者的依赖资源。
+        # 用户钩子只交给触达过 start 的参与者；预启动请求仍由独立 drain 收口。
+        participants = tuple(reversed(self._root.touched_runtimes))
+        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
             )
-        try:
-            hosted_failures = await hosted.stop(ShutdownReason.START_FAILURE)
-        except BaseException as hosted_error:
-            cleanup_failures.append(
-                HostedServiceLifecycleError(
-                    service="hosted-service-coordinator",
-                    operation="stop",
-                    error_type=type(hosted_error).__name__,
-                )
+        )
+        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
             )
-        else:
-            cleanup_failures.extend(hosted_failures)
-        await self._root.require_invocation_runtime().stop_accepting_and_wait()
-        cleanup_failures.extend(
-            await lifecycle.shutdown_touched(reason=ShutdownReason.START_FAILURE)
         )
-        cleanup_failures.extend(await lifecycle.close_container(exception=primary))
-        return tuple(cleanup_failures)
+        failures.extend(
+            await _await_shutdown_callbacks(partial(item.stop, reason) for item in participants)
+        )
+        self._root.touched_runtimes.clear()
+        return tuple(failures)
 
     async def stop(self) -> None:
         if self._root.state in (
@@ -318,21 +220,7 @@ class Application:
             if self._root.runtime_failure is not None
             else ShutdownReason.NORMAL
         )
-        hosted = self._root.require_hosted_service_coordinator()
-        # 关闭新工作入口，等待消费者退出后再逆序停止 HostedService。
-        hosted.close_admission()
-        infrastructure_failures: list[BaseException] = []
-        try:
-            await self._root.require_background_coordinator().stop()
-        except BaseException as background_error:
-            infrastructure_failures.append(background_error)
-        try:
-            hosted_failures = await hosted.stop(reason)
-        except BaseException as hosted_error:
-            infrastructure_failures.append(hosted_error)
-        else:
-            infrastructure_failures.extend(hosted_failures)
-        await self._root.require_invocation_runtime().stop_accepting_and_wait()
+        infrastructure_failures = list(await self._stop_runtimes(reason))
         module_failures = await lifecycle.shutdown_touched(
             reason=reason,
         )
@@ -398,6 +286,10 @@ class Application:
                 allowed=allowed,
             )
         await self._root.termination_event.wait()
+        monitor = self._root.runtime_monitor_task
+        if monitor is not None and monitor is not asyncio.current_task():
+            # 终态发布与监督器退出相邻；调用者取消等待不能取消仍在收口的监督任务。
+            await asyncio.shield(asyncio.gather(monitor, return_exceptions=True))
         failure = self._root.termination_failure
         if failure is not None:
             raise failure
@@ -405,8 +297,9 @@ class Application:
     async def _monitor_runtime_failure(self) -> None:
         current = asyncio.current_task()
         try:
-            # HostedService 只拥有 start/stop；持久任务等其他能力仍保留自身故障传播。
-            failure = await self._root.require_background_coordinator().wait_for_runtime_failure()
+            failure = await self._wait_for_runtime_failure()
+            if failure is None:
+                return
             if self._root.runtime_failure is None:
                 self._root.runtime_failure = ApplicationRuntimeError(
                     component=failure.component,
@@ -425,125 +318,64 @@ class Application:
             if self._root.runtime_monitor_task is current:
                 self._root.runtime_monitor_task = None
 
-    async def call(
-        self,
-        function: Callable[..., Awaitable[_R]],
-        /,
-        *args: object,
-        **kwargs: object,
-    ) -> _R:
-        """调用异步入口，业务实参显式传入，服务参数由最终 Dishka 图补齐。"""
-        return await self.call_as(
-            self._root.require_invocation_runtime().current_user(),
-            function,
-            *args,
-            **kwargs,
-        )
-
-    async def call_as(
-        self,
-        current_user: CurrentUser,
-        function: Callable[..., Awaitable[_R]],
-        /,
-        *args: object,
-        **kwargs: object,
-    ) -> _R:
-        """可信身份与调用许可覆盖 REQUEST 创建、业务执行和最终资源释放。"""
-        runtime = self._root.require_invocation_runtime()
-        return await _invoke_callable(
-            self._root.require_container(),
-            runtime,
-            current_user,
-            str(uuid4()),
-            function,
-            args,
-            kwargs,
-        )
-
-    async def invoke(
-        self,
-        method: Callable[Concatenate[_TContract, _P], Awaitable[_R]],
-        /,
-        *args: _P.args,
-        **kwargs: _P.kwargs,
-    ) -> _R:
-        """匿名调用公开 Protocol method；可信 caller 需显式使用 invoke_as。"""
-
-        return await self.invoke_as(CurrentUser.anonymous(), method, *args, **kwargs)
-
-    async def invoke_as(
-        self,
-        current_user: CurrentUser,
-        method: Callable[Concatenate[_TContract, _P], Awaitable[_R]],
-        /,
-        *args: _P.args,
-        **kwargs: _P.kwargs,
-    ) -> _R:
-        """由可信 Host/test 传入已验证身份，身份只绑定当前 Application 与 asyncio Task。"""
-
-        if self._root.state not in (ApplicationState.STARTING, ApplicationState.RUNNING):
-            raise ApplicationInvocationRejectedError(
-                reason=f"Application must be running, got {self._root.state.value}"
+    async def _wait_for_runtime_failure(self) -> ApplicationRuntimeError | None:
+        watchers = []
+        try:
+            for participant in self._root.runtimes:
+                if participant.failure is not None:
+                    pending = participant.failure()
+                    if pending is not None:
+                        watchers.append(asyncio.ensure_future(pending))
+            if not watchers:
+                return None
+            done, _ = await asyncio.wait(watchers, return_when=asyncio.FIRST_COMPLETED)
+            failure = next(task.result() for task in watchers if task in done)
+            if not isinstance(failure, ApplicationRuntimeError):
+                raise TypeError("runtime failure callback must return ApplicationRuntimeError")
+            return failure
+        except (Exception, asyncio.CancelledError) as error:
+            monitor = asyncio.current_task()
+            if (
+                isinstance(error, asyncio.CancelledError)
+                and monitor is not None
+                and monitor.cancelling()
+            ):
+                # 正式 stop 取消的是 monitor；子等待者取消不能冒充应用的停止请求。
+                raise
+            # 扩展监督器自身失效也必须终止应用；错误正文不跨越公共终态边界。
+            return ApplicationRuntimeError(
+                component="runtime-supervision", error_type=type(error).__name__
             )
-        container = self._root.require_container()
-        invoker = await container.get(_ScopedApplicationServiceInvoker)
-        result = await invoker.invoke(
-            container,
-            current_user,
-            str(uuid4()),
-            cast(Callable[..., Awaitable[object]], method),
-            cast(tuple[object, ...], args),
-            cast(dict[str, object], kwargs),
-        )
-        return cast(_R, result)
-
-    @asynccontextmanager
-    async def _invocation_lease_for_integration(self) -> AsyncIterator[None]:
-        """Web/internal entry 共用的 Application-local drain lease。"""
-
-        async with self._root.require_invocation_runtime().outer_lease():
-            yield
-
-    @asynccontextmanager
-    async def _http_request_lease_for_integration(self) -> AsyncIterator[None]:
-        # Phase 2 health contract 允许 composed/pre-start probe，但该 request 仍参与 stop drain；
-        # lease 中的 capability 会让随后进入 dispatcher 的业务 route 继续 fail closed。
-        async with self._root.require_invocation_runtime().outer_lease(allow_composed_request=True):
-            yield
+        finally:
+            # 每个监督任务都归当前 Application；正常 stop 和 fatal 竞争也不遗留等待者。
+            for watcher in watchers:
+                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)
 
-    @contextmanager
-    def _caller_context_for_integration(
-        self,
-        current_user: CurrentUser,
-        correlation_id: str,
-    ) -> Iterator[None]:
-        """HTTP bridge 的窄化入口；不公开 mutable principal 或 process-global current app。"""
 
-        runtime = self._root.require_invocation_runtime()
-        token = runtime.bind_caller(current_user, correlation_id)
+async def _await_shutdown_callbacks(
+    callbacks: Iterable[Callable[[], Awaitable[tuple[BaseException, ...] | None]]],
+) -> tuple[BaseException, ...]:
+    failures: list[BaseException] = []
+    for callback in callbacks:
         try:
-            yield
-        finally:
-            runtime.reset_caller(token)
-
-    async def _invoke_registration(
-        self,
-        registration: ApplicationServiceRegistration,
-        method_name: str,
-    ) -> object:
-        """框架内部 contributor 仍走 dispatcher，但不发布 public single Contract。"""
-
-        if self._root.state not in (ApplicationState.STARTING, ApplicationState.RUNNING):
-            raise ApplicationInvocationRejectedError(
-                reason=f"Application must be running, got {self._root.state.value}"
-            )
-        service = self.application_service_catalog._for_registration(registration)
-        method = service.methods.get(method_name)
-        if method is None:
-            raise AssertionError("internal contributor method is absent from its catalog entry")
-        container = self._root.require_container()
-        async with self._invocation_lease_for_integration():
-            with self._caller_context_for_integration(CurrentUser.anonymous(), str(uuid4())):
-                async with container(scope=Scope.REQUEST) as request_container:
-                    dispatcher = await request_container.get(_ApplicationServiceDispatcher)
-                    return await dispatcher.invoke(service, method, (), {})
+            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/state.py

@@ -1,4 +1,4 @@
-"""Single-Application mutable root、read-only views 与 transition ownership。"""
+"""Single-Application 核心状态、转换 ownership 与诊断视图。"""
 
 from __future__ import annotations
 
@@ -10,58 +10,36 @@ from uuid import UUID
 
 from dishka import AsyncContainer
 
-from ..application_services import ApplicationServiceCatalog
-from ..application_services.invocation import _InvocationRuntime
-from ..authorization import PermissionCatalog
-from ..background_jobs import BackgroundJobCatalog
-from ..background_workers import BackgroundWorkerCatalog
-from ..background_workers.runtime import _BackgroundCoordinator
-from ..caching import CacheCatalog
 from ..configuration import ConfigurationRoot
 from ..diagnostics import LifecyclePhase, LifecycleStage
 from ..diagnostics.journal import _DiagnosticJournal
 from ..errors import ApplicationRuntimeError, InvalidApplicationStateError, LifecycleInvocationError
-from ..events import LocalEventCatalog
-from ..events.contribution import EventContributionRegistry
-from ..hosted_services import ApplicationReadinessSnapshot, HostedServiceCatalog
-from ..hosted_services.runtime import _HostedServiceCoordinator
-from ..lifecycle import ApplicationState, ApplicationView
+from ..lifecycle import ApplicationState, ApplicationView, RuntimeParticipant
 from ..modularity import ModuleDescriptor, ModuleKey, ModuleRegistry
+from ..modularity.discovery import _DiscoveredType
 from ..options import OptionsSnapshot, PreOptionsSnapshot
 from ..options.registry import _OptionsRegistry
 from ..services import ServiceCatalog
 from ..services.contribution import ServiceContributionRegistry
-from ..settings import SettingCatalog
 
 LIFECYCLE_ERROR_TYPE = LifecycleInvocationError.__name__
 
 
 @dataclass(slots=True)
 class _ApplicationStateRoot:
-    """所有可变事实的唯一 owner；Application 之间不共享容器、状态或 journal。"""
+    """只拥有核心状态；能力的 Catalog、实例和协调器分别归图内的 Module。"""
 
     application_id: UUID
     registry: ModuleRegistry
+    discoveries: tuple[_DiscoveredType, ...]
     configuration: ConfigurationRoot
     pre_options_registry: _OptionsRegistry
     options_registry: _OptionsRegistry
     service_registry: ServiceContributionRegistry
-    event_registry: EventContributionRegistry
-    permission_catalog: PermissionCatalog
-    cache_catalog: CacheCatalog
-    setting_catalog: SettingCatalog
-    background_worker_catalog: BackgroundWorkerCatalog
-    background_job_catalog: BackgroundJobCatalog
-    hosted_service_catalog: HostedServiceCatalog
     journal: _DiagnosticJournal
     pre_options: PreOptionsSnapshot | None = None
     options: OptionsSnapshot | None = None
     service_catalog: ServiceCatalog | None = None
-    application_service_catalog: ApplicationServiceCatalog | None = None
-    event_catalog: LocalEventCatalog | None = None
-    invocation_runtime: _InvocationRuntime | None = None
-    background_coordinator: _BackgroundCoordinator | None = None
-    hosted_service_coordinator: _HostedServiceCoordinator | None = None
     container: AsyncContainer | None = None
     state: ApplicationState = ApplicationState.COMPOSED
     transition_token: object | None = None
@@ -72,6 +50,8 @@ class _ApplicationStateRoot:
     runtime_failure: ApplicationRuntimeError | None = None
     termination_failure: BaseException | None = None
     runtime_monitor_task: asyncio.Task[None] | None = None
+    runtimes: tuple[RuntimeParticipant, ...] = ()
+    touched_runtimes: list[RuntimeParticipant] = field(default_factory=list)
 
     def require_pre_options(self) -> PreOptionsSnapshot:
         if self.pre_options is None:
@@ -95,54 +75,6 @@ class _ApplicationStateRoot:
             raise RuntimeError("Dishka container is unavailable after Application cleanup")
         return self.container
 
-    def require_application_service_catalog(self) -> ApplicationServiceCatalog:
-        if self.application_service_catalog is None:
-            raise RuntimeError(
-                "Application Service catalog is unavailable before composition completes"
-            )
-        return self.application_service_catalog
-
-    def require_event_catalog(self) -> LocalEventCatalog:
-        if self.event_catalog is None:
-            raise RuntimeError("Local Event catalog is unavailable before composition completes")
-        return self.event_catalog
-
-    def require_permission_catalog(self) -> PermissionCatalog:
-        return self.permission_catalog
-
-    def require_cache_catalog(self) -> CacheCatalog:
-        return self.cache_catalog
-
-    def require_setting_catalog(self) -> SettingCatalog:
-        return self.setting_catalog
-
-    def require_background_worker_catalog(self) -> BackgroundWorkerCatalog:
-        return self.background_worker_catalog
-
-    def require_background_job_catalog(self) -> BackgroundJobCatalog:
-        return self.background_job_catalog
-
-    def require_invocation_runtime(self) -> _InvocationRuntime:
-        if self.invocation_runtime is None:
-            raise RuntimeError("Application invocation runtime is unavailable")
-        return self.invocation_runtime
-
-    def require_background_coordinator(self) -> _BackgroundCoordinator:
-        if self.background_coordinator is None:
-            raise RuntimeError("Application background coordinator is unavailable")
-        return self.background_coordinator
-
-    def require_hosted_service_catalog(self) -> HostedServiceCatalog:
-        return self.hosted_service_catalog
-
-    def require_hosted_service_coordinator(self) -> _HostedServiceCoordinator:
-        if self.hosted_service_coordinator is None:
-            raise RuntimeError("Hosted Service coordinator is unavailable")
-        return self.hosted_service_coordinator
-
-    def readiness(self) -> ApplicationReadinessSnapshot:
-        return self.require_hosted_service_coordinator().readiness()
-
     def view(self, state: ApplicationState | None) -> ApplicationView:
         return ApplicationView(
             application_id=self.application_id,