Add ServerRoomImpl to allow tests to reuse helpers with custom code (#766)

* Mostly factor out ProtoEvent logic

This allows tests to replace how we map Complement Events to PDUs.
This does not yet do everything as the mapping of /send_join to Rooms
isn't factored out.

* Factor out /send_join code to ServerRoomImpl

* Add ServerRoomImplCustom to make it more ergonomic to write overrides

* Update federation/server_room.go

Co-authored-by: Devon Hudson <[email protected]>

* More comments

---------

Co-authored-by: Devon Hudson <[email protected]>

Author: kegsay

federation/handle.go

@@ -59,29 +59,22 @@ func MakeJoinRequestsHandler(s *Server, w http.ResponseWriter, req *http.Request
 // or dealing with HTTP responses itself.
 func MakeRespMakeJoin(s *Server, room *ServerRoom, userID string) (resp fclient.RespMakeJoin, err error) {
 	// Generate a join event
-	proto := gomatrixserverlib.ProtoEvent{
-		SenderID:   userID,
-		RoomID:     room.RoomID,
-		Type:       "m.room.member",
-		StateKey:   &userID,
-		PrevEvents: []string{room.Timeline[len(room.Timeline)-1].EventID()},
-		Depth:      room.Timeline[len(room.Timeline)-1].Depth() + 1,
-	}
-	err = proto.SetContent(map[string]interface{}{"membership": spec.Join})
-	if err != nil {
-		err = fmt.Errorf("make_join cannot set membership content: %w", err)
-		return
-	}
-	stateNeeded, err := gomatrixserverlib.StateNeededForProtoEvent(&proto)
+	proto, err := room.ProtoEventCreator(Event{
+		Type:     "m.room.member",
+		StateKey: &userID,
+		Content: map[string]interface{}{
+			"membership": spec.Join,
+		},
+		Sender: userID,
+	})
 	if err != nil {
-		err = fmt.Errorf("make_join cannot calculate auth_events: %w", err)
+		err = fmt.Errorf("make_join cannot set create proto event: %w", err)
 		return
 	}
-	proto.AuthEvents = room.AuthEvents(stateNeeded)
 
 	resp = fclient.RespMakeJoin{
 		RoomVersion: room.Version,
-		JoinEvent:   proto,
+		JoinEvent:   *proto,
 	}
 	return
 }
@@ -91,29 +84,22 @@ func MakeRespMakeJoin(s *Server, room *ServerRoom, userID string) (resp fclient.
 // or dealing with HTTP responses itself.
 func MakeRespMakeKnock(s *Server, room *ServerRoom, userID string) (resp fclient.RespMakeKnock, err error) {
 	// Generate a knock event
-	proto := gomatrixserverlib.ProtoEvent{
-		SenderID:   userID,
-		RoomID:     room.RoomID,
-		Type:       "m.room.member",
-		StateKey:   &userID,
-		PrevEvents: []string{room.Timeline[len(room.Timeline)-1].EventID()},
-		Depth:      room.Timeline[len(room.Timeline)-1].Depth() + 1,
-	}
-	err = proto.SetContent(map[string]interface{}{"membership": spec.Join})
-	if err != nil {
-		err = fmt.Errorf("make_knock cannot set membership content: %w", err)
-		return
-	}
-	stateNeeded, err := gomatrixserverlib.StateNeededForProtoEvent(&proto)
+	proto, err := room.ProtoEventCreator(Event{
+		Type:     "m.room.member",
+		StateKey: &userID,
+		Content: map[string]interface{}{
+			"membership": spec.Join, // XXX this feels wrong?
+		},
+		Sender: userID,
+	})
 	if err != nil {
-		err = fmt.Errorf("make_knock cannot calculate auth_events: %w", err)
+		err = fmt.Errorf("make_knock cannot set create proto event: %w", err)
 		return
 	}
-	proto.AuthEvents = room.AuthEvents(stateNeeded)
 
 	resp = fclient.RespMakeKnock{
 		RoomVersion: room.Version,
-		KnockEvent:  proto,
+		KnockEvent:  *proto,
 	}
 	return
 }
@@ -173,40 +159,8 @@ func SendJoinRequestsHandler(s *Server, w http.ResponseWriter, req *http.Request
 		return
 	}
 
-	// build the state list *before* we insert the new event
-	var stateEvents []gomatrixserverlib.PDU
-	room.StateMutex.RLock()
-	for _, ev := range room.State {
-		// filter out non-critical memberships if this is a partial-state join
-		if expectPartialState {
-			if ev.Type() == "m.room.member" && ev.StateKey() != event.StateKey() {
-				continue
-			}
-		}
-		stateEvents = append(stateEvents, ev)
-	}
-	room.StateMutex.RUnlock()
-
-	authEvents := room.AuthChainForEvents(stateEvents)
-
-	// get servers in room *before* the join event
-	serversInRoom := []string{s.serverName}
-	if !omitServersInRoom {
-		serversInRoom = room.ServersInRoom()
-	}
-
-	// insert the join event into the room state
-	room.AddEvent(event)
-	log.Printf("Received send-join of event %s", event.EventID())
-
-	// return state and auth chain
-	b, err := json.Marshal(fclient.RespSendJoin{
-		Origin:         spec.ServerName(s.serverName),
-		AuthEvents:     gomatrixserverlib.NewEventJSONsFromEvents(authEvents),
-		StateEvents:    gomatrixserverlib.NewEventJSONsFromEvents(stateEvents),
-		MembersOmitted: expectPartialState,
-		ServersInRoom:  serversInRoom,
-	})
+	resp := room.GenerateSendJoinResponse(s, event, expectPartialState, omitServersInRoom)
+	b, err := json.Marshal(resp)
 	if err != nil {
 		w.WriteHeader(500)
 		w.Write([]byte("complement: HandleMakeSendJoinRequests send_join cannot marshal RespSendJoin: " + err.Error()))
@@ -410,7 +364,7 @@ func HandleEventAuthRequests() func(*Server) {
 
 			authEvents := room.AuthChainForEvents([]gomatrixserverlib.PDU{event})
 			resp := fclient.RespEventAuth{
-				gomatrixserverlib.NewEventJSONsFromEvents(authEvents),
+				AuthEvents: gomatrixserverlib.NewEventJSONsFromEvents(authEvents),
 			}
 			respJSON, err := json.Marshal(resp)
 			if err != nil {
@@ -590,8 +544,8 @@ func HandleTransactionRequests(pduCallback func(gomatrixserverlib.PDU), eduCallb
 				verImpl, err := gomatrixserverlib.GetRoomVersion(room.Version)
 				if err != nil {
 					log.Printf(
-						"complement: Transaction '%s': Failed to get room version '%s': %s",
-						transaction.TransactionID, event.EventID(), err.Error(),
+						"complement: Transaction '%s': Failed to get room version: %s",
+						transaction.TransactionID, err.Error(),
 					)
 					continue
 				}

federation/server.go

@@ -303,58 +303,15 @@ func (s *Server) DoFederationRequest(
 // It does not insert this event into the room however. See ServerRoom.AddEvent for that.
 func (s *Server) MustCreateEvent(t ct.TestLike, room *ServerRoom, ev Event) gomatrixserverlib.PDU {
 	t.Helper()
-	content, err := json.Marshal(ev.Content)
+	proto, err := room.ProtoEventCreator(ev)
 	if err != nil {
-		ct.Fatalf(t, "MustCreateEvent: failed to marshal event content %s - %+v", err, ev.Content)
+		ct.Fatalf(t, "MustCreateEvent: failed to create proto event: %v", err)
 	}
-	var unsigned []byte
-	if ev.Unsigned != nil {
-		unsigned, err = json.Marshal(ev.Unsigned)
-		if err != nil {
-			ct.Fatalf(t, "MustCreateEvent: failed to marshal event unsigned: %s - %+v", err, ev.Unsigned)
-		}
-	}
-
-	var prevEvents interface{}
-	if ev.PrevEvents != nil {
-		// We deliberately want to set the prev events.
-		prevEvents = ev.PrevEvents
-	} else {
-		// No other prev events were supplied so we'll just
-		// use the forward extremities of the room, which is
-		// the usual behaviour.
-		prevEvents = room.ForwardExtremities
-	}
-	proto := gomatrixserverlib.ProtoEvent{
-		SenderID:   ev.Sender,
-		Depth:      int64(room.Depth + 1), // depth starts at 1
-		Type:       ev.Type,
-		StateKey:   ev.StateKey,
-		Content:    content,
-		RoomID:     room.RoomID,
-		PrevEvents: prevEvents,
-		Unsigned:   unsigned,
-		AuthEvents: ev.AuthEvents,
-		Redacts:    ev.Redacts,
-	}
-	if proto.AuthEvents == nil {
-		var stateNeeded gomatrixserverlib.StateNeeded
-		stateNeeded, err = gomatrixserverlib.StateNeededForProtoEvent(&proto)
-		if err != nil {
-			ct.Fatalf(t, "MustCreateEvent: failed to work out auth_events : %s", err)
-		}
-		proto.AuthEvents = room.AuthEvents(stateNeeded)
-	}
-	verImpl, err := gomatrixserverlib.GetRoomVersion(room.Version)
+	pdu, err := room.EventCreator(s, proto)
 	if err != nil {
-		ct.Fatalf(t, "MustCreateEvent: invalid room version: %s", err)
+		ct.Fatalf(t, "MustCreateEvent: failed to create PDU: %v", err)
 	}
-	eb := verImpl.NewEventBuilderFromProtoEvent(&proto)
-	signedEvent, err := eb.Build(time.Now(), spec.ServerName(s.serverName), s.KeyID, s.Priv)
-	if err != nil {
-		ct.Fatalf(t, "MustCreateEvent: failed to sign event: %s", err)
-	}
-	return signedEvent
+	return pdu
 }
 
 // MustJoinRoom will make the server send a make_join and a send_join to join a room
@@ -424,12 +381,8 @@ func (s *Server) MustJoinRoom(t ct.TestLike, deployment FederationDeployment, re
 	if err != nil {
 		ct.Fatalf(t, "MustJoinRoom: send_join failed: %v", err)
 	}
-	stateEvents := sendJoinResp.StateEvents.UntrustedEvents(roomVer)
 	room := NewServerRoom(roomVer, roomID)
-	for _, ev := range stateEvents {
-		room.ReplaceCurrentState(ev)
-	}
-	room.AddEvent(joinEvent)
+	room.PopulateFromSendJoinResponse(joinEvent, sendJoinResp)
 	s.rooms[roomID] = room
 
 	t.Logf("Server.MustJoinRoom joined room ID %s", roomID)