From be7c636e70b8058fb737af1617c8eb16eedebc57 Mon Sep 17 00:00:00 2001 From: Kegan Dougal Date: Mon, 27 Apr 2020 19:18:26 +0100 Subject: [PATCH] Linting --- roomserver/query/backfill.go | 71 ++++++++++++++++++++---------------- roomserver/query/query.go | 58 +++++++++++++++++------------ 2 files changed, 74 insertions(+), 55 deletions(-) diff --git a/roomserver/query/backfill.go b/roomserver/query/backfill.go index b0ef0d82d..1ce442890 100644 --- a/roomserver/query/backfill.go +++ b/roomserver/query/backfill.go @@ -49,40 +49,12 @@ func (b *backfillRequester) StateIDsBeforeEvent(ctx context.Context, targetEvent if !ok { goto FederationHit } - // The state IDs BEFORE the target event are the state IDs BEFORE the prev_event PLUS the prev_event itself - newStateIDs := prevEventStateIDs[:] - if prevEvent.StateKey() == nil { - // state is the same as the previous event + newStateIDs := b.calculateNewStateIDs(targetEvent.Unwrap(), prevEvent, prevEventStateIDs) + if newStateIDs != nil { b.eventIDToBeforeStateIDs[targetEvent.EventID()] = newStateIDs return newStateIDs, nil } - - missingState := false // true if we are missing the info for a state event ID - foundEvent := false // true if we found a (type, state_key) match - // find which state ID to replace, if any - for i, id := range newStateIDs { - ev, ok := b.eventIDMap[id] - if !ok { - missingState = true - continue - } - if ev.Type() == prevEvent.Type() && ev.StateKey() != nil && ev.StateKey() == prevEvent.StateKey() { - newStateIDs[i] = prevEvent.EventID() - foundEvent = true - break - } - } - if !foundEvent && !missingState { - // we can be certain that this is new state - newStateIDs = append(newStateIDs, prevEvent.EventID()) - foundEvent = true - } - - if foundEvent { - b.eventIDToBeforeStateIDs[targetEvent.EventID()] = newStateIDs - return newStateIDs, nil - } - // else fallthrough because we don't know if one of the missing state IDs was the one we could replace. + // else we failed to calculate the new state, so fallthrough } FederationHit: @@ -105,6 +77,43 @@ FederationHit: return nil, lastErr } +func (b *backfillRequester) calculateNewStateIDs(targetEvent, prevEvent gomatrixserverlib.Event, prevEventStateIDs []string) []string { + newStateIDs := prevEventStateIDs[:] + if prevEvent.StateKey() == nil { + // state is the same as the previous event + b.eventIDToBeforeStateIDs[targetEvent.EventID()] = newStateIDs + return newStateIDs + } + + missingState := false // true if we are missing the info for a state event ID + foundEvent := false // true if we found a (type, state_key) match + // find which state ID to replace, if any + for i, id := range newStateIDs { + ev, ok := b.eventIDMap[id] + if !ok { + missingState = true + continue + } + // The state IDs BEFORE the target event are the state IDs BEFORE the prev_event PLUS the prev_event itself + if ev.Type() == prevEvent.Type() && ev.StateKey() != nil && ev.StateKey() == prevEvent.StateKey() { + newStateIDs[i] = prevEvent.EventID() + foundEvent = true + break + } + } + if !foundEvent && !missingState { + // we can be certain that this is new state + newStateIDs = append(newStateIDs, prevEvent.EventID()) + foundEvent = true + } + + if foundEvent { + b.eventIDToBeforeStateIDs[targetEvent.EventID()] = newStateIDs + return newStateIDs + } + return nil +} + func (b *backfillRequester) StateBeforeEvent(ctx context.Context, roomVer gomatrixserverlib.RoomVersion, event gomatrixserverlib.HeaderedEvent, eventIDs []string) (map[string]*gomatrixserverlib.Event, error) { // try to fetch the events from the database first events, err := b.ProvideEvents(roomVer, eventIDs) diff --git a/roomserver/query/query.go b/roomserver/query/query.go index a92942de8..f209e8ac9 100644 --- a/roomserver/query/query.go +++ b/roomserver/query/query.go @@ -551,37 +551,18 @@ func (r *RoomserverQueryAPI) backfillViaFederation(ctx context.Context, req *api } logrus.WithField("room_id", req.RoomID).Infof("backfilled %d events", len(events)) - backfilledEventMap := make(map[string]types.Event) - var roomNID types.RoomNID // persist these new events - auth checks have already been done - for _, ev := range events { - nidMap, err := r.DB.EventNIDs(ctx, ev.AuthEventIDs()) - if err != nil { // this shouldn't happen as RequestBackill already found them - logrus.WithError(err).WithField("auth_events", ev.AuthEventIDs()).Error("Failed to find one or more auth events") - continue - } - authNids := make([]types.EventNID, len(nidMap)) - i := 0 - for _, nid := range nidMap { - authNids[i] = nid - i++ - } - var stateAtEvent types.StateAtEvent - roomNID, stateAtEvent, err = r.DB.StoreEvent(ctx, ev.Unwrap(), nil, authNids) - if err != nil { - logrus.WithError(err).WithField("event_id", ev.EventID()).Error("Failed to store backfilled event") - continue - } - backfilledEventMap[ev.EventID()] = types.Event{ - EventNID: stateAtEvent.StateEntry.EventNID, - Event: ev.Unwrap(), - } + roomNID, backfilledEventMap := persistEvents(ctx, r.DB, events) + if err != nil { + return err } for _, ev := range backfilledEventMap { // now add state for these events stateIDs, ok := requester.eventIDToBeforeStateIDs[ev.EventID()] if !ok { + // this should be impossible as all events returned must have pass Step 5 of the PDU checks + // which requires a list of state IDs. logrus.WithError(err).WithField("event_id", ev.EventID()).Error("Failed to find state IDs for event which passed auth checks") continue } @@ -858,6 +839,35 @@ func getAuthChain( return authEvents, nil } +func persistEvents(ctx context.Context, db storage.Database, events []gomatrixserverlib.HeaderedEvent) (types.RoomNID, map[string]types.Event) { + var roomNID types.RoomNID + backfilledEventMap := make(map[string]types.Event) + for _, ev := range events { + nidMap, err := db.EventNIDs(ctx, ev.AuthEventIDs()) + if err != nil { // this shouldn't happen as RequestBackfill already found them + logrus.WithError(err).WithField("auth_events", ev.AuthEventIDs()).Error("Failed to find one or more auth events") + continue + } + authNids := make([]types.EventNID, len(nidMap)) + i := 0 + for _, nid := range nidMap { + authNids[i] = nid + i++ + } + var stateAtEvent types.StateAtEvent + roomNID, stateAtEvent, err = db.StoreEvent(ctx, ev.Unwrap(), nil, authNids) + if err != nil { + logrus.WithError(err).WithField("event_id", ev.EventID()).Error("Failed to store backfilled event") + continue + } + backfilledEventMap[ev.EventID()] = types.Event{ + EventNID: stateAtEvent.StateEntry.EventNID, + Event: ev.Unwrap(), + } + } + return roomNID, backfilledEventMap +} + // QueryRoomVersionCapabilities implements api.RoomserverQueryAPI func (r *RoomserverQueryAPI) QueryRoomVersionCapabilities( ctx context.Context,