Remove QueryCurrentState from current-state-server (#1395)

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)
 

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
 	}

currentstateserver/api/api.go

@@ -16,17 +16,11 @@ package api
 
 import (
 	"context"
-	"encoding/json"
-	"fmt"
-	"strings"
 
 	"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.
@@ -78,39 +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
-}
-
-// 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

@@ -26,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 {

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,

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{}

syncapi/internal/keychange_test.go

@@ -53,10 +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
-}
-
 // 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