mirror of
https://github.com/element-hq/synapse
synced 2024-08-20 22:30:21 +00:00
perl -pi -e 's#/matrix#/_matrix#g' ./cmdclient/console.py ./docs/client-server/howto.rst ./docs/client-server/specification.rst ./docs/client-server/swagger_matrix/directory ./docs/client-server/swagger_matrix/events ./docs/client-server/swagger_matrix/login ./docs/client-server/swagger_matrix/presence ./docs/client-server/swagger_matrix/profile ./docs/client-server/swagger_matrix/registration ./docs/client-server/swagger_matrix/rooms ./docs/server-server/specification.rst ./graph/graph.py ./jsfiddles/create_room_send_msg/demo.js ./jsfiddles/event_stream/demo.js ./jsfiddles/example_app/demo.js ./jsfiddles/register_login/demo.js ./jsfiddles/room_memberships/demo.js ./synapse/api/urls.py ./tests/federation/test_federation.py ./tests/handlers/test_presence.py ./tests/handlers/test_typing.py ./tests/rest/test_events.py ./tests/rest/test_presence.py ./tests/rest/test_profile.py ./tests/rest/test_rooms.py ./webclient/components/fileUpload/file-upload-service.js ./webclient/components/matrix/matrix-service.js
231 lines
9.2 KiB
ReStructuredText
231 lines
9.2 KiB
ReStructuredText
===========================
|
|
Matrix Server-to-Server API
|
|
===========================
|
|
|
|
A description of the protocol used to communicate between Matrix home servers;
|
|
also known as Federation.
|
|
|
|
|
|
Overview
|
|
========
|
|
|
|
The server-server API is a mechanism by which two home servers can exchange
|
|
Matrix event messages, both as a real-time push of current events, and as a
|
|
historic fetching mechanism to synchronise past history for clients to view. It
|
|
uses HTTP connections between each pair of servers involved as the underlying
|
|
transport. Messages are exchanged between servers in real-time by active pushing
|
|
from each server's HTTP client into the server of the other. Queries to fetch
|
|
historic data for the purpose of back-filling scrollback buffers and the like
|
|
can also be performed.
|
|
|
|
|
|
{ Matrix clients } { Matrix clients }
|
|
^ | ^ |
|
|
| events | | events |
|
|
| V | V
|
|
+------------------+ +------------------+
|
|
| |---------( HTTP )---------->| |
|
|
| Home Server | | Home Server |
|
|
| |<--------( HTTP )-----------| |
|
|
+------------------+ +------------------+
|
|
|
|
There are three main kinds of communication that occur between home servers:
|
|
|
|
* Queries
|
|
These are single request/response interactions between a given pair of
|
|
servers, initiated by one side sending an HTTP request to obtain some
|
|
information, and responded by the other. They are not persisted and contain
|
|
no long-term significant history. They simply request a snapshot state at the
|
|
instant the query is made.
|
|
|
|
* EDUs - Ephemeral Data Units
|
|
These are notifications of events that are pushed from one home server to
|
|
another. They are not persisted and contain no long-term significant history,
|
|
nor does the receiving home server have to reply to them.
|
|
|
|
* PDUs - Persisted Data Units
|
|
These are notifications of events that are broadcast from one home server to
|
|
any others that are interested in the same "context" (namely, a Room ID).
|
|
They are persisted to long-term storage and form the record of history for
|
|
that context.
|
|
|
|
Where Queries are presented directly across the HTTP connection as GET requests
|
|
to specific URLs, EDUs and PDUs are further wrapped in an envelope called a
|
|
Transaction, which is transferred from the origin to the destination home server
|
|
using a PUT request.
|
|
|
|
|
|
Transactions and EDUs/PDUs
|
|
==========================
|
|
|
|
The transfer of EDUs and PDUs between home servers is performed by an exchange
|
|
of Transaction messages, which are encoded as JSON objects with a dict as the
|
|
top-level element, passed over an HTTP PUT request. A Transaction is meaningful
|
|
only to the pair of home servers that exchanged it; they are not globally-
|
|
meaningful.
|
|
|
|
Each transaction has an opaque ID and timestamp (UNIX epoch time in
|
|
milliseconds) generated by its origin server, an origin and destination server
|
|
name, a list of "previous IDs", and a list of PDUs - the actual message payload
|
|
that the Transaction carries.
|
|
|
|
{"transaction_id":"916d630ea616342b42e98a3be0b74113",
|
|
"ts":1404835423000,
|
|
"origin":"red",
|
|
"destination":"blue",
|
|
"prev_ids":["e1da392e61898be4d2009b9fecce5325"],
|
|
"pdus":[...],
|
|
"edus":[...]}
|
|
|
|
The "previous IDs" field will contain a list of previous transaction IDs that
|
|
the origin server has sent to this destination. Its purpose is to act as a
|
|
sequence checking mechanism - the destination server can check whether it has
|
|
successfully received that Transaction, or ask for a retransmission if not.
|
|
|
|
The "pdus" field of a transaction is a list, containing zero or more PDUs.[*]
|
|
Each PDU is itself a dict containing a number of keys, the exact details of
|
|
which will vary depending on the type of PDU. Similarly, the "edus" field is
|
|
another list containing the EDUs. This key may be entirely absent if there are
|
|
no EDUs to transfer.
|
|
|
|
(* Normally the PDU list will be non-empty, but the server should cope with
|
|
receiving an "empty" transaction, as this is useful for informing peers of other
|
|
transaction IDs they should be aware of. This effectively acts as a push
|
|
mechanism to encourage peers to continue to replicate content.)
|
|
|
|
All PDUs have an ID, a context, a declaration of their type, a list of other PDU
|
|
IDs that have been seen recently on that context (regardless of which origin
|
|
sent them), and a nested content field containing the actual event content.
|
|
|
|
[[TODO(paul): Update this structure so that 'pdu_id' is a two-element
|
|
[origin,ref] pair like the prev_pdus are]]
|
|
|
|
{"pdu_id":"a4ecee13e2accdadf56c1025af232176",
|
|
"context":"#example.green",
|
|
"origin":"green",
|
|
"ts":1404838188000,
|
|
"pdu_type":"m.text",
|
|
"prev_pdus":[["blue","99d16afbc857975916f1d73e49e52b65"]],
|
|
"content":...
|
|
"is_state":false}
|
|
|
|
In contrast to the transaction layer, it is important to note that the prev_pdus
|
|
field of a PDU refers to PDUs that any origin server has sent, rather than
|
|
previous IDs that this origin has sent. This list may refer to other PDUs sent
|
|
by the same origin as the current one, or other origins.
|
|
|
|
Because of the distributed nature of participants in a Matrix conversation, it
|
|
is impossible to establish a globally-consistent total ordering on the events.
|
|
However, by annotating each outbound PDU at its origin with IDs of other PDUs it
|
|
has received, a partial ordering can be constructed allowing causallity
|
|
relationships to be preserved. A client can then display these messages to the
|
|
end-user in some order consistent with their content and ensure that no message
|
|
that is semantically in reply of an earlier one is ever displayed before it.
|
|
|
|
PDUs fall into two main categories: those that deliver Events, and those that
|
|
synchronise State. For PDUs that relate to State synchronisation, additional
|
|
keys exist to support this:
|
|
|
|
{...,
|
|
"is_state":true,
|
|
"state_key":TODO
|
|
"power_level":TODO
|
|
"prev_state_id":TODO
|
|
"prev_state_origin":TODO}
|
|
|
|
[[TODO(paul): At this point we should probably have a long description of how
|
|
State management works, with descriptions of clobbering rules, power levels, etc
|
|
etc... But some of that detail is rather up-in-the-air, on the whiteboard, and
|
|
so on. This part needs refining. And writing in its own document as the details
|
|
relate to the server/system as a whole, not specifically to server-server
|
|
federation.]]
|
|
|
|
EDUs, by comparison to PDUs, do not have an ID, a context, or a list of
|
|
"previous" IDs. The only mandatory fields for these are the type, origin and
|
|
destination home server names, and the actual nested content.
|
|
|
|
{"edu_type":"m.presence",
|
|
"origin":"blue",
|
|
"destination":"orange",
|
|
"content":...}
|
|
|
|
|
|
Protocol URLs
|
|
=============
|
|
|
|
All these URLs are namespaced within a prefix of
|
|
|
|
/_matrix/federation/v1/...
|
|
|
|
For active pushing of messages representing live activity "as it happens":
|
|
|
|
PUT .../send/:transaction_id/
|
|
Body: JSON encoding of a single Transaction
|
|
|
|
Response: [[TODO(paul): I don't actually understand what
|
|
ReplicationLayer.on_transaction() is doing here, so I'm not sure what the
|
|
response ought to be]]
|
|
|
|
The transaction_id path argument will override any ID given in the JSON body.
|
|
The destination name will be set to that of the receiving server itself. Each
|
|
embedded PDU in the transaction body will be processed.
|
|
|
|
|
|
To fetch a particular PDU:
|
|
|
|
GET .../pdu/:origin/:pdu_id/
|
|
|
|
Response: JSON encoding of a single Transaction containing one PDU
|
|
|
|
Retrieves a given PDU from the server. The response will contain a single new
|
|
Transaction, inside which will be the requested PDU.
|
|
|
|
|
|
To fetch all the state of a given context:
|
|
|
|
GET .../state/:context/
|
|
|
|
Response: JSON encoding of a single Transaction containing multiple PDUs
|
|
|
|
Retrieves a snapshot of the entire current state of the given context. The
|
|
response will contain a single Transaction, inside which will be a list of
|
|
PDUs that encode the state.
|
|
|
|
|
|
To backfill events on a given context:
|
|
|
|
GET .../backfill/:context/
|
|
Query args: v, limit
|
|
|
|
Response: JSON encoding of a single Transaction containing multiple PDUs
|
|
|
|
Retrieves a sliding-window history of previous PDUs that occurred on the
|
|
given context. Starting from the PDU ID(s) given in the "v" argument, the
|
|
PDUs that preceeded it are retrieved, up to a total number given by the
|
|
"limit" argument. These are then returned in a new Transaction containing all
|
|
off the PDUs.
|
|
|
|
|
|
To stream events all the events:
|
|
|
|
GET .../pull/
|
|
Query args: origin, v
|
|
|
|
Response: JSON encoding of a single Transaction consisting of multiple PDUs
|
|
|
|
Retrieves all of the transactions later than any version given by the "v"
|
|
arguments. [[TODO(paul): I'm not sure what the "origin" argument does because
|
|
I think at some point in the code it's got swapped around.]]
|
|
|
|
|
|
To make a query:
|
|
|
|
GET .../query/:query_type
|
|
Query args: as specified by the individual query types
|
|
|
|
Response: JSON encoding of a response object
|
|
|
|
Performs a single query request on the receiving home server. The Query Type
|
|
part of the path specifies the kind of query being made, and its query
|
|
arguments have a meaning specific to that kind of query. The response is a
|
|
JSON-encoded object whose meaning also depends on the kind of query.
|