Carry over the lab 3 solution

Bring the application, own tests, Dockerfile, toolchain, compose stack,
HAProxy and k6 configuration, migrations, hooks, evidence and level 4
scripts and the CI job from the lab 3 solution commit 61c0c28, merge
the lab 3 Makefile targets into the lab 4 skeleton Makefile without
touching its targets, and append the lab 3 solution variables to the
skeleton .env.example. The package and the application follow the
contract version 1.4.0, and the image and the throwaway test containers
are tagged lab4 so they do not collide with a lab 3 stand on the same
host.

This is the starting point of the lab 4 cycle: lint, own tests and the
offline skeleton check pass before any lab 4 change.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Artyom
2026-10-28 20:17:51 +03:00
co-authored by Claude Opus 5.5
parent b0f463ac5c
commit bf8e4e3cd1
129 changed files with 8698 additions and 1 deletions
View File
+66
View File
@@ -0,0 +1,66 @@
import asyncio
import logging
import os
import sys
from typing import Any
from gunicorn.arbiter import Arbiter
from gunicorn.glogging import Logger as GunicornBaseLogger
from uvicorn.server import Server
from uvicorn_worker import UvicornWorker
from messenger.main import LOG_FIELDS
from messenger.shared.entrypoints.health import DRAINING
from messenger.shared.infrastructure.logging import configure
LOG_LEVEL = os.environ.get("LOG_LEVEL", "INFO")
SHUTDOWN_SECONDS = int(os.environ.get("SHUTDOWN_TIMEOUT_SECONDS", "5"))
DRAIN_SECONDS = float(os.environ.get("DRAIN_SECONDS", "2"))
class StructlogGunicornLogger(GunicornBaseLogger):
def setup(self, cfg: object) -> None:
configure(LOG_LEVEL, LOG_FIELDS)
def access(self, resp: object, req: object, environ: object, request_time: object) -> None:
return
class DrainingServer(Server):
async def main_loop(self) -> None:
await super().main_loop()
if not self.force_exit:
DRAINING.set()
logging.getLogger("uvicorn.error").info("Draining for %.1f s", DRAIN_SECONDS)
await asyncio.sleep(DRAIN_SECONDS)
class MessengerWorker(UvicornWorker):
CONFIG_KWARGS: dict[str, Any] = {
"access_log": False,
"server_header": False,
"date_header": False,
"timeout_graceful_shutdown": max(1, int(SHUTDOWN_SECONDS - DRAIN_SECONDS)),
}
async def _serve(self) -> None:
self.config.app = self.wsgi
server = DrainingServer(config=self.config)
self._install_sigquit_handler()
await server.serve(sockets=self.sockets)
if not server.started:
sys.exit(Arbiter.WORKER_BOOT_ERROR)
bind = f"{os.environ.get('HOST', '0.0.0.0')}:{os.environ.get('PORT', '8080')}"
workers = int(os.environ.get("WEB_CONCURRENCY", "2"))
worker_class = "messenger.gunicorn_conf.MessengerWorker"
logger_class = StructlogGunicornLogger
loglevel = LOG_LEVEL.lower()
accesslog = None
errorlog = "-"
timeout = int(float(os.environ.get("REQUEST_TIMEOUT_SECONDS", "8")) + 5)
graceful_timeout = SHUTDOWN_SECONDS
keepalive = 5
preload_app = False
control_socket_disable = True
View File
@@ -0,0 +1,5 @@
from messenger.shared.application.messagebus import CommandBus
class IdentityCommandBus(CommandBus):
__slots__ = ()
@@ -0,0 +1,22 @@
from dataclasses import dataclass, field
from uuid import UUID
from messenger.identity.domain.models import Session
from messenger.shared.application.commands import Command
@dataclass(frozen=True, slots=True)
class RegisterUser(Command):
username: str
display_name: str
password: str = field(repr=False)
@dataclass(frozen=True, slots=True)
class OpenSession(Command):
user_id: UUID
@dataclass(frozen=True, slots=True)
class CloseSession(Command):
session: Session
@@ -0,0 +1,76 @@
from datetime import timedelta
from messenger.identity.application.commands import CloseSession, OpenSession, RegisterUser
from messenger.identity.application.ports import (
IdentityUnitOfWork,
PasswordHasher,
SessionDirectory,
)
from messenger.identity.domain.events import SessionClosed, SessionOpened
from messenger.identity.domain.models import Session, User
from messenger.identity.domain.values import DisplayName, Password, Username
from messenger.shared.application.ports import Clock, IdGenerator
class RegisterUserHandler:
__slots__ = ("_clock", "_hasher", "_ids", "_uow")
def __init__(
self, uow: IdentityUnitOfWork, clock: Clock, ids: IdGenerator, hasher: PasswordHasher
) -> None:
self._uow = uow
self._clock = clock
self._ids = ids
self._hasher = hasher
async def __call__(self, command: RegisterUser) -> User:
username = Username(command.username)
display_name = DisplayName(command.display_name)
password = Password(command.password)
password_hash = await self._hasher.hash(password.value)
user, event = User.register(
user_id=self._ids.new_id(),
username=username,
display_name=display_name,
password_hash=password_hash,
registered_at=self._clock.now(),
)
async with self._uow.transaction():
await self._uow.users.add(user)
self._uow.record(event)
await self._uow.commit()
return user
class OpenSessionHandler:
__slots__ = ("_clock", "_ttl", "_uow")
def __init__(self, uow: IdentityUnitOfWork, clock: Clock, ttl: timedelta) -> None:
self._uow = uow
self._clock = clock
self._ttl = ttl
async def __call__(self, command: OpenSession) -> tuple[str, Session]:
token, session = Session.issue(
user_id=command.user_id, issued_at=self._clock.now(), ttl=self._ttl
)
async with self._uow.transaction():
await self._uow.sessions.add(session)
self._uow.record(SessionOpened(user_id=session.user_id, expires_at=session.expires_at))
await self._uow.commit()
return token, session
class CloseSessionHandler:
__slots__ = ("_sessions", "_uow")
def __init__(self, uow: IdentityUnitOfWork, sessions: SessionDirectory) -> None:
self._uow = uow
self._sessions = sessions
async def __call__(self, command: CloseSession) -> None:
await self._sessions.invalidate(command.session)
async with self._uow.transaction():
await self._uow.sessions.remove(command.session.token_hash)
self._uow.record(SessionClosed(user_id=command.session.user_id))
await self._uow.commit()
@@ -0,0 +1,48 @@
from datetime import datetime
from typing import Protocol, runtime_checkable
from uuid import UUID
from messenger.identity.domain.models import Session, User
from messenger.shared.application.ports import UnitOfWork
@runtime_checkable
class UserRepository(Protocol):
async def add(self, user: User) -> None: ...
@runtime_checkable
class SessionRepository(Protocol):
async def add(self, session: Session) -> None: ...
async def remove(self, token_hash: bytes) -> None: ...
@runtime_checkable
class IdentityUnitOfWork(UnitOfWork, Protocol):
@property
def users(self) -> UserRepository: ...
@property
def sessions(self) -> SessionRepository: ...
@runtime_checkable
class UserDirectory(Protocol):
async def find(self, user_id: UUID) -> User | None: ...
async def find_by_username(self, username: str) -> User | None: ...
@runtime_checkable
class SessionDirectory(Protocol):
async def find(self, token_hash: bytes, now: datetime) -> Session | None: ...
async def invalidate(self, session: Session) -> None: ...
@runtime_checkable
class PasswordHasher(Protocol):
async def hash(self, password: str) -> str: ...
async def verify(self, password_hash: str | None, password: str) -> bool: ...
@@ -0,0 +1,43 @@
from uuid import UUID
from messenger.identity.application.ports import PasswordHasher, SessionDirectory, UserDirectory
from messenger.identity.domain.errors import ActorNotIdentified
from messenger.identity.domain.models import Session, User, token_digest
from messenger.shared.application.ports import Clock
class GetCurrentUser:
__slots__ = ("_directory",)
def __init__(self, directory: UserDirectory) -> None:
self._directory = directory
async def __call__(self, user_id: UUID) -> User:
user = await self._directory.find(user_id)
if user is None:
raise ActorNotIdentified("идентификация не подтверждена")
return user
class VerifyCredentials:
__slots__ = ("_directory", "_hasher")
def __init__(self, directory: UserDirectory, hasher: PasswordHasher) -> None:
self._directory = directory
self._hasher = hasher
async def __call__(self, username: str, password: str) -> User | None:
user = await self._directory.find_by_username(username)
valid = await self._hasher.verify(user.password_hash if user else None, password)
return user if valid else None
class Authenticate:
__slots__ = ("_clock", "_sessions")
def __init__(self, sessions: SessionDirectory, clock: Clock) -> None:
self._sessions = sessions
self._clock = clock
async def __call__(self, token: str) -> Session | None:
return await self._sessions.find(token_digest(token), self._clock.now())
+12
View File
@@ -0,0 +1,12 @@
from pydantic import Field, SecretStr
from messenger.shared.config import Settings
class IdentitySettings(Settings):
session_ttl_seconds: int = Field(default=3600, ge=1, le=30 * 24 * 3600)
password_hash_concurrency: int = Field(default=2, ge=1, le=64)
cache_url: SecretStr | None = None
session_cache_ttl_seconds: int = Field(default=300, ge=1, le=24 * 3600)
cache_timeout_seconds: float = Field(default=0.2, gt=0, le=5)
cache_cooldown_seconds: float = Field(default=1.0, ge=0, le=60)
+17
View File
@@ -0,0 +1,17 @@
from messenger.shared.domain.errors import DomainError
class IdentityError(DomainError):
pass
class InvalidUserData(IdentityError):
pass
class UsernameAlreadyTaken(IdentityError):
pass
class ActorNotIdentified(IdentityError):
pass
+25
View File
@@ -0,0 +1,25 @@
from dataclasses import dataclass, field
from datetime import datetime
from uuid import UUID
from messenger.shared.domain.events import DomainEvent
@dataclass(frozen=True, slots=True)
class UserRegistered(DomainEvent):
user_id: UUID
registered_at: datetime
name: str = field(init=False, default="user.registered")
@dataclass(frozen=True, slots=True)
class SessionOpened(DomainEvent):
user_id: UUID
expires_at: datetime
name: str = field(init=False, default="session.opened")
@dataclass(frozen=True, slots=True)
class SessionClosed(DomainEvent):
user_id: UUID
name: str = field(init=False, default="session.closed")
+62
View File
@@ -0,0 +1,62 @@
import secrets
from dataclasses import dataclass, field
from datetime import datetime, timedelta
from hashlib import sha256
from uuid import UUID
from messenger.identity.domain.events import UserRegistered
from messenger.identity.domain.values import DisplayName, Username
from messenger.shared.domain.events import DomainEvent
TOKEN_BYTES = 32
def token_digest(token: str) -> bytes:
return sha256(token.encode()).digest()
@dataclass(frozen=True, slots=True)
class User:
id: UUID
username: Username
display_name: DisplayName
created_at: datetime
password_hash: str = field(repr=False)
@classmethod
def register(
cls,
*,
user_id: UUID,
username: Username,
display_name: DisplayName,
password_hash: str,
registered_at: datetime,
) -> tuple[User, DomainEvent]:
user = cls(
id=user_id,
username=username,
display_name=display_name,
created_at=registered_at,
password_hash=password_hash,
)
return user, UserRegistered(user_id=user.id, registered_at=registered_at)
@dataclass(frozen=True, slots=True)
class Session:
token_hash: bytes = field(repr=False)
user_id: UUID
created_at: datetime
expires_at: datetime
@classmethod
def issue(cls, *, user_id: UUID, issued_at: datetime, ttl: timedelta) -> tuple[str, Session]:
token = secrets.token_urlsafe(TOKEN_BYTES)
session = cls(
token_hash=token_digest(token),
user_id=user_id,
created_at=issued_at,
expires_at=issued_at + ttl,
)
return token, session
+54
View File
@@ -0,0 +1,54 @@
import re
from dataclasses import dataclass, field
from messenger.identity.domain.errors import InvalidUserData
USERNAME_PATTERN = re.compile(r"\A[a-z0-9_]{3,32}\Z")
DISPLAY_NAME_MAX = 100
PASSWORD_MIN = 12
PASSWORD_MAX = 128
@dataclass(frozen=True, slots=True)
class Username:
value: str
def __post_init__(self) -> None:
if not isinstance(self.value, str):
raise InvalidUserData("поле username должно быть строкой")
if USERNAME_PATTERN.match(self.value) is None:
raise InvalidUserData("поле username должно соответствовать [a-z0-9_]{3,32}")
def __str__(self) -> str:
return self.value
@dataclass(frozen=True, slots=True)
class DisplayName:
value: str
def __post_init__(self) -> None:
if not isinstance(self.value, str):
raise InvalidUserData("поле display_name должно быть строкой")
if not self.value.strip():
raise InvalidUserData("поле display_name не может быть пустым или состоять из пробелов")
if len(self.value) > DISPLAY_NAME_MAX:
raise InvalidUserData(f"поле display_name длиннее {DISPLAY_NAME_MAX} символов Unicode")
def __str__(self) -> str:
return self.value
@dataclass(frozen=True, slots=True)
class Password:
value: str = field(repr=False)
def __post_init__(self) -> None:
if not isinstance(self.value, str):
raise InvalidUserData("поле password должно быть строкой")
if not self.value.strip():
raise InvalidUserData("поле password не может состоять из пробелов")
if not PASSWORD_MIN <= len(self.value) <= PASSWORD_MAX:
raise InvalidUserData(
f"поле password: от {PASSWORD_MIN} до {PASSWORD_MAX} символов Unicode"
)
@@ -0,0 +1,98 @@
import re
from base64 import b64decode
from binascii import Error as Base64Error
from typing import Annotated
from fastapi import Depends, Request
from starlette.types import Scope
from messenger.identity.application.queries import Authenticate, VerifyCredentials
from messenger.identity.domain.models import Session, User
from messenger.shared.entrypoints.errors import Unauthenticated
from messenger.shared.entrypoints.pipeline import Rejection, header
LOGIN_PATH = "/api/v1/auth/sessions"
PROTECTED_PREFIX = "/api/v1/"
PUBLIC_ROUTES = frozenset({("POST", "/api/v1/users")})
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
BEARER_CHALLENGE = 'Bearer realm="messenger"'
AUTHORIZATION = b"authorization"
TOKEN = re.compile(r"[A-Za-z0-9\-._~+/]{1,512}=*")
def normalized(path: str) -> str:
return path.rstrip("/") or "/"
def challenge_for(path: str) -> str:
return BASIC_CHALLENGE if normalized(path) == LOGIN_PATH else BEARER_CHALLENGE
def basic_credentials(value: str) -> tuple[str, str] | None:
scheme, _, encoded = value.partition(" ")
if scheme.lower() != "basic":
return None
try:
decoded = b64decode(encoded.strip(), validate=True).decode("utf-8")
except Base64Error, UnicodeDecodeError:
return None
username, separator, password = decoded.partition(":")
if not separator or not username.isascii():
return None
return username, password
def bearer_token(value: str) -> str | None:
scheme, _, token = value.partition(" ")
token = token.strip()
if scheme.lower() != "bearer" or TOKEN.fullmatch(token) is None:
return None
return token
def rejection(path: str) -> Rejection:
return Rejection(401, "unauthorized", (("www-authenticate", challenge_for(path)),))
async def guard(scope: Scope) -> Rejection | None:
method, path = scope["method"], normalized(scope["path"])
if not path.startswith(PROTECTED_PREFIX) or (method, path) in PUBLIC_ROUTES:
return None
container = scope["app"].state.dishka_container
state = scope.setdefault("state", {})
raw = header(scope, AUTHORIZATION)
if (method, path) == ("POST", LOGIN_PATH):
credentials = basic_credentials(raw)
verify = await container.get(VerifyCredentials)
user = await verify(*credentials) if credentials else None
if user is None:
return rejection(path)
state["user"] = user
state["actor"] = user.id
return None
token = bearer_token(raw)
authenticate = await container.get(Authenticate)
session = await authenticate(token) if token else None
if session is None:
return rejection(path)
state["session"] = session
state["actor"] = session.user_id
return None
async def verified_user(request: Request) -> User:
user = getattr(request.state, "user", None)
if not isinstance(user, User):
raise Unauthenticated("учётные данные не подтверждены")
return user
async def current_session(request: Request) -> Session:
session = getattr(request.state, "session", None)
if not isinstance(session, Session):
raise Unauthenticated("сессия не подтверждена")
return session
type VerifiedUser = Annotated[User, Depends(verified_user)]
type CurrentSession = Annotated[Session, Depends(current_session)]
@@ -0,0 +1,12 @@
from messenger.identity.domain.errors import (
ActorNotIdentified,
InvalidUserData,
UsernameAlreadyTaken,
)
from messenger.shared.domain.errors import DomainError
ERROR_CODES: dict[type[DomainError], tuple[str, int]] = {
InvalidUserData: ("invalid_request", 400),
UsernameAlreadyTaken: ("conflict", 409),
ActorNotIdentified: ("unauthorized", 401),
}
@@ -0,0 +1,57 @@
from dishka.integrations.fastapi import FromDishka, inject
from fastapi import APIRouter, Request, Response, status
from fastapi.exceptions import RequestValidationError
from messenger.identity.application.bus import IdentityCommandBus
from messenger.identity.application.commands import CloseSession, OpenSession, RegisterUser
from messenger.identity.application.queries import GetCurrentUser
from messenger.identity.entrypoints.authentication import CurrentSession, VerifiedUser
from messenger.identity.entrypoints.schemas import CreateUserRequest, SessionOut, UserOut
from messenger.shared.entrypoints.actor import Actor
router = APIRouter(prefix="/api/v1/users", tags=["users"])
sessions_router = APIRouter(prefix="/api/v1/auth/sessions", tags=["sessions"])
@router.post("", status_code=status.HTTP_201_CREATED)
@inject
async def create_user(
body: CreateUserRequest,
bus: FromDishka[IdentityCommandBus],
) -> UserOut:
user = await bus.execute(
RegisterUser(username=body.username, display_name=body.display_name, password=body.password)
)
return UserOut.of(user)
@router.get("/me")
@inject
async def current_user(
actor: Actor,
query: FromDishka[GetCurrentUser],
) -> UserOut:
return UserOut.of(await query(actor))
@sessions_router.post("", status_code=status.HTTP_201_CREATED)
@inject
async def open_session(
request: Request,
user: VerifiedUser,
bus: FromDishka[IdentityCommandBus],
) -> SessionOut:
if await request.body():
raise RequestValidationError([])
token, session = await bus.execute(OpenSession(user_id=user.id))
return SessionOut.of(token, session, user)
@sessions_router.delete("/current", status_code=status.HTTP_204_NO_CONTENT)
@inject
async def close_session(
session: CurrentSession,
bus: FromDishka[IdentityCommandBus],
) -> Response:
await bus.execute(CloseSession(session=session))
return Response(status_code=status.HTTP_204_NO_CONTENT)
+112
View File
@@ -0,0 +1,112 @@
from collections.abc import AsyncIterator
from datetime import timedelta
from dishka import Provider, Scope, provide
from redis.asyncio import Redis
from redis.asyncio.retry import Retry
from redis.backoff import NoBackoff
from messenger.identity.application.bus import IdentityCommandBus
from messenger.identity.application.commands import CloseSession, OpenSession, RegisterUser
from messenger.identity.application.handlers import (
CloseSessionHandler,
OpenSessionHandler,
RegisterUserHandler,
)
from messenger.identity.application.ports import (
IdentityUnitOfWork,
PasswordHasher,
SessionDirectory,
UserDirectory,
)
from messenger.identity.application.queries import Authenticate, GetCurrentUser, VerifyCredentials
from messenger.identity.config import IdentitySettings
from messenger.identity.infrastructure.argon2 import Argon2PasswordHasher
from messenger.identity.infrastructure.postgres import (
PostgresIdentityUnitOfWork,
PostgresSessionDirectory,
PostgresUserDirectory,
)
from messenger.identity.infrastructure.valkey import CachedSessionDirectory
from messenger.shared.application.commands import Command
from messenger.shared.application.messagebus import CommandHandler
from messenger.shared.application.ports import Clock, EventPublisher, IdGenerator, Logger
from messenger.shared.infrastructure.postgres import Database
class IdentityProvider(Provider):
def __init__(self, settings: IdentitySettings) -> None:
super().__init__()
self._settings = settings
@provide(scope=Scope.APP)
def settings(self) -> IdentitySettings:
return self._settings
@provide(scope=Scope.APP)
def hasher(self, settings: IdentitySettings) -> PasswordHasher:
return Argon2PasswordHasher(settings.password_hash_concurrency)
@provide(scope=Scope.APP)
def users(self, database: Database) -> UserDirectory:
return PostgresUserDirectory(database)
@provide(scope=Scope.APP)
async def sessions(
self, database: Database, settings: IdentitySettings, logger: Logger
) -> AsyncIterator[SessionDirectory]:
origin = PostgresSessionDirectory(database)
if settings.cache_url is None:
yield origin
return
client = Redis.from_url(
settings.cache_url.get_secret_value(),
socket_connect_timeout=settings.cache_timeout_seconds,
socket_timeout=settings.cache_timeout_seconds,
retry=Retry(NoBackoff(), 1),
)
try:
yield CachedSessionDirectory(
origin,
client,
logger,
limit=timedelta(seconds=settings.session_cache_ttl_seconds),
cooldown=settings.cache_cooldown_seconds,
)
finally:
await client.aclose()
@provide(scope=Scope.APP)
def verify(self, users: UserDirectory, hasher: PasswordHasher) -> VerifyCredentials:
return VerifyCredentials(users, hasher)
@provide(scope=Scope.APP)
def authenticate(self, sessions: SessionDirectory, clock: Clock) -> Authenticate:
return Authenticate(sessions, clock)
@provide(scope=Scope.REQUEST)
def unit_of_work(self, database: Database) -> IdentityUnitOfWork:
return PostgresIdentityUnitOfWork(database)
@provide(scope=Scope.REQUEST)
def current_user(self, users: UserDirectory) -> GetCurrentUser:
return GetCurrentUser(users)
@provide(scope=Scope.REQUEST)
def command_bus(
self,
uow: IdentityUnitOfWork,
publisher: EventPublisher,
clock: Clock,
ids: IdGenerator,
hasher: PasswordHasher,
sessions: SessionDirectory,
settings: IdentitySettings,
) -> IdentityCommandBus:
ttl = timedelta(seconds=settings.session_ttl_seconds)
handlers: dict[type[Command], CommandHandler] = {
RegisterUser: RegisterUserHandler(uow, clock, ids, hasher),
OpenSession: OpenSessionHandler(uow, clock, ttl),
CloseSession: CloseSessionHandler(uow, sessions),
}
return IdentityCommandBus(handlers, uow, publisher)
@@ -0,0 +1,20 @@
from messenger.identity.domain.events import SessionClosed, SessionOpened, UserRegistered
from messenger.shared.application.ports import Logger
LOG_FIELDS = frozenset({"actor_id"})
class IdentityJournal:
__slots__ = ("_logger",)
def __init__(self, logger: Logger) -> None:
self._logger = logger
async def on_user_registered(self, event: UserRegistered) -> None:
self._logger.info("audit.user_registered", actor_id=str(event.user_id))
async def on_session_opened(self, event: SessionOpened) -> None:
self._logger.info("audit.session_opened", actor_id=str(event.user_id))
async def on_session_closed(self, event: SessionClosed) -> None:
self._logger.info("audit.session_closed", actor_id=str(event.user_id))
@@ -0,0 +1,42 @@
from datetime import datetime
from typing import Literal
from uuid import UUID
from pydantic import BaseModel, ConfigDict
from messenger.identity.domain.models import Session, User
class CreateUserRequest(BaseModel):
model_config = ConfigDict(extra="forbid", strict=True)
username: str
display_name: str
password: str
class UserOut(BaseModel):
id: UUID
username: str
display_name: str
created_at: datetime
@classmethod
def of(cls, user: User) -> UserOut:
return cls(
id=user.id,
username=user.username.value,
display_name=user.display_name.value,
created_at=user.created_at,
)
class SessionOut(BaseModel):
token: str
token_type: Literal["Bearer"] = "Bearer"
expires_at: datetime
user: UserOut
@classmethod
def of(cls, token: str, session: Session, user: User) -> SessionOut:
return cls(token=token, expires_at=session.expires_at, user=UserOut.of(user))
@@ -0,0 +1,35 @@
import asyncio
import secrets
from argon2 import PasswordHasher, Type
from argon2.exceptions import InvalidHashError, VerificationError
TIME_COST = 2
MEMORY_COST_KIB = 19_456
PARALLELISM = 1
class Argon2PasswordHasher:
__slots__ = ("_dummy", "_hasher", "_slots")
def __init__(self, concurrency: int) -> None:
self._hasher = PasswordHasher(
time_cost=TIME_COST,
memory_cost=MEMORY_COST_KIB,
parallelism=PARALLELISM,
type=Type.ID,
)
self._slots = asyncio.Semaphore(concurrency)
self._dummy = self._hasher.hash(secrets.token_urlsafe(16))
async def hash(self, password: str) -> str:
async with self._slots:
return await asyncio.to_thread(self._hasher.hash, password)
async def verify(self, password_hash: str | None, password: str) -> bool:
async with self._slots:
try:
await asyncio.to_thread(self._hasher.verify, password_hash or self._dummy, password)
except VerificationError, InvalidHashError:
return False
return password_hash is not None
@@ -0,0 +1,124 @@
from datetime import datetime
from uuid import UUID
from asyncpg import Record
from messenger.identity.domain.errors import UsernameAlreadyTaken
from messenger.identity.domain.models import Session, User
from messenger.identity.domain.values import DisplayName, Username
from messenger.shared.infrastructure.postgres import Connection, Database, PostgresUnitOfWork
INSERT_USER = """
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES ($1, $2, $3, $4, $5)
ON CONFLICT (username) DO NOTHING
RETURNING true
"""
USER_BY_ID = """
SELECT id, username, display_name, password_hash, created_at FROM users WHERE id = $1
"""
USER_BY_USERNAME = """
SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = $1
"""
INSERT_SESSION = """
WITH expired AS (DELETE FROM sessions WHERE user_id = $2 AND expires_at <= $3)
INSERT INTO sessions (token_hash, user_id, created_at, expires_at) VALUES ($1, $2, $3, $4)
"""
DELETE_SESSION = "DELETE FROM sessions WHERE token_hash = $1"
ACTIVE_SESSION = """
SELECT token_hash, user_id, created_at, expires_at
FROM sessions
WHERE token_hash = $1 AND expires_at > $2
"""
def user_of(row: Record | None) -> User | None:
if row is None:
return None
return User(
id=row["id"],
username=Username(row["username"]),
display_name=DisplayName(row["display_name"]),
created_at=row["created_at"],
password_hash=row["password_hash"],
)
class PostgresUserRepository:
__slots__ = ("_connection",)
def __init__(self, connection: Connection) -> None:
self._connection = connection
async def add(self, user: User) -> None:
inserted = await self._connection.fetchval(
INSERT_USER,
user.id,
user.username.value,
user.display_name.value,
user.password_hash,
user.created_at,
)
if inserted is None:
raise UsernameAlreadyTaken("username уже занят")
class PostgresSessionRepository:
__slots__ = ("_connection",)
def __init__(self, connection: Connection) -> None:
self._connection = connection
async def add(self, session: Session) -> None:
await self._connection.execute(
INSERT_SESSION,
session.token_hash,
session.user_id,
session.created_at,
session.expires_at,
)
async def remove(self, token_hash: bytes) -> None:
await self._connection.execute(DELETE_SESSION, token_hash)
class PostgresIdentityUnitOfWork(PostgresUnitOfWork):
__slots__ = ()
@property
def users(self) -> PostgresUserRepository:
return PostgresUserRepository(self.connection)
@property
def sessions(self) -> PostgresSessionRepository:
return PostgresSessionRepository(self.connection)
class PostgresUserDirectory:
__slots__ = ("_database",)
def __init__(self, database: Database) -> None:
self._database = database
async def find(self, user_id: UUID) -> User | None:
async with self._database.connection() as connection:
return user_of(await connection.fetchrow(USER_BY_ID, user_id))
async def find_by_username(self, username: str) -> User | None:
async with self._database.connection() as connection:
return user_of(await connection.fetchrow(USER_BY_USERNAME, username))
class PostgresSessionDirectory:
__slots__ = ("_database",)
def __init__(self, database: Database) -> None:
self._database = database
async def find(self, token_hash: bytes, now: datetime) -> Session | None:
async with self._database.connection() as connection:
row = await connection.fetchrow(ACTIVE_SESSION, token_hash, now)
return None if row is None else Session(**dict(row))
async def invalidate(self, session: Session) -> None:
return None
@@ -0,0 +1,102 @@
import time
from collections.abc import Awaitable
from datetime import datetime, timedelta
from uuid import UUID
from redis.asyncio import Redis
from redis.exceptions import RedisError
from messenger.identity.application.ports import SessionDirectory
from messenger.identity.domain.models import Session
from messenger.shared.application.errors import Unavailable
from messenger.shared.application.ports import Logger
REVOKED = "-"
FAILURES = (RedisError, OSError)
def key_of(token_hash: bytes) -> str:
return f"session:{token_hash.hex()}"
def milliseconds(moment: datetime) -> int:
return int(moment.timestamp() * 1000)
def encode(session: Session) -> str:
return f"{session.user_id} {session.created_at.isoformat()} {session.expires_at.isoformat()}"
def decode(token_hash: bytes, value: str) -> Session:
user_id, created_at, expires_at = value.split(" ")
return Session(
token_hash=token_hash,
user_id=UUID(user_id),
created_at=datetime.fromisoformat(created_at),
expires_at=datetime.fromisoformat(expires_at),
)
class CachedSessionDirectory:
__slots__ = ("_client", "_cooldown", "_limit", "_logger", "_origin", "_resume_at")
def __init__(
self,
origin: SessionDirectory,
client: Redis,
logger: Logger,
*,
limit: timedelta,
cooldown: float,
) -> None:
self._origin = origin
self._client = client
self._logger = logger
self._limit = limit
self._cooldown = cooldown
self._resume_at = 0.0
async def find(self, token_hash: bytes, now: datetime) -> Session | None:
key = key_of(token_hash)
cached = await self._read(key)
if cached == REVOKED:
return None
if cached is not None:
session = decode(token_hash, cached)
return session if session.expires_at > now else None
session = await self._origin.find(token_hash, now)
if session is not None and self._closed():
until = milliseconds(min(session.expires_at, now + self._limit))
await self._quietly(self._client.set(key, encode(session), pxat=until, nx=True))
return session
async def invalidate(self, session: Session) -> None:
if not self._closed():
raise Unavailable("кэш сессий недоступен")
try:
await self._client.set(
key_of(session.token_hash), REVOKED, pxat=milliseconds(session.expires_at)
)
except FAILURES as error:
self._trip(error)
raise Unavailable("кэш сессий недоступен") from error
async def _read(self, key: str) -> str | None:
if not self._closed():
return None
value = await self._quietly(self._client.get(key))
return value.decode() if isinstance(value, bytes) else value
async def _quietly[ResultT](self, call: Awaitable[ResultT]) -> ResultT | None:
try:
return await call
except FAILURES as error:
self._trip(error)
return None
def _closed(self) -> bool:
return time.monotonic() >= self._resume_at
def _trip(self, error: Exception) -> None:
self._resume_at = time.monotonic() + self._cooldown
self._logger.warning("cache.bypassed", error=type(error).__name__, limit=self._cooldown)
+104
View File
@@ -0,0 +1,104 @@
from collections.abc import AsyncIterator
from contextlib import asynccontextmanager
from dishka import make_async_container
from dishka.integrations.fastapi import FastapiProvider, setup_dishka
from fastapi import FastAPI
from messenger.identity.config import IdentitySettings
from messenger.identity.domain.events import SessionClosed, SessionOpened, UserRegistered
from messenger.identity.entrypoints.authentication import challenge_for, guard
from messenger.identity.entrypoints.errors import ERROR_CODES as IDENTITY_ERRORS
from messenger.identity.entrypoints.http import router as users_router
from messenger.identity.entrypoints.http import sessions_router
from messenger.identity.entrypoints.ioc import IdentityProvider
from messenger.identity.entrypoints.journal import LOG_FIELDS as IDENTITY_FIELDS
from messenger.identity.entrypoints.journal import IdentityJournal
from messenger.messaging.config import MessagingSettings
from messenger.messaging.domain.events import ChatCreated, MessagePosted
from messenger.messaging.entrypoints.errors import ERROR_CODES as MESSAGING_ERRORS
from messenger.messaging.entrypoints.http import chats_router, messages_router
from messenger.messaging.entrypoints.ioc import MessagingProvider
from messenger.messaging.entrypoints.journal import LOG_FIELDS as MESSAGING_FIELDS
from messenger.messaging.entrypoints.journal import MessagingJournal
from messenger.shared.application.messagebus import EventBus
from messenger.shared.application.ports import Logger
from messenger.shared.config import PlatformSettings
from messenger.shared.entrypoints import errors, health
from messenger.shared.entrypoints.config import TransportSettings
from messenger.shared.entrypoints.ioc import PlatformProvider
from messenger.shared.entrypoints.pipeline import RequestPipeline
from messenger.shared.infrastructure.logging import PLATFORM_FIELDS, StructlogLogger
TRANSPORT_FIELDS = frozenset({"dropped_total", "queue", "instance"})
LOG_FIELDS = PLATFORM_FIELDS | TRANSPORT_FIELDS | IDENTITY_FIELDS | MESSAGING_FIELDS
ERROR_CODES = {**IDENTITY_ERRORS, **MESSAGING_ERRORS}
def wire_events(bus: EventBus, logger: Logger) -> None:
identity = IdentityJournal(logger)
bus.subscribe(UserRegistered, identity.on_user_registered)
bus.subscribe(SessionOpened, identity.on_session_opened)
bus.subscribe(SessionClosed, identity.on_session_closed)
messaging = MessagingJournal(logger)
bus.subscribe(ChatCreated, messaging.on_chat_created)
bus.subscribe(MessagePosted, messaging.on_message_posted)
def create_app(
platform: PlatformSettings | None = None,
transport: TransportSettings | None = None,
identity: IdentitySettings | None = None,
messaging: MessagingSettings | None = None,
) -> FastAPI:
platform = platform or PlatformSettings()
transport = transport or TransportSettings()
identity = identity or IdentitySettings()
messaging = messaging or MessagingSettings()
logger = StructlogLogger(level=platform.log_level, allowed_fields=LOG_FIELDS)
container = make_async_container(
PlatformProvider(platform, logger),
IdentityProvider(identity),
MessagingProvider(messaging),
FastapiProvider(),
)
@asynccontextmanager
async def lifespan(_app: FastAPI) -> AsyncIterator[None]:
bus = await container.get(EventBus)
wire_events(bus, logger)
bus.start()
logger.info("service.started")
try:
yield
finally:
await bus.stop()
await container.close()
logger.info("service.stopped")
app = FastAPI(
title="MTUSI Messenger",
version="1.4.0",
lifespan=lifespan,
docs_url="/docs" if transport.docs else None,
redoc_url=None,
openapi_url="/openapi.json" if transport.docs else None,
)
app.add_middleware(
RequestPipeline,
logger=logger,
max_bytes=transport.max_body_bytes,
timeout=transport.request_timeout_seconds,
guard=guard,
instance=platform.instance_id,
)
errors.install(app, logger, ERROR_CODES, challenge_for, platform.instance_id)
app.include_router(health.router)
app.include_router(users_router)
app.include_router(sessions_router)
app.include_router(chats_router)
app.include_router(messages_router)
setup_dishka(container, app)
return app
View File
@@ -0,0 +1,5 @@
from messenger.shared.application.messagebus import CommandBus
class MessagingCommandBus(CommandBus):
__slots__ = ()
@@ -0,0 +1,21 @@
from collections.abc import Sequence
from dataclasses import dataclass
from uuid import UUID
from messenger.shared.application.commands import Command
@dataclass(frozen=True, slots=True)
class CreateChat(Command):
creator_id: UUID
title: str
member_ids: Sequence[UUID]
@dataclass(frozen=True, slots=True)
class PostMessage(Command):
sender_id: UUID
chat_id: UUID
text: str
key: str
fingerprint: bytes
@@ -0,0 +1,62 @@
from datetime import timedelta
from messenger.messaging.application.commands import CreateChat, PostMessage
from messenger.messaging.application.ports import MessagingUnitOfWork
from messenger.messaging.domain.errors import ChatNotFound
from messenger.messaging.domain.models import Chat, Message, Receipt
from messenger.shared.application.ports import Clock, IdGenerator
class CreateChatHandler:
__slots__ = ("_clock", "_ids", "_uow")
def __init__(self, uow: MessagingUnitOfWork, clock: Clock, ids: IdGenerator) -> None:
self._uow = uow
self._clock = clock
self._ids = ids
async def __call__(self, command: CreateChat) -> Chat:
chat = Chat.create(
chat_id=self._ids.new_id(),
title=command.title,
member_ids=command.member_ids,
creator_id=command.creator_id,
created_at=self._clock.now(),
)
async with self._uow.transaction():
await self._uow.chats.add(chat)
await self._uow.commit()
return chat
class PostMessageHandler:
__slots__ = ("_clock", "_ids", "_ttl", "_uow")
def __init__(
self, uow: MessagingUnitOfWork, clock: Clock, ids: IdGenerator, ttl: timedelta
) -> None:
self._uow = uow
self._clock = clock
self._ids = ids
self._ttl = ttl
async def __call__(self, command: PostMessage) -> Message:
async with self._uow.transaction():
chat = await self._uow.chats.get(command.chat_id)
if chat is None:
raise ChatNotFound("чат не найден")
now = self._clock.now()
message = chat.post(
message_id=self._ids.new_id(),
sender_id=command.sender_id,
text=command.text,
now=now,
)
known = await self._uow.chats.receipt(
chat.id, command.sender_id, command.key, now - self._ttl
)
if known is not None:
return known.replay(command.fingerprint)
await self._uow.chats.append(Receipt(command.key, command.fingerprint, message))
await self._uow.commit()
return message
@@ -0,0 +1,46 @@
from datetime import datetime
from typing import Protocol, runtime_checkable
from uuid import UUID
from messenger.messaging.domain.keys import HistoryKey
from messenger.messaging.domain.models import Chat, Message, Receipt
from messenger.shared.application.ports import UnitOfWork
@runtime_checkable
class CursorCodec(Protocol):
def encode(self, scope: str, key: HistoryKey) -> str: ...
def decode(self, scope: str, raw: str) -> HistoryKey: ...
@runtime_checkable
class ChatRepository(Protocol):
async def add(self, chat: Chat) -> None: ...
async def get(self, chat_id: UUID) -> Chat | None: ...
async def receipt(
self, chat_id: UUID, sender_id: UUID, key: str, since: datetime
) -> Receipt | None: ...
async def append(self, receipt: Receipt) -> None: ...
@runtime_checkable
class MessagingUnitOfWork(UnitOfWork, Protocol):
@property
def chats(self) -> ChatRepository: ...
@runtime_checkable
class ChatDirectory(Protocol):
async def chat_for_member(self, chat_id: UUID, user_id: UUID) -> Chat | None: ...
async def chats_of(
self, user_id: UUID, *, after: HistoryKey | None, limit: int
) -> tuple[list[Chat], bool]: ...
async def history(
self, chat_id: UUID, *, after: HistoryKey | None, limit: int
) -> tuple[list[Message], bool]: ...
@@ -0,0 +1,73 @@
from dataclasses import dataclass
from uuid import UUID
from messenger.messaging.application.ports import ChatDirectory, CursorCodec
from messenger.messaging.domain.errors import ChatNotFound
from messenger.messaging.domain.keys import HistoryKey
from messenger.messaging.domain.models import Chat, Message
@dataclass(frozen=True, slots=True)
class Page[ItemT]:
items: list[ItemT]
next_cursor: str | None
def chats_scope(user_id: UUID) -> str:
return f"chats:{user_id}"
def messages_scope(chat_id: UUID) -> str:
return f"messages:{chat_id}"
class GetChat:
__slots__ = ("_chats",)
def __init__(self, chats: ChatDirectory) -> None:
self._chats = chats
async def __call__(self, chat_id: UUID, user_id: UUID) -> Chat:
chat = await self._chats.chat_for_member(chat_id, user_id)
if chat is None:
raise ChatNotFound("чат не найден")
return chat
class ListChats:
__slots__ = ("_chats", "_cursors")
def __init__(self, chats: ChatDirectory, cursors: CursorCodec) -> None:
self._chats = chats
self._cursors = cursors
async def __call__(self, user_id: UUID, *, limit: int, cursor: str | None) -> Page[Chat]:
scope = chats_scope(user_id)
after: HistoryKey | None = self._cursors.decode(scope, cursor) if cursor else None
items, has_more = await self._chats.chats_of(user_id, after=after, limit=limit)
next_cursor = self._cursors.encode(scope, items[-1].key) if has_more and items else None
return Page(items=items, next_cursor=next_cursor)
class ReadHistory:
__slots__ = ("_chats", "_cursors")
def __init__(self, chats: ChatDirectory, cursors: CursorCodec) -> None:
self._chats = chats
self._cursors = cursors
async def __call__(
self,
chat_id: UUID,
user_id: UUID,
*,
limit: int,
cursor: str | None,
) -> Page[Message]:
if await self._chats.chat_for_member(chat_id, user_id) is None:
raise ChatNotFound("чат не найден")
scope = messages_scope(chat_id)
after: HistoryKey | None = self._cursors.decode(scope, cursor) if cursor else None
items, has_more = await self._chats.history(chat_id, after=after, limit=limit)
next_cursor = self._cursors.encode(scope, items[-1].key) if has_more and items else None
return Page(items=items, next_cursor=next_cursor)
+8
View File
@@ -0,0 +1,8 @@
from pydantic import Field, SecretStr
from messenger.shared.config import Settings
class MessagingSettings(Settings):
cursor_secret: SecretStr = Field(min_length=16)
idempotency_ttl_seconds: int = Field(default=86_400, ge=1)
+25
View File
@@ -0,0 +1,25 @@
from messenger.shared.domain.errors import DomainError
class MessagingError(DomainError):
pass
class InvalidChatData(MessagingError):
pass
class InvalidMessageText(MessagingError):
pass
class InvalidPageRequest(MessagingError):
pass
class ChatNotFound(MessagingError):
pass
class IdempotencyConflict(MessagingError):
pass
+24
View File
@@ -0,0 +1,24 @@
from dataclasses import dataclass, field
from datetime import datetime
from uuid import UUID
from messenger.shared.domain.events import DomainEvent
@dataclass(frozen=True, slots=True)
class ChatCreated(DomainEvent):
chat_id: UUID
creator_id: UUID
member_count: int
created_at: datetime
name: str = field(init=False, default="chat.created")
@dataclass(frozen=True, slots=True)
class MessagePosted(DomainEvent):
message_id: UUID
chat_id: UUID
sender_id: UUID
text_length: int
created_at: datetime
name: str = field(init=False, default="message.posted")
+3
View File
@@ -0,0 +1,3 @@
from datetime import datetime
type HistoryKey = tuple[datetime, int]
+142
View File
@@ -0,0 +1,142 @@
from collections.abc import Sequence
from dataclasses import dataclass
from datetime import datetime, timedelta
from uuid import UUID
from messenger.messaging.domain.errors import ChatNotFound, IdempotencyConflict, InvalidChatData
from messenger.messaging.domain.events import ChatCreated, MessagePosted
from messenger.messaging.domain.keys import HistoryKey
from messenger.messaging.domain.values import CHAT_MEMBERS_MAX, ChatTitle, MessageText
from messenger.shared.domain.events import DomainEvent
TICK = timedelta(microseconds=1)
@dataclass(frozen=True, slots=True)
class Message:
id: UUID
chat_id: UUID
sender_id: UUID
text: MessageText
created_at: datetime
@property
def key(self) -> HistoryKey:
return (self.created_at, self.id.int)
@dataclass(frozen=True, slots=True)
class Receipt:
key: str
fingerprint: bytes
message: Message
def replay(self, fingerprint: bytes) -> Message:
if fingerprint != self.fingerprint:
raise IdempotencyConflict("ключ идемпотентности уже использован с другим телом")
return self.message
class Chat:
__slots__ = (
"_events",
"_members",
"created_at",
"id",
"last_message_at",
"member_ids",
"title",
)
def __init__(
self,
*,
chat_id: UUID,
title: ChatTitle,
member_ids: Sequence[UUID],
created_at: datetime,
last_message_at: datetime | None = None,
) -> None:
self.id = chat_id
self.title = title
self.member_ids: tuple[UUID, ...] = tuple(member_ids)
self.created_at = created_at
self.last_message_at = last_message_at
self._members: frozenset[UUID] = frozenset(member_ids)
self._events: list[DomainEvent] = []
@classmethod
def create(
cls,
*,
chat_id: UUID,
title: str,
member_ids: Sequence[UUID],
creator_id: UUID,
created_at: datetime,
) -> Chat:
if not member_ids:
raise InvalidChatData("поле member_ids не может быть пустым")
if len(member_ids) > CHAT_MEMBERS_MAX:
raise InvalidChatData(f"поле member_ids содержит больше {CHAT_MEMBERS_MAX} участников")
unique = set(member_ids)
if len(unique) != len(member_ids):
raise InvalidChatData("поле member_ids содержит дубликаты")
if creator_id not in unique:
raise InvalidChatData("создатель чата обязан входить в список member_ids")
chat = cls(
chat_id=chat_id,
title=ChatTitle(title),
member_ids=member_ids,
created_at=created_at,
)
chat.record(
ChatCreated(
chat_id=chat.id,
creator_id=creator_id,
member_count=len(unique),
created_at=created_at,
)
)
return chat
@property
def key(self) -> HistoryKey:
return (self.created_at, self.id.int)
def record(self, event: DomainEvent) -> None:
self._events.append(event)
def is_member(self, user_id: UUID) -> bool:
return user_id in self._members
def require_member(self, user_id: UUID) -> None:
if not self.is_member(user_id):
raise ChatNotFound("чат не найден")
def post(self, *, message_id: UUID, sender_id: UUID, text: str, now: datetime) -> Message:
self.require_member(sender_id)
last = self.last_message_at
created_at = now if last is None or now > last else last + TICK
message = Message(
id=message_id,
chat_id=self.id,
sender_id=sender_id,
text=MessageText(text),
created_at=created_at,
)
self.last_message_at = created_at
self.record(
MessagePosted(
message_id=message.id,
chat_id=self.id,
sender_id=sender_id,
text_length=len(message.text.value),
created_at=created_at,
)
)
return message
def collect_events(self) -> list[DomainEvent]:
events, self._events = self._events, []
return events
+39
View File
@@ -0,0 +1,39 @@
from dataclasses import dataclass
from messenger.messaging.domain.errors import InvalidChatData, InvalidMessageText
CHAT_TITLE_MAX = 100
MESSAGE_TEXT_MAX = 4000
CHAT_MEMBERS_MAX = 100
@dataclass(frozen=True, slots=True)
class ChatTitle:
value: str
def __post_init__(self) -> None:
if not isinstance(self.value, str):
raise InvalidChatData("поле title должно быть строкой")
if not self.value.strip():
raise InvalidChatData("поле title не может быть пустым или состоять из пробелов")
if len(self.value) > CHAT_TITLE_MAX:
raise InvalidChatData(f"поле title длиннее {CHAT_TITLE_MAX} символов Unicode")
def __str__(self) -> str:
return self.value
@dataclass(frozen=True, slots=True)
class MessageText:
value: str
def __post_init__(self) -> None:
if not isinstance(self.value, str):
raise InvalidMessageText("поле text должно быть строкой")
if not self.value.strip():
raise InvalidMessageText("поле text не может быть пустым или состоять из пробелов")
if len(self.value) > MESSAGE_TEXT_MAX:
raise InvalidMessageText(f"поле text длиннее {MESSAGE_TEXT_MAX} символов Unicode")
def __str__(self) -> str:
return self.value
@@ -0,0 +1,16 @@
from messenger.messaging.domain.errors import (
ChatNotFound,
IdempotencyConflict,
InvalidChatData,
InvalidMessageText,
InvalidPageRequest,
)
from messenger.shared.domain.errors import DomainError
ERROR_CODES: dict[type[DomainError], tuple[str, int]] = {
InvalidChatData: ("invalid_request", 400),
InvalidMessageText: ("invalid_request", 400),
InvalidPageRequest: ("invalid_request", 400),
ChatNotFound: ("not_found", 404),
IdempotencyConflict: ("conflict", 409),
}
@@ -0,0 +1,89 @@
from typing import Annotated
from uuid import UUID
from dishka.integrations.fastapi import FromDishka, inject
from fastapi import APIRouter, Query, status
from messenger.messaging.application.bus import MessagingCommandBus
from messenger.messaging.application.commands import CreateChat, PostMessage
from messenger.messaging.application.queries import GetChat, ListChats, ReadHistory
from messenger.messaging.entrypoints.schemas import (
ChatOut,
CreateChatRequest,
CreateMessageRequest,
IdempotencyKey,
MessageOut,
PageOut,
PageQuery,
)
from messenger.shared.entrypoints.actor import Actor
chats_router = APIRouter(prefix="/api/v1/chats", tags=["chats"])
messages_router = APIRouter(prefix="/api/v1/chats/{chat_id}/messages", tags=["messages"])
@chats_router.post("", status_code=status.HTTP_201_CREATED)
@inject
async def create_chat(
actor: Actor,
body: CreateChatRequest,
bus: FromDishka[MessagingCommandBus],
) -> ChatOut:
chat = await bus.execute(
CreateChat(creator_id=actor, title=body.title, member_ids=body.member_ids)
)
return ChatOut.of(chat)
@chats_router.get("")
@inject
async def list_chats(
actor: Actor,
page: Annotated[PageQuery, Query()],
query: FromDishka[ListChats],
) -> PageOut[ChatOut]:
chats = await query(actor, limit=page.limit, cursor=page.cursor)
return PageOut[ChatOut].of(chats, ChatOut.of)
@chats_router.get("/{chat_id}")
@inject
async def read_chat(
chat_id: UUID,
actor: Actor,
query: FromDishka[GetChat],
) -> ChatOut:
return ChatOut.of(await query(chat_id, actor))
@messages_router.post("", status_code=status.HTTP_201_CREATED)
@inject
async def post_message(
chat_id: UUID,
actor: Actor,
body: CreateMessageRequest,
key: IdempotencyKey,
bus: FromDishka[MessagingCommandBus],
) -> MessageOut:
message = await bus.execute(
PostMessage(
sender_id=actor,
chat_id=chat_id,
text=body.text,
key=key,
fingerprint=body.fingerprint(),
)
)
return MessageOut.of(message)
@messages_router.get("")
@inject
async def read_history(
chat_id: UUID,
actor: Actor,
page: Annotated[PageQuery, Query()],
query: FromDishka[ReadHistory],
) -> PageOut[MessageOut]:
messages = await query(chat_id, actor, limit=page.limit, cursor=page.cursor)
return PageOut[MessageOut].of(messages, MessageOut.of)
@@ -0,0 +1,69 @@
from datetime import timedelta
from dishka import Provider, Scope, provide
from messenger.messaging.application.bus import MessagingCommandBus
from messenger.messaging.application.commands import CreateChat, PostMessage
from messenger.messaging.application.handlers import CreateChatHandler, PostMessageHandler
from messenger.messaging.application.ports import ChatDirectory, CursorCodec, MessagingUnitOfWork
from messenger.messaging.application.queries import GetChat, ListChats, ReadHistory
from messenger.messaging.config import MessagingSettings
from messenger.messaging.infrastructure.cursor import SignedCursorCodec
from messenger.messaging.infrastructure.postgres import (
PostgresChatDirectory,
PostgresMessagingUnitOfWork,
)
from messenger.shared.application.commands import Command
from messenger.shared.application.messagebus import CommandHandler
from messenger.shared.application.ports import Clock, EventPublisher, IdGenerator
from messenger.shared.infrastructure.postgres import Database
class MessagingProvider(Provider):
def __init__(self, settings: MessagingSettings) -> None:
super().__init__()
self._settings = settings
@provide(scope=Scope.APP)
def settings(self) -> MessagingSettings:
return self._settings
@provide(scope=Scope.APP)
def directory(self, database: Database) -> ChatDirectory:
return PostgresChatDirectory(database)
@provide(scope=Scope.APP)
def cursors(self, settings: MessagingSettings) -> CursorCodec:
return SignedCursorCodec(settings.cursor_secret.get_secret_value().encode())
@provide(scope=Scope.REQUEST)
def unit_of_work(self, database: Database) -> MessagingUnitOfWork:
return PostgresMessagingUnitOfWork(database)
@provide(scope=Scope.REQUEST)
def chat(self, directory: ChatDirectory) -> GetChat:
return GetChat(directory)
@provide(scope=Scope.REQUEST)
def chat_list(self, directory: ChatDirectory, cursors: CursorCodec) -> ListChats:
return ListChats(directory, cursors)
@provide(scope=Scope.REQUEST)
def history(self, directory: ChatDirectory, cursors: CursorCodec) -> ReadHistory:
return ReadHistory(directory, cursors)
@provide(scope=Scope.REQUEST)
def command_bus(
self,
uow: MessagingUnitOfWork,
publisher: EventPublisher,
clock: Clock,
ids: IdGenerator,
settings: MessagingSettings,
) -> MessagingCommandBus:
ttl = timedelta(seconds=settings.idempotency_ttl_seconds)
handlers: dict[type[Command], CommandHandler] = {
CreateChat: CreateChatHandler(uow, clock, ids),
PostMessage: PostMessageHandler(uow, clock, ids, ttl),
}
return MessagingCommandBus(handlers, uow, publisher)
@@ -0,0 +1,27 @@
from messenger.messaging.domain.events import ChatCreated, MessagePosted
from messenger.shared.application.ports import Logger
LOG_FIELDS = frozenset({"chat_id", "message_id", "count"})
class MessagingJournal:
__slots__ = ("_logger",)
def __init__(self, logger: Logger) -> None:
self._logger = logger
async def on_chat_created(self, event: ChatCreated) -> None:
self._logger.info(
"audit.chat_created",
chat_id=str(event.chat_id),
actor_id=str(event.creator_id),
count=event.member_count,
)
async def on_message_posted(self, event: MessagePosted) -> None:
self._logger.info(
"audit.message_posted",
chat_id=str(event.chat_id),
actor_id=str(event.sender_id),
message_id=str(event.message_id),
)
@@ -0,0 +1,82 @@
from collections.abc import Callable
from datetime import datetime
from hashlib import sha256
from typing import Annotated, Self
from uuid import UUID
from fastapi import Header
from pydantic import BaseModel, ConfigDict, Field
from messenger.messaging.application.queries import Page
from messenger.messaging.domain.models import Chat, Message
STRICT = ConfigDict(extra="forbid", strict=True)
type IdempotencyKey = Annotated[
str,
Header(alias="Idempotency-Key", min_length=1, max_length=128, pattern=r"^[A-Za-z0-9._:-]+$"),
]
class CreateChatRequest(BaseModel):
model_config = STRICT
title: str
member_ids: list[Annotated[UUID, Field(strict=False)]]
class CreateMessageRequest(BaseModel):
model_config = STRICT
text: str
def fingerprint(self) -> bytes:
return sha256(self.model_dump_json().encode()).digest()
class PageQuery(BaseModel):
limit: int = Field(default=50, ge=1, le=100)
cursor: str | None = None
class ChatOut(BaseModel):
id: UUID
title: str
member_ids: tuple[UUID, ...]
created_at: datetime
@classmethod
def of(cls, chat: Chat) -> ChatOut:
return cls(
id=chat.id,
title=chat.title.value,
member_ids=chat.member_ids,
created_at=chat.created_at,
)
class MessageOut(BaseModel):
id: UUID
chat_id: UUID
sender_id: UUID
text: str
created_at: datetime
@classmethod
def of(cls, message: Message) -> MessageOut:
return cls(
id=message.id,
chat_id=message.chat_id,
sender_id=message.sender_id,
text=message.text.value,
created_at=message.created_at,
)
class PageOut[ItemT](BaseModel):
items: list[ItemT]
next_cursor: str | None
@classmethod
def of[SourceT](cls, page: Page[SourceT], view: Callable[[SourceT], ItemT]) -> Self:
return cls(items=[view(item) for item in page.items], next_cursor=page.next_cursor)
@@ -0,0 +1,59 @@
import hmac
from base64 import urlsafe_b64decode, urlsafe_b64encode
from datetime import UTC, datetime, timedelta
from hashlib import sha256
from messenger.messaging.domain.errors import InvalidPageRequest
from messenger.messaging.domain.keys import HistoryKey
VERSION = "1"
SIGNATURE_BYTES = 12
EPOCH = datetime(1970, 1, 1, tzinfo=UTC)
PARTS = 4
def _encode_part(value: bytes) -> str:
return urlsafe_b64encode(value).decode("ascii").rstrip("=")
def _decode_part(value: str) -> bytes:
padding = "=" * (-len(value) % 4)
try:
return urlsafe_b64decode(value + padding)
except (ValueError, TypeError) as error:
raise InvalidPageRequest("параметр cursor повреждён") from error
class SignedCursorCodec:
__slots__ = ("_secret",)
def __init__(self, secret: bytes) -> None:
self._secret = secret
def encode(self, scope: str, key: HistoryKey) -> str:
moment, identifier = key
micros = (moment - EPOCH) // timedelta(microseconds=1)
body = f"{VERSION}.{micros}.{identifier:032x}"
return f"{body}.{_encode_part(self._sign(scope, body))}"
def decode(self, scope: str, raw: str) -> HistoryKey:
parts = raw.split(".")
if len(parts) != PARTS or parts[0] != VERSION:
raise InvalidPageRequest("параметр cursor не распознан")
body = ".".join(parts[:3])
if not hmac.compare_digest(self._sign(scope, body), _decode_part(parts[3])):
raise InvalidPageRequest("параметр cursor недействителен для этого запроса")
try:
micros = int(parts[1])
identifier = int(parts[2], 16)
except ValueError as error:
raise InvalidPageRequest("параметр cursor повреждён") from error
try:
moment = EPOCH + timedelta(microseconds=micros)
except (OverflowError, ValueError) as error:
raise InvalidPageRequest("параметр cursor повреждён") from error
return (moment, identifier)
def _sign(self, scope: str, body: str) -> bytes:
payload = f"{scope}|{body}".encode()
return hmac.new(self._secret, payload, sha256).digest()[:SIGNATURE_BYTES]
@@ -0,0 +1,201 @@
from collections.abc import Sequence
from datetime import datetime
from uuid import UUID
from asyncpg import ForeignKeyViolationError, Record
from messenger.messaging.domain.errors import InvalidChatData
from messenger.messaging.domain.keys import HistoryKey
from messenger.messaging.domain.models import Chat, Message, Receipt
from messenger.messaging.domain.values import ChatTitle, MessageText
from messenger.shared.infrastructure.postgres import (
Connection,
Database,
EventSource,
PostgresUnitOfWork,
)
INSERT_CHAT = "INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)"
INSERT_MEMBERS = """
INSERT INTO chat_members (chat_id, user_id, position, chat_created_at)
SELECT $1, member.user_id, member.position, $3
FROM unnest($2::uuid[]) WITH ORDINALITY AS member (user_id, position)
"""
LOCK_CHAT = """
SELECT c.id, c.title, c.created_at, c.last_message_at,
ARRAY(SELECT user_id FROM chat_members WHERE chat_id = c.id ORDER BY position) AS member_ids
FROM chats c
WHERE c.id = $1
FOR UPDATE
"""
RECEIPT = """
SELECT k.fingerprint, m.id, m.chat_id, m.sender_id, m.text, m.created_at
FROM idempotency_keys k JOIN messages m ON m.id = k.message_id
WHERE k.chat_id = $1 AND k.user_id = $2 AND k.key = $3 AND k.created_at > $4
"""
APPEND_MESSAGE = """
WITH message AS (
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES ($1, $2, $3, $4, $5)
RETURNING id, chat_id, sender_id, created_at
), receipt AS (
INSERT INTO idempotency_keys (chat_id, user_id, key, fingerprint, message_id, created_at)
SELECT chat_id, sender_id, $6, $7, id, created_at FROM message
ON CONFLICT (chat_id, user_id, key) DO UPDATE
SET fingerprint = EXCLUDED.fingerprint,
message_id = EXCLUDED.message_id,
created_at = EXCLUDED.created_at
)
UPDATE chats SET last_message_at = message.created_at
FROM message
WHERE chats.id = message.chat_id
"""
CHAT_OF_MEMBER = """
SELECT c.id, c.title, c.created_at,
ARRAY(SELECT user_id FROM chat_members WHERE chat_id = c.id ORDER BY position) AS member_ids
FROM chat_members m JOIN chats c ON c.id = m.chat_id
WHERE m.chat_id = $1 AND m.user_id = $2
"""
CHATS_FIRST = """
SELECT c.id, c.title, c.created_at,
ARRAY(SELECT user_id FROM chat_members WHERE chat_id = c.id ORDER BY position) AS member_ids
FROM chat_members m JOIN chats c ON c.id = m.chat_id
WHERE m.user_id = $1
ORDER BY m.chat_created_at, m.chat_id
LIMIT $2
"""
CHATS_AFTER = """
SELECT c.id, c.title, c.created_at,
ARRAY(SELECT user_id FROM chat_members WHERE chat_id = c.id ORDER BY position) AS member_ids
FROM chat_members m JOIN chats c ON c.id = m.chat_id
WHERE m.user_id = $1 AND (m.chat_created_at, m.chat_id) > ($2, $3)
ORDER BY m.chat_created_at, m.chat_id
LIMIT $4
"""
HISTORY_FIRST = """
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = $1
ORDER BY created_at, id
LIMIT $2
"""
HISTORY_AFTER = """
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
ORDER BY created_at, id
LIMIT $4
"""
def chat_of(row: Record) -> Chat:
return Chat(
chat_id=row["id"],
title=ChatTitle(row["title"]),
member_ids=row["member_ids"],
created_at=row["created_at"],
last_message_at=row.get("last_message_at"),
)
def message_of(row: Record) -> Message:
return Message(
id=row["id"],
chat_id=row["chat_id"],
sender_id=row["sender_id"],
text=MessageText(row["text"]),
created_at=row["created_at"],
)
def page[ItemT](rows: Sequence[ItemT], limit: int) -> tuple[list[ItemT], bool]:
return list(rows[:limit]), len(rows) > limit
class PostgresChatRepository:
__slots__ = ("_connection", "_seen")
def __init__(self, connection: Connection, seen: list[EventSource]) -> None:
self._connection = connection
self._seen = seen
async def add(self, chat: Chat) -> None:
await self._connection.execute(INSERT_CHAT, chat.id, chat.title.value, chat.created_at)
try:
await self._connection.execute(
INSERT_MEMBERS, chat.id, list(chat.member_ids), chat.created_at
)
except ForeignKeyViolationError as error:
raise InvalidChatData("поле member_ids содержит неизвестного пользователя") from error
self._seen.append(chat)
async def get(self, chat_id: UUID) -> Chat | None:
row = await self._connection.fetchrow(LOCK_CHAT, chat_id)
if row is None:
return None
chat = chat_of(row)
self._seen.append(chat)
return chat
async def receipt(
self, chat_id: UUID, sender_id: UUID, key: str, since: datetime
) -> Receipt | None:
row = await self._connection.fetchrow(RECEIPT, chat_id, sender_id, key, since)
return None if row is None else Receipt(key, row["fingerprint"], message_of(row))
async def append(self, receipt: Receipt) -> None:
message = receipt.message
await self._connection.execute(
APPEND_MESSAGE,
message.id,
message.chat_id,
message.sender_id,
message.text.value,
message.created_at,
receipt.key,
receipt.fingerprint,
)
class PostgresMessagingUnitOfWork(PostgresUnitOfWork):
__slots__ = ()
@property
def chats(self) -> PostgresChatRepository:
return PostgresChatRepository(self.connection, self.seen)
class PostgresChatDirectory:
__slots__ = ("_database",)
def __init__(self, database: Database) -> None:
self._database = database
async def chat_for_member(self, chat_id: UUID, user_id: UUID) -> Chat | None:
async with self._database.connection() as connection:
row = await connection.fetchrow(CHAT_OF_MEMBER, chat_id, user_id)
return None if row is None else chat_of(row)
async def chats_of(
self, user_id: UUID, *, after: HistoryKey | None, limit: int
) -> tuple[list[Chat], bool]:
async with self._database.connection() as connection:
if after is None:
rows = await connection.fetch(CHATS_FIRST, user_id, limit + 1)
else:
rows = await connection.fetch(
CHATS_AFTER, user_id, after[0], UUID(int=after[1]), limit + 1
)
return page([chat_of(row) for row in rows], limit)
async def history(
self, chat_id: UUID, *, after: HistoryKey | None, limit: int
) -> tuple[list[Message], bool]:
async with self._database.connection() as connection:
if after is None:
rows = await connection.fetch(HISTORY_FIRST, chat_id, limit + 1)
else:
rows = await connection.fetch(
HISTORY_AFTER, chat_id, after[0], UUID(int=after[1]), limit + 1
)
return page([message_of(row) for row in rows], limit)
+70
View File
@@ -0,0 +1,70 @@
import asyncio
import hashlib
from importlib import resources
import asyncpg
from messenger.shared.config import PlatformSettings
from messenger.shared.infrastructure.logging import PLATFORM_FIELDS, StructlogLogger
LOCK_KEY = 20_260_002
JOURNAL = """
CREATE TABLE IF NOT EXISTS schema_migrations (
version text PRIMARY KEY,
checksum text NOT NULL,
applied_at timestamptz NOT NULL DEFAULT now()
)
"""
class MigrationChangedError(Exception):
pass
def migrations() -> list[tuple[str, str]]:
folder = resources.files("messenger") / "migrations"
found = (item for item in folder.iterdir() if item.name.endswith(".sql"))
return sorted((item.name.removesuffix(".sql"), item.read_text()) for item in found)
async def migrate(dsn: str) -> list[str]:
connection = await asyncpg.connect(dsn, timeout=10)
try:
await connection.execute("SELECT pg_advisory_lock($1)", LOCK_KEY)
await connection.execute(JOURNAL)
applied = dict(await connection.fetch("SELECT version, checksum FROM schema_migrations"))
done: list[str] = []
for version, sql in migrations():
checksum = hashlib.sha256(sql.encode()).hexdigest()
if version in applied:
if applied[version] != checksum:
raise MigrationChangedError(version)
continue
async with connection.transaction():
await connection.execute(sql)
await connection.execute(
"INSERT INTO schema_migrations (version, checksum) VALUES ($1, $2)",
version,
checksum,
)
done.append(version)
return done
finally:
await connection.close()
def main() -> None:
settings = PlatformSettings()
logger = StructlogLogger(level=settings.log_level, allowed_fields=PLATFORM_FIELDS | {"version"})
try:
done = asyncio.run(migrate(settings.database_url.get_secret_value()))
except MigrationChangedError as error:
logger.error("migration.changed", version=str(error))
raise SystemExit(1) from None
for version in done:
logger.info("migration.applied", version=version)
logger.info("migration.completed", reason="up to date" if not done else "applied")
if __name__ == "__main__":
main()
+46
View File
@@ -0,0 +1,46 @@
CREATE TABLE users (
id uuid PRIMARY KEY,
username text NOT NULL CONSTRAINT users_username_key UNIQUE
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
display_name text NOT NULL CHECK (char_length(display_name) BETWEEN 1 AND 100),
password_hash text NOT NULL CHECK (password_hash LIKE '$argon2id$%'),
created_at timestamptz NOT NULL
);
CREATE TABLE sessions (
token_hash bytea PRIMARY KEY CHECK (octet_length(token_hash) = 32),
user_id uuid NOT NULL REFERENCES users (id) ON DELETE CASCADE,
created_at timestamptz NOT NULL,
expires_at timestamptz NOT NULL,
CHECK (expires_at > created_at)
);
CREATE INDEX sessions_user_idx ON sessions (user_id);
CREATE TABLE chats (
id uuid PRIMARY KEY,
title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100),
created_at timestamptz NOT NULL,
last_message_at timestamptz
);
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
user_id uuid NOT NULL REFERENCES users (id),
position smallint NOT NULL CHECK (position BETWEEN 1 AND 100),
chat_created_at timestamptz NOT NULL,
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_created_at, chat_id);
CREATE TABLE messages (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL,
sender_id uuid NOT NULL,
text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000),
created_at timestamptz NOT NULL,
FOREIGN KEY (chat_id, sender_id) REFERENCES chat_members (chat_id, user_id)
);
CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id);
@@ -0,0 +1,10 @@
CREATE TABLE idempotency_keys (
chat_id uuid NOT NULL,
user_id uuid NOT NULL,
key text NOT NULL CHECK (key ~ '^[A-Za-z0-9._:-]{1,128}$'),
fingerprint bytea NOT NULL CHECK (octet_length(fingerprint) = 32),
message_id uuid NOT NULL REFERENCES messages (id) ON DELETE CASCADE,
created_at timestamptz NOT NULL,
PRIMARY KEY (chat_id, user_id, key),
FOREIGN KEY (chat_id, user_id) REFERENCES chat_members (chat_id, user_id)
);
View File
@@ -0,0 +1,2 @@
class Command:
pass
@@ -0,0 +1,2 @@
class Unavailable(Exception):
pass
@@ -0,0 +1,123 @@
import asyncio
from collections.abc import Awaitable, Callable, Mapping, Sequence
from contextlib import suppress
from typing import Any
from messenger.shared.application.commands import Command
from messenger.shared.application.ports import EventPublisher, Logger, UnitOfWork
from messenger.shared.domain.events import DomainEvent
type CommandHandler = Callable[[Any], Awaitable[Any]]
type EventHandler[EventT: DomainEvent] = Callable[[EventT], Awaitable[None]]
class CommandBus:
__slots__ = ("_handlers", "_publisher", "_uow")
def __init__(
self,
handlers: Mapping[type[Command], CommandHandler],
uow: UnitOfWork,
publisher: EventPublisher,
) -> None:
self._handlers = handlers
self._uow = uow
self._publisher = publisher
async def execute(self, command: Command) -> Any:
handler = self._handlers.get(type(command))
if handler is None:
raise LookupError(f"нет обработчика для команды {type(command).__name__}")
result = await handler(command)
events = self._uow.collect_new_events()
if events:
await self._publisher.publish(events)
return result
class EventBus:
__slots__ = ("_deferred", "_dropped", "_logger", "_projections", "_queue", "_worker")
def __init__(self, logger: Logger, *, max_queue: int = 10_000) -> None:
self._logger = logger
self._queue: asyncio.Queue[DomainEvent] = asyncio.Queue(maxsize=max_queue)
self._projections: dict[type[DomainEvent], list[Any]] = {}
self._deferred: dict[type[DomainEvent], list[Any]] = {}
self._worker: asyncio.Task[None] | None = None
self._dropped = 0
def project[EventT: DomainEvent](
self, event_type: type[EventT], handler: EventHandler[EventT]
) -> None:
self._projections.setdefault(event_type, []).append(handler)
def subscribe[EventT: DomainEvent](
self, event_type: type[EventT], handler: EventHandler[EventT]
) -> None:
self._deferred.setdefault(event_type, []).append(handler)
async def emit(self, event: DomainEvent) -> bool:
await self._run(self._projections.get(type(event), []), event, "projection")
if not self._deferred.get(type(event)):
return True
try:
self._queue.put_nowait(event)
except asyncio.QueueFull:
self._dropped += 1
self._logger.warning(
"event.dropped", event_name=event.name, dropped_total=self._dropped
)
return False
return True
@property
def dropped(self) -> int:
return self._dropped
@property
def pending(self) -> int:
return self._queue.qsize()
def start(self) -> None:
if self._worker is None:
self._worker = asyncio.create_task(self._drain())
async def stop(self) -> None:
if self._worker is None:
return
await self._queue.join()
self._worker.cancel()
with suppress(asyncio.CancelledError):
await self._worker
self._worker = None
async def _drain(self) -> None:
while True:
event = await self._queue.get()
try:
await self._run(self._deferred.get(type(event), []), event, "subscriber")
finally:
self._queue.task_done()
async def _run(self, handlers: Sequence[Any], event: DomainEvent, kind: str) -> None:
for handler in handlers:
try:
await handler(event)
except Exception as error:
self._logger.error(
"event.handler_failed",
event_name=event.name,
reason=kind,
error=type(error).__name__,
)
class InMemoryEventPublisher:
__slots__ = ("_bus",)
def __init__(self, bus: EventBus) -> None:
self._bus = bus
async def publish(self, events: Sequence[DomainEvent]) -> None:
for event in events:
await self._bus.emit(event)
+42
View File
@@ -0,0 +1,42 @@
from collections.abc import Sequence
from contextlib import AbstractAsyncContextManager
from datetime import datetime
from typing import Any, Protocol, runtime_checkable
from uuid import UUID
from messenger.shared.domain.events import DomainEvent
@runtime_checkable
class Clock(Protocol):
def now(self) -> datetime: ...
@runtime_checkable
class IdGenerator(Protocol):
def new_id(self) -> UUID: ...
@runtime_checkable
class Logger(Protocol):
def info(self, event: str, /, **fields: Any) -> None: ...
def warning(self, event: str, /, **fields: Any) -> None: ...
def error(self, event: str, /, **fields: Any) -> None: ...
@runtime_checkable
class UnitOfWork(Protocol):
def transaction(self) -> AbstractAsyncContextManager[None]: ...
async def commit(self) -> None: ...
def record(self, event: DomainEvent) -> None: ...
def collect_new_events(self) -> list[DomainEvent]: ...
@runtime_checkable
class EventPublisher(Protocol):
async def publish(self, events: Sequence[DomainEvent]) -> None: ...
+49
View File
@@ -0,0 +1,49 @@
import os
import socket
from pathlib import Path
from typing import Any
from pydantic import Field, SecretStr
from pydantic.fields import FieldInfo
from pydantic_settings import BaseSettings, PydanticBaseSettingsSource, SettingsConfigDict
CONFIG = SettingsConfigDict(extra="ignore", frozen=True)
class FileVariables(PydanticBaseSettingsSource):
def get_field_value(self, field: FieldInfo, field_name: str) -> tuple[Any, str, bool]:
path = os.environ.get(f"{field_name.upper()}_FILE")
return (Path(path).read_text().strip() if path else None), field_name, False
def __call__(self) -> dict[str, Any]:
found = {
name: self.get_field_value(field, name)[0]
for name, field in self.settings_cls.model_fields.items()
}
return {name: value for name, value in found.items() if value is not None}
class Settings(BaseSettings):
model_config = CONFIG
@classmethod
def settings_customise_sources(
cls,
settings_cls: type[BaseSettings],
init_settings: PydanticBaseSettingsSource,
env_settings: PydanticBaseSettingsSource,
dotenv_settings: PydanticBaseSettingsSource,
file_secret_settings: PydanticBaseSettingsSource,
) -> tuple[PydanticBaseSettingsSource, ...]:
return init_settings, env_settings, FileVariables(settings_cls)
class PlatformSettings(Settings):
log_level: str = "INFO"
instance_id: str = Field(default_factory=socket.gethostname, min_length=1)
event_queue_max: int = Field(default=10_000, ge=16)
database_url: SecretStr
db_pool_max_size: int = Field(default=8, ge=1, le=50)
db_connect_timeout_seconds: float = Field(default=1.0, gt=0, le=30)
db_acquire_timeout_seconds: float = Field(default=1.0, gt=0, le=30)
db_command_timeout_seconds: float = Field(default=2.0, gt=0, le=60)
+4
View File
@@ -0,0 +1,4 @@
class DomainError(Exception):
def __init__(self, detail: str) -> None:
super().__init__(detail)
self.detail = detail
+6
View File
@@ -0,0 +1,6 @@
from dataclasses import dataclass, field
@dataclass(frozen=True, slots=True)
class DomainEvent:
name: str = field(init=False, default="domain.event")
+16
View File
@@ -0,0 +1,16 @@
from typing import Annotated
from uuid import UUID
from fastapi import Depends, Request
from messenger.shared.entrypoints.errors import Unauthenticated
async def current_actor(request: Request) -> UUID:
actor = getattr(request.state, "actor", None)
if not isinstance(actor, UUID):
raise Unauthenticated("заголовок идентификации обязателен и должен быть действительным")
return actor
type Actor = Annotated[UUID, Depends(current_actor)]
@@ -0,0 +1,10 @@
from pydantic import Field
from messenger.shared.config import Settings
class TransportSettings(Settings):
docs: bool = False
max_body_bytes: int = Field(default=1_048_576, ge=4_096)
request_timeout_seconds: float = Field(default=8.0, gt=0, le=300)
shutdown_timeout_seconds: int = Field(default=5, ge=1, le=10)
+136
View File
@@ -0,0 +1,136 @@
from collections.abc import Callable, Mapping
from fastapi import FastAPI, Request, Response, status
from fastapi.exceptions import RequestValidationError
from starlette.exceptions import HTTPException
from messenger.shared.application.errors import Unavailable
from messenger.shared.application.ports import Logger
from messenger.shared.domain.errors import DomainError
from messenger.shared.entrypoints.schemas import ErrorEnvelope
REQUEST_ID_HEADER = "X-Request-Id"
INSTANCE_ID_HEADER = "X-Instance-Id"
type ErrorCodes = Mapping[type[DomainError], tuple[str, int]]
type Challenge = Callable[[str], str]
MESSAGES = {
"invalid_request": "Запрос не соответствует контракту",
"unauthorized": "Аутентификация не предоставлена или недействительна",
"not_found": "Объект не найден",
"conflict": "Конфликт состояния",
"payload_too_large": "Тело запроса больше допустимого",
"unsupported_media_type": "Неподдерживаемый тип содержимого",
"rate_limited": "Слишком много запросов",
"unavailable": "Сервис временно недоступен",
"internal_error": "Внутренняя ошибка",
}
STATUS_CODES = {
status.HTTP_400_BAD_REQUEST: "invalid_request",
status.HTTP_401_UNAUTHORIZED: "unauthorized",
status.HTTP_404_NOT_FOUND: "not_found",
status.HTTP_409_CONFLICT: "conflict",
status.HTTP_413_CONTENT_TOO_LARGE: "payload_too_large",
status.HTTP_415_UNSUPPORTED_MEDIA_TYPE: "unsupported_media_type",
status.HTTP_422_UNPROCESSABLE_CONTENT: "invalid_request",
status.HTTP_429_TOO_MANY_REQUESTS: "rate_limited",
status.HTTP_503_SERVICE_UNAVAILABLE: "unavailable",
}
class Unauthenticated(Exception):
pass
def classify(error: DomainError, codes: ErrorCodes) -> tuple[str, int]:
for kind in type(error).__mro__:
known = codes.get(kind) # type: ignore[arg-type]
if known is not None:
return known
return "internal_error", status.HTTP_500_INTERNAL_SERVER_ERROR
def route_of(request: Request) -> str:
route = request.scope.get("route")
return getattr(route, "path", request.url.path)
def install(
app: FastAPI, logger: Logger, codes: ErrorCodes, challenge: Challenge, instance: str
) -> None:
def error_response(request: Request, code: str, detail: str, http_status: int) -> Response:
request_id = getattr(request.state, "request_id", "") or "unknown"
headers = {REQUEST_ID_HEADER: request_id, INSTANCE_ID_HEADER: instance}
if http_status == status.HTTP_401_UNAUTHORIZED:
headers["WWW-Authenticate"] = challenge(request.url.path)
return Response(
status_code=http_status,
content=ErrorEnvelope.of(code, detail, request_id).model_dump_json(),
media_type="application/json",
headers=headers,
)
@app.exception_handler(DomainError)
async def _domain(request: Request, exc: DomainError) -> Response:
code, http_status = classify(exc, codes)
return error_response(request, code, exc.detail, http_status)
@app.exception_handler(Unavailable)
async def _unavailable(request: Request, exc: Unavailable) -> Response:
logger.warning(
"dependency.unavailable",
route=route_of(request),
error=type(exc.__cause__ or exc).__name__,
request_id=getattr(request.state, "request_id", None),
)
return error_response(
request,
"unavailable",
MESSAGES["unavailable"],
status.HTTP_503_SERVICE_UNAVAILABLE,
)
@app.exception_handler(Unauthenticated)
async def _unauthenticated(request: Request, _exc: Unauthenticated) -> Response:
return error_response(
request,
"unauthorized",
MESSAGES["unauthorized"],
status.HTTP_401_UNAUTHORIZED,
)
@app.exception_handler(RequestValidationError)
async def _validation(request: Request, _exc: RequestValidationError) -> Response:
return error_response(
request,
"invalid_request",
MESSAGES["invalid_request"],
status.HTTP_400_BAD_REQUEST,
)
@app.exception_handler(HTTPException)
async def _http(request: Request, exc: HTTPException) -> Response:
http_status = exc.status_code
if http_status == status.HTTP_405_METHOD_NOT_ALLOWED:
http_status = status.HTTP_404_NOT_FOUND
code = STATUS_CODES.get(http_status, "internal_error")
return error_response(
request, code, MESSAGES.get(code, MESSAGES["internal_error"]), http_status
)
@app.exception_handler(Exception)
async def _unexpected(request: Request, exc: Exception) -> Response:
logger.error(
"request.failed",
route=route_of(request),
error=type(exc).__name__,
request_id=getattr(request.state, "request_id", None),
)
return error_response(
request,
"internal_error",
MESSAGES["internal_error"],
status.HTTP_500_INTERNAL_SERVER_ERROR,
)
@@ -0,0 +1,25 @@
from threading import Event
from dishka.integrations.fastapi import FromDishka, inject
from fastapi import APIRouter
from messenger.shared.application.errors import Unavailable
from messenger.shared.entrypoints.schemas import HealthOut
from messenger.shared.infrastructure.postgres import Database
router = APIRouter(tags=["health"])
DRAINING = Event()
@router.get("/health/live")
async def live() -> HealthOut:
return HealthOut()
@router.get("/health/ready")
@inject
async def ready(database: FromDishka[Database]) -> HealthOut:
if DRAINING.is_set():
raise Unavailable("Реплика выходит из ротации")
await database.ping()
return HealthOut()
+54
View File
@@ -0,0 +1,54 @@
from collections.abc import AsyncIterator
from dishka import Provider, Scope, provide
from messenger.shared.application.messagebus import EventBus, InMemoryEventPublisher
from messenger.shared.application.ports import Clock, EventPublisher, IdGenerator, Logger
from messenger.shared.config import PlatformSettings
from messenger.shared.infrastructure.clock import MonotonicUtcClock
from messenger.shared.infrastructure.ids import Uuid7Generator
from messenger.shared.infrastructure.postgres import Database
class PlatformProvider(Provider):
def __init__(self, settings: PlatformSettings, logger: Logger) -> None:
super().__init__()
self._settings = settings
self._logger = logger
@provide(scope=Scope.APP)
def settings(self) -> PlatformSettings:
return self._settings
@provide(scope=Scope.APP)
def logger(self) -> Logger:
return self._logger
@provide(scope=Scope.APP)
def clock(self) -> Clock:
return MonotonicUtcClock()
@provide(scope=Scope.APP)
def ids(self) -> IdGenerator:
return Uuid7Generator()
@provide(scope=Scope.APP)
async def database(self, settings: PlatformSettings) -> AsyncIterator[Database]:
database = Database(
settings.database_url.get_secret_value(),
max_size=settings.db_pool_max_size,
connect_timeout=settings.db_connect_timeout_seconds,
acquire_timeout=settings.db_acquire_timeout_seconds,
command_timeout=settings.db_command_timeout_seconds,
)
await database.open()
yield database
await database.close()
@provide(scope=Scope.APP)
def event_bus(self, logger: Logger, settings: PlatformSettings) -> EventBus:
return EventBus(logger, max_queue=settings.event_queue_max)
@provide(scope=Scope.APP)
def publisher(self, bus: EventBus) -> EventPublisher:
return InMemoryEventPublisher(bus)
@@ -0,0 +1,165 @@
import asyncio
import time
from collections.abc import Awaitable, Callable
from dataclasses import dataclass
from uuid import uuid4
from starlette.types import ASGIApp, Message, Receive, Scope, Send
from messenger.shared.application.errors import Unavailable
from messenger.shared.application.ports import Logger
from messenger.shared.entrypoints.errors import INSTANCE_ID_HEADER, MESSAGES, REQUEST_ID_HEADER
from messenger.shared.entrypoints.schemas import ErrorEnvelope
type Headers = tuple[tuple[str, str], ...]
@dataclass(frozen=True, slots=True)
class Rejection:
status: int
code: str
headers: Headers = ()
type Guard = Callable[[Scope], Awaitable[Rejection | None]]
HEADER_BYTES = REQUEST_ID_HEADER.lower().encode()
INSTANCE_BYTES = INSTANCE_ID_HEADER.lower().encode()
STAMPED = frozenset({HEADER_BYTES, INSTANCE_BYTES})
MAX_REQUEST_ID = 200
def header(scope: Scope, name: bytes) -> str:
for key, value in scope["headers"]:
if key == name:
return value.decode("latin-1").strip()
return ""
async def send_error(
send: Send, status: int, code: str, request_id: str, headers: Headers = ()
) -> None:
body = ErrorEnvelope.of(code, MESSAGES[code], request_id).model_dump_json().encode()
await send(
{
"type": "http.response.start",
"status": status,
"headers": [
(b"content-type", b"application/json"),
(b"content-length", str(len(body)).encode()),
(HEADER_BYTES, request_id.encode("latin-1", "replace")),
*((name.encode(), value.encode("latin-1")) for name, value in headers),
],
}
)
await send({"type": "http.response.body", "body": body})
class RequestPipeline:
__slots__ = ("_app", "_guard", "_instance", "_logger", "_max_bytes", "_timeout")
def __init__(
self,
app: ASGIApp,
logger: Logger,
max_bytes: int,
timeout: float,
guard: Guard,
instance: str,
) -> None:
self._app = app
self._logger = logger
self._max_bytes = max_bytes
self._timeout = timeout
self._guard = guard
self._instance = instance.encode()
async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
if scope["type"] != "http":
await self._app(scope, receive, send)
return
incoming = header(scope, HEADER_BYTES)
request_id = incoming[:MAX_REQUEST_ID] if incoming else uuid4().hex
state = scope.setdefault("state", {})
state["request_id"] = request_id
state["actor"] = None
started = time.perf_counter()
status_holder = [500]
answered = [False]
async def wrapped_send(message: Message) -> None:
if message["type"] == "http.response.start":
status_holder[0] = message["status"]
answered[0] = True
headers = [
(key, value)
for key, value in message.get("headers", [])
if key.lower() not in STAMPED
]
headers.append((HEADER_BYTES, request_id.encode("latin-1", "replace")))
headers.append((INSTANCE_BYTES, self._instance))
message = {**message, "headers": headers}
await send(message)
declared = header(scope, b"content-length")
if declared.isdigit() and int(declared) > self._max_bytes:
await send_error(wrapped_send, 413, "payload_too_large", request_id)
self._log(scope, status_holder[0], request_id, started)
return
rejection: Rejection | None = None
try:
async with asyncio.timeout(self._timeout):
rejection = await self._guard(scope)
if rejection is None:
await self._app(scope, receive, wrapped_send)
except Unavailable as error:
self._logger.warning(
"dependency.unavailable",
route=self._route(scope),
error=type(error.__cause__ or error).__name__,
request_id=request_id,
)
rejection = Rejection(503, "unavailable")
except TimeoutError:
self._logger.warning(
"request.timeout",
method=scope["method"],
route=self._route(scope),
request_id=request_id,
limit=self._timeout,
duration_ms=round((time.perf_counter() - started) * 1000, 3),
)
if not answered[0]:
await send_error(wrapped_send, 503, "unavailable", request_id)
self._log(scope, status_holder[0], request_id, started)
return
except Exception:
self._logger.error(
"request.unhandled",
method=scope["method"],
route=self._route(scope),
request_id=request_id,
duration_ms=round((time.perf_counter() - started) * 1000, 3),
)
raise
if rejection is not None and not answered[0]:
await send_error(
wrapped_send, rejection.status, rejection.code, request_id, rejection.headers
)
self._log(scope, status_holder[0], request_id, started)
def _route(self, scope: Scope) -> str:
route = scope.get("route")
return getattr(route, "path", scope["path"])
def _log(self, scope: Scope, status: int, request_id: str, started: float) -> None:
self._logger.info(
"request.handled",
method=scope["method"],
route=self._route(scope),
status=status,
request_id=request_id,
duration_ms=round((time.perf_counter() - started) * 1000, 3),
)
@@ -0,0 +1,21 @@
from typing import Literal
from pydantic import BaseModel
class ErrorDetail(BaseModel):
code: str
message: str
request_id: str
class ErrorEnvelope(BaseModel):
error: ErrorDetail
@classmethod
def of(cls, code: str, message: str, request_id: str) -> ErrorEnvelope:
return cls(error=ErrorDetail(code=code, message=message, request_id=request_id))
class HealthOut(BaseModel):
status: Literal["ok"] = "ok"
@@ -0,0 +1,17 @@
from datetime import UTC, datetime, timedelta
TICK = timedelta(microseconds=1)
class MonotonicUtcClock:
__slots__ = ("_last",)
def __init__(self) -> None:
self._last: datetime | None = None
def now(self) -> datetime:
current = datetime.now(UTC)
if self._last is not None and current <= self._last:
current = self._last + TICK
self._last = current
return current
@@ -0,0 +1,8 @@
from uuid import UUID, uuid7
class Uuid7Generator:
__slots__ = ()
def new_id(self) -> UUID:
return uuid7()
@@ -0,0 +1,113 @@
import logging
import sys
from typing import Any
import orjson
import structlog
from structlog.typing import EventDict, Processor, WrappedLogger
PLATFORM_FIELDS = frozenset(
{
"method",
"route",
"status",
"duration_ms",
"request_id",
"event_name",
"error",
"reason",
"limit",
}
)
def render(obj: object, **_kwargs: object) -> str:
return orjson.dumps(obj).decode()
RESERVED = frozenset({"event", "level", "ts", "logger"})
FOREIGN_LOGGERS = (
"uvicorn",
"uvicorn.error",
"gunicorn",
"gunicorn.error",
"asyncio",
)
SILENCED_LOGGERS = ("uvicorn.access", "gunicorn.access")
def field_filter(allowed: frozenset[str]) -> Processor:
def drop_unlisted_fields(
_logger: WrappedLogger, _method: str, event_dict: EventDict
) -> EventDict:
return {
key: value
for key, value in event_dict.items()
if (key in RESERVED or key in allowed) and value is not None
}
return drop_unlisted_fields
def configure(level: str = "INFO", allowed_fields: frozenset[str] = PLATFORM_FIELDS) -> None:
shared = [
structlog.contextvars.merge_contextvars,
structlog.processors.add_log_level,
structlog.processors.TimeStamper(fmt="iso", utc=True, key="ts"),
]
structlog.configure(
processors=[*shared, structlog.stdlib.ProcessorFormatter.wrap_for_formatter],
logger_factory=structlog.stdlib.LoggerFactory(),
wrapper_class=structlog.stdlib.BoundLogger,
cache_logger_on_first_use=False,
)
handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(
structlog.stdlib.ProcessorFormatter(
foreign_pre_chain=shared,
processors=[
structlog.stdlib.ProcessorFormatter.remove_processors_meta,
field_filter(allowed_fields),
structlog.processors.JSONRenderer(serializer=render),
],
)
)
root = logging.getLogger()
for existing in list(root.handlers):
root.removeHandler(existing)
root.addHandler(handler)
root.setLevel(level.upper())
for name in FOREIGN_LOGGERS:
foreign = logging.getLogger(name)
for existing in list(foreign.handlers):
foreign.removeHandler(existing)
foreign.propagate = True
for name in SILENCED_LOGGERS:
silenced = logging.getLogger(name)
for existing in list(silenced.handlers):
silenced.removeHandler(existing)
silenced.propagate = False
class StructlogLogger:
__slots__ = ("_logger",)
def __init__(
self,
name: str = "messenger",
level: str = "INFO",
allowed_fields: frozenset[str] = PLATFORM_FIELDS,
) -> None:
configure(level, allowed_fields)
self._logger = structlog.get_logger(name)
def info(self, event: str, /, **fields: Any) -> None:
self._logger.info(event, **fields)
def warning(self, event: str, /, **fields: Any) -> None:
self._logger.warning(event, **fields)
def error(self, event: str, /, **fields: Any) -> None:
self._logger.error(event, **fields)
@@ -0,0 +1,118 @@
from collections.abc import AsyncIterator
from contextlib import asynccontextmanager
from typing import Any, Protocol
import asyncpg
from messenger.shared.application.errors import Unavailable
from messenger.shared.domain.events import DomainEvent
FAILURES = (
OSError,
asyncpg.InterfaceError,
asyncpg.PostgresConnectionError,
asyncpg.exceptions.OperatorInterventionError,
asyncpg.exceptions.InsufficientResourcesError,
asyncpg.exceptions.LockNotAvailableError,
)
PING_TIMEOUT_SECONDS = 0.4
type Connection = asyncpg.Connection
class EventSource(Protocol):
def collect_events(self) -> list[DomainEvent]: ...
class Database:
__slots__ = ("_acquire_timeout", "_pool")
def __init__(
self,
dsn: str,
*,
max_size: int,
connect_timeout: float,
acquire_timeout: float,
command_timeout: float,
) -> None:
self._acquire_timeout = acquire_timeout
self._pool = asyncpg.create_pool(
dsn,
min_size=0,
max_size=max_size,
timeout=connect_timeout,
command_timeout=command_timeout,
max_inactive_connection_lifetime=60,
server_settings={
"statement_timeout": str(int(command_timeout * 1000)),
"lock_timeout": str(int(command_timeout * 1000)),
"idle_in_transaction_session_timeout": "10000",
},
)
async def open(self) -> None:
await self._pool
async def close(self) -> None:
await self._pool.close()
@asynccontextmanager
async def connection(self, wait: float | None = None) -> AsyncIterator[Connection]:
try:
async with self._pool.acquire(timeout=wait or self._acquire_timeout) as connection:
yield connection
except FAILURES as error:
raise Unavailable("PostgreSQL недоступен") from error
async def ping(self) -> None:
async with self.connection(PING_TIMEOUT_SECONDS) as connection:
await connection.fetchval("SELECT 1", timeout=PING_TIMEOUT_SECONDS)
class PostgresUnitOfWork:
__slots__ = ("_committed", "_connection", "_database", "_events", "_transaction", "seen")
def __init__(self, database: Database) -> None:
self._database = database
self._connection: Connection | None = None
self._transaction: Any = None
self._committed = False
self._events: list[DomainEvent] = []
self.seen: list[EventSource] = []
@property
def connection(self) -> Connection:
if self._connection is None:
raise RuntimeError("репозиторий используется вне транзакции")
return self._connection
@asynccontextmanager
async def transaction(self) -> AsyncIterator[None]:
async with self._database.connection() as connection:
self._connection = connection
self._transaction = connection.transaction()
await self._transaction.start()
self._committed = False
try:
yield
finally:
if not self._committed:
self._events.clear()
await self._transaction.rollback()
self.seen.clear()
self._connection = None
async def commit(self) -> None:
await self._transaction.commit()
self._committed = True
for source in self.seen:
self._events.extend(source.collect_events())
def record(self, event: DomainEvent) -> None:
self._events.append(event)
def collect_new_events(self) -> list[DomainEvent]:
events, self._events = self._events, []
return events