Restore PerformError on rsAPI.PerformInvite

clientapi/routing/createroom.go

@@ -402,15 +402,23 @@ func createRoom(
 			}
 		}
 		// Send the invite event to the roomserver.
-		if err := roomserverAPI.SendInvite(
+		err = roomserverAPI.SendInvite(
 			req.Context(), rsAPI,
 			inviteEvent.Headered(roomVersion),
 			strippedState,         // invite room state
 			cfg.Matrix.ServerName, // send as server
 			nil,                   // transaction ID
-		); err != nil {
+		)
-			util.GetLogger(req.Context()).WithError(err).Error("SendInvite failed")
+		switch e := err.(type) {
-			return jsonerror.InternalServerError()
+		case *roomserverAPI.PerformError:
+			return e.JSONResponse()
+		case nil:
+		default:
+			util.GetLogger(req.Context()).WithError(err).Error("roomserverAPI.SendInvite failed")
+			return util.JSONResponse{
+				Code: http.StatusInternalServerError,
+				JSON: jsonerror.InternalServerError(),
+			}
 		}
 	}
 

clientapi/routing/membership.go

@@ -221,17 +221,21 @@ func SendInvite(
 		cfg.Matrix.ServerName,
 		nil,
 	)
-	if err != nil {
+	switch e := err.(type) {
-		util.GetLogger(req.Context()).WithError(err).Error("roomserverAPI.SendInvite failed")
+	case *roomserverAPI.PerformError:
-		return util.JSONResponse{
+		return e.JSONResponse()
-			Code: http.StatusForbidden,
+	case nil:
-			JSON: jsonerror.Forbidden(err.Error()),
-		}
-	}
 		return util.JSONResponse{
 			Code: http.StatusOK,
 			JSON: struct{}{},
 		}
+	default:
+		util.GetLogger(req.Context()).WithError(err).Error("roomserverAPI.SendInvite failed")
+		return util.JSONResponse{
+			Code: http.StatusInternalServerError,
+			JSON: jsonerror.InternalServerError(),
+		}
+	}
 }
 
 func buildMembershipEvent(

federationapi/routing/invite.go

@@ -143,17 +143,24 @@ func processInvite(
 	)
 
 	// Add the invite event to the roomserver.
-	if err := api.SendInvite(
+	err = api.SendInvite(
 		ctx, rsAPI, signedEvent.Headered(roomVer), strippedState, api.DoNotSendToOtherServers, nil,
-	); err != nil {
+	)
-		util.GetLogger(ctx).WithError(err).Error("producer.SendInvite failed")
+	switch e := err.(type) {
-		return jsonerror.InternalServerError()
+	case *api.PerformError:
-	}
+		return e.JSONResponse()
-
+	case nil:
 		// Return the signed event to the originating server, it should then tell
 		// the other servers in the room that we have been invited.
 		return util.JSONResponse{
 			Code: http.StatusOK,
 			JSON: gomatrixserverlib.RespInviteV2{Event: signedEvent},
 		}
+	default:
+		util.GetLogger(ctx).WithError(err).Error("api.SendInvite failed")
+		return util.JSONResponse{
+			Code: http.StatusInternalServerError,
+			JSON: jsonerror.InternalServerError(),
+		}
+	}
 }

roomserver/api/perform.go

@@ -105,6 +105,7 @@ type PerformInviteRequest struct {
 }
 
 type PerformInviteResponse struct {
+	Error *PerformError `json:"error"`
 }
 
 // PerformBackfillRequest is a request to PerformBackfill.

roomserver/api/wrapper.go

@@ -112,6 +112,9 @@ func SendInvite(
 	}
 	response := &PerformInviteResponse{}
 	if err := rsAPI.PerformInvite(ctx, request, response); err != nil {
+		if response.Error != nil {
+			return response.Error
+		}
 		return fmt.Errorf("rsAPI.PerformInvite: %w", err)
 	}
 

roomserver/internal/perform_invite.go

@@ -2,7 +2,6 @@ package internal
 
 import (
 	"context"
-	"errors"
 	"fmt"
 
 	federationSenderAPI "github.com/matrix-org/dendrite/federationsender/api"
@@ -48,17 +47,17 @@ func (r *RoomserverInternalAPI) PerformInvite(
 	}
 	if len(inviteState) == 0 {
 		if err := event.SetUnsignedField("invite_room_state", struct{}{}); err != nil {
-			return err
+			return fmt.Errorf("event.SetUnsignedField: %w", err)
 		}
 	} else {
 		if err := event.SetUnsignedField("invite_room_state", inviteState); err != nil {
-			return err
+			return fmt.Errorf("event.SetUnsignedField: %w", err)
 		}
 	}
 
 	updater, err := r.DB.MembershipUpdater(ctx, roomID, targetUserID, isTargetLocal, req.RoomVersion)
 	if err != nil {
-		return err
+		return fmt.Errorf("r.DB.MembershipUpdater: %w", err)
 	}
 	succeeded := false
 	defer func() {
@@ -96,7 +95,11 @@ func (r *RoomserverInternalAPI) PerformInvite(
 		// For now we will implement option 2. Since in the abesence of a retry
 		// mechanism it will be equivalent to option 1, and we don't have a
 		// signalling mechanism to implement option 3.
-		return errors.New("The user is already in the room")
+		res.Error = &api.PerformError{
+			Code: api.PerformErrorNoOperation,
+			Msg:  "User is already joined to room",
+		}
+		return res.Error
 	}
 
 	if isOriginLocal {
@@ -108,10 +111,11 @@ func (r *RoomserverInternalAPI) PerformInvite(
 				"processInviteEvent.checkAuthEvents failed for event",
 			)
 			if _, ok := err.(*gomatrixserverlib.NotAllowed); ok {
-				return &api.PerformError{
+				res.Error = &api.PerformError{
 					Msg:  err.Error(),
 					Code: api.PerformErrorNotAllowed,
 				}
+				return fmt.Errorf("checkAuthEvents: %w", err)
 			}
 			return err
 		}
@@ -128,6 +132,10 @@ func (r *RoomserverInternalAPI) PerformInvite(
 			}
 			fsRes := &federationSenderAPI.PerformInviteResponse{}
 			if err = r.fsAPI.PerformInvite(ctx, fsReq, fsRes); err != nil {
+				res.Error = &api.PerformError{
+					Msg:  err.Error(),
+					Code: api.PerformErrorNoOperation,
+				}
 				return fmt.Errorf("r.fsAPI.PerformInvite: %w", err)
 			}
 			event = fsRes.SignedEvent
@@ -137,11 +145,11 @@ func (r *RoomserverInternalAPI) PerformInvite(
 	unwrapped := event.Unwrap()
 	outputUpdates, err := updateToInviteMembership(updater, &unwrapped, nil, req.Event.RoomVersion)
 	if err != nil {
-		return err
+		return fmt.Errorf("updateToInviteMembership: %w", err)
 	}
 
 	if err = r.WriteOutputEvents(roomID, outputUpdates); err != nil {
-		return err
+		return fmt.Errorf("r.WriteOutputEvents: %w", err)
 	}
 
 	succeeded = true