Merge branch 'master' into neilalexander/cspassword

clientapi/routing/directory.go

@@ -273,7 +273,7 @@ func SetVisibility(
 	req *http.Request, stateAPI currentstateAPI.CurrentStateInternalAPI, rsAPI roomserverAPI.RoomserverInternalAPI, dev *userapi.Device,
 	roomID string,
 ) util.JSONResponse {
-	resErr := checkMemberInRoom(req.Context(), stateAPI, dev.UserID, roomID)
+	resErr := checkMemberInRoom(req.Context(), rsAPI, dev.UserID, roomID)
 	if resErr != nil {
 		return *resErr
 	}

clientapi/routing/membership.go

@@ -25,7 +25,6 @@ import (
 	"github.com/matrix-org/dendrite/clientapi/httputil"
 	"github.com/matrix-org/dendrite/clientapi/jsonerror"
 	"github.com/matrix-org/dendrite/clientapi/threepid"
-	currentstateAPI "github.com/matrix-org/dendrite/currentstateserver/api"
 	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/internal/eventutil"
 	"github.com/matrix-org/dendrite/roomserver/api"
@@ -95,7 +94,6 @@ func SendKick(
 	req *http.Request, accountDB accounts.Database, device *userapi.Device,
 	roomID string, cfg *config.ClientAPI,
 	rsAPI roomserverAPI.RoomserverInternalAPI, asAPI appserviceAPI.AppServiceQueryAPI,
-	stateAPI currentstateAPI.CurrentStateInternalAPI,
 ) util.JSONResponse {
 	body, evTime, roomVer, reqErr := extractRequestData(req, roomID, rsAPI)
 	if reqErr != nil {
@@ -108,7 +106,7 @@ func SendKick(
 		}
 	}
 
-	errRes := checkMemberInRoom(req.Context(), stateAPI, device.UserID, roomID)
+	errRes := checkMemberInRoom(req.Context(), rsAPI, device.UserID, roomID)
 	if errRes != nil {
 		return *errRes
 	}
@@ -372,13 +370,13 @@ func checkAndProcessThreepid(
 	return
 }
 
-func checkMemberInRoom(ctx context.Context, stateAPI currentstateAPI.CurrentStateInternalAPI, userID, roomID string) *util.JSONResponse {
+func checkMemberInRoom(ctx context.Context, rsAPI api.RoomserverInternalAPI, userID, roomID string) *util.JSONResponse {
 	tuple := gomatrixserverlib.StateKeyTuple{
 		EventType: gomatrixserverlib.MRoomMember,
 		StateKey:  userID,
 	}
-	var membershipRes currentstateAPI.QueryCurrentStateResponse
+	var membershipRes api.QueryCurrentStateResponse
-	err := stateAPI.QueryCurrentState(ctx, &currentstateAPI.QueryCurrentStateRequest{
+	err := rsAPI.QueryCurrentState(ctx, &api.QueryCurrentStateRequest{
 		RoomID:      roomID,
 		StateTuples: []gomatrixserverlib.StateKeyTuple{tuple},
 	}, &membershipRes)

clientapi/routing/redaction.go

@@ -21,7 +21,6 @@ import (
 
 	"github.com/matrix-org/dendrite/clientapi/httputil"
 	"github.com/matrix-org/dendrite/clientapi/jsonerror"
-	currentstateAPI "github.com/matrix-org/dendrite/currentstateserver/api"
 	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/internal/eventutil"
 	"github.com/matrix-org/dendrite/roomserver/api"
@@ -41,9 +40,9 @@ type redactionResponse struct {
 
 func SendRedaction(
 	req *http.Request, device *userapi.Device, roomID, eventID string, cfg *config.ClientAPI,
-	rsAPI roomserverAPI.RoomserverInternalAPI, stateAPI currentstateAPI.CurrentStateInternalAPI,
+	rsAPI roomserverAPI.RoomserverInternalAPI,
 ) util.JSONResponse {
-	resErr := checkMemberInRoom(req.Context(), stateAPI, device.UserID, roomID)
+	resErr := checkMemberInRoom(req.Context(), rsAPI, device.UserID, roomID)
 	if resErr != nil {
 		return *resErr
 	}
@@ -67,7 +66,7 @@ func SendRedaction(
 	// https://matrix.org/docs/spec/client_server/r0.6.1#put-matrix-client-r0-rooms-roomid-redact-eventid-txnid
 	allowedToRedact := ev.Sender() == device.UserID
 	if !allowedToRedact {
-		plEvent := currentstateAPI.GetEvent(req.Context(), stateAPI, roomID, gomatrixserverlib.StateKeyTuple{
+		plEvent := roomserverAPI.GetStateEvent(req.Context(), rsAPI, roomID, gomatrixserverlib.StateKeyTuple{
 			EventType: gomatrixserverlib.MRoomPowerLevels,
 			StateKey:  "",
 		})

clientapi/routing/routing.go

@@ -165,7 +165,7 @@ func Setup(
 			if err != nil {
 				return util.ErrorResponse(err)
 			}
-			return SendKick(req, accountDB, device, vars["roomID"], cfg, rsAPI, asAPI, stateAPI)
+			return SendKick(req, accountDB, device, vars["roomID"], cfg, rsAPI, asAPI)
 		}),
 	).Methods(http.MethodPost, http.MethodOptions)
 	r0mux.Handle("/rooms/{roomID}/unban",
@@ -361,7 +361,7 @@ func Setup(
 			if err != nil {
 				return util.ErrorResponse(err)
 			}
-			return SendTyping(req, device, vars["roomID"], vars["userID"], accountDB, eduAPI, stateAPI)
+			return SendTyping(req, device, vars["roomID"], vars["userID"], accountDB, eduAPI, rsAPI)
 		}),
 	).Methods(http.MethodPut, http.MethodOptions)
 	r0mux.Handle("/rooms/{roomID}/redact/{eventID}",
@@ -370,7 +370,7 @@ func Setup(
 			if err != nil {
 				return util.ErrorResponse(err)
 			}
-			return SendRedaction(req, device, vars["roomID"], vars["eventID"], cfg, rsAPI, stateAPI)
+			return SendRedaction(req, device, vars["roomID"], vars["eventID"], cfg, rsAPI)
 		}),
 	).Methods(http.MethodPost, http.MethodOptions)
 	r0mux.Handle("/rooms/{roomID}/redact/{eventID}/{txnId}",
@@ -379,7 +379,7 @@ func Setup(
 			if err != nil {
 				return util.ErrorResponse(err)
 			}
-			return SendRedaction(req, device, vars["roomID"], vars["eventID"], cfg, rsAPI, stateAPI)
+			return SendRedaction(req, device, vars["roomID"], vars["eventID"], cfg, rsAPI)
 		}),
 	).Methods(http.MethodPut, http.MethodOptions)
 
@@ -648,7 +648,7 @@ func Setup(
 				req.Context(),
 				device,
 				userAPI,
-				stateAPI,
+				rsAPI,
 				cfg.Matrix.ServerName,
 				postContent.SearchString,
 				postContent.Limit,

clientapi/routing/sendtyping.go

@@ -17,8 +17,8 @@ import (
 
 	"github.com/matrix-org/dendrite/clientapi/httputil"
 	"github.com/matrix-org/dendrite/clientapi/jsonerror"
-	currentstateAPI "github.com/matrix-org/dendrite/currentstateserver/api"
 	"github.com/matrix-org/dendrite/eduserver/api"
+	roomserverAPI "github.com/matrix-org/dendrite/roomserver/api"
 	userapi "github.com/matrix-org/dendrite/userapi/api"
 	"github.com/matrix-org/dendrite/userapi/storage/accounts"
 	"github.com/matrix-org/util"
@@ -35,7 +35,7 @@ func SendTyping(
 	req *http.Request, device *userapi.Device, roomID string,
 	userID string, accountDB accounts.Database,
 	eduAPI api.EDUServerInputAPI,
-	stateAPI currentstateAPI.CurrentStateInternalAPI,
+	rsAPI roomserverAPI.RoomserverInternalAPI,
 ) util.JSONResponse {
 	if device.UserID != userID {
 		return util.JSONResponse{
@@ -45,7 +45,7 @@ func SendTyping(
 	}
 
 	// Verify that the user is a member of this room
-	resErr := checkMemberInRoom(req.Context(), stateAPI, userID, roomID)
+	resErr := checkMemberInRoom(req.Context(), rsAPI, userID, roomID)
 	if resErr != nil {
 		return *resErr
 	}

clientapi/routing/userdirectory.go

@@ -19,7 +19,7 @@ import (
 	"fmt"
 
 	"github.com/matrix-org/dendrite/clientapi/auth/authtypes"
-	currentstateAPI "github.com/matrix-org/dendrite/currentstateserver/api"
+	"github.com/matrix-org/dendrite/roomserver/api"
 	userapi "github.com/matrix-org/dendrite/userapi/api"
 	"github.com/matrix-org/gomatrixserverlib"
 	"github.com/matrix-org/util"
@@ -34,7 +34,7 @@ func SearchUserDirectory(
 	ctx context.Context,
 	device *userapi.Device,
 	userAPI userapi.UserInternalAPI,
-	stateAPI currentstateAPI.CurrentStateInternalAPI,
+	rsAPI api.RoomserverInternalAPI,
 	serverName gomatrixserverlib.ServerName,
 	searchString string,
 	limit int,
@@ -81,14 +81,14 @@ func SearchUserDirectory(
 	// start searching for known users from joined rooms.
 
 	if len(results) <= limit {
-		stateReq := &currentstateAPI.QueryKnownUsersRequest{
+		stateReq := &api.QueryKnownUsersRequest{
 			UserID:       device.UserID,
 			SearchString: searchString,
 			Limit:        limit - len(results),
 		}
-		stateRes := &currentstateAPI.QueryKnownUsersResponse{}
+		stateRes := &api.QueryKnownUsersResponse{}
-		if err := stateAPI.QueryKnownUsers(ctx, stateReq, stateRes); err != nil {
+		if err := rsAPI.QueryKnownUsers(ctx, stateReq, stateRes); err != nil {
-			errRes := util.ErrorResponse(fmt.Errorf("stateAPI.QueryKnownUsers: %w", err))
+			errRes := util.ErrorResponse(fmt.Errorf("rsAPI.QueryKnownUsers: %w", err))
 			return &errRes
 		}
 

currentstateserver/api/api.go

@@ -16,26 +16,17 @@ package api
 
 import (
 	"context"
-	"encoding/json"
-	"fmt"
-	"strings"
 
-	"github.com/matrix-org/dendrite/clientapi/auth/authtypes"
 	"github.com/matrix-org/gomatrixserverlib"
 )
 
 type CurrentStateInternalAPI interface {
-	// QueryCurrentState retrieves the requested state events. If state events are not found, they will be missing from
-	// the response.
-	QueryCurrentState(ctx context.Context, req *QueryCurrentStateRequest, res *QueryCurrentStateResponse) error
 	// QueryRoomsForUser retrieves a list of room IDs matching the given query.
 	QueryRoomsForUser(ctx context.Context, req *QueryRoomsForUserRequest, res *QueryRoomsForUserResponse) error
 	// QueryBulkStateContent does a bulk query for state event content in the given rooms.
 	QueryBulkStateContent(ctx context.Context, req *QueryBulkStateContentRequest, res *QueryBulkStateContentResponse) error
 	// QuerySharedUsers returns a list of users who share at least 1 room in common with the given user.
 	QuerySharedUsers(ctx context.Context, req *QuerySharedUsersRequest, res *QuerySharedUsersResponse) error
-	// QueryKnownUsers returns a list of users that we know about from our joined rooms.
-	QueryKnownUsers(ctx context.Context, req *QueryKnownUsersRequest, res *QueryKnownUsersResponse) error
 }
 
 type QuerySharedUsersRequest struct {
@@ -81,49 +72,3 @@ type QueryBulkStateContentResponse struct {
 	// map of room ID -> tuple -> content_value
 	Rooms map[string]map[gomatrixserverlib.StateKeyTuple]string
 }
-
-type QueryCurrentStateRequest struct {
-	RoomID      string
-	StateTuples []gomatrixserverlib.StateKeyTuple
-}
-
-type QueryCurrentStateResponse struct {
-	StateEvents map[gomatrixserverlib.StateKeyTuple]*gomatrixserverlib.HeaderedEvent
-}
-
-type QueryKnownUsersRequest struct {
-	UserID       string `json:"user_id"`
-	SearchString string `json:"search_string"`
-	Limit        int    `json:"limit"`
-}
-
-type QueryKnownUsersResponse struct {
-	Users []authtypes.FullyQualifiedProfile `json:"profiles"`
-}
-
-// MarshalJSON stringifies the StateKeyTuple keys so they can be sent over the wire in HTTP API mode.
-func (r *QueryCurrentStateResponse) MarshalJSON() ([]byte, error) {
-	se := make(map[string]*gomatrixserverlib.HeaderedEvent, len(r.StateEvents))
-	for k, v := range r.StateEvents {
-		// use 0x1F (unit separator) as the delimiter between type/state key,
-		se[fmt.Sprintf("%s\x1F%s", k.EventType, k.StateKey)] = v
-	}
-	return json.Marshal(se)
-}
-
-func (r *QueryCurrentStateResponse) UnmarshalJSON(data []byte) error {
-	res := make(map[string]*gomatrixserverlib.HeaderedEvent)
-	err := json.Unmarshal(data, &res)
-	if err != nil {
-		return err
-	}
-	r.StateEvents = make(map[gomatrixserverlib.StateKeyTuple]*gomatrixserverlib.HeaderedEvent, len(res))
-	for k, v := range res {
-		fields := strings.Split(k, "\x1F")
-		r.StateEvents[gomatrixserverlib.StateKeyTuple{
-			EventType: fields[0],
-			StateKey:  fields[1],
-		}] = v
-	}
-	return nil
-}

currentstateserver/api/wrapper.go

@@ -21,24 +21,6 @@ import (
 	"github.com/matrix-org/util"
 )
 
-// GetEvent returns the current state event in the room or nil.
-func GetEvent(ctx context.Context, stateAPI CurrentStateInternalAPI, roomID string, tuple gomatrixserverlib.StateKeyTuple) *gomatrixserverlib.HeaderedEvent {
-	var res QueryCurrentStateResponse
-	err := stateAPI.QueryCurrentState(ctx, &QueryCurrentStateRequest{
-		RoomID:      roomID,
-		StateTuples: []gomatrixserverlib.StateKeyTuple{tuple},
-	}, &res)
-	if err != nil {
-		util.GetLogger(ctx).WithError(err).Error("Failed to QueryCurrentState")
-		return nil
-	}
-	ev, ok := res.StateEvents[tuple]
-	if ok {
-		return ev
-	}
-	return nil
-}
-
 // PopulatePublicRooms extracts PublicRoom information for all the provided room IDs. The IDs are not checked to see if they are visible in the
 // published room directory.
 // due to lots of switches

currentstateserver/currentstateserver_test.go

@@ -15,7 +15,6 @@
 package currentstateserver
 
 import (
-	"bytes"
 	"context"
 	"crypto/ed25519"
 	"encoding/json"
@@ -139,81 +138,6 @@ func MustMakeInternalAPI(t *testing.T) (api.CurrentStateInternalAPI, storage.Dat
 	}
 }
 
-func TestQueryCurrentState(t *testing.T) {
-	currStateAPI, db, producer, cancel := MustMakeInternalAPI(t)
-	defer cancel()
-	plTuple := gomatrixserverlib.StateKeyTuple{
-		EventType: "m.room.power_levels",
-		StateKey:  "",
-	}
-	plEvent := testEvents[4]
-	offset := MustWriteOutputEvent(t, producer, &roomserverAPI.OutputNewRoomEvent{
-		Event:             plEvent,
-		AddsStateEventIDs: []string{plEvent.EventID()},
-	})
-	waitForOffsetProcessed(t, db, offset)
-
-	testCases := []struct {
-		req     api.QueryCurrentStateRequest
-		wantRes api.QueryCurrentStateResponse
-		wantErr error
-	}{
-		{
-			req: api.QueryCurrentStateRequest{
-				RoomID: plEvent.RoomID(),
-				StateTuples: []gomatrixserverlib.StateKeyTuple{
-					plTuple,
-				},
-			},
-			wantRes: api.QueryCurrentStateResponse{
-				StateEvents: map[gomatrixserverlib.StateKeyTuple]*gomatrixserverlib.HeaderedEvent{
-					plTuple: &plEvent,
-				},
-			},
-		},
-	}
-
-	runCases := func(testAPI api.CurrentStateInternalAPI) {
-		for _, tc := range testCases {
-			var gotRes api.QueryCurrentStateResponse
-			gotErr := testAPI.QueryCurrentState(context.TODO(), &tc.req, &gotRes)
-			if tc.wantErr == nil && gotErr != nil || tc.wantErr != nil && gotErr == nil {
-				t.Errorf("QueryCurrentState error, got %s want %s", gotErr, tc.wantErr)
-				continue
-			}
-			for tuple, wantEvent := range tc.wantRes.StateEvents {
-				gotEvent, ok := gotRes.StateEvents[tuple]
-				if !ok {
-					t.Errorf("QueryCurrentState want tuple %+v but it is missing from the response", tuple)
-					continue
-				}
-				gotCanon, err := gomatrixserverlib.CanonicalJSON(gotEvent.JSON())
-				if err != nil {
-					t.Errorf("CanonicalJSON failed: %w", err)
-					continue
-				}
-				if !bytes.Equal(gotCanon, wantEvent.JSON()) {
-					t.Errorf("QueryCurrentState tuple %+v got event JSON %s want %s", tuple, string(gotCanon), string(wantEvent.JSON()))
-				}
-			}
-		}
-	}
-	t.Run("HTTP API", func(t *testing.T) {
-		router := mux.NewRouter().PathPrefix(httputil.InternalPathPrefix).Subrouter()
-		AddInternalRoutes(router, currStateAPI)
-		apiURL, cancel := test.ListenAndServe(t, router, false)
-		defer cancel()
-		httpAPI, err := inthttp.NewCurrentStateAPIClient(apiURL, &http.Client{})
-		if err != nil {
-			t.Fatalf("failed to create HTTP client")
-		}
-		runCases(httpAPI)
-	})
-	t.Run("Monolith", func(t *testing.T) {
-		runCases(currStateAPI)
-	})
-}
-
 func mustMakeMembershipEvent(t *testing.T, roomID, userID, membership string) *roomserverAPI.OutputNewRoomEvent {
 	eb := gomatrixserverlib.EventBuilder{
 		RoomID:   roomID,

currentstateserver/internal/api.go

@@ -17,7 +17,6 @@ package internal
 import (
 	"context"
 
-	"github.com/matrix-org/dendrite/clientapi/auth/authtypes"
 	"github.com/matrix-org/dendrite/currentstateserver/api"
 	"github.com/matrix-org/dendrite/currentstateserver/storage"
 	"github.com/matrix-org/gomatrixserverlib"
@@ -27,20 +26,6 @@ type CurrentStateInternalAPI struct {
 	DB storage.Database
 }
 
-func (a *CurrentStateInternalAPI) QueryCurrentState(ctx context.Context, req *api.QueryCurrentStateRequest, res *api.QueryCurrentStateResponse) error {
-	res.StateEvents = make(map[gomatrixserverlib.StateKeyTuple]*gomatrixserverlib.HeaderedEvent)
-	for _, tuple := range req.StateTuples {
-		ev, err := a.DB.GetStateEvent(ctx, req.RoomID, tuple.EventType, tuple.StateKey)
-		if err != nil {
-			return err
-		}
-		if ev != nil {
-			res.StateEvents[tuple] = ev
-		}
-	}
-	return nil
-}
-
 func (a *CurrentStateInternalAPI) QueryRoomsForUser(ctx context.Context, req *api.QueryRoomsForUserRequest, res *api.QueryRoomsForUserResponse) error {
 	roomIDs, err := a.DB.GetRoomsByMembership(ctx, req.UserID, req.WantMembership)
 	if err != nil {
@@ -50,19 +35,6 @@ func (a *CurrentStateInternalAPI) QueryRoomsForUser(ctx context.Context, req *ap
 	return nil
 }
 
-func (a *CurrentStateInternalAPI) QueryKnownUsers(ctx context.Context, req *api.QueryKnownUsersRequest, res *api.QueryKnownUsersResponse) error {
-	users, err := a.DB.GetKnownUsers(ctx, req.UserID, req.SearchString, req.Limit)
-	if err != nil {
-		return err
-	}
-	for _, user := range users {
-		res.Users = append(res.Users, authtypes.FullyQualifiedProfile{
-			UserID: user,
-		})
-	}
-	return nil
-}
-
 func (a *CurrentStateInternalAPI) QueryBulkStateContent(ctx context.Context, req *api.QueryBulkStateContentRequest, res *api.QueryBulkStateContentResponse) error {
 	events, err := a.DB.GetBulkStateContent(ctx, req.RoomIDs, req.StateTuples, req.AllowWildcards)
 	if err != nil {

currentstateserver/inthttp/client.go

@@ -26,11 +26,9 @@ import (
 
 // HTTP paths for the internal HTTP APIs
 const (
-	QueryCurrentStatePath     = "/currentstateserver/queryCurrentState"
 	QueryRoomsForUserPath     = "/currentstateserver/queryRoomsForUser"
 	QueryBulkStateContentPath = "/currentstateserver/queryBulkStateContent"
 	QuerySharedUsersPath      = "/currentstateserver/querySharedUsers"
-	QueryKnownUsersPath       = "/currentstateserver/queryKnownUsers"
 )
 
 // NewCurrentStateAPIClient creates a CurrentStateInternalAPI implemented by talking to a HTTP POST API.
@@ -53,18 +51,6 @@ type httpCurrentStateInternalAPI struct {
 	httpClient *http.Client
 }
 
-func (h *httpCurrentStateInternalAPI) QueryCurrentState(
-	ctx context.Context,
-	request *api.QueryCurrentStateRequest,
-	response *api.QueryCurrentStateResponse,
-) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "QueryCurrentState")
-	defer span.Finish()
-
-	apiURL := h.apiURL + QueryCurrentStatePath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
-}
-
 func (h *httpCurrentStateInternalAPI) QueryRoomsForUser(
 	ctx context.Context,
 	request *api.QueryRoomsForUserRequest,
@@ -98,13 +84,3 @@ func (h *httpCurrentStateInternalAPI) QuerySharedUsers(
 	apiURL := h.apiURL + QuerySharedUsersPath
 	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, req, res)
 }
-
-func (h *httpCurrentStateInternalAPI) QueryKnownUsers(
-	ctx context.Context, req *api.QueryKnownUsersRequest, res *api.QueryKnownUsersResponse,
-) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "QueryKnownUsers")
-	defer span.Finish()
-
-	apiURL := h.apiURL + QueryKnownUsersPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, req, res)
-}

currentstateserver/inthttp/server.go

@@ -25,19 +25,6 @@ import (
 )
 
 func AddRoutes(internalAPIMux *mux.Router, intAPI api.CurrentStateInternalAPI) {
-	internalAPIMux.Handle(QueryCurrentStatePath,
-		httputil.MakeInternalAPI("queryCurrentState", func(req *http.Request) util.JSONResponse {
-			request := api.QueryCurrentStateRequest{}
-			response := api.QueryCurrentStateResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := intAPI.QueryCurrentState(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
-	)
 	internalAPIMux.Handle(QueryRoomsForUserPath,
 		httputil.MakeInternalAPI("queryRoomsForUser", func(req *http.Request) util.JSONResponse {
 			request := api.QueryRoomsForUserRequest{}
@@ -77,17 +64,4 @@ func AddRoutes(internalAPIMux *mux.Router, intAPI api.CurrentStateInternalAPI) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	internalAPIMux.Handle(QuerySharedUsersPath,
-		httputil.MakeInternalAPI("queryKnownUsers", func(req *http.Request) util.JSONResponse {
-			request := api.QueryKnownUsersRequest{}
-			response := api.QueryKnownUsersResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := intAPI.QueryKnownUsers(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
-	)
 }

roomserver/inthttp/server.go

@@ -364,7 +364,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	internalAPIMux.Handle(RoomserverQuerySharedUsersPath,
+	internalAPIMux.Handle(RoomserverQueryKnownUsersPath,
 		httputil.MakeInternalAPI("queryKnownUsers", func(req *http.Request) util.JSONResponse {
 			request := api.QueryKnownUsersRequest{}
 			response := api.QueryKnownUsersResponse{}

syncapi/internal/keychange_test.go

@@ -53,14 +53,6 @@ type mockCurrentStateAPI struct {
 	roomIDToJoinedMembers map[string][]string
 }
 
-func (s *mockCurrentStateAPI) QueryCurrentState(ctx context.Context, req *api.QueryCurrentStateRequest, res *api.QueryCurrentStateResponse) error {
-	return nil
-}
-
-func (s *mockCurrentStateAPI) QueryKnownUsers(ctx context.Context, req *api.QueryKnownUsersRequest, res *api.QueryKnownUsersResponse) error {
-	return nil
-}
-
 // QueryRoomsForUser retrieves a list of room IDs matching the given query.
 func (s *mockCurrentStateAPI) QueryRoomsForUser(ctx context.Context, req *api.QueryRoomsForUserRequest, res *api.QueryRoomsForUserResponse) error {
 	return nil

syncapi/storage/shared/syncserver.go

@@ -743,9 +743,11 @@ func (d *Database) addInvitesToResponse(
 		res.Rooms.Invite[roomID] = *ir
 	}
 	for roomID := range retiredInvites {
+		if _, ok := res.Rooms.Join[roomID]; !ok {
 			lr := types.NewLeaveResponse()
 			res.Rooms.Leave[roomID] = *lr
 		}
+	}
 	return nil
 }
 
@@ -996,26 +998,8 @@ func (d *Database) getStateDeltasForFullStateSync(
 	r types.Range, userID string,
 	stateFilter *gomatrixserverlib.StateFilter,
 ) ([]stateDelta, []string, error) {
-	joinedRoomIDs, err := d.CurrentRoomState.SelectRoomIDsWithMembership(ctx, txn, userID, gomatrixserverlib.Join)
-	if err != nil {
-		return nil, nil, err
-	}
-
 	// Use a reasonable initial capacity
-	deltas := make([]stateDelta, 0, len(joinedRoomIDs))
+	deltas := make(map[string]stateDelta)
-
-	// Add full states for all joined rooms
-	for _, joinedRoomID := range joinedRoomIDs {
-		s, stateErr := d.currentStateStreamEventsForRoom(ctx, txn, joinedRoomID, stateFilter)
-		if stateErr != nil {
-			return nil, nil, stateErr
-		}
-		deltas = append(deltas, stateDelta{
-			membership:  gomatrixserverlib.Join,
-			stateEvents: d.StreamEventsToEvents(device, s),
-			roomID:      joinedRoomID,
-		})
-	}
 
 	// Get all the state events ever between these two positions
 	stateNeeded, eventMap, err := d.OutputEvents.SelectStateInRange(ctx, txn, r, stateFilter)
@@ -1031,12 +1015,12 @@ func (d *Database) getStateDeltasForFullStateSync(
 		for _, ev := range stateStreamEvents {
 			if membership := getMembershipFromEvent(&ev.Event, userID); membership != "" {
 				if membership != gomatrixserverlib.Join { // We've already added full state for all joined rooms above.
-					deltas = append(deltas, stateDelta{
+					deltas[roomID] = stateDelta{
 						membership:    membership,
 						membershipPos: ev.StreamPosition,
 						stateEvents:   d.StreamEventsToEvents(device, stateStreamEvents),
 						roomID:        roomID,
-					})
+					}
 				}
 
 				break
@@ -1044,7 +1028,33 @@ func (d *Database) getStateDeltasForFullStateSync(
 		}
 	}
 
-	return deltas, joinedRoomIDs, nil
+	joinedRoomIDs, err := d.CurrentRoomState.SelectRoomIDsWithMembership(ctx, txn, userID, gomatrixserverlib.Join)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// Add full states for all joined rooms
+	for _, joinedRoomID := range joinedRoomIDs {
+		s, stateErr := d.currentStateStreamEventsForRoom(ctx, txn, joinedRoomID, stateFilter)
+		if stateErr != nil {
+			return nil, nil, stateErr
+		}
+		deltas[joinedRoomID] = stateDelta{
+			membership:  gomatrixserverlib.Join,
+			stateEvents: d.StreamEventsToEvents(device, s),
+			roomID:      joinedRoomID,
+		}
+	}
+
+	// Create a response array.
+	result := make([]stateDelta, len(deltas))
+	i := 0
+	for _, delta := range deltas {
+		result[i] = delta
+		i++
+	}
+
+	return result, joinedRoomIDs, nil
 }
 
 func (d *Database) currentStateStreamEventsForRoom(