2017-06-28 16:10:17 +01:00
|
|
|
// Copyright 2017 Vector Creations Ltd
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
// you may not use this file except in compliance with the License.
|
|
|
|
// You may obtain a copy of the License at
|
|
|
|
//
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
//
|
|
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
// See the License for the specific language governing permissions and
|
|
|
|
// limitations under the License.
|
|
|
|
|
|
|
|
package consumers
|
|
|
|
|
|
|
|
import (
|
2017-09-13 13:37:50 +01:00
|
|
|
"context"
|
2017-06-28 16:10:17 +01:00
|
|
|
"encoding/json"
|
|
|
|
"fmt"
|
|
|
|
|
2020-04-22 15:26:56 +01:00
|
|
|
"github.com/Shopify/sarama"
|
2017-06-28 16:10:17 +01:00
|
|
|
"github.com/matrix-org/dendrite/federationsender/queue"
|
|
|
|
"github.com/matrix-org/dendrite/federationsender/storage"
|
|
|
|
"github.com/matrix-org/dendrite/federationsender/types"
|
2020-05-21 14:40:13 +01:00
|
|
|
"github.com/matrix-org/dendrite/internal"
|
2017-06-28 16:10:17 +01:00
|
|
|
"github.com/matrix-org/dendrite/roomserver/api"
|
2020-12-02 17:41:00 +00:00
|
|
|
"github.com/matrix-org/dendrite/setup/config"
|
2017-06-28 16:10:17 +01:00
|
|
|
"github.com/matrix-org/gomatrixserverlib"
|
2017-11-16 10:12:02 +00:00
|
|
|
log "github.com/sirupsen/logrus"
|
2017-06-28 16:10:17 +01:00
|
|
|
)
|
|
|
|
|
2017-10-11 18:13:43 +01:00
|
|
|
// OutputRoomEventConsumer consumes events that originated in the room server.
|
|
|
|
type OutputRoomEventConsumer struct {
|
2020-08-10 14:18:04 +01:00
|
|
|
cfg *config.FederationSender
|
2020-05-01 10:48:17 +01:00
|
|
|
rsAPI api.RoomserverInternalAPI
|
2020-05-21 14:40:13 +01:00
|
|
|
rsConsumer *internal.ContinualConsumer
|
2020-05-01 10:48:17 +01:00
|
|
|
db storage.Database
|
|
|
|
queues *queue.OutgoingQueues
|
2017-06-28 16:10:17 +01:00
|
|
|
}
|
|
|
|
|
2017-10-11 18:13:43 +01:00
|
|
|
// NewOutputRoomEventConsumer creates a new OutputRoomEventConsumer. Call Start() to begin consuming from room servers.
|
|
|
|
func NewOutputRoomEventConsumer(
|
2020-08-10 14:18:04 +01:00
|
|
|
cfg *config.FederationSender,
|
2017-08-16 13:36:41 +01:00
|
|
|
kafkaConsumer sarama.Consumer,
|
|
|
|
queues *queue.OutgoingQueues,
|
2020-01-03 14:07:05 +00:00
|
|
|
store storage.Database,
|
2020-05-01 10:48:17 +01:00
|
|
|
rsAPI api.RoomserverInternalAPI,
|
2017-10-11 18:13:43 +01:00
|
|
|
) *OutputRoomEventConsumer {
|
2020-05-21 14:40:13 +01:00
|
|
|
consumer := internal.ContinualConsumer{
|
2020-09-01 16:53:38 +01:00
|
|
|
ComponentName: "federationsender/roomserver",
|
2020-08-10 15:18:37 +01:00
|
|
|
Topic: string(cfg.Matrix.Kafka.TopicFor(config.TopicOutputRoomEvent)),
|
2017-06-28 16:10:17 +01:00
|
|
|
Consumer: kafkaConsumer,
|
|
|
|
PartitionStore: store,
|
|
|
|
}
|
2017-10-11 18:13:43 +01:00
|
|
|
s := &OutputRoomEventConsumer{
|
2020-05-01 10:48:17 +01:00
|
|
|
cfg: cfg,
|
|
|
|
rsConsumer: &consumer,
|
|
|
|
db: store,
|
|
|
|
queues: queues,
|
|
|
|
rsAPI: rsAPI,
|
2017-06-28 16:10:17 +01:00
|
|
|
}
|
|
|
|
consumer.ProcessMessage = s.onMessage
|
|
|
|
|
2017-08-16 13:36:41 +01:00
|
|
|
return s
|
2017-06-28 16:10:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Start consuming from room servers
|
2017-10-11 18:13:43 +01:00
|
|
|
func (s *OutputRoomEventConsumer) Start() error {
|
2020-05-01 10:48:17 +01:00
|
|
|
return s.rsConsumer.Start()
|
2017-06-28 16:10:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// onMessage is called when the federation server receives a new event from the room server output log.
|
|
|
|
// It is unsafe to call this with messages for the same room in multiple gorountines
|
|
|
|
// because updates it will likely fail with a types.EventIDMismatchError when it
|
|
|
|
// realises that it cannot update the room state using the deltas.
|
2017-10-11 18:13:43 +01:00
|
|
|
func (s *OutputRoomEventConsumer) onMessage(msg *sarama.ConsumerMessage) error {
|
2017-06-28 16:10:17 +01:00
|
|
|
// Parse out the event JSON
|
2017-07-12 10:46:29 +01:00
|
|
|
var output api.OutputEvent
|
2017-06-28 16:10:17 +01:00
|
|
|
if err := json.Unmarshal(msg.Value, &output); err != nil {
|
|
|
|
// If the message was invalid, log it and move on to the next message in the stream
|
|
|
|
log.WithError(err).Errorf("roomserver output log: message parse failure")
|
|
|
|
return nil
|
|
|
|
}
|
2020-04-03 14:29:06 +01:00
|
|
|
|
|
|
|
switch output.Type {
|
|
|
|
case api.OutputTypeNewRoomEvent:
|
2020-11-16 15:44:53 +00:00
|
|
|
ev := output.NewRoomEvent.Event
|
2020-04-03 14:29:06 +01:00
|
|
|
|
2020-10-22 10:39:16 +01:00
|
|
|
if output.NewRoomEvent.RewritesState {
|
|
|
|
if err := s.db.PurgeRoomState(context.TODO(), ev.RoomID()); err != nil {
|
|
|
|
return fmt.Errorf("s.db.PurgeRoom: %w", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-03 14:29:06 +01:00
|
|
|
if err := s.processMessage(*output.NewRoomEvent); err != nil {
|
2020-12-04 14:08:17 +00:00
|
|
|
switch err.(type) {
|
|
|
|
case *queue.ErrorFederationDisabled:
|
|
|
|
log.WithField("error", output.Type).Info(
|
|
|
|
err.Error(),
|
|
|
|
)
|
|
|
|
default:
|
|
|
|
// panic rather than continue with an inconsistent database
|
|
|
|
log.WithFields(log.Fields{
|
2021-01-18 12:58:48 +00:00
|
|
|
"event_id": ev.EventID(),
|
2020-12-04 14:08:17 +00:00
|
|
|
"event": string(ev.JSON()),
|
|
|
|
"add": output.NewRoomEvent.AddsStateEventIDs,
|
|
|
|
"del": output.NewRoomEvent.RemovesStateEventIDs,
|
|
|
|
log.ErrorKey: err,
|
|
|
|
}).Panicf("roomserver output log: write room event failure")
|
|
|
|
}
|
2020-04-03 14:29:06 +01:00
|
|
|
return nil
|
|
|
|
}
|
2021-01-22 14:55:08 +00:00
|
|
|
case api.OutputTypeNewInboundPeek:
|
|
|
|
if err := s.processInboundPeek(*output.NewInboundPeek); err != nil {
|
|
|
|
log.WithFields(log.Fields{
|
|
|
|
"event": output.NewInboundPeek,
|
|
|
|
log.ErrorKey: err,
|
|
|
|
}).Panicf("roomserver output log: remote peek event failure")
|
|
|
|
return nil
|
|
|
|
}
|
2020-04-03 14:29:06 +01:00
|
|
|
default:
|
2017-07-12 10:46:29 +01:00
|
|
|
log.WithField("type", output.Type).Debug(
|
|
|
|
"roomserver output log: ignoring unknown output type",
|
|
|
|
)
|
2017-06-28 16:10:17 +01:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2021-01-22 14:55:08 +00:00
|
|
|
// processInboundPeek starts tracking a new federated inbound peek (replacing the existing one if any)
|
|
|
|
// causing the federationsender to start sending messages to the peeking server
|
|
|
|
func (s *OutputRoomEventConsumer) processInboundPeek(orp api.OutputNewInboundPeek) error {
|
|
|
|
|
|
|
|
// FIXME: there's a race here - we should start /sending new peeked events
|
|
|
|
// atomically after the orp.LatestEventID to ensure there are no gaps between
|
|
|
|
// the peek beginning and the send stream beginning.
|
|
|
|
//
|
|
|
|
// We probably need to track orp.LatestEventID on the inbound peek, but it's
|
|
|
|
// unclear how we then use that to prevent the race when we start the send
|
|
|
|
// stream.
|
|
|
|
//
|
|
|
|
// This is making the tests flakey.
|
|
|
|
|
|
|
|
return s.db.AddInboundPeek(context.TODO(), orp.ServerName, orp.RoomID, orp.PeekID, orp.RenewalInterval)
|
|
|
|
}
|
|
|
|
|
2017-06-28 16:10:17 +01:00
|
|
|
// processMessage updates the list of currently joined hosts in the room
|
|
|
|
// and then sends the event to the hosts that were joined before the event.
|
2017-10-11 18:13:43 +01:00
|
|
|
func (s *OutputRoomEventConsumer) processMessage(ore api.OutputNewRoomEvent) error {
|
2020-06-11 19:50:40 +01:00
|
|
|
addsJoinedHosts, err := joinedHostsFromEvents(gomatrixserverlib.UnwrapEventHeaders(ore.AddsState()))
|
2017-06-28 16:10:17 +01:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
// Update our copy of the current state.
|
|
|
|
// We keep a copy of the current state because the state at each event is
|
|
|
|
// expressed as a delta against the current state.
|
2017-10-06 14:13:53 +01:00
|
|
|
// TODO(#290): handle EventIDMismatchError and recover the current state by
|
|
|
|
// talking to the roomserver
|
2017-06-28 16:10:17 +01:00
|
|
|
oldJoinedHosts, err := s.db.UpdateRoom(
|
2017-09-18 14:15:17 +01:00
|
|
|
context.TODO(),
|
|
|
|
ore.Event.RoomID(),
|
|
|
|
ore.LastSentEventID,
|
|
|
|
ore.Event.EventID(),
|
|
|
|
addsJoinedHosts,
|
|
|
|
ore.RemovesStateEventIDs,
|
2017-06-28 16:10:17 +01:00
|
|
|
)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2017-10-16 13:20:24 +01:00
|
|
|
if oldJoinedHosts == nil {
|
|
|
|
// This means that there is nothing to update as this is a duplicate
|
|
|
|
// message.
|
|
|
|
// This can happen if dendrite crashed between reading the message and
|
|
|
|
// persisting the stream position.
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-06-28 16:10:17 +01:00
|
|
|
if ore.SendAsServer == api.DoNotSendToOtherServers {
|
|
|
|
// Ignore event that we don't need to send anywhere.
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Work out which hosts were joined at the event itself.
|
2017-07-12 10:46:29 +01:00
|
|
|
joinedHostsAtEvent, err := s.joinedHostsAtEvent(ore, oldJoinedHosts)
|
2017-06-28 16:10:17 +01:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2021-01-22 14:55:08 +00:00
|
|
|
// TODO: do housekeeping to evict unrenewed peeking hosts
|
|
|
|
|
|
|
|
// TODO: implement query to let the fedapi check whether a given peek is live or not
|
|
|
|
|
2017-06-28 16:10:17 +01:00
|
|
|
// Send the event.
|
2017-10-16 13:20:24 +01:00
|
|
|
return s.queues.SendEvent(
|
2020-11-16 15:44:53 +00:00
|
|
|
ore.Event, gomatrixserverlib.ServerName(ore.SendAsServer), joinedHostsAtEvent,
|
2017-10-16 13:20:24 +01:00
|
|
|
)
|
2017-06-28 16:10:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// joinedHostsAtEvent works out a list of matrix servers that were joined to
|
2021-01-22 14:55:08 +00:00
|
|
|
// the room at the event (including peeking ones)
|
2017-06-28 16:10:17 +01:00
|
|
|
// It is important to use the state at the event for sending messages because:
|
|
|
|
// 1) We shouldn't send messages to servers that weren't in the room.
|
|
|
|
// 2) If a server is kicked from the rooms it should still be told about the
|
|
|
|
// kick event,
|
|
|
|
// Usually the list can be calculated locally, but sometimes it will need fetch
|
|
|
|
// events from the room server.
|
|
|
|
// Returns an error if there was a problem talking to the room server.
|
2017-10-11 18:13:43 +01:00
|
|
|
func (s *OutputRoomEventConsumer) joinedHostsAtEvent(
|
2017-07-12 10:46:29 +01:00
|
|
|
ore api.OutputNewRoomEvent, oldJoinedHosts []types.JoinedHost,
|
2017-06-28 16:10:17 +01:00
|
|
|
) ([]gomatrixserverlib.ServerName, error) {
|
|
|
|
// Combine the delta into a single delta so that the adds and removes can
|
|
|
|
// cancel each other out. This should reduce the number of times we need
|
|
|
|
// to fetch a state event from the room server.
|
|
|
|
combinedAdds, combinedRemoves := combineDeltas(
|
|
|
|
ore.AddsStateEventIDs, ore.RemovesStateEventIDs,
|
|
|
|
ore.StateBeforeAddsEventIDs, ore.StateBeforeRemovesEventIDs,
|
|
|
|
)
|
2020-03-17 11:01:25 +00:00
|
|
|
combinedAddsEvents, err := s.lookupStateEvents(combinedAdds, ore.Event.Event)
|
2017-06-28 16:10:17 +01:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
combinedAddsJoinedHosts, err := joinedHostsFromEvents(combinedAddsEvents)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
removed := map[string]bool{}
|
|
|
|
for _, eventID := range combinedRemoves {
|
|
|
|
removed[eventID] = true
|
|
|
|
}
|
|
|
|
|
|
|
|
joined := map[gomatrixserverlib.ServerName]bool{}
|
|
|
|
for _, joinedHost := range oldJoinedHosts {
|
|
|
|
if removed[joinedHost.MemberEventID] {
|
|
|
|
// This m.room.member event is part of the current state of the
|
|
|
|
// room, but not part of the state at the event we are processing
|
|
|
|
// Therefore we can't use it to tell whether the server was in
|
|
|
|
// the room at the event.
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
joined[joinedHost.ServerName] = true
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, joinedHost := range combinedAddsJoinedHosts {
|
|
|
|
// This m.room.member event was part of the state of the room at the
|
|
|
|
// event, but isn't part of the current state of the room now.
|
|
|
|
joined[joinedHost.ServerName] = true
|
|
|
|
}
|
|
|
|
|
2021-01-22 14:55:08 +00:00
|
|
|
// handle peeking hosts
|
|
|
|
inboundPeeks, err := s.db.GetInboundPeeks(context.TODO(), ore.Event.Event.RoomID())
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
for _, inboundPeek := range inboundPeeks {
|
|
|
|
joined[inboundPeek.ServerName] = true
|
|
|
|
}
|
|
|
|
|
2017-06-28 16:10:17 +01:00
|
|
|
var result []gomatrixserverlib.ServerName
|
|
|
|
for serverName, include := range joined {
|
|
|
|
if include {
|
|
|
|
result = append(result, serverName)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// joinedHostsFromEvents turns a list of state events into a list of joined hosts.
|
|
|
|
// This errors if one of the events was invalid.
|
|
|
|
// It should be impossible for an invalid event to get this far in the pipeline.
|
2020-11-16 15:44:53 +00:00
|
|
|
func joinedHostsFromEvents(evs []*gomatrixserverlib.Event) ([]types.JoinedHost, error) {
|
2017-06-28 16:10:17 +01:00
|
|
|
var joinedHosts []types.JoinedHost
|
|
|
|
for _, ev := range evs {
|
|
|
|
if ev.Type() != "m.room.member" || ev.StateKey() == nil {
|
|
|
|
continue
|
|
|
|
}
|
2017-07-07 14:11:32 +01:00
|
|
|
membership, err := ev.Membership()
|
|
|
|
if err != nil {
|
2017-06-28 16:10:17 +01:00
|
|
|
return nil, err
|
|
|
|
}
|
2019-08-06 15:07:36 +01:00
|
|
|
if membership != gomatrixserverlib.Join {
|
2017-06-28 16:10:17 +01:00
|
|
|
continue
|
|
|
|
}
|
2017-07-07 14:11:32 +01:00
|
|
|
_, serverName, err := gomatrixserverlib.SplitID('@', *ev.StateKey())
|
2017-06-28 16:10:17 +01:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
joinedHosts = append(joinedHosts, types.JoinedHost{
|
|
|
|
MemberEventID: ev.EventID(), ServerName: serverName,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
return joinedHosts, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// combineDeltas combines two deltas into a single delta.
|
|
|
|
// Assumes that the order of operations is add(1), remove(1), add(2), remove(2).
|
|
|
|
// Removes duplicate entries and redundant operations from each delta.
|
|
|
|
func combineDeltas(adds1, removes1, adds2, removes2 []string) (adds, removes []string) {
|
|
|
|
addSet := map[string]bool{}
|
|
|
|
removeSet := map[string]bool{}
|
|
|
|
|
|
|
|
// combine processes each unique value in a list.
|
|
|
|
// If the value is in the removeFrom set then it is removed from that set.
|
|
|
|
// Otherwise it is added to the addTo set.
|
|
|
|
combine := func(values []string, removeFrom, addTo map[string]bool) {
|
|
|
|
processed := map[string]bool{}
|
|
|
|
for _, value := range values {
|
|
|
|
if processed[value] {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
processed[value] = true
|
|
|
|
if removeFrom[value] {
|
|
|
|
delete(removeFrom, value)
|
|
|
|
} else {
|
|
|
|
addTo[value] = true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
combine(adds1, nil, addSet)
|
|
|
|
combine(removes1, addSet, removeSet)
|
|
|
|
combine(adds2, removeSet, addSet)
|
|
|
|
combine(removes2, addSet, removeSet)
|
|
|
|
|
|
|
|
for value := range addSet {
|
|
|
|
adds = append(adds, value)
|
|
|
|
}
|
|
|
|
for value := range removeSet {
|
|
|
|
removes = append(removes, value)
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// lookupStateEvents looks up the state events that are added by a new event.
|
2017-10-11 18:13:43 +01:00
|
|
|
func (s *OutputRoomEventConsumer) lookupStateEvents(
|
2020-11-16 15:44:53 +00:00
|
|
|
addsStateEventIDs []string, event *gomatrixserverlib.Event,
|
|
|
|
) ([]*gomatrixserverlib.Event, error) {
|
2017-06-28 16:10:17 +01:00
|
|
|
// Fast path if there aren't any new state events.
|
|
|
|
if len(addsStateEventIDs) == 0 {
|
|
|
|
return nil, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Fast path if the only state event added is the event itself.
|
|
|
|
if len(addsStateEventIDs) == 1 && addsStateEventIDs[0] == event.EventID() {
|
2020-11-16 15:44:53 +00:00
|
|
|
return []*gomatrixserverlib.Event{event}, nil
|
2017-06-28 16:10:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
missing := addsStateEventIDs
|
2020-11-16 15:44:53 +00:00
|
|
|
var result []*gomatrixserverlib.Event
|
2017-06-28 16:10:17 +01:00
|
|
|
|
|
|
|
// Check if event itself is being added.
|
|
|
|
for _, eventID := range missing {
|
|
|
|
if eventID == event.EventID() {
|
|
|
|
result = append(result, event)
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
missing = missingEventsFrom(result, addsStateEventIDs)
|
|
|
|
|
|
|
|
if len(missing) == 0 {
|
|
|
|
return result, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// At this point the missing events are neither the event itself nor are
|
|
|
|
// they present in our local database. Our only option is to fetch them
|
|
|
|
// from the roomserver using the query API.
|
|
|
|
eventReq := api.QueryEventsByIDRequest{EventIDs: missing}
|
|
|
|
var eventResp api.QueryEventsByIDResponse
|
2020-05-01 10:48:17 +01:00
|
|
|
if err := s.rsAPI.QueryEventsByID(context.TODO(), &eventReq, &eventResp); err != nil {
|
2017-06-28 16:10:17 +01:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2020-03-16 17:29:52 +00:00
|
|
|
for _, headeredEvent := range eventResp.Events {
|
|
|
|
result = append(result, headeredEvent.Event)
|
|
|
|
}
|
|
|
|
|
2017-06-28 16:10:17 +01:00
|
|
|
missing = missingEventsFrom(result, addsStateEventIDs)
|
|
|
|
|
|
|
|
if len(missing) != 0 {
|
|
|
|
return nil, fmt.Errorf(
|
|
|
|
"missing %d state events IDs at event %q", len(missing), event.EventID(),
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
return result, nil
|
|
|
|
}
|
|
|
|
|
2020-11-16 15:44:53 +00:00
|
|
|
func missingEventsFrom(events []*gomatrixserverlib.Event, required []string) []string {
|
2017-06-28 16:10:17 +01:00
|
|
|
have := map[string]bool{}
|
|
|
|
for _, event := range events {
|
|
|
|
have[event.EventID()] = true
|
|
|
|
}
|
|
|
|
var missing []string
|
|
|
|
for _, eventID := range required {
|
|
|
|
if !have[eventID] {
|
|
|
|
missing = append(missing, eventID)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return missing
|
|
|
|
}
|