mirror of
https://github.com/matrix-org/dendrite.git
synced 2024-11-27 00:31:55 -06:00
a763cbb0e1
* Put federation client functions into their own file
* Look for missing auth events in RS input
* Remove retrieveMissingAuthEvents from federation API
* Logging
* Sorta transplanted the code over
* Use event origin failing all else
* Don't get stuck on mutexes:
* Add verifier
* Don't mark state events with zero snapshot NID as not existing
* Check missing state if not an outlier before storing the event
* Reject instead of soft-fail, don't copy roominfo so much
* Use synchronous contexts, limit time to fetch missing events
* Clean up some commented out bits
* Simplify `/send` endpoint significantly
* Submit async
* Report errors on sending to RS input
* Set max payload in NATS to 16MB
* Tweak metrics
* Add `workerForRoom` for tidiness
* Try skipping unmarshalling errors for RespMissingEvents
* Track missing prev events separately to avoid calculating state when not possible
* Tweak logic around checking missing state
* Care about state when checking missing prev events
* Don't check missing state for create events
* Try that again
* Handle create events better
* Send create room events as new
* Use given event kind when sending auth/state events
* Revert "Use given event kind when sending auth/state events"
This reverts commit 089d64d271
.
* Only search for missing prev events or state for new events
* Tweaks
* We only have missing prev if we don't supply state
* Room version tweaks
* Allow async inputs again
* Apply backpressure to consumers/synchronous requests to hopefully stop things being overwhelmed
* Set timeouts on roomserver input tasks (need to decide what timeout makes sense)
* Use work queue policy, deliver all on restart
* Reduce chance of duplicates being sent by NATS
* Limit the number of servers we attempt to reduce backpressure
* Some review comment fixes
* Tidy up a couple things
* Don't limit servers, randomise order using map
* Some context refactoring
* Update gmsl
* Don't resend create events
* Set stateIDs length correctly or else the roomserver thinks there are missing events when there aren't
* Exclude our own servername
* Try backing off servers
* Make excluding self behaviour optional
* Exclude self from g_m_e
* Update sytest-whitelist
* Update consumers for the roomserver output stream
* Remember to send outliers for state returned from /gme
* Make full HTTP tests less upsetti
* Remove 'If a device list update goes missing, the server resyncs on the next one' from the sytest blacklist
* Remove debugging test
* Fix blacklist again, remove unnecessary duplicate context
* Clearer contexts, don't use background in case there's something happening there
* Don't queue up events more than once in memory
* Correctly identify create events when checking for state
* Fill in gaps again in /gme code
* Remove `AuthEventIDs` from `InputRoomEvent`
* Remove stray field
Co-authored-by: Kegan Dougal <kegan@matrix.org>
201 lines
5.9 KiB
Go
201 lines
5.9 KiB
Go
package internal
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/getsentry/sentry-go"
|
|
asAPI "github.com/matrix-org/dendrite/appservice/api"
|
|
fsAPI "github.com/matrix-org/dendrite/federationapi/api"
|
|
"github.com/matrix-org/dendrite/internal/caching"
|
|
"github.com/matrix-org/dendrite/roomserver/acls"
|
|
"github.com/matrix-org/dendrite/roomserver/api"
|
|
"github.com/matrix-org/dendrite/roomserver/internal/input"
|
|
"github.com/matrix-org/dendrite/roomserver/internal/perform"
|
|
"github.com/matrix-org/dendrite/roomserver/internal/query"
|
|
"github.com/matrix-org/dendrite/roomserver/storage"
|
|
"github.com/matrix-org/dendrite/setup/config"
|
|
"github.com/matrix-org/gomatrixserverlib"
|
|
"github.com/nats-io/nats.go"
|
|
"github.com/sirupsen/logrus"
|
|
)
|
|
|
|
// RoomserverInternalAPI is an implementation of api.RoomserverInternalAPI
|
|
type RoomserverInternalAPI struct {
|
|
*input.Inputer
|
|
*query.Queryer
|
|
*perform.Inviter
|
|
*perform.Joiner
|
|
*perform.Peeker
|
|
*perform.InboundPeeker
|
|
*perform.Unpeeker
|
|
*perform.Leaver
|
|
*perform.Publisher
|
|
*perform.Backfiller
|
|
*perform.Forgetter
|
|
DB storage.Database
|
|
Cfg *config.RoomServer
|
|
Cache caching.RoomServerCaches
|
|
ServerName gomatrixserverlib.ServerName
|
|
KeyRing gomatrixserverlib.JSONVerifier
|
|
ServerACLs *acls.ServerACLs
|
|
fsAPI fsAPI.FederationInternalAPI
|
|
asAPI asAPI.AppServiceQueryAPI
|
|
JetStream nats.JetStreamContext
|
|
Durable nats.SubOpt
|
|
InputRoomEventTopic string // JetStream topic for new input room events
|
|
OutputRoomEventTopic string // JetStream topic for new output room events
|
|
PerspectiveServerNames []gomatrixserverlib.ServerName
|
|
}
|
|
|
|
func NewRoomserverAPI(
|
|
cfg *config.RoomServer, roomserverDB storage.Database, consumer nats.JetStreamContext,
|
|
inputRoomEventTopic, outputRoomEventTopic string, caches caching.RoomServerCaches,
|
|
perspectiveServerNames []gomatrixserverlib.ServerName,
|
|
) *RoomserverInternalAPI {
|
|
serverACLs := acls.NewServerACLs(roomserverDB)
|
|
a := &RoomserverInternalAPI{
|
|
DB: roomserverDB,
|
|
Cfg: cfg,
|
|
Cache: caches,
|
|
ServerName: cfg.Matrix.ServerName,
|
|
PerspectiveServerNames: perspectiveServerNames,
|
|
InputRoomEventTopic: inputRoomEventTopic,
|
|
OutputRoomEventTopic: outputRoomEventTopic,
|
|
JetStream: consumer,
|
|
Durable: cfg.Matrix.JetStream.Durable("RoomserverInputConsumer"),
|
|
ServerACLs: serverACLs,
|
|
Queryer: &query.Queryer{
|
|
DB: roomserverDB,
|
|
Cache: caches,
|
|
ServerName: cfg.Matrix.ServerName,
|
|
ServerACLs: serverACLs,
|
|
},
|
|
// perform-er structs get initialised when we have a federation sender to use
|
|
}
|
|
return a
|
|
}
|
|
|
|
// SetFederationInputAPI passes in a federation input API reference so that we can
|
|
// avoid the chicken-and-egg problem of both the roomserver input API and the
|
|
// federation input API being interdependent.
|
|
func (r *RoomserverInternalAPI) SetFederationAPI(fsAPI fsAPI.FederationInternalAPI, keyRing *gomatrixserverlib.KeyRing) {
|
|
r.fsAPI = fsAPI
|
|
r.KeyRing = keyRing
|
|
|
|
r.Inputer = &input.Inputer{
|
|
DB: r.DB,
|
|
InputRoomEventTopic: r.InputRoomEventTopic,
|
|
OutputRoomEventTopic: r.OutputRoomEventTopic,
|
|
JetStream: r.JetStream,
|
|
Durable: r.Durable,
|
|
ServerName: r.Cfg.Matrix.ServerName,
|
|
FSAPI: fsAPI,
|
|
KeyRing: keyRing,
|
|
ACLs: r.ServerACLs,
|
|
Queryer: r.Queryer,
|
|
}
|
|
r.Inviter = &perform.Inviter{
|
|
DB: r.DB,
|
|
Cfg: r.Cfg,
|
|
FSAPI: r.fsAPI,
|
|
Inputer: r.Inputer,
|
|
}
|
|
r.Joiner = &perform.Joiner{
|
|
ServerName: r.Cfg.Matrix.ServerName,
|
|
Cfg: r.Cfg,
|
|
DB: r.DB,
|
|
FSAPI: r.fsAPI,
|
|
RSAPI: r,
|
|
Inputer: r.Inputer,
|
|
Queryer: r.Queryer,
|
|
}
|
|
r.Peeker = &perform.Peeker{
|
|
ServerName: r.Cfg.Matrix.ServerName,
|
|
Cfg: r.Cfg,
|
|
DB: r.DB,
|
|
FSAPI: r.fsAPI,
|
|
Inputer: r.Inputer,
|
|
}
|
|
r.InboundPeeker = &perform.InboundPeeker{
|
|
DB: r.DB,
|
|
Inputer: r.Inputer,
|
|
}
|
|
r.Unpeeker = &perform.Unpeeker{
|
|
ServerName: r.Cfg.Matrix.ServerName,
|
|
Cfg: r.Cfg,
|
|
DB: r.DB,
|
|
FSAPI: r.fsAPI,
|
|
Inputer: r.Inputer,
|
|
}
|
|
r.Leaver = &perform.Leaver{
|
|
Cfg: r.Cfg,
|
|
DB: r.DB,
|
|
FSAPI: r.fsAPI,
|
|
Inputer: r.Inputer,
|
|
}
|
|
r.Publisher = &perform.Publisher{
|
|
DB: r.DB,
|
|
}
|
|
r.Backfiller = &perform.Backfiller{
|
|
ServerName: r.ServerName,
|
|
DB: r.DB,
|
|
FSAPI: r.fsAPI,
|
|
KeyRing: r.KeyRing,
|
|
// Perspective servers are trusted to not lie about server keys, so we will also
|
|
// prefer these servers when backfilling (assuming they are in the room) rather
|
|
// than trying random servers
|
|
PreferServers: r.PerspectiveServerNames,
|
|
}
|
|
r.Forgetter = &perform.Forgetter{
|
|
DB: r.DB,
|
|
}
|
|
|
|
if err := r.Inputer.Start(); err != nil {
|
|
logrus.WithError(err).Panic("failed to start roomserver input API")
|
|
}
|
|
}
|
|
|
|
func (r *RoomserverInternalAPI) SetAppserviceAPI(asAPI asAPI.AppServiceQueryAPI) {
|
|
r.asAPI = asAPI
|
|
}
|
|
|
|
func (r *RoomserverInternalAPI) PerformInvite(
|
|
ctx context.Context,
|
|
req *api.PerformInviteRequest,
|
|
res *api.PerformInviteResponse,
|
|
) error {
|
|
outputEvents, err := r.Inviter.PerformInvite(ctx, req, res)
|
|
if err != nil {
|
|
sentry.CaptureException(err)
|
|
return err
|
|
}
|
|
if len(outputEvents) == 0 {
|
|
return nil
|
|
}
|
|
return r.WriteOutputEvents(req.Event.RoomID(), outputEvents)
|
|
}
|
|
|
|
func (r *RoomserverInternalAPI) PerformLeave(
|
|
ctx context.Context,
|
|
req *api.PerformLeaveRequest,
|
|
res *api.PerformLeaveResponse,
|
|
) error {
|
|
outputEvents, err := r.Leaver.PerformLeave(ctx, req, res)
|
|
if err != nil {
|
|
sentry.CaptureException(err)
|
|
return err
|
|
}
|
|
if len(outputEvents) == 0 {
|
|
return nil
|
|
}
|
|
return r.WriteOutputEvents(req.RoomID, outputEvents)
|
|
}
|
|
|
|
func (r *RoomserverInternalAPI) PerformForget(
|
|
ctx context.Context,
|
|
req *api.PerformForgetRequest,
|
|
resp *api.PerformForgetResponse,
|
|
) error {
|
|
return r.Forgetter.PerformForget(ctx, req, resp)
|
|
}
|