From 22f0e6244d1d755d237a887a397ed6af58c4ee0d Mon Sep 17 00:00:00 2001 From: Artyom Date: Thu, 29 Oct 2026 01:06:49 +0300 Subject: [PATCH] Post a message with one statement under the chat lock Sending a message used to be BEGIN, a SELECT ... FOR UPDATE of the chat with its members, a lookup of the idempotency key, the insert CTE and COMMIT. Three of those round trips ran under the chat row lock, and each one waited for the replica's event loop, so under load the lock holders sat idle in transaction while everyone else queued behind them. The new MessageLog port has one PostgreSQL adapter that does it all in a single statement with an implicit transaction: lock the chat row joined with the sender's membership, stamp the message with the later of the replica clock and the last message plus one microsecond, claim the key (overwriting it only if it has expired), insert the message only when the key was claimed, and move last_message_at. The foreign key from the key to the message is checked at the end of the statement, so the key may be written first. When the key is already taken the adapter reads the stored result with a second statement outside the lock, which also covers a concurrent duplicate that waited for the first one; the handler then replays it or answers 409 as before. The chat aggregate no longer takes part in posting, so its post, membership and last_message_at members and their unit tests are gone; Message.posted() builds the event. An invalid text is still answered 404 for an outsider: only then the handler reads the membership. A new API test pins the clock rule against a real database: a lagging replica clock gets the last stamp plus one microsecond, a clock ahead is kept. The concurrency, same-key race, expiry and access tests pass unchanged. Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_01V1d3RLHNBBMA6UqBLLJv27 --- .../changes/add-lab3-scaling-cost/tasks.md | 2 +- .../messaging/application/handlers.py | 52 +++++---- src/messenger/messaging/application/ports.py | 9 +- src/messenger/messaging/domain/models.py | 58 +++------- src/messenger/messaging/entrypoints/ioc.py | 16 ++- .../messaging/infrastructure/postgres.py | 102 +++++++++--------- student-tests/api/test_concurrency.py | 19 ++++ student-tests/unit/test_domain.py | 61 +++-------- 8 files changed, 146 insertions(+), 173 deletions(-) diff --git a/openspec/changes/add-lab3-scaling-cost/tasks.md b/openspec/changes/add-lab3-scaling-cost/tasks.md index 5f4730ad..c75a684e 100644 --- a/openspec/changes/add-lab3-scaling-cost/tasks.md +++ b/openspec/changes/add-lab3-scaling-cost/tasks.md @@ -20,7 +20,7 @@ ## 4. Улучшение - [x] 4.1 Выбор улучшения по узкому месту серии B, запись в `design.md`: запись сообщения одним оператором SQL -- [ ] 4.2 Реализация улучшения +- [x] 4.2 Реализация улучшения - [ ] 4.3 `make track1-compare`: до и после на той же конфигурации и интенсивностях, ≥3 повтора - [ ] 4.4 Проверка группы: `make lint`, `make student-test`, `make test` diff --git a/src/messenger/messaging/application/handlers.py b/src/messenger/messaging/application/handlers.py index c4b96fbb..b411a241 100644 --- a/src/messenger/messaging/application/handlers.py +++ b/src/messenger/messaging/application/handlers.py @@ -1,9 +1,10 @@ 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.messaging.application.ports import ChatDirectory, MessageLog, MessagingUnitOfWork +from messenger.messaging.domain.errors import ChatNotFound, InvalidMessageText +from messenger.messaging.domain.models import Chat, Message +from messenger.messaging.domain.values import MessageText from messenger.shared.application.ports import Clock, IdGenerator @@ -30,33 +31,38 @@ class CreateChatHandler: class PostMessageHandler: - __slots__ = ("_clock", "_ids", "_ttl", "_uow") + __slots__ = ("_chats", "_clock", "_ids", "_log", "_ttl", "_uow") def __init__( - self, uow: MessagingUnitOfWork, clock: Clock, ids: IdGenerator, ttl: timedelta + self, + uow: MessagingUnitOfWork, + log: MessageLog, + chats: ChatDirectory, + clock: Clock, + ids: IdGenerator, + *, + ttl: timedelta, ) -> None: self._uow = uow + self._log = log + self._chats = chats 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() + try: + text = MessageText(command.text) + except InvalidMessageText: + if await self._chats.chat_for_member(command.chat_id, command.sender_id) is None: + raise ChatNotFound("чат не найден") from None + raise + now = self._clock.now() + draft = Message(self._ids.new_id(), command.chat_id, command.sender_id, text, now) + receipt = await self._log.post(draft, command.key, command.fingerprint, now - self._ttl) + if receipt is None: + raise ChatNotFound("чат не найден") + message = receipt.replay(command.fingerprint) + if message.id == draft.id: + self._uow.record(message.posted()) return message diff --git a/src/messenger/messaging/application/ports.py b/src/messenger/messaging/application/ports.py index adf82004..7882b9e0 100644 --- a/src/messenger/messaging/application/ports.py +++ b/src/messenger/messaging/application/ports.py @@ -18,14 +18,13 @@ class CursorCodec(Protocol): 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 +@runtime_checkable +class MessageLog(Protocol): + async def post( + self, message: Message, key: str, fingerprint: bytes, since: datetime ) -> Receipt | None: ... - async def append(self, receipt: Receipt) -> None: ... - @runtime_checkable class MessagingUnitOfWork(UnitOfWork, Protocol): diff --git a/src/messenger/messaging/domain/models.py b/src/messenger/messaging/domain/models.py index dc1109cc..fae84bed 100644 --- a/src/messenger/messaging/domain/models.py +++ b/src/messenger/messaging/domain/models.py @@ -1,16 +1,14 @@ from collections.abc import Sequence from dataclasses import dataclass -from datetime import datetime, timedelta +from datetime import datetime from uuid import UUID -from messenger.messaging.domain.errors import ChatNotFound, IdempotencyConflict, InvalidChatData +from messenger.messaging.domain.errors import 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: @@ -24,6 +22,15 @@ class Message: def key(self) -> HistoryKey: return (self.created_at, self.id.int) + def posted(self) -> MessagePosted: + return MessagePosted( + message_id=self.id, + chat_id=self.chat_id, + sender_id=self.sender_id, + text_length=len(self.text.value), + created_at=self.created_at, + ) + @dataclass(frozen=True, slots=True) class Receipt: @@ -38,15 +45,7 @@ class Receipt: class Chat: - __slots__ = ( - "_events", - "_members", - "created_at", - "id", - "last_message_at", - "member_ids", - "title", - ) + __slots__ = ("_events", "created_at", "id", "member_ids", "title") def __init__( self, @@ -55,14 +54,11 @@ class Chat: 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 @@ -107,36 +103,6 @@ class Chat: 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 diff --git a/src/messenger/messaging/entrypoints/ioc.py b/src/messenger/messaging/entrypoints/ioc.py index 88d5909d..80734a0b 100644 --- a/src/messenger/messaging/entrypoints/ioc.py +++ b/src/messenger/messaging/entrypoints/ioc.py @@ -5,12 +5,18 @@ 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.ports import ( + ChatDirectory, + CursorCodec, + MessageLog, + 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, + PostgresMessageLog, PostgresMessagingUnitOfWork, ) from messenger.shared.application.commands import Command @@ -32,6 +38,10 @@ class MessagingProvider(Provider): def directory(self, database: Database) -> ChatDirectory: return PostgresChatDirectory(database) + @provide(scope=Scope.APP) + def log(self, database: Database) -> MessageLog: + return PostgresMessageLog(database) + @provide(scope=Scope.APP) def cursors(self, settings: MessagingSettings) -> CursorCodec: return SignedCursorCodec(settings.cursor_secret.get_secret_value().encode()) @@ -56,6 +66,8 @@ class MessagingProvider(Provider): def command_bus( self, uow: MessagingUnitOfWork, + log: MessageLog, + directory: ChatDirectory, publisher: EventPublisher, clock: Clock, ids: IdGenerator, @@ -64,6 +76,6 @@ class MessagingProvider(Provider): ttl = timedelta(seconds=settings.idempotency_ttl_seconds) handlers: dict[type[Command], CommandHandler] = { CreateChat: CreateChatHandler(uow, clock, ids), - PostMessage: PostMessageHandler(uow, clock, ids, ttl), + PostMessage: PostMessageHandler(uow, log, directory, clock, ids, ttl=ttl), } return MessagingCommandBus(handlers, uow, publisher) diff --git a/src/messenger/messaging/infrastructure/postgres.py b/src/messenger/messaging/infrastructure/postgres.py index 7d23d27d..52b5f97f 100644 --- a/src/messenger/messaging/infrastructure/postgres.py +++ b/src/messenger/messaging/infrastructure/postgres.py @@ -1,4 +1,5 @@ from collections.abc import Sequence +from dataclasses import replace from datetime import datetime from uuid import UUID @@ -8,6 +9,7 @@ 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.application.errors import Unavailable from messenger.shared.infrastructure.postgres import ( Connection, Database, @@ -21,35 +23,35 @@ 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 +POST_MESSAGE = """ +WITH chat AS ( + SELECT c.id, GREATEST($5::timestamptz, c.last_message_at + interval '1 microsecond') AS stamp + FROM chats c JOIN chat_members m ON m.chat_id = c.id AND m.user_id = $3 + WHERE c.id = $2 + FOR UPDATE OF c +), receipt AS ( + INSERT INTO idempotency_keys (chat_id, user_id, key, fingerprint, message_id, created_at) + SELECT id, $3, $6, $7, $1, stamp FROM chat + ON CONFLICT (chat_id, user_id, key) DO UPDATE + SET fingerprint = EXCLUDED.fingerprint, + message_id = EXCLUDED.message_id, + created_at = EXCLUDED.created_at + WHERE idempotency_keys.created_at <= $8 + RETURNING created_at +), message AS ( + INSERT INTO messages (id, chat_id, sender_id, text, created_at) + SELECT $1, $2, $3, $4, created_at FROM receipt + RETURNING created_at +), touched AS ( + UPDATE chats SET last_message_at = message.created_at FROM message WHERE chats.id = $2 +) +SELECT EXISTS (SELECT FROM chat) AS member, (SELECT created_at FROM message) AS created_at """ 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 @@ -94,7 +96,6 @@ def chat_of(row: Record) -> Chat: title=ChatTitle(row["title"]), member_ids=row["member_ids"], created_at=row["created_at"], - last_message_at=row.get("last_message_at"), ) @@ -129,32 +130,37 @@ class PostgresChatRepository: 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 +class PostgresMessageLog: + __slots__ = ("_database",) + + def __init__(self, database: Database) -> None: + self._database = database + + async def post( + self, message: Message, key: str, fingerprint: bytes, 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, - ) + chat_id, sender_id = message.chat_id, message.sender_id + async with self._database.connection() as connection: + row = await connection.fetchrow( + POST_MESSAGE, + message.id, + chat_id, + sender_id, + message.text.value, + message.created_at, + key, + fingerprint, + since, + ) + if row is None or not row["member"]: + return None + if row["created_at"] is not None: + return Receipt(key, fingerprint, replace(message, created_at=row["created_at"])) + known = await connection.fetchrow(RECEIPT, chat_id, sender_id, key, since) + if known is None: + raise Unavailable("ключ идемпотентности занят незавершённой записью") + return Receipt(key, known["fingerprint"], message_of(known)) class PostgresMessagingUnitOfWork(PostgresUnitOfWork): diff --git a/student-tests/api/test_concurrency.py b/student-tests/api/test_concurrency.py index aeeeb4e5..756bf6b3 100644 --- a/student-tests/api/test_concurrency.py +++ b/student-tests/api/test_concurrency.py @@ -1,10 +1,13 @@ import asyncio +from datetime import UTC, datetime, timedelta from urllib.parse import quote from uuid import uuid4 +import pytest from httpx import AsyncClient from conftest import PASSWORD, actor, keyed, make_chat, register +from messenger.shared.infrastructure.clock import MonotonicUtcClock CLIENTS = 10 PER_CLIENT = 10 @@ -60,6 +63,22 @@ async def test_hundred_messages_from_ten_clients(client: AsyncClient) -> None: assert len(set(stamps)) == TOTAL, "created_at внутри чата обязан строго возрастать" +async def test_history_follows_the_clock_but_never_moves_back( + monkeypatch: pytest.MonkeyPatch, client: AsyncClient +) -> None: + alice = await register(client, "alice") + chat = await make_chat(client, alice) + base = datetime.now(UTC) + timedelta(minutes=10) + stamps = [] + for moment in (base, base - timedelta(minutes=5), base + timedelta(seconds=5)): + monkeypatch.setattr(MonotonicUtcClock, "now", lambda _self, moment=moment: moment) + response = await client.post( + f"/api/v1/chats/{chat['id']}/messages", json={"text": "часы"}, headers=keyed(alice) + ) + stamps.append(datetime.fromisoformat(response.json()["created_at"])) + assert stamps == [base, base + timedelta(microseconds=1), base + timedelta(seconds=5)] + + async def test_parallel_registration_keeps_username_unique(client: AsyncClient) -> None: body = {"username": f"race_{uuid4().hex[:12]}", "display_name": "Гонка", "password": PASSWORD} responses = await asyncio.gather(*(client.post("/api/v1/users", json=body) for _ in range(20))) diff --git a/student-tests/unit/test_domain.py b/student-tests/unit/test_domain.py index c0706583..d1d66397 100644 --- a/student-tests/unit/test_domain.py +++ b/student-tests/unit/test_domain.py @@ -9,12 +9,11 @@ from messenger.identity.domain.errors import InvalidUserData from messenger.identity.domain.models import Session, User, token_digest from messenger.identity.domain.values import DisplayName, Password, Username from messenger.messaging.domain.errors import ( - ChatNotFound, IdempotencyConflict, InvalidChatData, InvalidMessageText, ) -from messenger.messaging.domain.models import Chat, Receipt +from messenger.messaging.domain.models import Chat, Message, Receipt from messenger.messaging.domain.values import MessageText from messenger.shared.infrastructure.clock import MonotonicUtcClock @@ -87,17 +86,6 @@ def test_message_text_rejects_blank() -> None: MessageText(raw) -def make_chat(*members: object) -> Chat: - ids = [uuid4() for _ in members] if members else [uuid4()] - return Chat.create( - chat_id=uuid4(), - title="Чат", - member_ids=ids, - creator_id=ids[0], - created_at=MOMENT, - ) - - def test_chat_requires_creator_in_members() -> None: members = [uuid4(), uuid4()] with pytest.raises(InvalidChatData): @@ -134,48 +122,25 @@ def test_chat_rejects_more_than_hundred_members() -> None: ) -def test_outsider_cannot_post() -> None: - chat = make_chat(1) - with pytest.raises(ChatNotFound): - chat.post(message_id=uuid4(), sender_id=uuid4(), text="привет", now=MOMENT) - - -def test_post_never_moves_history_back() -> None: - chat = make_chat(1) - sender = chat.member_ids[0] - first = chat.post( - message_id=uuid4(), sender_id=sender, text="первое", now=MOMENT + timedelta(seconds=1) - ) - second = chat.post(message_id=uuid4(), sender_id=sender, text="второе", now=MOMENT) - assert second.created_at == first.created_at + timedelta(microseconds=1) - assert chat.last_message_at == second.created_at - - -def test_post_keeps_clock_when_it_is_ahead() -> None: - chat = make_chat(1) - sender = chat.member_ids[0] - first = chat.post(message_id=uuid4(), sender_id=sender, text="первое", now=MOMENT) - later = MOMENT + timedelta(seconds=5) - second = chat.post(message_id=uuid4(), sender_id=sender, text="второе", now=later) - assert first.created_at == MOMENT - assert second.created_at == later - - -def test_post_validates_membership_before_text() -> None: - chat = make_chat(1) - with pytest.raises(ChatNotFound): - chat.post(message_id=uuid4(), sender_id=uuid4(), text="", now=MOMENT) - - def test_receipt_replays_only_the_same_request() -> None: - chat = make_chat(1) - message = chat.post(message_id=uuid4(), sender_id=chat.member_ids[0], text="раз", now=MOMENT) + message = Message(uuid4(), uuid4(), uuid4(), MessageText("раз"), MOMENT) receipt = Receipt("key-1", b"a" * 32, message) assert receipt.replay(b"a" * 32) is message with pytest.raises(IdempotencyConflict): receipt.replay(b"b" * 32) +def test_posted_message_describes_itself() -> None: + message = Message(uuid4(), uuid4(), uuid4(), MessageText("пять"), MOMENT) + event = message.posted() + assert (event.message_id, event.chat_id, event.sender_id) == ( + message.id, + message.chat_id, + message.sender_id, + ) + assert (event.text_length, event.created_at, event.name) == (4, MOMENT, "message.posted") + + def test_user_registration_emits_event() -> None: user, event = User.register( user_id=uuid4(),