loadAuthEvents loads all of the auth events for a given event recursively, along with a map that contains state entries for all of the auth events.
( ctx context.Context, event *gomatrixserverlib.Event, eventMap map[string]types.Event, )
| 1088 | // loadAuthEvents loads all of the auth events for a given event recursively, |
| 1089 | // along with a map that contains state entries for all of the auth events. |
| 1090 | func (l *authEventLoader) loadAuthEvents( |
| 1091 | ctx context.Context, event *gomatrixserverlib.Event, eventMap map[string]types.Event, |
| 1092 | ) ([]*gomatrixserverlib.Event, map[string]types.StateEntry, error) { |
| 1093 | l.Lock() |
| 1094 | defer l.Unlock() |
| 1095 | authEvents := []types.Event{} // our returned list |
| 1096 | included := map[string]struct{}{} // dedupes authEvents above |
| 1097 | queue := event.AuthEventIDs() |
| 1098 | for i := 0; i < len(queue); i++ { |
| 1099 | // Reuse the same underlying memory, since it reduces the |
| 1100 | // amount of allocations we make the more times we call |
| 1101 | // loadAuthEvents. |
| 1102 | l.lookupFromDB = l.lookupFromDB[:0] |
| 1103 | l.lookupFromMem = l.lookupFromMem[:0] |
| 1104 | l.lookedUpEvents = l.lookedUpEvents[:0] |
| 1105 | |
| 1106 | // Separate out the list of events in the queue based on if |
| 1107 | // we think we already know the event in memory or not. |
| 1108 | for _, authEventID := range queue { |
| 1109 | if _, ok := included[authEventID]; ok { |
| 1110 | continue |
| 1111 | } |
| 1112 | if _, ok := eventMap[authEventID]; ok { |
| 1113 | l.lookupFromMem = append(l.lookupFromMem, authEventID) |
| 1114 | } else { |
| 1115 | l.lookupFromDB = append(l.lookupFromDB, authEventID) |
| 1116 | } |
| 1117 | } |
| 1118 | // If there's nothing to do, stop here. |
| 1119 | if len(l.lookupFromDB) == 0 && len(l.lookupFromMem) == 0 { |
| 1120 | break |
| 1121 | } |
| 1122 | |
| 1123 | // If we need to get events from the database, go and fetch |
| 1124 | // those now. |
| 1125 | if len(l.lookupFromDB) > 0 { |
| 1126 | eventsFromDB, err := l.v.db.EventsFromIDs(ctx, l.lookupFromDB) |
| 1127 | if err != nil { |
| 1128 | return nil, nil, fmt.Errorf("v.db.EventsFromIDs: %w", err) |
| 1129 | } |
| 1130 | l.lookedUpEvents = append(l.lookedUpEvents, eventsFromDB...) |
| 1131 | for _, event := range eventsFromDB { |
| 1132 | eventMap[event.EventID()] = event |
| 1133 | } |
| 1134 | } |
| 1135 | |
| 1136 | // Fill in the gaps with events that we already have in memory. |
| 1137 | if len(l.lookupFromMem) > 0 { |
| 1138 | for _, eventID := range l.lookupFromMem { |
| 1139 | l.lookedUpEvents = append(l.lookedUpEvents, eventMap[eventID]) |
| 1140 | } |
| 1141 | } |
| 1142 | |
| 1143 | // From the events that we've retrieved, work out which auth |
| 1144 | // events to look up on the next iteration. |
| 1145 | add := map[string]struct{}{} |
| 1146 | for _, event := range l.lookedUpEvents { |
| 1147 | authEvents = append(authEvents, event) |
no test coverage detected