Remove KindRewrite (#1481)

* Don't send rewrite events

* Remove final traces of rewrite events

* Remove test that is no longer needed

* Revert "Remove test that is no longer needed"

This reverts commit 9a45babff690480acd656a52f2c2950a5f7e9ada.

* Update test to use KindOutlier

federationsender/internal/perform.go

@@ -232,7 +232,7 @@ func (r *FederationSenderInternalAPI) performJoinUsingServer(
 		// If we successfully performed a send_join above then the other
 		// server now thinks we're a part of the room. Send the newly
 		// returned state to the roomserver to update our local view.
-		if err = roomserverAPI.SendEventWithRewrite(
+		if err = roomserverAPI.SendEventWithState(
 			ctx, r.rsAPI,
 			respState,
 			event.Headered(respMakeJoin.RoomVersion),

roomserver/api/input.go

@@ -35,10 +35,6 @@ const (
 	// KindBackfill event extend the contiguous graph going backwards.
 	// They always have state.
 	KindBackfill = 3
-	// KindRewrite events are used when rewriting the head of the room
-	// graph with entirely new state. The output events generated will
-	// be state events rather than timeline events.
-	KindRewrite = 4
 )
 
 // DoNotSendToOtherServers tells us not to send the event to other matrix

roomserver/api/wrapper.go

@@ -80,99 +80,6 @@ func SendEventWithState(
 	return SendInputRoomEvents(ctx, rsAPI, ires)
 }
 
-// SendEventWithRewrite writes an event with KindNew to the roomserver along
-// with a number of rewrite and outlier events for state and auth events
-// respectively.
-func SendEventWithRewrite(
-	ctx context.Context, rsAPI RoomserverInternalAPI, state *gomatrixserverlib.RespState,
-	event gomatrixserverlib.HeaderedEvent, haveEventIDs map[string]bool,
-) error {
-	isCurrentState := map[string]struct{}{}
-	for _, se := range state.StateEvents {
-		isCurrentState[se.EventID()] = struct{}{}
-	}
-
-	authAndStateEvents, err := state.Events()
-	if err != nil {
-		return err
-	}
-
-	var ires []InputRoomEvent
-	var stateIDs []string
-
-	// This function generates three things:
-	// A - A set of "rewrite" events, which will form the newly rewritten
-	//     state before the event, which includes every rewrite event that
-	//     came before it in its state
-	// B - A set of "outlier" events, which are auth events but not part
-	//     of the rewritten state
-	// C - A "new" event, which include all of the rewrite events in its
-	//     state
-	for _, authOrStateEvent := range authAndStateEvents {
-		if authOrStateEvent.StateKey() == nil {
-			continue
-		}
-		if haveEventIDs[authOrStateEvent.EventID()] {
-			continue
-		}
-		if event.StateKey() == nil {
-			continue
-		}
-
-		// We will handle an event as if it's an outlier if one of the
-		// following conditions is true:
-		storeAsOutlier := false
-		if _, ok := isCurrentState[authOrStateEvent.EventID()]; !ok {
-			// The event is an auth event and isn't a part of the state set.
-			// We'll send it as an outlier because we need it to be stored
-			// in case something is referring to it as an auth event.
-			storeAsOutlier = true
-		}
-
-		if storeAsOutlier {
-			ires = append(ires, InputRoomEvent{
-				Kind:         KindOutlier,
-				Event:        authOrStateEvent.Headered(event.RoomVersion),
-				AuthEventIDs: authOrStateEvent.AuthEventIDs(),
-			})
-			continue
-		}
-
-		// If the event isn't an outlier then we'll instead send it as a
-		// rewrite event, so that it'll form part of the rewritten state.
-		// These events will go through the membership and latest event
-		// updaters and we will generate output events, but they will be
-		// flagged as non-current (i.e. didn't just happen) events.
-		// Each of these rewrite events includes all of the rewrite events
-		// that came before in their StateEventIDs.
-		ires = append(ires, InputRoomEvent{
-			Kind:          KindRewrite,
-			Event:         authOrStateEvent.Headered(event.RoomVersion),
-			AuthEventIDs:  authOrStateEvent.AuthEventIDs(),
-			HasState:      true,
-			StateEventIDs: stateIDs,
-		})
-
-		// Add the event ID into the StateEventIDs of all subsequent
-		// rewrite events, and the new event.
-		stateIDs = append(stateIDs, authOrStateEvent.EventID())
-	}
-
-	// Send the final event as a new event, which will generate
-	// a timeline output event for it. All of the rewrite events
-	// that came before will be sent as StateEventIDs, forming a
-	// new clean state before the event.
-	ires = append(ires, InputRoomEvent{
-		Kind:          KindNew,
-		Event:         event,
-		AuthEventIDs:  event.AuthEventIDs(),
-		HasState:      true,
-		StateEventIDs: stateIDs,
-	})
-
-	return SendInputRoomEvents(ctx, rsAPI, ires)
-}
-
 // SendInputRoomEvents to the roomserver.
 func SendInputRoomEvents(
 	ctx context.Context, rsAPI RoomserverInternalAPI, ires []InputRoomEvent,

roomserver/internal/input/input_events.go

@@ -136,15 +136,6 @@ func (r *Inputer) processRoomEvent(
 		return event.EventID(), rejectionErr
 	}
 
-	if input.Kind == api.KindRewrite {
-		logrus.WithFields(logrus.Fields{
-			"event_id": event.EventID(),
-			"type":     event.Type(),
-			"room":     event.RoomID(),
-		}).Debug("Stored rewrite")
-		return event.EventID(), nil
-	}
-
 	if err = r.updateLatestEvents(
 		ctx,                 // context
 		roomInfo,            // room info for the room being updated

roomserver/roomserver_test.go

@@ -238,7 +238,7 @@ func TestOutputRedactedEvent(t *testing.T) {
 	}
 }
 
-// This tests that rewriting state via KindRewrite works correctly.
+// This tests that rewriting state works correctly.
 // This creates a small room with a create/join/name state, then replays it
 // with a new room name. We expect the output events to contain the original events,
 // followed by a single OutputNewRoomEvent with RewritesState set to true with the
@@ -344,7 +344,7 @@ func TestOutputRewritesState(t *testing.T) {
 	for i := 0; i < len(rewriteEvents)-1; i++ {
 		ev := rewriteEvents[i]
 		inputEvents = append(inputEvents, api.InputRoomEvent{
-			Kind:          api.KindRewrite,
+			Kind:          api.KindOutlier,
 			Event:         ev,
 			AuthEventIDs:  ev.AuthEventIDs(),
 			HasState:      true,