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) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01V1d3RLHNBBMA6UqBLLJv27
This commit is contained in:
Artyom
2026-10-29 01:06:49 +03:00
co-authored by Claude Opus 5.5
parent edc091dbc4
commit 22f0e6244d
8 changed files with 146 additions and 173 deletions
@@ -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`
+29 -23
View File
@@ -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
+4 -5
View File
@@ -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):
+12 -46
View File
@@ -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
+14 -2
View File
@@ -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)
@@ -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):
+19
View File
@@ -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)))
+13 -48
View File
@@ -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(),