Clean up a bit

syncapi/streams/stream_devicelist.go

@@ -7,7 +7,7 @@ import (
 )
 
 type DeviceListStreamProvider struct {
-	StreamLogProvider
+	PartitionedStreamProvider
 }
 
 func (p *DeviceListStreamProvider) CompleteSync(

syncapi/streams/streams.go

@@ -9,13 +9,12 @@ import (
 
 type Streams struct {
 	PDUStreamProvider          types.StreamProvider
-	PDUTopologyProvider        types.TopologyProvider
 	TypingStreamProvider       types.StreamProvider
 	ReceiptStreamProvider      types.StreamProvider
 	InviteStreamProvider       types.StreamProvider
 	SendToDeviceStreamProvider types.StreamProvider
 	AccountDataStreamProvider  types.StreamProvider
-	DeviceListStreamProvider   types.StreamLogProvider
+	DeviceListStreamProvider   types.PartitionedStreamProvider
 }
 
 func NewSyncStreamProviders(
@@ -23,19 +22,29 @@ func NewSyncStreamProviders(
 	eduCache *cache.EDUCache,
 ) *Streams {
 	streams := &Streams{
-		PDUStreamProvider: &PDUStreamProvider{StreamProvider{DB: d}},
+		PDUStreamProvider: &PDUStreamProvider{
+			StreamProvider: StreamProvider{DB: d},
+		},
 		TypingStreamProvider: &TypingStreamProvider{
 			StreamProvider: StreamProvider{DB: d},
 			EDUCache:       eduCache,
 		},
-		ReceiptStreamProvider:      &ReceiptStreamProvider{StreamProvider{DB: d}},
-		InviteStreamProvider:       &InviteStreamProvider{StreamProvider{DB: d}},
-		SendToDeviceStreamProvider: &SendToDeviceStreamProvider{StreamProvider{DB: d}},
+		ReceiptStreamProvider: &ReceiptStreamProvider{
+			StreamProvider: StreamProvider{DB: d},
+		},
+		InviteStreamProvider: &InviteStreamProvider{
+			StreamProvider: StreamProvider{DB: d},
+		},
+		SendToDeviceStreamProvider: &SendToDeviceStreamProvider{
+			StreamProvider: StreamProvider{DB: d},
+		},
 		AccountDataStreamProvider: &AccountDataStreamProvider{
 			StreamProvider: StreamProvider{DB: d},
 			userAPI:        userAPI,
 		},
-		DeviceListStreamProvider: &DeviceListStreamProvider{StreamLogProvider{DB: d}},
+		DeviceListStreamProvider: &DeviceListStreamProvider{
+			PartitionedStreamProvider: PartitionedStreamProvider{DB: d},
+		},
 	}
 
 	streams.PDUStreamProvider.Setup()

syncapi/streams/template_pstream.go

@@ -8,19 +8,19 @@ import (
 	"github.com/matrix-org/dendrite/syncapi/types"
 )
 
-type StreamLogProvider struct {
+type PartitionedStreamProvider struct {
 	DB          storage.Database
 	latest      types.LogPosition
 	latestMutex sync.RWMutex
 	update      *sync.Cond
 }
 
-func (p *StreamLogProvider) Setup() {
+func (p *PartitionedStreamProvider) Setup() {
 	locker := &sync.Mutex{}
 	p.update = sync.NewCond(locker)
 }
 
-func (p *StreamLogProvider) Advance(
+func (p *PartitionedStreamProvider) Advance(
 	latest types.LogPosition,
 ) {
 	p.latestMutex.Lock()
@@ -32,7 +32,7 @@ func (p *StreamLogProvider) Advance(
 	}
 }
 
-func (p *StreamLogProvider) LatestPosition(
+func (p *PartitionedStreamProvider) LatestPosition(
 	ctx context.Context,
 ) types.LogPosition {
 	p.latestMutex.RLock()
@@ -41,7 +41,7 @@ func (p *StreamLogProvider) LatestPosition(
 	return p.latest
 }
 
-func (p *StreamLogProvider) NotifyAfter(
+func (p *PartitionedStreamProvider) NotifyAfter(
 	ctx context.Context,
 	from types.LogPosition,
 ) chan struct{} {
@@ -67,7 +67,7 @@ func (p *StreamLogProvider) NotifyAfter(
 	// sync.Cond will fire every time the latest position
 	// updates, so we can check and see if we've advanced
 	// past it.
-	go func(p *StreamLogProvider) {
+	go func(p *PartitionedStreamProvider) {
 		p.update.L.Lock()
 		defer p.update.L.Unlock()
 

syncapi/types/provider.go

@@ -48,7 +48,7 @@ type StreamProvider interface {
 	LatestPosition(ctx context.Context) StreamPosition
 }
 
-type StreamLogProvider interface {
+type PartitionedStreamProvider interface {
 	Setup()
 	Advance(latest LogPosition)
 	CompleteSync(ctx context.Context, req *SyncRequest) LogPosition
@@ -56,15 +56,3 @@ type StreamLogProvider interface {
 	NotifyAfter(ctx context.Context, from LogPosition) chan struct{}
 	LatestPosition(ctx context.Context) LogPosition
 }
-
-type TopologyProvider interface {
-	// Range will update the response to include all updates between
-	// the from and to sync positions for the given room. It will always
-	// return immediately, making no changes if the range contains no
-	// updates.
-	TopologyRange(ctx context.Context, res *Response, roomID string, from, to TopologyToken, filter gomatrixserverlib.EventFilter)
-
-	// LatestPosition returns the latest stream position for this stream
-	// for the given room.
-	TopologyLatestPosition(ctx context.Context, roomID string) TopologyToken
-}