Add NATS JetStream support (#1866)

* Add NATS JetStream support
Update shopify/sarama

* Fix addresses

* Don't change Addresses in Defaults

* Update saramajetstream

* Add missing error check

Keep typing events for at least one minute

* Use all configured NATS addresses

* Update saramajetstream

* Try setting up with NATS

* Make sure NATS uses own persistent directory (TODO: make this configurable)

* Update go.mod/go.sum

* Jetstream package

* Various other refactoring

* Build fixes

* Config tweaks, make random jetstream storage path for CI

* Disable interest policies

* Try to sane default on jetstream base path

* Try to use in-memory for CI

* Restore storage/retention

* Update nats.go dependency

* Adapt changes to config

* Remove unneeded TopicFor

* Dep update

* Revert "Remove unneeded TopicFor"

This reverts commit f5a4e4a339.

* Revert changes made to streams

* Fix build problems

* Update nats-server

* Update go.mod/go.sum

* Roomserver input API queuing using NATS

* Fix topic naming

* Prometheus metrics

* More refactoring to remove saramajetstream

* Add missing topic

* Don't try to populate map that doesn't exist

* Roomserver output topic

* Update go.mod/go.sum

* Message acknowledgements

* Ack tweaks

* Try to resume transaction re-sends

* Try to resume transaction re-sends

* Update to matrix-org/gomatrixserverlib@91dadfb

* Remove internal.PartitionStorer from components that don't consume keychanges

* Try to reduce re-allocations a bit in resolveConflictsV2

* Tweak delivery options on RS input

* Publish send-to-device messages into correct JetStream subject

* Async and sync roomserver input

* Update dendrite-config.yaml

* Remove roomserver tests for now (they need rewriting)

* Remove roomserver test again (was merged back in)

* Update documentation

* Docker updates

* More Docker updates

* Update Docker readme again

* Fix lint issues

* Send final event in `processEvent` synchronously (since this might stop Sytest from being so upset)

* Don't report event rejection errors via `/send`, since apparently this is upsetting tests that don't expect that

* Go 1.16 instead of Go 1.13 for upgrade tests and Complement

* Revert "Don't report event rejection errors via `/send`, since apparently this is upsetting tests that don't expect that"

This reverts commit 368675283f.

* Don't report any errors on `/send` to see what fun that creates

* Fix panics on closed channel sends

* Enforce state key matches sender

* Do the same for leave

* Various tweaks to make tests happier

Squashed commit of the following:

commit 13f9028e7a
Author: Neil Alexander <neilalexander@users.noreply.github.com>
Date:   Tue Jan 4 15:47:14 2022 +0000

    Do the same for leave

commit e6be7f05c3
Author: Neil Alexander <neilalexander@users.noreply.github.com>
Date:   Tue Jan 4 15:33:42 2022 +0000

    Enforce state key matches sender

commit 85ede6d64b
Author: Neil Alexander <neilalexander@users.noreply.github.com>
Date:   Tue Jan 4 14:07:04 2022 +0000

    Fix panics on closed channel sends

commit 9755494a98
Author: Neil Alexander <neilalexander@users.noreply.github.com>
Date:   Tue Jan 4 13:38:22 2022 +0000

    Don't report any errors on `/send` to see what fun that creates

commit 3bb4f87b5d
Author: Neil Alexander <neilalexander@users.noreply.github.com>
Date:   Tue Jan 4 13:00:26 2022 +0000

    Revert "Don't report event rejection errors via `/send`, since apparently this is upsetting tests that don't expect that"

    This reverts commit 368675283f.

commit fe2673ed7b
Author: Neil Alexander <neilalexander@users.noreply.github.com>
Date:   Tue Jan 4 12:09:34 2022 +0000

    Go 1.16 instead of Go 1.13 for upgrade tests and Complement

commit 368675283f
Author: Neil Alexander <neilalexander@users.noreply.github.com>
Date:   Tue Jan 4 11:51:45 2022 +0000

    Don't report event rejection errors via `/send`, since apparently this is upsetting tests that don't expect that

commit b028dfc085
Author: Neil Alexander <neilalexander@users.noreply.github.com>
Date:   Tue Jan 4 10:29:08 2022 +0000

    Send final event in `processEvent` synchronously (since this might stop Sytest from being so upset)

* Merge in NATS Server v2.6.6 and nats.go v1.13 into the in-process connection fork

* Add `jetstream.WithJetStreamMessage` to make ack/nak-ing less messy, use process context in consumers

* Fix consumer component name in  federation API

* Add comment explaining where streams are defined

* Tweaks to roomserver input with comments

* Finish that sentence that I apparently forgot to finish in INSTALL.md

* Bump version number of config to 2

* Add comments around asynchronous sends to roomserver in processEventWithMissingState

* More useful error message when the config version does not match

* Set version in generate-config

* Fix version in config.Defaults

Co-authored-by: Neil Alexander <neilalexander@users.noreply.github.com>

federationapi/consumers/eduserver.go

@@ -17,233 +17,236 @@ package consumers
 import (
 	"context"
 	"encoding/json"
-	"fmt"
 
-	"github.com/Shopify/sarama"
 	"github.com/matrix-org/dendrite/eduserver/api"
 	"github.com/matrix-org/dendrite/federationapi/queue"
 	"github.com/matrix-org/dendrite/federationapi/storage"
-	"github.com/matrix-org/dendrite/internal"
 	"github.com/matrix-org/dendrite/setup/config"
+	"github.com/matrix-org/dendrite/setup/jetstream"
 	"github.com/matrix-org/dendrite/setup/process"
 	"github.com/matrix-org/gomatrixserverlib"
 	"github.com/matrix-org/util"
+	"github.com/nats-io/nats.go"
 	log "github.com/sirupsen/logrus"
 )
 
 // OutputEDUConsumer consumes events that originate in EDU server.
 type OutputEDUConsumer struct {
-	typingConsumer       *internal.ContinualConsumer
-	sendToDeviceConsumer *internal.ContinualConsumer
-	receiptConsumer      *internal.ContinualConsumer
-	db                   storage.Database
-	queues               *queue.OutgoingQueues
-	ServerName           gomatrixserverlib.ServerName
-	TypingTopic          string
-	SendToDeviceTopic    string
+	ctx               context.Context
+	jetstream         nats.JetStreamContext
+	db                storage.Database
+	queues            *queue.OutgoingQueues
+	ServerName        gomatrixserverlib.ServerName
+	typingTopic       string
+	sendToDeviceTopic string
+	receiptTopic      string
 }
 
 // NewOutputEDUConsumer creates a new OutputEDUConsumer. Call Start() to begin consuming from EDU servers.
 func NewOutputEDUConsumer(
 	process *process.ProcessContext,
 	cfg *config.FederationAPI,
-	kafkaConsumer sarama.Consumer,
+	js nats.JetStreamContext,
 	queues *queue.OutgoingQueues,
 	store storage.Database,
 ) *OutputEDUConsumer {
-	c := &OutputEDUConsumer{
-		typingConsumer: &internal.ContinualConsumer{
-			Process:        process,
-			ComponentName:  "eduserver/typing",
-			Topic:          cfg.Matrix.Kafka.TopicFor(config.TopicOutputTypingEvent),
-			Consumer:       kafkaConsumer,
-			PartitionStore: store,
-		},
-		sendToDeviceConsumer: &internal.ContinualConsumer{
-			Process:        process,
-			ComponentName:  "eduserver/sendtodevice",
-			Topic:          cfg.Matrix.Kafka.TopicFor(config.TopicOutputSendToDeviceEvent),
-			Consumer:       kafkaConsumer,
-			PartitionStore: store,
-		},
-		receiptConsumer: &internal.ContinualConsumer{
-			Process:        process,
-			ComponentName:  "eduserver/receipt",
-			Topic:          cfg.Matrix.Kafka.TopicFor(config.TopicOutputReceiptEvent),
-			Consumer:       kafkaConsumer,
-			PartitionStore: store,
-		},
+	return &OutputEDUConsumer{
+		ctx:               process.Context(),
+		jetstream:         js,
 		queues:            queues,
 		db:                store,
 		ServerName:        cfg.Matrix.ServerName,
-		TypingTopic:       cfg.Matrix.Kafka.TopicFor(config.TopicOutputTypingEvent),
-		SendToDeviceTopic: cfg.Matrix.Kafka.TopicFor(config.TopicOutputSendToDeviceEvent),
+		typingTopic:       cfg.Matrix.JetStream.TopicFor(jetstream.OutputTypingEvent),
+		sendToDeviceTopic: cfg.Matrix.JetStream.TopicFor(jetstream.OutputSendToDeviceEvent),
+		receiptTopic:      cfg.Matrix.JetStream.TopicFor(jetstream.OutputReceiptEvent),
 	}
-	c.typingConsumer.ProcessMessage = c.onTypingEvent
-	c.sendToDeviceConsumer.ProcessMessage = c.onSendToDeviceEvent
-	c.receiptConsumer.ProcessMessage = c.onReceiptEvent
-
-	return c
 }
 
 // Start consuming from EDU servers
 func (t *OutputEDUConsumer) Start() error {
-	if err := t.typingConsumer.Start(); err != nil {
-		return fmt.Errorf("t.typingConsumer.Start: %w", err)
+	if _, err := t.jetstream.Subscribe(t.typingTopic, t.onTypingEvent); err != nil {
+		return err
 	}
-	if err := t.sendToDeviceConsumer.Start(); err != nil {
-		return fmt.Errorf("t.sendToDeviceConsumer.Start: %w", err)
+	if _, err := t.jetstream.Subscribe(t.sendToDeviceTopic, t.onSendToDeviceEvent); err != nil {
+		return err
 	}
-	if err := t.receiptConsumer.Start(); err != nil {
-		return fmt.Errorf("t.receiptConsumer.Start: %w", err)
+	if _, err := t.jetstream.Subscribe(t.receiptTopic, t.onReceiptEvent); err != nil {
+		return err
 	}
 	return nil
 }
 
 // onSendToDeviceEvent is called in response to a message received on the
 // send-to-device events topic from the EDU server.
-func (t *OutputEDUConsumer) onSendToDeviceEvent(msg *sarama.ConsumerMessage) error {
+func (t *OutputEDUConsumer) onSendToDeviceEvent(msg *nats.Msg) {
 	// Extract the send-to-device event from msg.
-	var ote api.OutputSendToDeviceEvent
-	if err := json.Unmarshal(msg.Value, &ote); err != nil {
-		log.WithError(err).Errorf("eduserver output log: message parse failed (expected send-to-device)")
-		return nil
-	}
+	jetstream.WithJetStreamMessage(msg, func(msg *nats.Msg) bool {
+		var ote api.OutputSendToDeviceEvent
+		if err := json.Unmarshal(msg.Data, &ote); err != nil {
+			log.WithError(err).Errorf("eduserver output log: message parse failed (expected send-to-device)")
+			return true
+		}
 
-	// only send send-to-device events which originated from us
-	_, originServerName, err := gomatrixserverlib.SplitID('@', ote.Sender)
-	if err != nil {
-		log.WithError(err).WithField("user_id", ote.Sender).Error("Failed to extract domain from send-to-device sender")
-		return nil
-	}
-	if originServerName != t.ServerName {
-		log.WithField("other_server", originServerName).Info("Suppressing send-to-device: originated elsewhere")
-		return nil
-	}
+		// only send send-to-device events which originated from us
+		_, originServerName, err := gomatrixserverlib.SplitID('@', ote.Sender)
+		if err != nil {
+			log.WithError(err).WithField("user_id", ote.Sender).Error("Failed to extract domain from send-to-device sender")
+			return true
+		}
+		if originServerName != t.ServerName {
+			log.WithField("other_server", originServerName).Info("Suppressing send-to-device: originated elsewhere")
+			return true
+		}
 
-	_, destServerName, err := gomatrixserverlib.SplitID('@', ote.UserID)
-	if err != nil {
-		log.WithError(err).WithField("user_id", ote.UserID).Error("Failed to extract domain from send-to-device destination")
-		return nil
-	}
+		_, destServerName, err := gomatrixserverlib.SplitID('@', ote.UserID)
+		if err != nil {
+			log.WithError(err).WithField("user_id", ote.UserID).Error("Failed to extract domain from send-to-device destination")
+			return true
+		}
 
-	// Pack the EDU and marshal it
-	edu := &gomatrixserverlib.EDU{
-		Type:   gomatrixserverlib.MDirectToDevice,
-		Origin: string(t.ServerName),
-	}
-	tdm := gomatrixserverlib.ToDeviceMessage{
-		Sender:    ote.Sender,
-		Type:      ote.Type,
-		MessageID: util.RandomString(32),
-		Messages: map[string]map[string]json.RawMessage{
-			ote.UserID: {
-				ote.DeviceID: ote.Content,
+		// Pack the EDU and marshal it
+		edu := &gomatrixserverlib.EDU{
+			Type:   gomatrixserverlib.MDirectToDevice,
+			Origin: string(t.ServerName),
+		}
+		tdm := gomatrixserverlib.ToDeviceMessage{
+			Sender:    ote.Sender,
+			Type:      ote.Type,
+			MessageID: util.RandomString(32),
+			Messages: map[string]map[string]json.RawMessage{
+				ote.UserID: {
+					ote.DeviceID: ote.Content,
+				},
 			},
-		},
-	}
-	if edu.Content, err = json.Marshal(tdm); err != nil {
-		return err
-	}
+		}
+		if edu.Content, err = json.Marshal(tdm); err != nil {
+			log.WithError(err).Error("failed to marshal EDU JSON")
+			return true
+		}
 
-	log.Infof("Sending send-to-device message into %q destination queue", destServerName)
-	return t.queues.SendEDU(edu, t.ServerName, []gomatrixserverlib.ServerName{destServerName})
+		log.Infof("Sending send-to-device message into %q destination queue", destServerName)
+		if err := t.queues.SendEDU(edu, t.ServerName, []gomatrixserverlib.ServerName{destServerName}); err != nil {
+			log.WithError(err).Error("failed to send EDU")
+			return false
+		}
+
+		return true
+	})
 }
 
 // onTypingEvent is called in response to a message received on the typing
 // events topic from the EDU server.
-func (t *OutputEDUConsumer) onTypingEvent(msg *sarama.ConsumerMessage) error {
-	// Extract the typing event from msg.
-	var ote api.OutputTypingEvent
-	if err := json.Unmarshal(msg.Value, &ote); err != nil {
-		// Skip this msg but continue processing messages.
-		log.WithError(err).Errorf("eduserver output log: message parse failed (expected typing)")
-		return nil
-	}
+func (t *OutputEDUConsumer) onTypingEvent(msg *nats.Msg) {
+	jetstream.WithJetStreamMessage(msg, func(msg *nats.Msg) bool {
+		// Extract the typing event from msg.
+		var ote api.OutputTypingEvent
+		if err := json.Unmarshal(msg.Data, &ote); err != nil {
+			// Skip this msg but continue processing messages.
+			log.WithError(err).Errorf("eduserver output log: message parse failed (expected typing)")
+			_ = msg.Ack()
+			return true
+		}
 
-	// only send typing events which originated from us
-	_, typingServerName, err := gomatrixserverlib.SplitID('@', ote.Event.UserID)
-	if err != nil {
-		log.WithError(err).WithField("user_id", ote.Event.UserID).Error("Failed to extract domain from typing sender")
-		return nil
-	}
-	if typingServerName != t.ServerName {
-		log.WithField("other_server", typingServerName).Info("Suppressing typing notif: originated elsewhere")
-		return nil
-	}
+		// only send typing events which originated from us
+		_, typingServerName, err := gomatrixserverlib.SplitID('@', ote.Event.UserID)
+		if err != nil {
+			log.WithError(err).WithField("user_id", ote.Event.UserID).Error("Failed to extract domain from typing sender")
+			_ = msg.Ack()
+			return true
+		}
+		if typingServerName != t.ServerName {
+			return true
+		}
 
-	joined, err := t.db.GetJoinedHosts(context.TODO(), ote.Event.RoomID)
-	if err != nil {
-		return err
-	}
+		joined, err := t.db.GetJoinedHosts(t.ctx, ote.Event.RoomID)
+		if err != nil {
+			log.WithError(err).WithField("room_id", ote.Event.RoomID).Error("failed to get joined hosts for room")
+			return false
+		}
 
-	names := make([]gomatrixserverlib.ServerName, len(joined))
-	for i := range joined {
-		names[i] = joined[i].ServerName
-	}
+		names := make([]gomatrixserverlib.ServerName, len(joined))
+		for i := range joined {
+			names[i] = joined[i].ServerName
+		}
 
-	edu := &gomatrixserverlib.EDU{Type: ote.Event.Type}
-	if edu.Content, err = json.Marshal(map[string]interface{}{
-		"room_id": ote.Event.RoomID,
-		"user_id": ote.Event.UserID,
-		"typing":  ote.Event.Typing,
-	}); err != nil {
-		return err
-	}
+		edu := &gomatrixserverlib.EDU{Type: ote.Event.Type}
+		if edu.Content, err = json.Marshal(map[string]interface{}{
+			"room_id": ote.Event.RoomID,
+			"user_id": ote.Event.UserID,
+			"typing":  ote.Event.Typing,
+		}); err != nil {
+			log.WithError(err).Error("failed to marshal EDU JSON")
+			return true
+		}
 
-	return t.queues.SendEDU(edu, t.ServerName, names)
+		if err := t.queues.SendEDU(edu, t.ServerName, names); err != nil {
+			log.WithError(err).Error("failed to send EDU")
+			return false
+		}
+
+		return true
+	})
 }
 
 // onReceiptEvent is called in response to a message received on the receipt
 // events topic from the EDU server.
-func (t *OutputEDUConsumer) onReceiptEvent(msg *sarama.ConsumerMessage) error {
-	// Extract the typing event from msg.
-	var receipt api.OutputReceiptEvent
-	if err := json.Unmarshal(msg.Value, &receipt); err != nil {
-		// Skip this msg but continue processing messages.
-		log.WithError(err).Errorf("eduserver output log: message parse failed (expected receipt)")
-		return nil
-	}
+func (t *OutputEDUConsumer) onReceiptEvent(msg *nats.Msg) {
+	jetstream.WithJetStreamMessage(msg, func(msg *nats.Msg) bool {
+		// Extract the typing event from msg.
+		var receipt api.OutputReceiptEvent
+		if err := json.Unmarshal(msg.Data, &receipt); err != nil {
+			// Skip this msg but continue processing messages.
+			log.WithError(err).Errorf("eduserver output log: message parse failed (expected receipt)")
+			return true
+		}
 
-	// only send receipt events which originated from us
-	_, receiptServerName, err := gomatrixserverlib.SplitID('@', receipt.UserID)
-	if err != nil {
-		log.WithError(err).WithField("user_id", receipt.UserID).Error("Failed to extract domain from receipt sender")
-		return nil
-	}
-	if receiptServerName != t.ServerName {
-		return nil // don't log, very spammy as it logs for each remote receipt
-	}
+		// only send receipt events which originated from us
+		_, receiptServerName, err := gomatrixserverlib.SplitID('@', receipt.UserID)
+		if err != nil {
+			log.WithError(err).WithField("user_id", receipt.UserID).Error("failed to extract domain from receipt sender")
+			return true
+		}
+		if receiptServerName != t.ServerName {
+			return true
+		}
 
-	joined, err := t.db.GetJoinedHosts(context.TODO(), receipt.RoomID)
-	if err != nil {
-		return err
-	}
+		joined, err := t.db.GetJoinedHosts(t.ctx, receipt.RoomID)
+		if err != nil {
+			log.WithError(err).WithField("room_id", receipt.RoomID).Error("failed to get joined hosts for room")
+			return false
+		}
 
-	names := make([]gomatrixserverlib.ServerName, len(joined))
-	for i := range joined {
-		names[i] = joined[i].ServerName
-	}
+		names := make([]gomatrixserverlib.ServerName, len(joined))
+		for i := range joined {
+			names[i] = joined[i].ServerName
+		}
 
-	content := map[string]api.FederationReceiptMRead{}
-	content[receipt.RoomID] = api.FederationReceiptMRead{
-		User: map[string]api.FederationReceiptData{
-			receipt.UserID: {
-				Data: api.ReceiptTS{
-					TS: receipt.Timestamp,
+		content := map[string]api.FederationReceiptMRead{}
+		content[receipt.RoomID] = api.FederationReceiptMRead{
+			User: map[string]api.FederationReceiptData{
+				receipt.UserID: {
+					Data: api.ReceiptTS{
+						TS: receipt.Timestamp,
+					},
+					EventIDs: []string{receipt.EventID},
 				},
-				EventIDs: []string{receipt.EventID},
 			},
-		},
-	}
+		}
 
-	edu := &gomatrixserverlib.EDU{
-		Type:   gomatrixserverlib.MReceipt,
-		Origin: string(t.ServerName),
-	}
-	if edu.Content, err = json.Marshal(content); err != nil {
-		return err
-	}
+		edu := &gomatrixserverlib.EDU{
+			Type:   gomatrixserverlib.MReceipt,
+			Origin: string(t.ServerName),
+		}
+		if edu.Content, err = json.Marshal(content); err != nil {
+			log.WithError(err).Error("failed to marshal EDU JSON")
+			return true
+		}
 
-	return t.queues.SendEDU(edu, t.ServerName, names)
+		if err := t.queues.SendEDU(edu, t.ServerName, names); err != nil {
+			log.WithError(err).Error("failed to send EDU")
+			return false
+		}
+
+		return true
+	})
 }