mirror of
https://github.com/hoernschen/dendrite.git
synced 2025-07-31 13:22:46 +00:00
Use PDU not *Event in HeaderedEvent (#3073)
Requires https://github.com/matrix-org/gomatrixserverlib/pull/376 This has numerous upsides: - Less type casting to `*Event` is required. - Making Dendrite work with `PDU` interfaces means we can swap out Event impls more easily. - Tests which represent weird event shapes are easier to write. Part of a series of refactors on GMSL.
This commit is contained in:
kegsay
GitHub
parent
696cbb70b8
commit
f5b3144dc3
64 changed files with 296 additions and 284 deletions
|
|
@ -66,7 +66,7 @@ func CheckForSoftFail(
|
|||
|
||||
// Work out which of the state events we actually need.
|
||||
stateNeeded := gomatrixserverlib.StateNeededForAuth(
|
||||
gomatrixserverlib.ToPDUs([]*gomatrixserverlib.Event{event.Event}),
|
||||
[]gomatrixserverlib.PDU{event.PDU},
|
||||
)
|
||||
|
||||
// Load the actual auth events from the database.
|
||||
|
|
@ -76,7 +76,7 @@ func CheckForSoftFail(
|
|||
}
|
||||
|
||||
// Check if the event is allowed.
|
||||
if err = gomatrixserverlib.Allowed(event.Event, &authEvents); err != nil {
|
||||
if err = gomatrixserverlib.Allowed(event.PDU, &authEvents); err != nil {
|
||||
// return true, nil
|
||||
return true, err
|
||||
}
|
||||
|
|
@ -100,7 +100,7 @@ func CheckAuthEvents(
|
|||
authStateEntries = types.DeduplicateStateEntries(authStateEntries)
|
||||
|
||||
// Work out which of the state events we actually need.
|
||||
stateNeeded := gomatrixserverlib.StateNeededForAuth([]gomatrixserverlib.PDU{event.Event})
|
||||
stateNeeded := gomatrixserverlib.StateNeededForAuth([]gomatrixserverlib.PDU{event.PDU})
|
||||
|
||||
// Load the actual auth events from the database.
|
||||
authEvents, err := loadAuthEvents(ctx, db, roomInfo, stateNeeded, authStateEntries)
|
||||
|
|
@ -109,7 +109,7 @@ func CheckAuthEvents(
|
|||
}
|
||||
|
||||
// Check if the event is allowed.
|
||||
if err = gomatrixserverlib.Allowed(event.Event, &authEvents); err != nil {
|
||||
if err = gomatrixserverlib.Allowed(event.PDU, &authEvents); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
|
|
@ -170,7 +170,7 @@ func (ae *authEvents) lookupEventWithEmptyStateKey(typeNID types.EventTypeNID) g
|
|||
if !ok {
|
||||
return nil
|
||||
}
|
||||
return event.Event
|
||||
return event.PDU
|
||||
}
|
||||
|
||||
func (ae *authEvents) lookupEvent(typeNID types.EventTypeNID, stateKey string) gomatrixserverlib.PDU {
|
||||
|
|
@ -189,7 +189,7 @@ func (ae *authEvents) lookupEvent(typeNID types.EventTypeNID, stateKey string) g
|
|||
if !ok {
|
||||
return nil
|
||||
}
|
||||
return event.Event
|
||||
return event.PDU
|
||||
}
|
||||
|
||||
// loadAuthEvents loads the events needed for authentication from the supplied room state.
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ func UpdateToInviteMembership(
|
|||
updates = append(updates, api.OutputEvent{
|
||||
Type: api.OutputTypeNewInviteEvent,
|
||||
NewInviteEvent: &api.OutputNewInviteEvent{
|
||||
Event: &types.HeaderedEvent{Event: add.Event},
|
||||
Event: &types.HeaderedEvent{PDU: add.PDU},
|
||||
RoomVersion: roomVersion,
|
||||
},
|
||||
})
|
||||
|
|
@ -90,9 +90,9 @@ func IsServerCurrentlyInRoom(ctx context.Context, db storage.Database, serverNam
|
|||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
gmslEvents := make([]*gomatrixserverlib.Event, len(events))
|
||||
gmslEvents := make([]gomatrixserverlib.PDU, len(events))
|
||||
for i := range events {
|
||||
gmslEvents[i] = events[i].Event
|
||||
gmslEvents[i] = events[i].PDU
|
||||
}
|
||||
return auth.IsAnyUserOnServerWithMembership(serverName, gmslEvents, spec.Join), nil
|
||||
}
|
||||
|
|
@ -234,22 +234,22 @@ func MembershipAtEvent(ctx context.Context, db storage.RoomDatabase, info *types
|
|||
|
||||
func LoadEvents(
|
||||
ctx context.Context, db storage.RoomDatabase, roomInfo *types.RoomInfo, eventNIDs []types.EventNID,
|
||||
) ([]*gomatrixserverlib.Event, error) {
|
||||
) ([]gomatrixserverlib.PDU, error) {
|
||||
stateEvents, err := db.Events(ctx, roomInfo, eventNIDs)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
result := make([]*gomatrixserverlib.Event, len(stateEvents))
|
||||
result := make([]gomatrixserverlib.PDU, len(stateEvents))
|
||||
for i := range stateEvents {
|
||||
result[i] = stateEvents[i].Event
|
||||
result[i] = stateEvents[i].PDU
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func LoadStateEvents(
|
||||
ctx context.Context, db storage.RoomDatabase, roomInfo *types.RoomInfo, stateEntries []types.StateEntry,
|
||||
) ([]*gomatrixserverlib.Event, error) {
|
||||
) ([]gomatrixserverlib.PDU, error) {
|
||||
eventNIDs := make([]types.EventNID, len(stateEntries))
|
||||
for i := range stateEntries {
|
||||
eventNIDs[i] = stateEntries[i].EventNID
|
||||
|
|
@ -287,7 +287,7 @@ func CheckServerAllowedToSeeEvent(
|
|||
|
||||
func slowGetHistoryVisibilityState(
|
||||
ctx context.Context, db storage.Database, info *types.RoomInfo, eventID string, serverName spec.ServerName,
|
||||
) ([]*gomatrixserverlib.Event, error) {
|
||||
) ([]gomatrixserverlib.PDU, error) {
|
||||
roomState := state.NewStateResolution(db, info)
|
||||
stateEntries, err := roomState.LoadStateAtEvent(ctx, eventID)
|
||||
if err != nil {
|
||||
|
|
@ -479,7 +479,7 @@ func QueryLatestEventsAndState(
|
|||
}
|
||||
|
||||
for _, event := range stateEvents {
|
||||
response.StateEvents = append(response.StateEvents, &types.HeaderedEvent{Event: event})
|
||||
response.StateEvents = append(response.StateEvents, &types.HeaderedEvent{PDU: event})
|
||||
}
|
||||
|
||||
return nil
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ func TestIsInvitePendingWithoutNID(t *testing.T) {
|
|||
var authNIDs []types.EventNID
|
||||
for _, x := range room.Events() {
|
||||
|
||||
roomInfo, err := db.GetOrCreateRoomInfo(context.Background(), x.Event)
|
||||
roomInfo, err := db.GetOrCreateRoomInfo(context.Background(), x.PDU)
|
||||
assert.NoError(t, err)
|
||||
assert.NotNil(t, roomInfo)
|
||||
|
||||
|
|
@ -52,7 +52,7 @@ func TestIsInvitePendingWithoutNID(t *testing.T) {
|
|||
eventStateKeyNID, err := db.GetOrCreateEventStateKeyNID(context.Background(), x.StateKey())
|
||||
assert.NoError(t, err)
|
||||
|
||||
evNID, _, err := db.StoreEvent(context.Background(), x.Event, roomInfo, eventTypeNID, eventStateKeyNID, authNIDs, false)
|
||||
evNID, _, err := db.StoreEvent(context.Background(), x.PDU, roomInfo, eventTypeNID, eventStateKeyNID, authNIDs, false)
|
||||
assert.NoError(t, err)
|
||||
authNIDs = append(authNIDs, evNID)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -102,7 +102,7 @@ func (r *Inputer) processRoomEvent(
|
|||
|
||||
// Parse and validate the event JSON
|
||||
headered := input.Event
|
||||
event := headered.Event
|
||||
event := headered.PDU
|
||||
logger := util.GetLogger(ctx).WithFields(logrus.Fields{
|
||||
"event_id": event.EventID(),
|
||||
"room_id": event.RoomID(),
|
||||
|
|
@ -232,7 +232,7 @@ func (r *Inputer) processRoomEvent(
|
|||
roomsMu: internal.NewMutexByRoom(),
|
||||
servers: serverRes.ServerNames,
|
||||
hadEvents: map[string]bool{},
|
||||
haveEvents: map[string]*gomatrixserverlib.Event{},
|
||||
haveEvents: map[string]gomatrixserverlib.PDU{},
|
||||
}
|
||||
var stateSnapshot *parsedRespState
|
||||
if stateSnapshot, err = missingState.processEventWithMissingState(ctx, event, headered.Version()); err != nil {
|
||||
|
|
@ -389,8 +389,8 @@ func (r *Inputer) processRoomEvent(
|
|||
// we do this after calculating state for this event as we may need to get power levels
|
||||
var (
|
||||
redactedEventID string
|
||||
redactionEvent *gomatrixserverlib.Event
|
||||
redactedEvent *gomatrixserverlib.Event
|
||||
redactionEvent gomatrixserverlib.PDU
|
||||
redactedEvent gomatrixserverlib.PDU
|
||||
)
|
||||
if !isRejected && !isCreateEvent {
|
||||
resolver := state.NewStateResolution(r.DB, roomInfo)
|
||||
|
|
@ -467,7 +467,7 @@ func (r *Inputer) processRoomEvent(
|
|||
Type: api.OutputTypeRedactedEvent,
|
||||
RedactedEvent: &api.OutputRedactedEvent{
|
||||
RedactedEventID: redactedEventID,
|
||||
RedactedBecause: &types.HeaderedEvent{Event: redactionEvent},
|
||||
RedactedBecause: &types.HeaderedEvent{PDU: redactionEvent},
|
||||
},
|
||||
},
|
||||
})
|
||||
|
|
@ -490,7 +490,7 @@ func (r *Inputer) processRoomEvent(
|
|||
}
|
||||
|
||||
// handleRemoteRoomUpgrade updates published rooms and room aliases
|
||||
func (r *Inputer) handleRemoteRoomUpgrade(ctx context.Context, event *gomatrixserverlib.Event) error {
|
||||
func (r *Inputer) handleRemoteRoomUpgrade(ctx context.Context, event gomatrixserverlib.PDU) error {
|
||||
oldRoomID := event.RoomID()
|
||||
newRoomID := gjson.GetBytes(event.Content(), "replacement_room").Str
|
||||
return r.DB.UpgradeRoom(ctx, oldRoomID, newRoomID, event.Sender())
|
||||
|
|
@ -509,9 +509,9 @@ func (r *Inputer) processStateBefore(
|
|||
missingPrev bool,
|
||||
) (historyVisibility gomatrixserverlib.HistoryVisibility, rejectionErr error, err error) {
|
||||
historyVisibility = gomatrixserverlib.HistoryVisibilityShared // Default to shared.
|
||||
event := input.Event.Event
|
||||
event := input.Event.PDU
|
||||
isCreateEvent := event.Type() == spec.MRoomCreate && event.StateKeyEquals("")
|
||||
var stateBeforeEvent []*gomatrixserverlib.Event
|
||||
var stateBeforeEvent []gomatrixserverlib.PDU
|
||||
switch {
|
||||
case isCreateEvent:
|
||||
// There's no state before a create event so there is nothing
|
||||
|
|
@ -524,9 +524,9 @@ func (r *Inputer) processStateBefore(
|
|||
if err != nil {
|
||||
return "", nil, fmt.Errorf("r.DB.EventsFromIDs: %w", err)
|
||||
}
|
||||
stateBeforeEvent = make([]*gomatrixserverlib.Event, 0, len(stateEvents))
|
||||
stateBeforeEvent = make([]gomatrixserverlib.PDU, 0, len(stateEvents))
|
||||
for _, entry := range stateEvents {
|
||||
stateBeforeEvent = append(stateBeforeEvent, entry.Event)
|
||||
stateBeforeEvent = append(stateBeforeEvent, entry.PDU)
|
||||
}
|
||||
case missingPrev:
|
||||
// We don't know all of the prev events, so we can't work out
|
||||
|
|
@ -567,9 +567,9 @@ func (r *Inputer) processStateBefore(
|
|||
rejectionErr = fmt.Errorf("prev events of %q are not known", event.EventID())
|
||||
return
|
||||
default:
|
||||
stateBeforeEvent = make([]*gomatrixserverlib.Event, len(stateBeforeRes.StateEvents))
|
||||
stateBeforeEvent = make([]gomatrixserverlib.PDU, len(stateBeforeRes.StateEvents))
|
||||
for i := range stateBeforeRes.StateEvents {
|
||||
stateBeforeEvent[i] = stateBeforeRes.StateEvents[i].Event
|
||||
stateBeforeEvent[i] = stateBeforeRes.StateEvents[i].PDU
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -626,7 +626,7 @@ func (r *Inputer) fetchAuthEvents(
|
|||
|
||||
for _, authEventID := range authEventIDs {
|
||||
authEvents, err := r.DB.EventsFromIDs(ctx, roomInfo, []string{authEventID})
|
||||
if err != nil || len(authEvents) == 0 || authEvents[0].Event == nil {
|
||||
if err != nil || len(authEvents) == 0 || authEvents[0].PDU == nil {
|
||||
unknown[authEventID] = struct{}{}
|
||||
continue
|
||||
}
|
||||
|
|
@ -641,7 +641,7 @@ func (r *Inputer) fetchAuthEvents(
|
|||
}
|
||||
known[authEventID] = &ev // don't take the pointer of the iterated event
|
||||
if !isRejected {
|
||||
if err = auth.AddEvent(ev.Event); err != nil {
|
||||
if err = auth.AddEvent(ev.PDU); err != nil {
|
||||
return fmt.Errorf("auth.AddEvent: %w", err)
|
||||
}
|
||||
}
|
||||
|
|
@ -745,7 +745,7 @@ nextAuthEvent:
|
|||
// Now we know about this event, it was stored and the signatures were OK.
|
||||
known[authEvent.EventID()] = &types.Event{
|
||||
EventNID: eventNID,
|
||||
Event: authEvent.(*gomatrixserverlib.Event),
|
||||
PDU: authEvent,
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -757,7 +757,7 @@ func (r *Inputer) calculateAndSetState(
|
|||
input *api.InputRoomEvent,
|
||||
roomInfo *types.RoomInfo,
|
||||
stateAtEvent *types.StateAtEvent,
|
||||
event *gomatrixserverlib.Event,
|
||||
event gomatrixserverlib.PDU,
|
||||
isRejected bool,
|
||||
) error {
|
||||
trace, ctx := internal.StartRegion(ctx, "calculateAndSetState")
|
||||
|
|
@ -799,7 +799,7 @@ func (r *Inputer) calculateAndSetState(
|
|||
}
|
||||
|
||||
// kickGuests kicks guests users from m.room.guest_access rooms, if guest access is now prohibited.
|
||||
func (r *Inputer) kickGuests(ctx context.Context, event *gomatrixserverlib.Event, roomInfo *types.RoomInfo) error {
|
||||
func (r *Inputer) kickGuests(ctx context.Context, event gomatrixserverlib.PDU, roomInfo *types.RoomInfo) error {
|
||||
membershipNIDs, err := r.DB.GetMembershipEventNIDsForRoom(ctx, roomInfo.RoomNID, true, true)
|
||||
if err != nil {
|
||||
return err
|
||||
|
|
|
|||
|
|
@ -18,21 +18,21 @@ func Test_EventAuth(t *testing.T) {
|
|||
room2 := test.NewRoom(t, alice, test.RoomPreset(test.PresetPublicChat))
|
||||
|
||||
authEventIDs := make([]string, 0, 4)
|
||||
authEvents := []*gomatrixserverlib.Event{}
|
||||
authEvents := []gomatrixserverlib.PDU{}
|
||||
|
||||
// Add the legal auth events from room2
|
||||
for _, x := range room2.Events() {
|
||||
if x.Type() == spec.MRoomCreate {
|
||||
authEventIDs = append(authEventIDs, x.EventID())
|
||||
authEvents = append(authEvents, x.Event)
|
||||
authEvents = append(authEvents, x.PDU)
|
||||
}
|
||||
if x.Type() == spec.MRoomPowerLevels {
|
||||
authEventIDs = append(authEventIDs, x.EventID())
|
||||
authEvents = append(authEvents, x.Event)
|
||||
authEvents = append(authEvents, x.PDU)
|
||||
}
|
||||
if x.Type() == spec.MRoomJoinRules {
|
||||
authEventIDs = append(authEventIDs, x.EventID())
|
||||
authEvents = append(authEvents, x.Event)
|
||||
authEvents = append(authEvents, x.PDU)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -40,7 +40,7 @@ func Test_EventAuth(t *testing.T) {
|
|||
for _, x := range room1.Events() {
|
||||
if x.Type() == spec.MRoomMember {
|
||||
authEventIDs = append(authEventIDs, x.EventID())
|
||||
authEvents = append(authEvents, x.Event)
|
||||
authEvents = append(authEvents, x.PDU)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -58,7 +58,7 @@ func Test_EventAuth(t *testing.T) {
|
|||
}
|
||||
|
||||
// Finally check that the event is NOT allowed
|
||||
if err := gomatrixserverlib.Allowed(ev.Event, &allower); err == nil {
|
||||
if err := gomatrixserverlib.Allowed(ev.PDU, &allower); err == nil {
|
||||
t.Fatalf("event should not be allowed, but it was")
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -53,7 +53,7 @@ func (r *Inputer) updateLatestEvents(
|
|||
ctx context.Context,
|
||||
roomInfo *types.RoomInfo,
|
||||
stateAtEvent types.StateAtEvent,
|
||||
event *gomatrixserverlib.Event,
|
||||
event gomatrixserverlib.PDU,
|
||||
sendAsServer string,
|
||||
transactionID *api.TransactionID,
|
||||
rewritesState bool,
|
||||
|
|
@ -101,7 +101,7 @@ type latestEventsUpdater struct {
|
|||
updater *shared.RoomUpdater
|
||||
roomInfo *types.RoomInfo
|
||||
stateAtEvent types.StateAtEvent
|
||||
event *gomatrixserverlib.Event
|
||||
event gomatrixserverlib.PDU
|
||||
transactionID *api.TransactionID
|
||||
rewritesState bool
|
||||
// Which server to send this event as.
|
||||
|
|
@ -326,7 +326,7 @@ func (u *latestEventsUpdater) latestState() error {
|
|||
// true if the new event is included in those extremites, false otherwise.
|
||||
func (u *latestEventsUpdater) calculateLatest(
|
||||
oldLatest []types.StateAtEventAndReference,
|
||||
newEvent *gomatrixserverlib.Event,
|
||||
newEvent gomatrixserverlib.PDU,
|
||||
newStateAndRef types.StateAtEventAndReference,
|
||||
) (bool, error) {
|
||||
trace, _ := internal.StartRegion(u.ctx, "calculateLatest")
|
||||
|
|
@ -393,7 +393,7 @@ func (u *latestEventsUpdater) makeOutputNewRoomEvent() (*api.OutputEvent, error)
|
|||
}
|
||||
|
||||
ore := api.OutputNewRoomEvent{
|
||||
Event: &types.HeaderedEvent{Event: u.event},
|
||||
Event: &types.HeaderedEvent{PDU: u.event},
|
||||
RewritesState: u.rewritesState,
|
||||
LastSentEventID: u.lastEventIDSent,
|
||||
LatestEventIDs: latestEventIDs,
|
||||
|
|
|
|||
|
|
@ -22,19 +22,19 @@ import (
|
|||
)
|
||||
|
||||
type parsedRespState struct {
|
||||
AuthEvents []*gomatrixserverlib.Event
|
||||
StateEvents []*gomatrixserverlib.Event
|
||||
AuthEvents []gomatrixserverlib.PDU
|
||||
StateEvents []gomatrixserverlib.PDU
|
||||
}
|
||||
|
||||
func (p *parsedRespState) Events() []gomatrixserverlib.PDU {
|
||||
eventsByID := make(map[string]*gomatrixserverlib.Event, len(p.AuthEvents)+len(p.StateEvents))
|
||||
eventsByID := make(map[string]gomatrixserverlib.PDU, len(p.AuthEvents)+len(p.StateEvents))
|
||||
for i, event := range p.AuthEvents {
|
||||
eventsByID[event.EventID()] = p.AuthEvents[i]
|
||||
}
|
||||
for i, event := range p.StateEvents {
|
||||
eventsByID[event.EventID()] = p.StateEvents[i]
|
||||
}
|
||||
allEvents := make([]*gomatrixserverlib.Event, 0, len(eventsByID))
|
||||
allEvents := make([]gomatrixserverlib.PDU, 0, len(eventsByID))
|
||||
for _, event := range eventsByID {
|
||||
allEvents = append(allEvents, event)
|
||||
}
|
||||
|
|
@ -55,7 +55,7 @@ type missingStateReq struct {
|
|||
servers []spec.ServerName
|
||||
hadEvents map[string]bool
|
||||
hadEventsMutex sync.Mutex
|
||||
haveEvents map[string]*gomatrixserverlib.Event
|
||||
haveEvents map[string]gomatrixserverlib.PDU
|
||||
haveEventsMutex sync.Mutex
|
||||
}
|
||||
|
||||
|
|
@ -63,7 +63,7 @@ type missingStateReq struct {
|
|||
// request, as called from processRoomEvent.
|
||||
// nolint:gocyclo
|
||||
func (t *missingStateReq) processEventWithMissingState(
|
||||
ctx context.Context, e *gomatrixserverlib.Event, roomVersion gomatrixserverlib.RoomVersion,
|
||||
ctx context.Context, e gomatrixserverlib.PDU, roomVersion gomatrixserverlib.RoomVersion,
|
||||
) (*parsedRespState, error) {
|
||||
trace, ctx := internal.StartRegion(ctx, "processEventWithMissingState")
|
||||
defer trace.EndRegion()
|
||||
|
|
@ -107,7 +107,7 @@ func (t *missingStateReq) processEventWithMissingState(
|
|||
for _, newEvent := range newEvents {
|
||||
err = t.inputer.processRoomEvent(ctx, t.virtualHost, &api.InputRoomEvent{
|
||||
Kind: api.KindOld,
|
||||
Event: &types.HeaderedEvent{Event: newEvent},
|
||||
Event: &types.HeaderedEvent{PDU: newEvent},
|
||||
Origin: t.origin,
|
||||
SendAsServer: api.DoNotSendToOtherServers,
|
||||
})
|
||||
|
|
@ -156,7 +156,7 @@ func (t *missingStateReq) processEventWithMissingState(
|
|||
}
|
||||
outlierRoomEvents = append(outlierRoomEvents, api.InputRoomEvent{
|
||||
Kind: api.KindOutlier,
|
||||
Event: &types.HeaderedEvent{Event: outlier.(*gomatrixserverlib.Event)},
|
||||
Event: &types.HeaderedEvent{PDU: outlier},
|
||||
Origin: t.origin,
|
||||
})
|
||||
}
|
||||
|
|
@ -186,7 +186,7 @@ func (t *missingStateReq) processEventWithMissingState(
|
|||
|
||||
err = t.inputer.processRoomEvent(ctx, t.virtualHost, &api.InputRoomEvent{
|
||||
Kind: api.KindOld,
|
||||
Event: &types.HeaderedEvent{Event: backwardsExtremity},
|
||||
Event: &types.HeaderedEvent{PDU: backwardsExtremity},
|
||||
Origin: t.origin,
|
||||
HasState: true,
|
||||
StateEventIDs: stateIDs,
|
||||
|
|
@ -205,7 +205,7 @@ func (t *missingStateReq) processEventWithMissingState(
|
|||
for _, newEvent := range newEvents {
|
||||
err = t.inputer.processRoomEvent(ctx, t.virtualHost, &api.InputRoomEvent{
|
||||
Kind: api.KindOld,
|
||||
Event: &types.HeaderedEvent{Event: newEvent},
|
||||
Event: &types.HeaderedEvent{PDU: newEvent},
|
||||
Origin: t.origin,
|
||||
SendAsServer: api.DoNotSendToOtherServers,
|
||||
})
|
||||
|
|
@ -243,7 +243,7 @@ func (t *missingStateReq) processEventWithMissingState(
|
|||
return resolvedState, nil
|
||||
}
|
||||
|
||||
func (t *missingStateReq) lookupResolvedStateBeforeEvent(ctx context.Context, e *gomatrixserverlib.Event, roomVersion gomatrixserverlib.RoomVersion) (*parsedRespState, error) {
|
||||
func (t *missingStateReq) lookupResolvedStateBeforeEvent(ctx context.Context, e gomatrixserverlib.PDU, roomVersion gomatrixserverlib.RoomVersion) (*parsedRespState, error) {
|
||||
trace, ctx := internal.StartRegion(ctx, "lookupResolvedStateBeforeEvent")
|
||||
defer trace.EndRegion()
|
||||
|
||||
|
|
@ -368,7 +368,7 @@ func (t *missingStateReq) lookupStateAfterEvent(ctx context.Context, roomVersion
|
|||
return respState, false, nil
|
||||
}
|
||||
|
||||
func (t *missingStateReq) cacheAndReturn(ev *gomatrixserverlib.Event) *gomatrixserverlib.Event {
|
||||
func (t *missingStateReq) cacheAndReturn(ev gomatrixserverlib.PDU) gomatrixserverlib.PDU {
|
||||
t.haveEventsMutex.Lock()
|
||||
defer t.haveEventsMutex.Unlock()
|
||||
if cached, exists := t.haveEvents[ev.EventID()]; exists {
|
||||
|
|
@ -403,11 +403,11 @@ func (t *missingStateReq) lookupStateAfterEventLocally(ctx context.Context, even
|
|||
t.log.WithError(err).Warnf("failed to load state events locally")
|
||||
return nil
|
||||
}
|
||||
res.StateEvents = make([]*gomatrixserverlib.Event, 0, len(stateEvents))
|
||||
res.StateEvents = make([]gomatrixserverlib.PDU, 0, len(stateEvents))
|
||||
for _, ev := range stateEvents {
|
||||
// set the event from the haveEvents cache - this means we will share pointers with other prev_event branches for this
|
||||
// processEvent request, which is better for memory.
|
||||
res.StateEvents = append(res.StateEvents, t.cacheAndReturn(ev.Event))
|
||||
res.StateEvents = append(res.StateEvents, t.cacheAndReturn(ev.PDU))
|
||||
t.hadEvent(ev.EventID())
|
||||
}
|
||||
|
||||
|
|
@ -415,7 +415,7 @@ func (t *missingStateReq) lookupStateAfterEventLocally(ctx context.Context, even
|
|||
stateEvents, stateEventNIDs, stateEntries, stateAtEvents = nil, nil, nil, nil // nolint:ineffassign
|
||||
|
||||
missingAuthEvents := map[string]bool{}
|
||||
res.AuthEvents = make([]*gomatrixserverlib.Event, 0, len(stateEvents)*3)
|
||||
res.AuthEvents = make([]gomatrixserverlib.PDU, 0, len(stateEvents)*3)
|
||||
for _, ev := range stateEvents {
|
||||
t.haveEventsMutex.Lock()
|
||||
for _, ae := range ev.AuthEventIDs() {
|
||||
|
|
@ -440,7 +440,7 @@ func (t *missingStateReq) lookupStateAfterEventLocally(ctx context.Context, even
|
|||
return nil
|
||||
}
|
||||
for i, ev := range events {
|
||||
res.AuthEvents = append(res.AuthEvents, t.cacheAndReturn(events[i].Event))
|
||||
res.AuthEvents = append(res.AuthEvents, t.cacheAndReturn(events[i].PDU))
|
||||
t.hadEvent(ev.EventID())
|
||||
}
|
||||
}
|
||||
|
|
@ -459,12 +459,12 @@ func (t *missingStateReq) lookupStateBeforeEvent(ctx context.Context, roomVersio
|
|||
return t.lookupMissingStateViaStateIDs(ctx, roomID, eventID, roomVersion)
|
||||
}
|
||||
|
||||
func (t *missingStateReq) resolveStatesAndCheck(ctx context.Context, roomVersion gomatrixserverlib.RoomVersion, states []*parsedRespState, backwardsExtremity *gomatrixserverlib.Event) (*parsedRespState, error) {
|
||||
func (t *missingStateReq) resolveStatesAndCheck(ctx context.Context, roomVersion gomatrixserverlib.RoomVersion, states []*parsedRespState, backwardsExtremity gomatrixserverlib.PDU) (*parsedRespState, error) {
|
||||
trace, ctx := internal.StartRegion(ctx, "resolveStatesAndCheck")
|
||||
defer trace.EndRegion()
|
||||
|
||||
var authEventList []*gomatrixserverlib.Event
|
||||
var stateEventList []*gomatrixserverlib.Event
|
||||
var authEventList []gomatrixserverlib.PDU
|
||||
var stateEventList []gomatrixserverlib.PDU
|
||||
for _, state := range states {
|
||||
authEventList = append(authEventList, state.AuthEvents...)
|
||||
stateEventList = append(stateEventList, state.StateEvents...)
|
||||
|
|
@ -485,7 +485,7 @@ retryAllowedState:
|
|||
case verifySigError:
|
||||
return &parsedRespState{
|
||||
AuthEvents: authEventList,
|
||||
StateEvents: gomatrixserverlib.TempCastToEvents(resolvedStateEvents),
|
||||
StateEvents: resolvedStateEvents,
|
||||
}, nil
|
||||
case nil:
|
||||
// do nothing
|
||||
|
|
@ -501,13 +501,13 @@ retryAllowedState:
|
|||
}
|
||||
return &parsedRespState{
|
||||
AuthEvents: authEventList,
|
||||
StateEvents: gomatrixserverlib.TempCastToEvents(resolvedStateEvents),
|
||||
StateEvents: resolvedStateEvents,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// get missing events for `e`. If `isGapFilled`=true then `newEvents` contains all the events to inject,
|
||||
// without `e`. If `isGapFilled=false` then `newEvents` contains the response to /get_missing_events
|
||||
func (t *missingStateReq) getMissingEvents(ctx context.Context, e *gomatrixserverlib.Event, roomVersion gomatrixserverlib.RoomVersion) (newEvents []*gomatrixserverlib.Event, isGapFilled, prevStateKnown bool, err error) {
|
||||
func (t *missingStateReq) getMissingEvents(ctx context.Context, e gomatrixserverlib.PDU, roomVersion gomatrixserverlib.RoomVersion) (newEvents []gomatrixserverlib.PDU, isGapFilled, prevStateKnown bool, err error) {
|
||||
trace, ctx := internal.StartRegion(ctx, "getMissingEvents")
|
||||
defer trace.EndRegion()
|
||||
|
||||
|
|
@ -560,7 +560,7 @@ func (t *missingStateReq) getMissingEvents(ctx context.Context, e *gomatrixserve
|
|||
|
||||
// Make sure events from the missingResp are using the cache - missing events
|
||||
// will be added and duplicates will be removed.
|
||||
missingEvents := make([]*gomatrixserverlib.Event, 0, len(missingResp.Events))
|
||||
missingEvents := make([]gomatrixserverlib.PDU, 0, len(missingResp.Events))
|
||||
for _, ev := range missingResp.Events.UntrustedEvents(roomVersion) {
|
||||
if err = gomatrixserverlib.VerifyEventSignatures(ctx, ev, t.keys); err != nil {
|
||||
continue
|
||||
|
|
@ -570,9 +570,8 @@ func (t *missingStateReq) getMissingEvents(ctx context.Context, e *gomatrixserve
|
|||
logger.Debugf("get_missing_events returned %d events (%d passed signature checks)", len(missingResp.Events), len(missingEvents))
|
||||
|
||||
// topologically sort and sanity check that we are making forward progress
|
||||
newEventsPDUs := gomatrixserverlib.ReverseTopologicalOrdering(
|
||||
newEvents = gomatrixserverlib.ReverseTopologicalOrdering(
|
||||
gomatrixserverlib.ToPDUs(missingEvents), gomatrixserverlib.TopologicalOrderByPrevEvents)
|
||||
newEvents = gomatrixserverlib.TempCastToEvents(newEventsPDUs)
|
||||
shouldHaveSomeEventIDs := e.PrevEventIDs()
|
||||
hasPrevEvent := false
|
||||
Event:
|
||||
|
|
@ -618,7 +617,7 @@ Event:
|
|||
return newEvents, true, t.isPrevStateKnown(ctx, e), nil
|
||||
}
|
||||
|
||||
func (t *missingStateReq) isPrevStateKnown(ctx context.Context, e *gomatrixserverlib.Event) bool {
|
||||
func (t *missingStateReq) isPrevStateKnown(ctx context.Context, e gomatrixserverlib.PDU) bool {
|
||||
expected := len(e.PrevEventIDs())
|
||||
state, err := t.db.StateAtEventIDs(ctx, e.PrevEventIDs())
|
||||
if err != nil || len(state) != expected {
|
||||
|
|
@ -707,7 +706,7 @@ func (t *missingStateReq) lookupMissingStateViaStateIDs(ctx context.Context, roo
|
|||
}
|
||||
|
||||
for i, ev := range events {
|
||||
events[i].Event = t.cacheAndReturn(events[i].Event)
|
||||
events[i].PDU = t.cacheAndReturn(events[i].PDU)
|
||||
t.hadEvent(ev.EventID())
|
||||
evID := events[i].EventID()
|
||||
if missing[evID] {
|
||||
|
|
@ -839,7 +838,7 @@ func (t *missingStateReq) createRespStateFromStateIDs(
|
|||
return &respState, nil
|
||||
}
|
||||
|
||||
func (t *missingStateReq) lookupEvent(ctx context.Context, roomVersion gomatrixserverlib.RoomVersion, _, missingEventID string, localFirst bool) (*gomatrixserverlib.Event, error) {
|
||||
func (t *missingStateReq) lookupEvent(ctx context.Context, roomVersion gomatrixserverlib.RoomVersion, _, missingEventID string, localFirst bool) (gomatrixserverlib.PDU, error) {
|
||||
trace, ctx := internal.StartRegion(ctx, "lookupEvent")
|
||||
defer trace.EndRegion()
|
||||
|
||||
|
|
@ -854,7 +853,7 @@ func (t *missingStateReq) lookupEvent(ctx context.Context, roomVersion gomatrixs
|
|||
if err != nil {
|
||||
t.log.Warnf("Failed to query roomserver for missing event %s: %s - falling back to remote", missingEventID, err)
|
||||
} else if len(events) == 1 {
|
||||
return events[0].Event, nil
|
||||
return events[0].PDU, nil
|
||||
}
|
||||
}
|
||||
var event *gomatrixserverlib.Event
|
||||
|
|
@ -894,7 +893,7 @@ func (t *missingStateReq) lookupEvent(ctx context.Context, roomVersion gomatrixs
|
|||
return t.cacheAndReturn(event), nil
|
||||
}
|
||||
|
||||
func checkAllowedByState(e *gomatrixserverlib.Event, stateEvents []gomatrixserverlib.PDU) error {
|
||||
func checkAllowedByState(e gomatrixserverlib.PDU, stateEvents []gomatrixserverlib.PDU) error {
|
||||
authUsingState := gomatrixserverlib.NewAuthEvents(nil)
|
||||
for i := range stateEvents {
|
||||
err := authUsingState.AddEvent(stateEvents[i])
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ func TestSingleTransactionOnInput(t *testing.T) {
|
|||
}
|
||||
in := api.InputRoomEvent{
|
||||
Kind: api.KindOutlier, // don't panic if we generate an output event
|
||||
Event: &types.HeaderedEvent{Event: event},
|
||||
Event: &types.HeaderedEvent{PDU: event},
|
||||
}
|
||||
|
||||
inputter := &input.Inputer{
|
||||
|
|
|
|||
|
|
@ -248,8 +248,8 @@ func (r *Admin) PerformAdminDownloadState(
|
|||
return err
|
||||
}
|
||||
|
||||
authEventMap := map[string]*gomatrixserverlib.Event{}
|
||||
stateEventMap := map[string]*gomatrixserverlib.Event{}
|
||||
authEventMap := map[string]gomatrixserverlib.PDU{}
|
||||
stateEventMap := map[string]gomatrixserverlib.PDU{}
|
||||
|
||||
for _, fwdExtremity := range fwdExtremities {
|
||||
var state gomatrixserverlib.StateResponse
|
||||
|
|
@ -276,10 +276,10 @@ func (r *Admin) PerformAdminDownloadState(
|
|||
stateIDs := make([]string, 0, len(stateEventMap))
|
||||
|
||||
for _, authEvent := range authEventMap {
|
||||
authEvents = append(authEvents, &types.HeaderedEvent{Event: authEvent})
|
||||
authEvents = append(authEvents, &types.HeaderedEvent{PDU: authEvent})
|
||||
}
|
||||
for _, stateEvent := range stateEventMap {
|
||||
stateEvents = append(stateEvents, &types.HeaderedEvent{Event: stateEvent})
|
||||
stateEvents = append(stateEvents, &types.HeaderedEvent{PDU: stateEvent})
|
||||
stateIDs = append(stateIDs, stateEvent.EventID())
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -86,7 +86,7 @@ func (r *Backfiller) PerformBackfill(
|
|||
|
||||
// Retrieve events from the list that was filled previously. If we fail to get
|
||||
// events from the database then attempt once to get them from federation instead.
|
||||
var loadedEvents []*gomatrixserverlib.Event
|
||||
var loadedEvents []gomatrixserverlib.PDU
|
||||
loadedEvents, err = helpers.LoadEvents(ctx, r.DB, info, resultNIDs)
|
||||
if err != nil {
|
||||
if _, ok := err.(types.MissingEventError); ok {
|
||||
|
|
@ -99,7 +99,7 @@ func (r *Backfiller) PerformBackfill(
|
|||
if _, ok := redactEventIDs[event.EventID()]; ok {
|
||||
event.Redact()
|
||||
}
|
||||
response.Events = append(response.Events, &types.HeaderedEvent{Event: event})
|
||||
response.Events = append(response.Events, &types.HeaderedEvent{PDU: event})
|
||||
}
|
||||
|
||||
return err
|
||||
|
|
@ -133,7 +133,7 @@ func (r *Backfiller) backfillViaFederation(ctx context.Context, req *api.Perform
|
|||
logrus.WithError(err).WithField("room_id", req.RoomID).Infof("backfilled %d events", len(events))
|
||||
|
||||
// persist these new events - auth checks have already been done
|
||||
roomNID, backfilledEventMap := persistEvents(ctx, r.DB, gomatrixserverlib.TempCastToEvents(events))
|
||||
roomNID, backfilledEventMap := persistEvents(ctx, r.DB, events)
|
||||
|
||||
for _, ev := range backfilledEventMap {
|
||||
// now add state for these events
|
||||
|
|
@ -170,7 +170,7 @@ func (r *Backfiller) backfillViaFederation(ctx context.Context, req *api.Perform
|
|||
|
||||
res.Events = make([]*types.HeaderedEvent, len(events))
|
||||
for i := range events {
|
||||
res.Events[i] = &types.HeaderedEvent{Event: events[i].(*gomatrixserverlib.Event)}
|
||||
res.Events[i] = &types.HeaderedEvent{PDU: events[i]}
|
||||
}
|
||||
res.HistoryVisibility = requester.historyVisiblity
|
||||
return nil
|
||||
|
|
@ -230,15 +230,15 @@ func (r *Backfiller) fetchAndStoreMissingEvents(ctx context.Context, roomVer gom
|
|||
logger.WithError(err).Warn("event failed PDU checks")
|
||||
continue
|
||||
}
|
||||
missingMap[id] = &types.HeaderedEvent{Event: res.Event.(*gomatrixserverlib.Event)}
|
||||
missingMap[id] = &types.HeaderedEvent{PDU: res.Event}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var newEvents []*gomatrixserverlib.Event
|
||||
var newEvents []gomatrixserverlib.PDU
|
||||
for _, ev := range missingMap {
|
||||
if ev != nil {
|
||||
newEvents = append(newEvents, ev.Event)
|
||||
newEvents = append(newEvents, ev.PDU)
|
||||
}
|
||||
}
|
||||
util.GetLogger(ctx).Infof("Persisting %d new events", len(newEvents))
|
||||
|
|
@ -540,7 +540,7 @@ func (b *backfillRequester) ProvideEvents(roomVer gomatrixserverlib.RoomVersion,
|
|||
}
|
||||
events := make([]gomatrixserverlib.PDU, len(eventsWithNids))
|
||||
for i := range eventsWithNids {
|
||||
events[i] = eventsWithNids[i].Event
|
||||
events[i] = eventsWithNids[i].PDU
|
||||
}
|
||||
return events, nil
|
||||
}
|
||||
|
|
@ -569,9 +569,9 @@ func joinEventsFromHistoryVisibility(
|
|||
// feels more secure here.
|
||||
return nil, gomatrixserverlib.HistoryVisibilityJoined, err
|
||||
}
|
||||
events := make([]*gomatrixserverlib.Event, len(stateEvents))
|
||||
events := make([]gomatrixserverlib.PDU, len(stateEvents))
|
||||
for i := range stateEvents {
|
||||
events[i] = stateEvents[i].Event
|
||||
events[i] = stateEvents[i].PDU
|
||||
}
|
||||
|
||||
// Can we see events in the room?
|
||||
|
|
@ -590,7 +590,7 @@ func joinEventsFromHistoryVisibility(
|
|||
return evs, visibility, err
|
||||
}
|
||||
|
||||
func persistEvents(ctx context.Context, db storage.Database, events []*gomatrixserverlib.Event) (types.RoomNID, map[string]types.Event) {
|
||||
func persistEvents(ctx context.Context, db storage.Database, events []gomatrixserverlib.PDU) (types.RoomNID, map[string]types.Event) {
|
||||
var roomNID types.RoomNID
|
||||
var eventNID types.EventNID
|
||||
backfilledEventMap := make(map[string]types.Event)
|
||||
|
|
@ -648,7 +648,7 @@ func persistEvents(ctx context.Context, db storage.Database, events []*gomatrixs
|
|||
}
|
||||
backfilledEventMap[ev.EventID()] = types.Event{
|
||||
EventNID: eventNID,
|
||||
Event: ev,
|
||||
PDU: ev,
|
||||
}
|
||||
}
|
||||
return roomNID, backfilledEventMap
|
||||
|
|
|
|||
|
|
@ -56,7 +56,7 @@ func (r *InboundPeeker) PerformInboundPeek(
|
|||
response.RoomExists = true
|
||||
response.RoomVersion = info.RoomVersion
|
||||
|
||||
var stateEvents []*gomatrixserverlib.Event
|
||||
var stateEvents []gomatrixserverlib.PDU
|
||||
|
||||
var currentStateSnapshotNID types.StateSnapshotNID
|
||||
latestEventRefs, currentStateSnapshotNID, _, err :=
|
||||
|
|
@ -70,13 +70,13 @@ func (r *InboundPeeker) PerformInboundPeek(
|
|||
}
|
||||
var sortedLatestEvents []gomatrixserverlib.PDU
|
||||
for _, ev := range latestEvents {
|
||||
sortedLatestEvents = append(sortedLatestEvents, ev.Event)
|
||||
sortedLatestEvents = append(sortedLatestEvents, ev.PDU)
|
||||
}
|
||||
sortedLatestEvents = gomatrixserverlib.ReverseTopologicalOrdering(
|
||||
sortedLatestEvents,
|
||||
gomatrixserverlib.TopologicalOrderByPrevEvents,
|
||||
)
|
||||
response.LatestEvent = &types.HeaderedEvent{Event: sortedLatestEvents[0].(*gomatrixserverlib.Event)}
|
||||
response.LatestEvent = &types.HeaderedEvent{PDU: sortedLatestEvents[0]}
|
||||
|
||||
// XXX: do we actually need to do a state resolution here?
|
||||
roomState := state.NewStateResolution(r.DB, info)
|
||||
|
|
@ -106,11 +106,11 @@ func (r *InboundPeeker) PerformInboundPeek(
|
|||
}
|
||||
|
||||
for _, event := range stateEvents {
|
||||
response.StateEvents = append(response.StateEvents, &types.HeaderedEvent{Event: event})
|
||||
response.StateEvents = append(response.StateEvents, &types.HeaderedEvent{PDU: event})
|
||||
}
|
||||
|
||||
for _, event := range authEvents {
|
||||
response.AuthChainEvents = append(response.AuthChainEvents, &types.HeaderedEvent{Event: event})
|
||||
response.AuthChainEvents = append(response.AuthChainEvents, &types.HeaderedEvent{PDU: event})
|
||||
}
|
||||
|
||||
err = r.Inputer.OutputProducer.ProduceRoomEvents(request.RoomID, []api.OutputEvent{
|
||||
|
|
|
|||
|
|
@ -110,7 +110,7 @@ func (r *Inviter) PerformInvite(
|
|||
}
|
||||
outputUpdates, err = helpers.UpdateToInviteMembership(updater, &types.Event{
|
||||
EventNID: 0,
|
||||
Event: event.Event,
|
||||
PDU: event.PDU,
|
||||
}, outputUpdates, req.Event.Version())
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("updateToInviteMembership: %w", err)
|
||||
|
|
@ -274,11 +274,11 @@ func buildInviteStrippedState(
|
|||
return nil, err
|
||||
}
|
||||
inviteState := []fclient.InviteV2StrippedState{
|
||||
fclient.NewInviteV2StrippedState(input.Event.Event),
|
||||
fclient.NewInviteV2StrippedState(input.Event.PDU),
|
||||
}
|
||||
stateEvents = append(stateEvents, types.Event{Event: input.Event.Event})
|
||||
stateEvents = append(stateEvents, types.Event{PDU: input.Event.PDU})
|
||||
for _, event := range stateEvents {
|
||||
inviteState = append(inviteState, fclient.NewInviteV2StrippedState(event.Event))
|
||||
inviteState = append(inviteState, fclient.NewInviteV2StrippedState(event.PDU))
|
||||
}
|
||||
return inviteState, nil
|
||||
}
|
||||
|
|
|
|||
|
|
@ -485,7 +485,7 @@ func (r *Upgrader) sendInitialEvents(ctx context.Context, evTime time.Time, user
|
|||
}
|
||||
|
||||
// Add the event to the list of auth events
|
||||
builtEvents = append(builtEvents, &types.HeaderedEvent{Event: event})
|
||||
builtEvents = append(builtEvents, &types.HeaderedEvent{PDU: event})
|
||||
err = authEvents.AddEvent(event)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to add new %q event to auth set: %w", builder.Type, err)
|
||||
|
|
@ -555,12 +555,12 @@ func (r *Upgrader) makeHeaderedEvent(ctx context.Context, evTime time.Time, user
|
|||
return nil, fmt.Errorf("failed to build new %q event: %w", builder.Type, err)
|
||||
}
|
||||
// check to see if this user can perform this operation
|
||||
stateEvents := make([]*gomatrixserverlib.Event, len(queryRes.StateEvents))
|
||||
stateEvents := make([]gomatrixserverlib.PDU, len(queryRes.StateEvents))
|
||||
for i := range queryRes.StateEvents {
|
||||
stateEvents[i] = queryRes.StateEvents[i].Event
|
||||
stateEvents[i] = queryRes.StateEvents[i].PDU
|
||||
}
|
||||
provider := gomatrixserverlib.NewAuthEvents(gomatrixserverlib.ToPDUs(stateEvents))
|
||||
if err = gomatrixserverlib.Allowed(headeredEvent.Event, &provider); err != nil {
|
||||
provider := gomatrixserverlib.NewAuthEvents(stateEvents)
|
||||
if err = gomatrixserverlib.Allowed(headeredEvent.PDU, &provider); err != nil {
|
||||
return nil, api.ErrNotAllowed{Err: fmt.Errorf("failed to auth new %q event: %w", builder.Type, err)} // TODO: Is this error string comprehensible to the client?
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -121,17 +121,16 @@ func (r *Queryer) QueryStateAfterEvents(
|
|||
return fmt.Errorf("getAuthChain: %w", err)
|
||||
}
|
||||
|
||||
stateEventsPDU, err := gomatrixserverlib.ResolveConflicts(
|
||||
stateEvents, err = gomatrixserverlib.ResolveConflicts(
|
||||
info.RoomVersion, gomatrixserverlib.ToPDUs(stateEvents), gomatrixserverlib.ToPDUs(authEvents),
|
||||
)
|
||||
if err != nil {
|
||||
return fmt.Errorf("state.ResolveConflictsAdhoc: %w", err)
|
||||
}
|
||||
stateEvents = gomatrixserverlib.TempCastToEvents(stateEventsPDU)
|
||||
}
|
||||
|
||||
for _, event := range stateEvents {
|
||||
response.StateEvents = append(response.StateEvents, &types.HeaderedEvent{Event: event})
|
||||
response.StateEvents = append(response.StateEvents, &types.HeaderedEvent{PDU: event})
|
||||
}
|
||||
|
||||
return nil
|
||||
|
|
@ -176,7 +175,7 @@ func (r *Queryer) QueryEventsByID(
|
|||
}
|
||||
|
||||
for _, event := range events {
|
||||
response.Events = append(response.Events, &types.HeaderedEvent{Event: event.Event})
|
||||
response.Events = append(response.Events, &types.HeaderedEvent{PDU: event.PDU})
|
||||
}
|
||||
|
||||
return nil
|
||||
|
|
@ -310,7 +309,7 @@ func (r *Queryer) QueryMembershipAtEvent(
|
|||
for i := range memberships {
|
||||
ev := memberships[i]
|
||||
if ev.Type() == spec.MRoomMember && ev.StateKeyEquals(request.UserID) {
|
||||
response.Membership[eventID] = &types.HeaderedEvent{Event: ev.Event}
|
||||
response.Membership[eventID] = &types.HeaderedEvent{PDU: ev.PDU}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -350,7 +349,7 @@ func (r *Queryer) QueryMembershipsForRoom(
|
|||
return fmt.Errorf("r.DB.Events: %w", err)
|
||||
}
|
||||
for _, event := range events {
|
||||
clientEvent := synctypes.ToClientEvent(event.Event, synctypes.FormatAll)
|
||||
clientEvent := synctypes.ToClientEvent(event.PDU, synctypes.FormatAll)
|
||||
response.JoinEvents = append(response.JoinEvents, clientEvent)
|
||||
}
|
||||
return nil
|
||||
|
|
@ -399,7 +398,7 @@ func (r *Queryer) QueryMembershipsForRoom(
|
|||
}
|
||||
|
||||
for _, event := range events {
|
||||
clientEvent := synctypes.ToClientEvent(event.Event, synctypes.FormatAll)
|
||||
clientEvent := synctypes.ToClientEvent(event.PDU, synctypes.FormatAll)
|
||||
response.JoinEvents = append(response.JoinEvents, clientEvent)
|
||||
}
|
||||
|
||||
|
|
@ -527,7 +526,7 @@ func (r *Queryer) QueryMissingEvents(
|
|||
if _, ok := redactEventIDs[event.EventID()]; ok {
|
||||
event.Redact()
|
||||
}
|
||||
response.Events = append(response.Events, &types.HeaderedEvent{Event: event})
|
||||
response.Events = append(response.Events, &types.HeaderedEvent{PDU: event})
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -554,18 +553,18 @@ func (r *Queryer) QueryStateAndAuthChain(
|
|||
// the entire current state of the room
|
||||
// TODO: this probably means it should be a different query operation...
|
||||
if request.OnlyFetchAuthChain {
|
||||
var authEvents []*gomatrixserverlib.Event
|
||||
var authEvents []gomatrixserverlib.PDU
|
||||
authEvents, err = GetAuthChain(ctx, r.DB.EventsFromIDs, info, request.AuthEventIDs)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, event := range authEvents {
|
||||
response.AuthChainEvents = append(response.AuthChainEvents, &types.HeaderedEvent{Event: event})
|
||||
response.AuthChainEvents = append(response.AuthChainEvents, &types.HeaderedEvent{PDU: event})
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
var stateEvents []*gomatrixserverlib.Event
|
||||
var stateEvents []gomatrixserverlib.PDU
|
||||
stateEvents, rejected, stateMissing, err := r.loadStateAtEventIDs(ctx, info, request.PrevEventIDs)
|
||||
if err != nil {
|
||||
return err
|
||||
|
|
@ -588,28 +587,27 @@ func (r *Queryer) QueryStateAndAuthChain(
|
|||
}
|
||||
|
||||
if request.ResolveState {
|
||||
stateEventsPDU, err2 := gomatrixserverlib.ResolveConflicts(
|
||||
stateEvents, err = gomatrixserverlib.ResolveConflicts(
|
||||
info.RoomVersion, gomatrixserverlib.ToPDUs(stateEvents), gomatrixserverlib.ToPDUs(authEvents),
|
||||
)
|
||||
if err2 != nil {
|
||||
return err2
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
stateEvents = gomatrixserverlib.TempCastToEvents(stateEventsPDU)
|
||||
}
|
||||
|
||||
for _, event := range stateEvents {
|
||||
response.StateEvents = append(response.StateEvents, &types.HeaderedEvent{Event: event})
|
||||
response.StateEvents = append(response.StateEvents, &types.HeaderedEvent{PDU: event})
|
||||
}
|
||||
|
||||
for _, event := range authEvents {
|
||||
response.AuthChainEvents = append(response.AuthChainEvents, &types.HeaderedEvent{Event: event})
|
||||
response.AuthChainEvents = append(response.AuthChainEvents, &types.HeaderedEvent{PDU: event})
|
||||
}
|
||||
|
||||
return err
|
||||
}
|
||||
|
||||
// first bool: is rejected, second bool: state missing
|
||||
func (r *Queryer) loadStateAtEventIDs(ctx context.Context, roomInfo *types.RoomInfo, eventIDs []string) ([]*gomatrixserverlib.Event, bool, bool, error) {
|
||||
func (r *Queryer) loadStateAtEventIDs(ctx context.Context, roomInfo *types.RoomInfo, eventIDs []string) ([]gomatrixserverlib.PDU, bool, bool, error) {
|
||||
roomState := state.NewStateResolution(r.DB, roomInfo)
|
||||
prevStates, err := r.DB.StateAtEventIDs(ctx, eventIDs)
|
||||
if err != nil {
|
||||
|
|
@ -651,13 +649,13 @@ type eventsFromIDs func(context.Context, *types.RoomInfo, []string) ([]types.Eve
|
|||
// given events. Will *not* error if we don't have all auth events.
|
||||
func GetAuthChain(
|
||||
ctx context.Context, fn eventsFromIDs, roomInfo *types.RoomInfo, authEventIDs []string,
|
||||
) ([]*gomatrixserverlib.Event, error) {
|
||||
) ([]gomatrixserverlib.PDU, error) {
|
||||
// List of event IDs to fetch. On each pass, these events will be requested
|
||||
// from the database and the `eventsToFetch` will be updated with any new
|
||||
// events that we have learned about and need to find. When `eventsToFetch`
|
||||
// is eventually empty, we should have reached the end of the chain.
|
||||
eventsToFetch := authEventIDs
|
||||
authEventsMap := make(map[string]*gomatrixserverlib.Event)
|
||||
authEventsMap := make(map[string]gomatrixserverlib.PDU)
|
||||
|
||||
for len(eventsToFetch) > 0 {
|
||||
// Try to retrieve the events from the database.
|
||||
|
|
@ -673,14 +671,14 @@ func GetAuthChain(
|
|||
for _, event := range events {
|
||||
// Store the event in the event map - this prevents us from requesting it
|
||||
// from the database again.
|
||||
authEventsMap[event.EventID()] = event.Event
|
||||
authEventsMap[event.EventID()] = event.PDU
|
||||
|
||||
// Extract all of the auth events from the newly obtained event. If we
|
||||
// don't already have a record of the event, record it in the list of
|
||||
// events we want to request for the next pass.
|
||||
for _, authEvent := range event.AuthEvents() {
|
||||
if _, ok := authEventsMap[authEvent.EventID]; !ok {
|
||||
eventsToFetch = append(eventsToFetch, authEvent.EventID)
|
||||
for _, authEventID := range event.AuthEventIDs() {
|
||||
if _, ok := authEventsMap[authEventID]; !ok {
|
||||
eventsToFetch = append(eventsToFetch, authEventID)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -688,7 +686,7 @@ func GetAuthChain(
|
|||
|
||||
// We've now retrieved all of the events we can. Flatten them down into an
|
||||
// array and return them.
|
||||
var authEvents []*gomatrixserverlib.Event
|
||||
var authEvents []gomatrixserverlib.PDU
|
||||
for _, event := range authEventsMap {
|
||||
authEvents = append(authEvents, event)
|
||||
}
|
||||
|
|
@ -854,7 +852,7 @@ func (r *Queryer) QueryAuthChain(ctx context.Context, req *api.QueryAuthChainReq
|
|||
}
|
||||
hchain := make([]*types.HeaderedEvent, len(chain))
|
||||
for i := range chain {
|
||||
hchain[i] = &types.HeaderedEvent{Event: chain[i]}
|
||||
hchain[i] = &types.HeaderedEvent{PDU: chain[i]}
|
||||
}
|
||||
res.AuthChain = hchain
|
||||
return nil
|
||||
|
|
|
|||
|
|
@ -84,7 +84,7 @@ func (db *getEventDB) EventsFromIDs(ctx context.Context, roomInfo *types.RoomInf
|
|||
for _, evID := range eventIDs {
|
||||
res = append(res, types.Event{
|
||||
EventNID: 0,
|
||||
Event: db.eventMap[evID],
|
||||
PDU: db.eventMap[evID],
|
||||
})
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue