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

python_ddd_framework/hosted_services/runtime.py

@@ -10,7 +10,8 @@ from typing import cast
 from dishka import AsyncContainer
 
 from ..application_services import ApplicationServiceCatalog
-from ..lifecycle import ApplicationState, ShutdownReason
+from ..application_services.invocation import _InvocationRuntime
+from ..lifecycle import ApplicationState, RuntimeParticipant, ShutdownReason
 from .bridge import HostedServiceContext, _HostedServiceBridge
 from .catalog import HostedServiceCatalog, HostedServiceRegistration
 from .contracts import HostedService, HostedServiceStatus
@@ -25,6 +26,8 @@ class _HostedServiceEntry:
     service: HostedService
     context: HostedServiceContext
     bridge: _HostedServiceBridge
+    started: bool = False
+    failed: bool = False
 
 
 class _HostedServiceCoordinator:
@@ -72,6 +75,38 @@ class _HostedServiceCoordinator:
     def readiness(self) -> ApplicationReadinessSnapshot:
         return self._state_owner.snapshot(self._state_getter())
 
+    def runtime_participant(self) -> RuntimeParticipant:
+        enabled = True
+
+        def prepare(run_services: bool) -> None:
+            nonlocal enabled
+            enabled = run_services
+
+        async def start() -> None:
+            if not enabled:
+                return
+            try:
+                await self.start()
+            except HostedServiceLifecycleError:
+                raise
+            except BaseException as error:
+                raise HostedServiceLifecycleError(
+                    service=type(self).__qualname__,
+                    operation="start",
+                    error_type=type(error).__name__,
+                ) from error
+
+        return RuntimeParticipant(
+            prepare=prepare,
+            start=start,
+            stop=self.stop,
+            quiesce=self.close_admission,
+            stopping=self.stopping,
+            close_admission=self.close_admission,
+            drain=self.drain,
+            ready=lambda: self.readiness().ready,
+        )
+
     def select_child(self) -> None:
         if self._started:
             raise RuntimeError("Hosted Service process selection must precede start")
@@ -97,6 +132,7 @@ class _HostedServiceCoordinator:
         if container is None or application_service_catalog is None:
             raise RuntimeError("Hosted Service coordinator container is unavailable")
         self._started = True
+        runtime = await container.get(_InvocationRuntime)
         for registration in self._registrations:
             self._state_owner.set_status(registration.name, HostedServiceStatus.STARTING)
             try:
@@ -121,17 +157,55 @@ class _HostedServiceCoordinator:
                 container=container,
                 catalog=application_service_catalog,
                 limit=self._options.max_pending_invocations,
+                runtime=runtime,
+                stopping_owners=(registration.service_type,),
             )
             context = HostedServiceContext(registration.name, bridge)
             entry = _HostedServiceEntry(registration, resolved, context, bridge)
             self._entries.append(entry)
             bridge.open()
             await self._start_entry(entry)
+            entry.started = True
 
     def close_admission(self) -> None:
         for entry in self._entries:
             entry.bridge.close()
 
+    async def stopping(self, reason: ShutdownReason) -> tuple[BaseException, ...]:
+        failures: list[BaseException] = []
+        for entry in reversed(self._entries):
+            self._state_owner.set_status(entry.registration.name, HostedServiceStatus.STOPPING)
+            if not entry.started:
+                continue
+            assert self._container is not None
+            runtime = await self._container.get(_InvocationRuntime)
+            permission = runtime.grant_stopping(entry.registration.service_type)
+            context = HostedServiceContext(entry.registration.name, entry.bridge, permission)
+            try:
+                failure = await self._stop_entry(entry, reason, context=context)
+            except BaseException as error:
+                failures.append(error)
+                entry.failed = True
+            else:
+                if failure is not None:
+                    failures.append(failure)
+                    entry.failed = True
+            finally:
+                runtime.revoke_stopping(permission)
+        return tuple(failures)
+
+    async def drain(self) -> None:
+        outcomes = await asyncio.gather(
+            *(
+                entry.bridge.drain(self._options.shutdown_timeout.total_seconds())
+                for entry in self._entries
+            ),
+            return_exceptions=True,
+        )
+        failures = tuple(item for item in outcomes if isinstance(item, BaseException))
+        if failures:
+            raise BaseExceptionGroup("Hosted Service invocation drain failed", failures)
+
     async def stop(
         self,
         reason: ShutdownReason,
@@ -147,19 +221,14 @@ class _HostedServiceCoordinator:
             if failure is not None:
                 failures.append(failure)
 
-        if self._entries:
-            await asyncio.gather(
-                *(
-                    entry.bridge.drain(self._options.shutdown_timeout.total_seconds())
-                    for entry in self._entries
-                )
-            )
         failed_names = {failure.service for failure in failures}
         for entry in self._entries:
             name = entry.registration.name
             self._state_owner.set_status(
                 name,
-                HostedServiceStatus.FAILED if name in failed_names else HostedServiceStatus.STOPPED,
+                HostedServiceStatus.FAILED
+                if name in failed_names or entry.failed
+                else HostedServiceStatus.STOPPED,
             )
         self._started = False
         return tuple(failures)
@@ -224,18 +293,29 @@ class _HostedServiceCoordinator:
         self,
         entry: _HostedServiceEntry,
         reason: ShutdownReason,
+        *,
+        context: HostedServiceContext | None = None,
     ) -> HostedServiceLifecycleError | None:
         name = entry.registration.name
-        callback = cast(
-            Callable[[ShutdownReason], Awaitable[object]],
-            entry.service.stop,
-        )
+        operation = "stopping" if context is not None else "stop"
 
         async def invoke_stop() -> object:
-            return await callback(reason)
+            if context is None:
+                callback = cast(Callable[[ShutdownReason], Awaitable[object]], entry.service.stop)
+                return await callback(reason)
+            stopping_callback = cast(
+                Callable[[HostedServiceContext, ShutdownReason], Awaitable[object]],
+                entry.service.stopping,
+            )
+            try:
+                return await stopping_callback(context, reason)
+            finally:
+                # 返回和失败都在用户钩子的 task 内撤权，不留下一轮调度的准入窗口。
+                assert context._permission is not None
+                context._permission.runtime.revoke_stopping(context._permission)
 
         stop_task = asyncio.create_task(
-            invoke_stop(), name=f"python-ddd-framework-hosted-service-stop:{name}"
+            invoke_stop(), name=f"python-ddd-framework-hosted-service-{operation}:{name}"
         )
         done, _ = await asyncio.wait(
             (stop_task,), timeout=self._options.shutdown_timeout.total_seconds()
@@ -243,25 +323,28 @@ class _HostedServiceCoordinator:
         timed_out = not done
         if timed_out:
             # 取消只是一项请求。实现可能在 finally 中异步释放 SDK 资源；完成前不能释放容器。
+            if context is not None:
+                assert context._permission is not None
+                context._permission.runtime.revoke_stopping(context._permission)
             stop_task.cancel()
         try:
             result = await stop_task
         except BaseException as original_error:
             return HostedServiceLifecycleError(
                 service=name,
-                operation="stop",
+                operation=operation,
                 error_type="TimeoutError"
                 if timed_out and isinstance(original_error, asyncio.CancelledError)
                 else type(original_error).__name__,
             )
         if timed_out:
             return HostedServiceLifecycleError(
-                service=name, operation="stop", error_type="TimeoutError"
+                service=name, operation=operation, error_type="TimeoutError"
             )
         if result is not None:
             return HostedServiceLifecycleError(
                 service=name,
-                operation="stop",
+                operation=operation,
                 error_type="InvalidReturnValue",
             )
         return None

python_ddd_framework/identity/__init__.py

@@ -1,11 +1,17 @@
+from .application import (
+    DefaultAuthenticationApplicationService,
+)
 from .contracts import (
     IDENTITY_ROLES_MANAGE,
+    IDENTITY_USER_EXTENSION,
     IDENTITY_USERS_MANAGE,
     AuthenticationApplicationService,
+    ChangePasswordCommand,
     CreateRoleCommand,
     CreateUserCommand,
     CurrentUserView,
     IdentityAccessStore,
+    IdentityConcurrencyCommand,
     IdentityLoginStore,
     IdentityManagementApplicationService,
     IdentityOptions,
@@ -19,10 +25,16 @@ from .contracts import (
     RefreshSessionStore,
     RefreshTokenCommand,
     RevokeTokenCommand,
+    RolePermissionsView,
     RoleView,
+    SetPasswordCommand,
     SetRolePermissionsCommand,
+    SetUserActiveCommand,
     SetUserRolesCommand,
     TokenPair,
+    UpdateRoleCommand,
+    UpdateUserCommand,
+    UserRolesView,
     UserView,
 )
 from .errors import (
@@ -31,6 +43,7 @@ from .errors import (
     IdentityResourceNotFoundError,
     InvalidCredentialsError,
 )
+from .management import DefaultIdentityManagementApplicationService
 from .module import IdentityModule
 from .passwords import PasswordHasher
 from .services import IdentityAuthenticator
@@ -39,12 +52,17 @@ from .tokens import JwtTokenService
 __all__ = (
     "IDENTITY_ROLES_MANAGE",
     "IDENTITY_USERS_MANAGE",
+    "IDENTITY_USER_EXTENSION",
     "AuthenticationApplicationService",
+    "ChangePasswordCommand",
     "CreateRoleCommand",
     "CreateUserCommand",
     "CurrentUserView",
+    "DefaultAuthenticationApplicationService",
+    "DefaultIdentityManagementApplicationService",
     "IdentityAccessStore",
     "IdentityAuthenticator",
+    "IdentityConcurrencyCommand",
     "IdentityConflictError",
     "IdentityDefinitionError",
     "IdentityLoginStore",
@@ -65,9 +83,15 @@ __all__ = (
     "RefreshSessionStore",
     "RefreshTokenCommand",
     "RevokeTokenCommand",
+    "RolePermissionsView",
     "RoleView",
+    "SetPasswordCommand",
     "SetRolePermissionsCommand",
+    "SetUserActiveCommand",
     "SetUserRolesCommand",
     "TokenPair",
+    "UpdateRoleCommand",
+    "UpdateUserCommand",
+    "UserRolesView",
     "UserView",
 )

python_ddd_framework/identity/application.py

@@ -2,27 +2,23 @@
 
 from __future__ import annotations
 
-from datetime import UTC, datetime, timedelta
+from datetime import UTC, datetime
 from uuid import UUID, uuid4
 
-from ..application_services import ApplicationService, DataSeedContributor, application_service
+from ..application_services import ApplicationService, application_service
 from ..authorization import (
     CurrentUser,
     PermissionCatalog,
-    PermissionName,
     allow_anonymous,
     authorize,
 )
 from ..options import Options
+from ..seeding.contracts import DataSeedContributor
 from .contracts import (
-    IDENTITY_ROLES_MANAGE,
-    IDENTITY_USERS_MANAGE,
     AuthenticationApplicationService,
-    CreateRoleCommand,
-    CreateUserCommand,
+    ChangePasswordCommand,
     CurrentUserView,
     IdentityLoginStore,
-    IdentityManagementApplicationService,
     IdentityOptions,
     IdentityRepository,
     IdentityRole,
@@ -33,34 +29,24 @@ from .contracts import (
     RefreshSessionStore,
     RefreshTokenCommand,
     RevokeTokenCommand,
-    RoleView,
-    SetRolePermissionsCommand,
-    SetUserRolesCommand,
     TokenPair,
-    UserView,
     _normalize_name,
 )
 from .errors import (
-    IdentityConflictError,
-    IdentityResourceNotFoundError,
     InvalidCredentialsError,
 )
 from .passwords import PasswordHasher
 from .tokens import (
-    ACCESS_TOKEN_LIFETIME,
     BEARER_TOKEN_TYPE,
     JwtTokenService,
     hash_refresh_token,
     new_refresh_token,
 )
 
-FAILED_ATTEMPT_LIMIT = 5
-LOCKOUT_DURATION = timedelta(minutes=15)
-
 
 @authorize()
 @application_service(provides=AuthenticationApplicationService)
-class _AuthenticationApplicationService(ApplicationService):
+class DefaultAuthenticationApplicationService(ApplicationService):
     def __init__(
         self,
         login_store: IdentityLoginStore,
@@ -68,12 +54,16 @@ class _AuthenticationApplicationService(ApplicationService):
         passwords: PasswordHasher,
         tokens: JwtTokenService,
         current_user: CurrentUser,
+        repository: IdentityRepository,
+        options: Options[IdentityOptions],
     ) -> None:
         self._login_store = login_store
         self._sessions = sessions
         self._passwords = passwords
         self._tokens = tokens
         self._current_user = current_user
+        self._repository = repository
+        self._options = options.value
 
     @allow_anonymous
     async def login(self, command: LoginCommand) -> TokenPair:
@@ -95,8 +85,8 @@ class _AuthenticationApplicationService(ApplicationService):
                 await self._login_store.record_failure(
                     user.user_id,
                     now=now,
-                    attempt_limit=FAILED_ATTEMPT_LIMIT,
-                    lockout_duration_seconds=int(LOCKOUT_DURATION.total_seconds()),
+                    attempt_limit=self._options.failed_attempt_limit,
+                    lockout_duration_seconds=int(self._options.lockout_duration.total_seconds()),
                 )
             raise InvalidCredentialsError
 
@@ -146,6 +136,28 @@ class _AuthenticationApplicationService(ApplicationService):
             user_id=self._current_user.user_id,
             session_id=self._current_user.session_id,
             username=self._current_user.username,
+            concurrency_version=(
+                await self._repository.get_user(self._current_user.user_id)
+            ).concurrency_version,
+        )
+
+    async def change_password(self, command: ChangePasswordCommand) -> None:
+        user_id = self._current_user.user_id
+        if user_id is None:
+            raise InvalidCredentialsError
+        user = await self._repository.get_user(user_id)
+        verified, _ = await self._passwords.verify(
+            command.old_password.get_secret_value(), user.password_hash
+        )
+        if not verified:
+            raise InvalidCredentialsError
+        password_hash = await self._passwords.hash(command.new_password.get_secret_value())
+        # Hash 在线程计算；写入时重新核对版本及旧 hash，拒绝计算期间的凭据竞争。
+        await self._repository.set_password(
+            user_id,
+            password_hash,
+            command.concurrency_version,
+            expected_password_hash=user.password_hash,
         )
 
     def _token_pair(
@@ -159,77 +171,10 @@ class _AuthenticationApplicationService(ApplicationService):
             access_token=self._tokens.issue(session.user_id, session.session_id, now=now),
             refresh_token=refresh_token,
             token_type=BEARER_TOKEN_TYPE,
-            expires_in=int(ACCESS_TOKEN_LIFETIME.total_seconds()),
-        )
-
-
-@application_service(provides=IdentityManagementApplicationService)
-class _IdentityManagementApplicationService(ApplicationService):
-    def __init__(
-        self,
-        repository: IdentityRepository,
-        passwords: PasswordHasher,
-        permissions: PermissionCatalog,
-    ) -> None:
-        self._repository = repository
-        self._passwords = passwords
-        self._permissions = permissions
-
-    @authorize(IDENTITY_USERS_MANAGE)
-    async def create_user(self, command: CreateUserCommand) -> UserView:
-        normalized = _normalize_name(command.username, role="username")
-        if await self._repository.find_user_by_normalized_username(normalized) is not None:
-            raise IdentityConflictError(resource="user")
-        user = IdentityUser(
-            user_id=uuid4(),
-            username=command.username.strip(),
-            normalized_username=normalized,
-            password_hash=await self._passwords.hash(command.password.get_secret_value()),
-            is_active=True,
-            failed_access_count=0,
-            lockout_end=None,
-            permission_version=0,
+            expires_in=int(self._options.access_token_lifetime.total_seconds()),
         )
-        await self._repository.create_user(user)
-        return UserView(user.user_id, user.username, user.is_active, ())
 
-    @authorize(IDENTITY_USERS_MANAGE)
-    async def get_users(self) -> tuple[UserView, ...]:
-        return await self._repository.list_users()
 
-    @authorize(IDENTITY_ROLES_MANAGE)
-    async def create_role(self, command: CreateRoleCommand) -> RoleView:
-        normalized = _normalize_name(command.name, role="role name")
-        if await self._repository.find_role_by_normalized_name(normalized) is not None:
-            raise IdentityConflictError(resource="role")
-        role = IdentityRole(uuid4(), command.name.strip(), normalized, 0)
-        await self._repository.create_role(role)
-        return RoleView(role.role_id, role.name, ())
-
-    @authorize(IDENTITY_ROLES_MANAGE)
-    async def get_roles(self) -> tuple[RoleView, ...]:
-        return await self._repository.list_roles()
-
-    @authorize(IDENTITY_USERS_MANAGE, IDENTITY_ROLES_MANAGE)
-    async def set_user_roles(self, user_id: UUID, command: SetUserRolesCommand) -> None:
-        role_ids = tuple(dict.fromkeys(command.role_ids))
-        await self._repository.set_user_roles(user_id, role_ids)
-
-    @authorize(IDENTITY_ROLES_MANAGE)
-    async def set_role_permissions(self, role_id: UUID, command: SetRolePermissionsCommand) -> None:
-        names = tuple(PermissionName(item) for item in command.permissions)
-        if len(set(names)) != len(names):
-            raise IdentityConflictError(resource="role permission")
-        unknown = tuple(item for item in names if item not in self._permissions)
-        if unknown:
-            raise IdentityResourceNotFoundError(resource="permission")
-        await self._repository.set_role_permissions(
-            role_id,
-            tuple(item.value for item in names),
-        )
-
-
-@application_service()
 class IdentityAdminSeedContributor(DataSeedContributor):
     def __init__(
         self,
@@ -270,8 +215,11 @@ class IdentityAdminSeedContributor(DataSeedContributor):
         await self._repository.set_role_permissions(
             role.role_id,
             tuple(item.name.value for item in self._permissions.definitions),
+            role.concurrency_version,
+        )
+        await self._repository.set_user_roles(
+            user.user_id, (role.role_id,), user.concurrency_version
         )
-        await self._repository.set_user_roles(user.user_id, (role.role_id,))
 
 
 def _new_session(user_id: UUID, refresh_token: str, *, now: datetime) -> RefreshSession: