Bring high level room joining logic into GMSL (#372)

Author: devonh

authchain.go

@@ -5,8 +5,8 @@ import (
 	"fmt"
 )
 
-// AuthChainProvider returns the requested list of auth events.
-type AuthChainProvider func(roomVer RoomVersion, eventIDs []string) ([]*Event, error)
+// EventProvider returns the requested list of events.
+type EventProvider func(roomVer RoomVersion, eventIDs []string) ([]*Event, error)
 
 // VerifyEventAuthChain will verify that the event is allowed according to its auth_events, and then
 // recursively verify each of those auth_events.
@@ -19,7 +19,7 @@ type AuthChainProvider func(roomVer RoomVersion, eventIDs []string) ([]*Event, e
 // The `provideEvents` function will only be called for *new* events rather than for everything as it is
 // assumed that this function is costly. Failing to provide all the requested events will fail this function.
 // Returning an error from `provideEvents` will also fail this function.
-func VerifyEventAuthChain(ctx context.Context, eventToVerify *HeaderedEvent, provideEvents AuthChainProvider) error {
+func VerifyEventAuthChain(ctx context.Context, eventToVerify *HeaderedEvent, provideEvents EventProvider) error {
 	eventsByID := make(map[string]*Event) // A lookup table for verifying this auth chain
 	evv := eventToVerify.Unwrap()
 	eventsByID[evv.EventID()] = evv

authchain_test.go

@@ -70,7 +70,7 @@ func TestVerifyEventAuthChainCascadeFailure(t *testing.T) {
 	}
 }
 
-func provideEvents(t *testing.T, events [][]byte) gomatrixserverlib.AuthChainProvider {
+func provideEvents(t *testing.T, events [][]byte) gomatrixserverlib.EventProvider {
 	eventMap := make(map[string]*gomatrixserverlib.Event)
 	for _, eventBytes := range events {
 		ev, err := gomatrixserverlib.MustGetRoomVersion(gomatrixserverlib.RoomVersionV1).NewEventFromTrustedJSON(eventBytes, false)

authstate.go

@@ -163,7 +163,7 @@ func VerifyAuthRulesAtState(ctx context.Context, sp StateProvider, eventToVerify
 
 func checkAllowedByAuthEvents(
 	event *Event, eventsByID map[string]*Event,
-	missingAuth AuthChainProvider,
+	missingAuth EventProvider,
 ) error {
 	authEvents := NewAuthEvents(nil)
 
@@ -173,7 +173,7 @@ func checkAllowedByAuthEvents(
 		if !ok {
 			// We don't have an entry in the eventsByID map - neither an event nor nil.
 			if missingAuth != nil {
-				// If we have a AuthChainProvider then ask it for the missing event.
+				// If we have a EventProvider then ask it for the missing event.
 				if ev, err := missingAuth(event.Version(), []string{ae}); err == nil && len(ev) > 0 {
 					// It claims to have returned events - populate the eventsByID
 					// map and the authEvents provider so that we can retry with the
@@ -193,7 +193,7 @@ func checkAllowedByAuthEvents(
 				}
 				goto retryEvent
 			} else {
-				// If we didn't have a AuthChainProvider then we can't get the event
+				// If we didn't have a EventProvider then we can't get the event
 				// so just carry on without it. If it was important for anything then
 				// Check() below will catch it.
 				continue
@@ -206,7 +206,7 @@ func checkAllowedByAuthEvents(
 			}
 		} else {
 			// We had an entry in the map but it contains nil, which means that we tried
-			// to use the AuthChainProvider to retrieve it and failed, so at this point
+			// to use the EventProvider to retrieve it and failed, so at this point
 			// we just have to ignore the event.
 			continue
 		}
@@ -229,7 +229,7 @@ func checkAllowedByAuthEvents(
 // return parameter). Does not alter any input args.
 func CheckStateResponse(
 	ctx context.Context, r StateResponse, roomVersion RoomVersion,
-	keyRing JSONVerifier, missingAuth AuthChainProvider,
+	keyRing JSONVerifier, missingAuth EventProvider,
 ) ([]*Event, []*Event, error) {
 	logger := util.GetLogger(ctx)
 	authEvents := r.GetAuthEvents().UntrustedEvents(roomVersion)
@@ -322,7 +322,7 @@ func CheckStateResponse(
 func CheckSendJoinResponse(
 	ctx context.Context, roomVersion RoomVersion, r StateResponse,
 	keyRing JSONVerifier, joinEvent *Event,
-	missingAuth AuthChainProvider,
+	missingAuth EventProvider,
 ) (StateResponse, error) {
 	// First check that the state is valid and that the events in the response
 	// are correctly signed.

errors.go

@@ -1,6 +1,10 @@
 package gomatrixserverlib
 
-import "fmt"
+import (
+	"fmt"
+
+	"github.com/matrix-org/gomatrixserverlib/spec"
+)
 
 // MissingAuthEventError refers to a situation where one of the auth
 // event for a given event was not found.
@@ -27,3 +31,15 @@ func (e BadJSONError) Error() string {
 func (e BadJSONError) Unwrap() error {
 	return e.err
 }
+
+// FederationError contains context surrounding why a federation request may have failed.
+type FederationError struct {
+	ServerName spec.ServerName // The server being contacted.
+	Transient  bool            // Whether the failure is permanent (will fail if performed again) or not.
+	Reachable  bool            // Whether the server could be contacted.
+	Err        error           // The underlying error message.
+}
+
+func (e FederationError) Error() string {
+	return fmt.Sprintf("FederationError(t=%v, r=%v): %s", e.Transient, e.Reachable, e.Err.Error())
+}

fclient/federationclient.go

@@ -26,7 +26,7 @@ type FederationClient interface {
 	// Perform operations
 	LookupRoomAlias(ctx context.Context, origin, s spec.ServerName, roomAlias string) (res RespDirectory, err error)
 	Peek(ctx context.Context, origin, s spec.ServerName, roomID, peekID string, roomVersions []gomatrixserverlib.RoomVersion) (res RespPeek, err error)
-	MakeJoin(ctx context.Context, origin, s spec.ServerName, roomID, userID string, roomVersions []gomatrixserverlib.RoomVersion) (res RespMakeJoin, err error)
+	MakeJoin(ctx context.Context, origin, s spec.ServerName, roomID, userID string) (res RespMakeJoin, err error)
 	SendJoin(ctx context.Context, origin, s spec.ServerName, event *gomatrixserverlib.Event) (res RespSendJoin, err error)
 	MakeLeave(ctx context.Context, origin, s spec.ServerName, roomID, userID string) (res RespMakeLeave, err error)
 	SendLeave(ctx context.Context, origin, s spec.ServerName, event *gomatrixserverlib.Event) (err error)
@@ -180,6 +180,18 @@ func makeVersionQueryString(roomVersions []gomatrixserverlib.RoomVersion) string
 	return versionQueryString
 }
 
+// Takes the map of room version implementations and converts it into a list of
+// room version strings.
+func roomVersionsToList(
+	versionsMap map[gomatrixserverlib.RoomVersion]gomatrixserverlib.IRoomVersion,
+) []gomatrixserverlib.RoomVersion {
+	var supportedVersions []gomatrixserverlib.RoomVersion
+	for version := range versionsMap {
+		supportedVersions = append(supportedVersions, version)
+	}
+	return supportedVersions
+}
+
 // MakeJoin makes a join m.room.member event for a room on a remote matrix server.
 // This is used to join a room the local server isn't a member of.
 // We need to query a remote server because if we aren't in the room we don't
@@ -191,8 +203,8 @@ func makeVersionQueryString(roomVersions []gomatrixserverlib.RoomVersion) string
 // See https://matrix.org/docs/spec/server_server/unstable.html#joining-rooms
 func (ac *federationClient) MakeJoin(
 	ctx context.Context, origin, s spec.ServerName, roomID, userID string,
-	roomVersions []gomatrixserverlib.RoomVersion,
 ) (res RespMakeJoin, err error) {
+	roomVersions := roomVersionsToList(gomatrixserverlib.RoomVersions())
 	versionQueryString := makeVersionQueryString(roomVersions)
 	path := federationPathPrefixV1 + "/make_join/" +
 		url.PathEscape(roomID) + "/" +

fclient/federationclient_test.go

@@ -89,8 +89,8 @@ func TestSendJoinFallback(t *testing.T) {
 	if err != nil {
 		t.Fatalf("SendJoin returned an error: %s", err)
 	}
-	if !reflect.DeepEqual(res.StateEvents, wantRes.StateEvents) {
-		t.Fatalf("SendJoin response got %+v want %+v", res.StateEvents, wantRes.StateEvents)
+	if !reflect.DeepEqual(res.GetStateEvents(), wantRes.StateEvents) {
+		t.Fatalf("SendJoin response got %+v want %+v", res.GetStateEvents(), wantRes.StateEvents)
 	}
 }
 
@@ -150,11 +150,11 @@ func TestSendJoinJSON(t *testing.T) {
 	}
 	wantStateEvents := gomatrixserverlib.EventJSONs{[]byte(retEv)}
 	wantAuthChain := gomatrixserverlib.EventJSONs{[]byte(retEv)}
-	if !reflect.DeepEqual(res.StateEvents, wantStateEvents) {
-		t.Fatalf("SendJoin response got state %+v want %+v", jsonify(res.StateEvents), jsonify(wantStateEvents))
+	if !reflect.DeepEqual(res.GetStateEvents(), wantStateEvents) {
+		t.Fatalf("SendJoin response got state %+v want %+v", jsonify(res.GetStateEvents()), jsonify(wantStateEvents))
 	}
-	if !reflect.DeepEqual(res.AuthEvents, wantAuthChain) {
-		t.Fatalf("SendJoin response got auth %+v want %+v", jsonify(res.AuthEvents), jsonify(wantAuthChain))
+	if !reflect.DeepEqual(res.GetAuthEvents(), wantAuthChain) {
+		t.Fatalf("SendJoin response got auth %+v want %+v", jsonify(res.GetAuthEvents()), jsonify(wantAuthChain))
 	}
 }
 

fclient/federationtypes.go

@@ -253,6 +253,14 @@ type RespMakeJoin struct {
 	RoomVersion gomatrixserverlib.RoomVersion  `json:"room_version"`
 }
 
+func (r *RespMakeJoin) GetJoinEvent() gomatrixserverlib.EventBuilder {
+	return r.JoinEvent
+}
+
+func (r *RespMakeJoin) GetRoomVersion() gomatrixserverlib.RoomVersion {
+	return r.RoomVersion
+}
+
 // A RespSendJoin is the content of a response to PUT /_matrix/federation/v2/send_join/{roomID}/{eventID}
 type RespSendJoin struct {
 	// A list of events giving the state of the room before the request event.
@@ -278,6 +286,22 @@ func (r *RespSendJoin) GetAuthEvents() gomatrixserverlib.EventJSONs {
 	return r.AuthEvents
 }
 
+func (r *RespSendJoin) GetOrigin() spec.ServerName {
+	return r.Origin
+}
+
+func (r *RespSendJoin) GetJoinEvent() spec.RawJSON {
+	return r.Event
+}
+
+func (r *RespSendJoin) GetMembersOmitted() bool {
+	return r.MembersOmitted
+}
+
+func (r *RespSendJoin) GetServersInRoom() []string {
+	return r.ServersInRoom
+}
+
 // MarshalJSON implements json.Marshaller
 func (r RespSendJoin) MarshalJSON() ([]byte, error) {
 	fields := respSendJoinFields{

join.go

@@ -0,0 +1,26 @@
+package gomatrixserverlib
+
+import (
+	"context"
+
+	"github.com/matrix-org/gomatrixserverlib/spec"
+)
+
+type FederatedJoinClient interface {
+	MakeJoin(ctx context.Context, origin, s spec.ServerName, roomID, userID string) (res MakeJoinResponse, err error)
+	SendJoin(ctx context.Context, origin, s spec.ServerName, event *Event) (res SendJoinResponse, err error)
+}
+
+type MakeJoinResponse interface {
+	GetJoinEvent() EventBuilder
+	GetRoomVersion() RoomVersion
+}
+
+type SendJoinResponse interface {
+	GetAuthEvents() EventJSONs
+	GetStateEvents() EventJSONs
+	GetOrigin() spec.ServerName
+	GetJoinEvent() spec.RawJSON
+	GetMembersOmitted() bool
+	GetServersInRoom() []string
+}

load.go

@@ -18,7 +18,7 @@ type EventLoadResult struct {
 type EventsLoader struct {
 	roomVer       RoomVersion
 	keyRing       JSONVerifier
-	provider      AuthChainProvider
+	provider      EventProvider
 	stateProvider StateProvider
 	// Set to true to do:
 	// 6. Passes authorization rules based on the current state of the room, otherwise it is "soft failed".
@@ -27,7 +27,7 @@ type EventsLoader struct {
 }
 
 // NewEventsLoader returns a new events loader
-func NewEventsLoader(roomVer RoomVersion, keyRing JSONVerifier, stateProvider StateProvider, provider AuthChainProvider, performSoftFailCheck bool) *EventsLoader {
+func NewEventsLoader(roomVer RoomVersion, keyRing JSONVerifier, stateProvider StateProvider, provider EventProvider, performSoftFailCheck bool) *EventsLoader {
 	return &EventsLoader{
 		roomVer:              roomVer,
 		keyRing:              keyRing,