tajniak81andClaude Opus 5
d187ad0d17
CI / Test (ubuntu-latest) (push) Canceled after 0s
CI / Test (windows-latest) (push) Canceled after 0s
CI / Storage tests on PostgreSQL (push) Canceled after 0s
CI / Complement (federation off) (push) Canceled after 0s
CI / golangci-lint (push) Canceled after 0s
CI / Smoke test the binary (push) Canceled after 0s
Implements PLAN.md Phase 4: the read model. /sync, /messages and /context, the filters that narrow them, and the streams a response carries that are not room events — typing, receipts, presence and to-device messages. With this a client can be used against Warp, which is milestone M1. The one architectural choice is that the syncapi has no copy of the rooms: it reads them through the roomserver. Dendrite gives its syncapi its own tables and feeds them from the output stream, which is right for a design where the two can be separate processes, and Dendrite's could be. Warp is one process by decision, and there the copy buys nothing and costs the hardest class of bug a homeserver has — a read model that disagrees with the room, where a client is shown a message that was rejected and the only way to find out is to compare two tables. So the roomserver grew a read model (stream.go, roomsync.go, visibility.go) rather than exporting its store: reading an event means parsing it under its room's version, and a second copy of the version registry, the parser and the client projection would be a second place for them to disagree. syncapi: stream tokens naming a position in each of five independent streams, so a client that has seen receipt 7 but only event 4 can say so in one opaque string. A token with fewer positions than this build writes is accepted and the rest read as zero, which is what lets a token stored before a stream existed go on working. The PDU position comes from MAX(stream_ordering) and not from the counter row the other four use: the counter is advanced inside the writing transaction, so a token taken from it would name a position whose event no reader can see yet, and the event would be skipped for good once that transaction committed. Long polling goes through a notifier that wakes by room and by user rather than globally — an event wakes the listeners of its room, a membership event also wakes the user it names, so an invite reaches a client that is not in the room yet. A wake-up is only ever a hint: the listener re-reads the streams and decides for itself what changed, which is what makes it safe for the notifier to hold no state about what each client has seen. The listener registers before the read, so an event landing in between leaves the channel signalled and the sync reads again rather than blocking on a change it just missed. EventPersisted must not block, because it is called with the room's write lock still held. "Something happened" is not "a token moved". A stream can move without this user being concerned by it, and returning on every such move would turn a long poll back into a busy loop. The same trap caught presence twice over: a client says it is still online by syncing, so ?set_presence= makes every sync a presence write, and a stream that moved each time would wake every peer, which would sync, which would move it again. SetPresence therefore reports whether anything a peer would notice actually changed, and a write that only refreshes the last-active timestamp leaves the stream alone. Timeline windows are named by their two ends and a direction, Low exclusive and High inclusive in both directions, rather than by "from" and "to" as the wire format spells them. Each of those would otherwise be the low bound in one direction and the high bound in the other, which is exactly the off-by-one every pagination bug is made of; the handlers translate once and nothing below them thinks about it again. A sync's timeline is read backwards and reported forwards, because a client wants the newest events of the window it missed — a forward read with a limit hands it the oldest and then calls the rest a gap. visibility: history visibility is now a span rather than a yes or no, which is what Phase 3 deferred here. A user who has left a room is served the room as it was when they left — their state reads, their members and their timeline — instead of being refused, and is bounded above at their own membership event so a kicked client cannot go on streaming. Their span is found from their own member events, so a user who joined, left and rejoined sees their latest span. ?at= on /members is honoured for the same reason. What is left is that the span is computed from the room's current history_visibility where the spec judges each event by the one in force when it was sent; that is a state read per event and belongs with open question 1. Typing is held in memory and nowhere else: notifications expire in seconds, are worthless across a restart, and arrive one per keystroke-burst per room, so persisting them would be the busiest table in the database holding the least valuable data in it. Receipts only ever advance, compared on the position of the event acknowledged rather than on arrival, because two of a user's clients read at different speeds and the slower one must not drag the marker backwards. To-device queues are per device and drained by the next sync rather than by the one that delivered them, so a client that crashes in between gets the batch again — the right way round, since a lost key share leaves a message permanently undecryptable and a duplicate is ignored. A wildcard addressee is expanded when sent, not stored, because "every device" means the ones that existed then. Presence is off by default, which answers PLAN.md open question 3. It is the noisiest thing in Matrix and the one genuinely fan-out notification here; a private homeserver gains little from it. With it off the endpoints refuse rather than disappearing, because a client that gets a 404 from /presence concludes the server is too old to have it and stops asking. storage: one migration per driver adding the receipt, to-device, presence and filter tables with a counter row each, and a stream position on the existing account data table rather than a parallel one — there is exactly one current value per (user, room, type), and a second table would be a second thing to keep in step. Account data is reported in an event list but is not an event, so it gets its own response type: a room event with an empty sender and no timestamp would make a client decide what that meant. Deliberately missing, each named in docs/sync.md: notification counts (they need push rules, Phase 8), device lists (the keyserver, Phase 7), anything remote (Phase 5), threads (Phase 10). device_lists is sent as two empty lists because a client reads a missing one as malformed; the notification counts are left out entirely, because a zero there is a claim and an absent field is not. Tested through HTTP rather than against the builder, because what is worth pinning down is the response a client sees — which section a room lands in, whether a token handed back can be handed in again, whether paging terminates and loses nothing. The storage tests run against both SQL drivers; the notifier has its own tests for the concurrent case. A live server was driven end to end, which is what caught the two bugs the unit tests had missed: a backwards /messages page must be in reverse chronological order, and `start` must name where the page began rather than position zero when ?from= was omitted. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
208 lines
10 KiB
Markdown
208 lines
10 KiB
Markdown
# Rooms
|
|
|
|
`internal/roomserver` and the room half of `internal/storage`: PLAN.md
|
|
Phase 3. This is what turns the event core of Phase 2 into rooms a client
|
|
can use — locally. Nothing here talks to another server; federation is
|
|
Phase 5, and every operation that would need it is refused with a message
|
|
that says so rather than a bare `M_FORBIDDEN`.
|
|
|
|
## Where the decisions live
|
|
|
|
| Question | Answered by |
|
|
|---|---|
|
|
| Is this event well-formed? | `internal/matrix/event` |
|
|
| May this event be in the room? | `internal/matrix/auth` |
|
|
| Which of two conflicting states wins? | `internal/matrix/stateres` |
|
|
| What are this room's prev_events, depth and auth_events? | `roomserver` |
|
|
| Who may call this endpoint? | nobody — see below |
|
|
| How is any of it stored? | `storage.RoomStore` |
|
|
|
|
The third row is the important one. `internal/matrix` is pure library code
|
|
with no storage and no HTTP; the roomserver is what connects those rules to
|
|
a database and to a room's history. It is the only thing in Warp that
|
|
creates an event.
|
|
|
|
The fifth row is not a joke. The Client-Server handlers do no authorisation
|
|
of their own: whether Alice may kick Bob, rename the room or send a message
|
|
is a question about the room's power levels and membership, and the one
|
|
place that is answered correctly is the authorisation rules inside the
|
|
pipeline. A handler-level check would be a second, worse copy of them. The
|
|
handlers do check the two things the rules cannot see — that the caller is
|
|
who their token says, and that a path parameter is a well-formed ID.
|
|
|
|
## The input pipeline
|
|
|
|
Every event goes through one function, `roomserver.send`, whatever sent it.
|
|
The stages are:
|
|
|
|
1. **Validate** — the sender is a user of this server (we can only sign as
|
|
ourselves), and the content is a JSON object within the size limit.
|
|
2. **Authorise** — the event is built against the room's state with exactly
|
|
the `auth_events` the selection algorithm asks for, then run through
|
|
`auth.CheckAuthEvents` (rule 3) and `auth.Check` (everything else).
|
|
3. **Resolve** — the state the event is judged against is the state after
|
|
the room's forward extremities, resolved with state resolution v2 when
|
|
there is more than one.
|
|
4. **Persist** — the event, its state snapshot, the new current state, the
|
|
new forward extremity and any transaction ID go down in one transaction.
|
|
5. **Emit** — the `Notifier` is told. Phase 4 plugs the syncapi in here, so
|
|
that a client blocked in `/sync` hears about an event in milliseconds
|
|
rather than when its timeout expires. See [sync.md](sync.md).
|
|
|
|
### Why there is a lock per room
|
|
|
|
Two events racing into one room would each pick up the same forward
|
|
extremities, both become one, and fork the room for no reason — which would
|
|
then need state resolution to put back together. A mutex per room instead
|
|
keeps every locally created event a child of the one before it, so a room
|
|
this server fills on its own always has exactly one forward extremity. The
|
|
admin room detail reports the extremities for that reason: more than one
|
|
means something unusual happened.
|
|
|
|
### Why state resolution is here at all
|
|
|
|
With that lock, a Phase 3 room cannot fork, so the resolution path is
|
|
unreachable from outside. It is implemented anyway because the alternative
|
|
is a pipeline that authorises against one arbitrary branch of a fork
|
|
without saying so — and because `stateAfter`, which it needs, is also what
|
|
federation will need in Phase 5.
|
|
|
|
### Soft failure
|
|
|
|
An event can be allowed by the rules against its own `auth_events` and
|
|
still fail against the room's *current* state; the spec calls that soft
|
|
failure and asks a server to keep the event but not let it into the forward
|
|
extremities. There is no soft-failure check here, because for an event
|
|
created on this server the two states are the same one. It arrives with
|
|
events that come from somewhere else.
|
|
|
|
## Room versions
|
|
|
|
Versions 3 to 12 all work, and the tests create a room at each of them and
|
|
send a message into it. Version 12 is the one that earns the coverage: its
|
|
room ID *is* the create event's ID, its create event carries no `room_id`
|
|
at all, and the create event is left out of every other event's
|
|
`auth_events`. Two consequences worth knowing:
|
|
|
|
- `createRoom` has to build the create event before it can name the room,
|
|
which is why that one event does not go through `send`.
|
|
- The state `auth.Check` is given is the event's `auth_events` **plus the
|
|
create event**, because from version 12 the create event is identified by
|
|
the room ID rather than cited. The rules still need it: it is what says
|
|
who the room's creators are.
|
|
|
|
`createRoom` defaults to version 11, which is what the registry says and
|
|
why (`internal/matrix/roomversion`): the spec asks servers to stay there for
|
|
a while after 1.16 so clients and bridges catch up.
|
|
|
|
## Storage
|
|
|
|
Events are keyed by event ID rather than by a numeric surrogate. An event ID
|
|
appears in `prev_events`, `auth_events`, state snapshots and client requests
|
|
alike, so a surrogate would have to be translated at every one of those
|
|
boundaries.
|
|
|
|
**Stream ordering** is this server's own monotonic position for an event,
|
|
handed out by a counter row inside the write transaction. Neither
|
|
`AUTOINCREMENT` nor a sequence would do: the two engines spell those
|
|
differently, and a PostgreSQL sequence is explicitly not transactional, so a
|
|
rolled-back write would leave a hole that `/sync` would have to be taught to
|
|
skip.
|
|
|
|
**State snapshots** are stored per event and deduplicated by a hash of their
|
|
contents. That is what makes a per-event snapshot affordable: every message
|
|
in a room whose state is not changing resolves to the snapshot the previous
|
|
one already stored, so the table grows with state changes rather than with
|
|
traffic. It is also what makes "the state after a forward extremity"
|
|
answerable, which state resolution needs.
|
|
|
|
**Current state** is kept as its own table, which is derivable from the
|
|
events and stored anyway because every authorisation decision reads it. The
|
|
`membership` column is a denormalised copy of `content.membership` on member
|
|
rows, so "the rooms @alice is joined to" is an index lookup rather than a
|
|
scan that parses JSON.
|
|
|
|
**The room's listing columns** — name, topic, canonical alias, join rule,
|
|
history visibility, guest access, room type and the joined-member count —
|
|
live on the room row. The public room directory orders every published room
|
|
by member count and pages the result, which cannot be done by reading each
|
|
room's state in turn. The roomserver recomputes them when one of the state
|
|
events behind them changes, and only then; a room full of chat does not
|
|
rewrite its own row on every line.
|
|
|
|
## Federation-disabled behaviour
|
|
|
|
PLAN.md section 3, enforced here:
|
|
|
|
| Operation | While federation is off |
|
|
|---|---|
|
|
| `/join` a room this server does not have | `403`, naming federation |
|
|
| Inviting `@user:other.example` | `403`, naming federation |
|
|
| Resolving `#alias:other.example` | `403`, naming federation |
|
|
| `publicRooms?server=other.example` | `403`, naming federation |
|
|
| Room and event IDs | unchanged — a room created offline federates normally if federation is later turned on |
|
|
| Signing | unchanged — every event is signed with the server key |
|
|
|
|
The messages are explicit on purpose. `M_FORBIDDEN` alone sends a user to
|
|
their operator and the operator hunting through power levels.
|
|
|
|
Restricted joins are the interesting case. The rule needs a signature from
|
|
the authorising user's server checked, so it normally needs a key fetcher —
|
|
but while federation is off every room is local, this server's own key is in
|
|
hand, and the rule can be applied in full. A join authorised via a *remote*
|
|
user is refused, like everything else that would need another server.
|
|
|
|
## Known gaps
|
|
|
|
These are deliberate, and each one is somebody else's phase.
|
|
|
|
**History visibility is judged by the room's current setting, not by the
|
|
one in force when each event was sent.** Phase 4 built the rest of it:
|
|
`roomserver.VisibleRange` works out the span of a room a user may read,
|
|
which a user who has left is now served from rather than being refused, and
|
|
`?at=` on `/members` is honoured. What is left is that the span is computed
|
|
from the room's *current* `history_visibility`, where the spec judges each
|
|
event by the one in force when it was sent. Doing it exactly is a state
|
|
read per event and belongs with the state storage work of open question 1.
|
|
See [sync.md](sync.md#visibility).
|
|
|
|
**No knocking endpoint.** The `knock` join rule is enforced by the
|
|
authorisation rules — a knock-rule room needs an invite to join — but
|
|
`POST /knock/{roomIdOrAlias}` is not served.
|
|
|
|
**No third-party invites.** They go through an identity server, which Warp
|
|
does not talk to (Phase 9). `createRoom` with `invite_3pid`, and `/invite`
|
|
with `id_server`, are refused rather than silently dropped.
|
|
|
|
**No room upgrades.** `POST /rooms/{roomID}/upgrade` and the tombstone
|
|
handling that goes with it are not served.
|
|
|
|
**A half-built room can be left behind.** `createRoom` sends a dozen events
|
|
through the pipeline one at a time, each authorised against what the ones
|
|
before it produced, and a failure part-way through leaves a room that exists
|
|
and is incomplete. That is the lesser evil: the alternative is holding every
|
|
event of a new room in memory and writing them in one transaction, which
|
|
would make the pipeline that authorises them a special case — and the
|
|
pipeline is the one thing in here that must not have special cases. Such a
|
|
room is visible only to its creator and can be purged. The one failure that
|
|
is handled properly is an alias clash, which takes the room row back out,
|
|
because it is the one a second client can cause at any time.
|
|
|
|
## Tests
|
|
|
|
`internal/roomserver` tests run against the real event core and a real
|
|
SQLite database, not fakes: what is under test is whether an event this
|
|
server signs is one the authorisation rules accept, and a fake of either
|
|
would only prove that the pipeline calls what the fake expects.
|
|
`internal/storage` tests the room store against both SQL drivers.
|
|
`internal/clientapi` and `internal/adminapi` test the HTTP surface through
|
|
`httptest`.
|
|
|
|
Two things the local-only shape makes untestable here, both covered in
|
|
`internal/matrix/auth`:
|
|
|
|
- The power-level half of the redaction test. A redaction applies when it
|
|
comes from the same server as its target, and every user here is on one
|
|
server, so that branch covers every pair of them.
|
|
- Soft failure, and state resolution across a real fork.
|