mirrors/dendrite
1
0
Fork 0
mirror of https://github.com/matrix-org/dendrite.git synced 2025-12-07 06:53:09 -06:00
Code Issues Packages Projects Releases Wiki Activity

Linter cleanup with ToClientEvent refactor

Browse source
This commit is contained in:
Devon Hudson 2023-09-13 15:10:25 -06:00
parent 163e865e93
commit a10f103d55
No known key found for this signature in database
GPG key ID: CD06B18E77F6A628
12 changed files with 43 additions and 220 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
clientapi/routing/state.go
View file

@ -172,28 +172,9 @@ func OnIncomingStateRequest(ctx context.Context, device *userapi.Device, rsAPI a
}
}
for _, ev := range stateAfterRes.StateEvents {
sender := spec.UserID{}
evRoomID, err := spec.NewRoomID(ev.RoomID())
if err != nil {
util.GetLogger(ctx).WithError(err).Error("Event roomID is invalid")
continue
}
userID, err := rsAPI.QueryUserIDForSender(ctx, *evRoomID, ev.SenderID())
if err == nil && userID != nil {
sender = *userID
}
sk := ev.StateKey()
if sk != nil && *sk != "" {
skUserID, err := rsAPI.QueryUserIDForSender(ctx, *evRoomID, spec.SenderID(*ev.StateKey()))
if err == nil && skUserID != nil {
skString := skUserID.String()
sk = &skString
}
}
clientEvent, err := synctypes.ToClientEvent(ev, synctypes.FormatAll, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
return rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
}, sender.String(), sk)
})
if err != nil {
util.GetLogger(ctx).WithError(err).Error("Failed converting to ClientEvent")
continue

10
internal/eventutil/events.go
View file

@ -176,17 +176,9 @@ func RedactEvent(ctx context.Context, redactionEvent, redactedEvent gomatrixserv
return fmt.Errorf("RedactEvent: redactionEvent isn't a redaction event, is '%s'", redactionEvent.Type())
}
redactedEvent.Redact()
validRoomID, err := spec.NewRoomID(redactionEvent.RoomID())
if err != nil {
return err
}
senderID, err := querier.QueryUserIDForSender(ctx, *validRoomID, redactionEvent.SenderID())
if err != nil {
return err
}
clientEvent, err := synctypes.ToClientEvent(redactionEvent, synctypes.FormatSync, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
return querier.QueryUserIDForSender(ctx, roomID, senderID)
}, senderID.String(), redactionEvent.StateKey())
})
if err != nil {
return err
}

27
syncapi/routing/getevent.go
View file

@ -118,34 +118,9 @@ func GetEvent(
}
}
senderUserID, err := rsAPI.QueryUserIDForSender(req.Context(), *roomID, events[0].SenderID())
if err != nil || senderUserID == nil {
util.GetLogger(req.Context()).WithError(err).WithField("senderID", events[0].SenderID()).WithField("roomID", *roomID).Error("QueryUserIDForSender errored or returned nil-user ID when user should be part of a room")
return util.JSONResponse{
Code: http.StatusInternalServerError,
JSON: spec.Unknown("internal server error"),
}
}
sk := events[0].StateKey()
if sk != nil && *sk != "" {
evRoomID, err := spec.NewRoomID(events[0].RoomID())
if err != nil {
return util.JSONResponse{
Code: http.StatusBadRequest,
JSON: spec.BadJSON("roomID is invalid"),
}
}
skUserID, err := rsAPI.QueryUserIDForSender(ctx, *evRoomID, spec.SenderID(*events[0].StateKey()))
if err == nil && skUserID != nil {
skString := skUserID.String()
sk = &skString
}
}
clientEvent, err := synctypes.ToClientEvent(events[0], synctypes.FormatAll, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
return rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
}, senderUserID.String(), sk)
})
if err != nil {
util.GetLogger(req.Context()).WithError(err).WithField("senderID", events[0].SenderID()).WithField("roomID", *roomID).Error("Failed converting to ClientEvent")
return util.JSONResponse{

17
syncapi/routing/relations.go
View file

@ -130,24 +130,9 @@ func Relations(
// type if it was specified.
res.Chunk = make([]synctypes.ClientEvent, 0, len(filteredEvents))
for _, event := range filteredEvents {
sender := spec.UserID{}
userID, err := rsAPI.QueryUserIDForSender(req.Context(), *roomID, event.SenderID())
if err == nil && userID != nil {
sender = *userID
}
sk := event.StateKey()
if sk != nil && *sk != "" {
skUserID, err := rsAPI.QueryUserIDForSender(req.Context(), *roomID, spec.SenderID(*event.StateKey()))
if err == nil && skUserID != nil {
skString := skUserID.String()
sk = &skString
}
}
clientEvent, err := synctypes.ToClientEvent(event.PDU, synctypes.FormatAll, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
return rsAPI.QueryUserIDForSender(req.Context(), roomID, senderID)
}, sender.String(), sk)
})
if err != nil {
util.GetLogger(req.Context()).WithError(err).WithField("senderID", events[0].SenderID()).WithField("roomID", *roomID).Error("Failed converting to ClientEvent")
continue

24
syncapi/routing/search.go
View file

@ -235,31 +235,11 @@ func Search(req *http.Request, device *api.Device, syncDB storage.Database, fts
profileInfos[userID.String()] = profile
}
sender := spec.UserID{}
validRoomID, roomErr := spec.NewRoomID(event.RoomID())
if err != nil {
logrus.WithError(roomErr).WithField("room_id", event.RoomID()).Warn("failed to query userprofile")
continue
}
userID, err := rsAPI.QueryUserIDForSender(req.Context(), *validRoomID, event.SenderID())
if err == nil && userID != nil {
sender = *userID
}
sk := event.StateKey()
if sk != nil && *sk != "" {
skUserID, err := rsAPI.QueryUserIDForSender(req.Context(), *validRoomID, spec.SenderID(*event.StateKey()))
if err == nil && skUserID != nil {
skString := skUserID.String()
sk = &skString
}
}
clientEvent, err := synctypes.ToClientEvent(event, synctypes.FormatAll, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
return rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
}, sender.String(), sk)
})
if err != nil {
util.GetLogger(req.Context()).WithError(err).WithField("senderID", event.SenderID()).WithField("roomID", *validRoomID).Error("Failed converting to ClientEvent")
util.GetLogger(req.Context()).WithError(err).WithField("senderID", event.SenderID()).Error("Failed converting to ClientEvent")
continue
}

11
syncapi/streams/stream_invite.go
View file

@ -79,20 +79,11 @@ func (p *InviteStreamProvider) IncrementalSync(
user = *sender
}
sk := inviteEvent.StateKey()
if sk != nil && *sk != "" {
skUserID, err := p.rsAPI.QueryUserIDForSender(ctx, *validRoomID, spec.SenderID(*inviteEvent.StateKey()))
if err == nil && skUserID != nil {
skString := skUserID.String()
sk = &skString
}
}
// skip ignored user events
if _, ok := req.IgnoredUsers.List[user.String()]; ok {
continue
}
ir, err := types.NewInviteResponse(ctx, p.rsAPI, inviteEvent, user, sk, eventFormat)
ir, err := types.NewInviteResponse(ctx, p.rsAPI, inviteEvent, eventFormat)
if err != nil {
req.Log.WithError(err).Error("failed creating invite response")
continue

57
syncapi/synctypes/clientevent.go
View file

@ -80,7 +80,7 @@ func ToClientEvents(serverEvs []gomatrixserverlib.PDU, format ClientEventFormat,
if se == nil {
continue // TODO: shouldn't happen?
}
ev, err := ToClientEvent(se, format, userIDForSender, string(se.SenderID()), se.StateKey())
ev, err := ToClientEvent(se, format, userIDForSender)
if err != nil {
logrus.Errorf("Failed converting event to ClientEvent: %s", err.Error())
continue
@ -93,25 +93,7 @@ func ToClientEvents(serverEvs []gomatrixserverlib.PDU, format ClientEventFormat,
// ToClientEvent converts a single server event to a client event.
// It provides default logic for event.SenderID & event.StateKey -> userID conversions.
func ToClientEventDefault(userIDQuery spec.UserIDForSender, event gomatrixserverlib.PDU) ClientEvent {
sender := spec.UserID{}
validRoomID, err := spec.NewRoomID(event.RoomID())
if err != nil {
return ClientEvent{}
}
userID, err := userIDQuery(*validRoomID, event.SenderID())
if err == nil && userID != nil {
sender = *userID
}
sk := event.StateKey()
if sk != nil && *sk != "" {
skUserID, err := userIDQuery(*validRoomID, spec.SenderID(*event.StateKey()))
if err == nil && skUserID != nil {
skString := skUserID.String()
sk = &skString
}
}
ev, err := ToClientEvent(event, FormatAll, userIDQuery, sender.String(), sk)
ev, err := ToClientEvent(event, FormatAll, userIDQuery)
if err != nil {
return ClientEvent{}
}
@ -147,12 +129,12 @@ func FromClientStateKey(roomID spec.RoomID, stateKey string, senderIDQuery spec.
}
// ToClientEvent converts a single server event to a client event.
func ToClientEvent(se gomatrixserverlib.PDU, format ClientEventFormat, userIDForSender spec.UserIDForSender, sender string, stateKey *string) (*ClientEvent, error) {
func ToClientEvent(se gomatrixserverlib.PDU, format ClientEventFormat, userIDForSender spec.UserIDForSender) (*ClientEvent, error) {
ce := ClientEvent{
Content: se.Content(),
Sender: sender,
Sender: string(se.SenderID()),
Type: se.Type(),
StateKey: stateKey,
StateKey: se.StateKey(),
Unsigned: se.Unsigned(),
OriginServerTS: se.OriginServerTS(),
EventID: se.EventID(),
@ -300,7 +282,7 @@ func updateInviteEvent(userIDForSender spec.UserIDForSender, ev gomatrixserverli
return nil, err
}
newState, err := getUpdatedInviteRoomState(userIDForSender, inviteRoomState, ev, *userID, ev.StateKey(), eventFormat)
newState, err := getUpdatedInviteRoomState(userIDForSender, inviteRoomState, ev, *validRoomID, eventFormat)
if err != nil {
return nil, err
}
@ -324,7 +306,7 @@ type InviteRoomStateEvent struct {
Type string `json:"type"`
}
func getUpdatedInviteRoomState(userIDForSender spec.UserIDForSender, inviteRoomState gjson.Result, event gomatrixserverlib.PDU, inviterUserID spec.UserID, stateKey *string, eventFormat ClientEventFormat) (spec.RawJSON, error) {
func getUpdatedInviteRoomState(userIDForSender spec.UserIDForSender, inviteRoomState gjson.Result, event gomatrixserverlib.PDU, roomID spec.RoomID, eventFormat ClientEventFormat) (spec.RawJSON, error) {
var res spec.RawJSON
inviteStateEvents := []InviteRoomStateEvent{}
err := json.Unmarshal([]byte(inviteRoomState.Raw), &inviteStateEvents)
@ -333,22 +315,17 @@ func getUpdatedInviteRoomState(userIDForSender spec.UserIDForSender, inviteRoomS
}
if event.Version() == gomatrixserverlib.RoomVersionPseudoIDs && eventFormat != FormatSyncFederation {
validRoomID, err := spec.NewRoomID(event.RoomID())
if err != nil {
return nil, err
}
for i, ev := range inviteStateEvents {
userID, err := userIDForSender(*validRoomID, spec.SenderID(ev.SenderID))
if err != nil {
return nil, err
userID, userIDErr := userIDForSender(roomID, spec.SenderID(ev.SenderID))
if userIDErr != nil {
return nil, userIDErr
}
inviteStateEvents[i].SenderID = userID.String()
if ev.StateKey != nil && *ev.StateKey != "" {
userID, err := userIDForSender(*validRoomID, spec.SenderID(*ev.StateKey))
if err != nil {
return nil, err
userID, senderErr := userIDForSender(roomID, spec.SenderID(*ev.StateKey))
if senderErr != nil {
return nil, senderErr
}
if userID != nil {
user := userID.String()
@ -356,10 +333,10 @@ func getUpdatedInviteRoomState(userIDForSender spec.UserIDForSender, inviteRoomS
}
}
updatedContent, err := updateCreateEvent(ev.Content, userIDForSender, *validRoomID)
if err != nil {
err = fmt.Errorf("Failed to update m.room.create event for ClientEvent: %s", err.Error())
return nil, err
updatedContent, updateErr := updateCreateEvent(ev.Content, userIDForSender, roomID)
if updateErr != nil {
updateErr = fmt.Errorf("Failed to update m.room.create event for ClientEvent: %s", userIDErr.Error())
return nil, updateErr
}
inviteStateEvents[i].Content = updatedContent
}

20
syncapi/synctypes/clientevent_test.go
View file

@ -17,7 +17,6 @@ package synctypes
import (
"bytes"
"context"
"encoding/json"
"fmt"
"reflect"
@ -27,7 +26,7 @@ import (
"github.com/matrix-org/gomatrixserverlib/spec"
)
func queryUserIDForSender(ctx context.Context, roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
func queryUserIDForSender(senderID spec.SenderID) (*spec.UserID, error) {
if senderID == "" {
return nil, nil
}
@ -116,8 +115,8 @@ func TestToClientEvent(t *testing.T) { // nolint: gocyclo
}
sk := ""
ce, err := ToClientEvent(ev, FormatAll, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
return queryUserIDForSender(context.Background(), roomID, senderID)
}, userID.String(), &sk)
return queryUserIDForSender(senderID)
})
if err != nil {
t.Fatalf("failed to create ClientEvent: %s", err)
}
@ -175,14 +174,9 @@ func TestToClientFormatSync(t *testing.T) {
if err != nil {
t.Fatalf("failed to create Event: %s", err)
}
userID, err := spec.NewUserID("@test:localhost", true)
if err != nil {
t.Fatalf("failed to create userID: %s", err)
}
sk := ""
ce, err := ToClientEvent(ev, FormatSync, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
return queryUserIDForSender(context.Background(), roomID, senderID)
}, userID.String(), &sk)
return queryUserIDForSender(senderID)
})
if err != nil {
t.Fatalf("failed to create ClientEvent: %s", err)
}
@ -226,8 +220,8 @@ func TestToClientEventFormatSyncFederation(t *testing.T) { // nolint: gocyclo
}
sk := ""
ce, err := ToClientEvent(ev, FormatSyncFederation, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
return queryUserIDForSender(context.Background(), roomID, senderID)
}, userID.String(), &sk)
return queryUserIDForSender(senderID)
})
if err != nil {
t.Fatalf("failed to create ClientEvent: %s", err)
}

4
syncapi/types/types.go
View file

@ -533,7 +533,7 @@ type InviteResponse struct {
}
// NewInviteResponse creates an empty response with initialised arrays.
func NewInviteResponse(ctx context.Context, rsAPI api.QuerySenderIDAPI, event *types.HeaderedEvent, userID spec.UserID, stateKey *string, eventFormat synctypes.ClientEventFormat) (*InviteResponse, error) {
func NewInviteResponse(ctx context.Context, rsAPI api.QuerySenderIDAPI, event *types.HeaderedEvent, eventFormat synctypes.ClientEventFormat) (*InviteResponse, error) {
res := InviteResponse{}
res.InviteState.Events = []json.RawMessage{}
@ -554,7 +554,7 @@ func NewInviteResponse(ctx context.Context, rsAPI api.QuerySenderIDAPI, event *t
// This is needed for clients to work out *who* sent the invite.
inviteEvent, err := synctypes.ToClientEvent(eventNoUnsigned, eventFormat, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
return rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
}, userID.String(), stateKey)
})
if err != nil {
return nil, err
}

13
syncapi/types/types_test.go
View file

@ -73,19 +73,8 @@ func TestNewInviteResponse(t *testing.T) {
t.Fatal(err)
}
sender, err := spec.NewUserID("@neilalexander:matrix.org", true)
if err != nil {
t.Fatal(err)
}
skUserID, err := spec.NewUserID("@neilalexander:dendrite.neilalexander.dev", true)
if err != nil {
t.Fatal(err)
}
skString := skUserID.String()
sk := &skString
rsAPI := FakeRoomserverAPI{}
res, err := NewInviteResponse(context.Background(), &rsAPI, &types.HeaderedEvent{PDU: ev}, *sender, sk, synctypes.FormatSync)
res, err := NewInviteResponse(context.Background(), &rsAPI, &types.HeaderedEvent{PDU: ev}, synctypes.FormatSync)
if err != nil {
t.Fatal(err)
}

49
userapi/consumers/roomserver.go
View file

@ -301,31 +301,11 @@ func (s *OutputRoomEventConsumer) processMessage(ctx context.Context, event *rst
switch {
case event.Type() == spec.MRoomMember:
sender := spec.UserID{}
validRoomID, roomErr := spec.NewRoomID(event.RoomID())
if roomErr != nil {
return roomErr
}
userID, queryErr := s.rsAPI.QueryUserIDForSender(ctx, *validRoomID, event.SenderID())
if queryErr == nil && userID != nil {
sender = *userID
}
sk := event.StateKey()
if sk != nil && *sk != "" {
skUserID, queryErr := s.rsAPI.QueryUserIDForSender(ctx, *validRoomID, spec.SenderID(*sk))
if queryErr == nil && skUserID != nil {
skString := skUserID.String()
sk = &skString
} else {
return fmt.Errorf("queryUserIDForSender: userID unknown for %s", *sk)
}
}
cevent, err := synctypes.ToClientEvent(event, synctypes.FormatAll, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
cevent, clientEvErr := synctypes.ToClientEvent(event, synctypes.FormatAll, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
return s.rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
}, sender.String(), sk)
if err != nil {
return err
})
if clientEvErr != nil {
return clientEvErr
}
var member *localMembership
member, err = newLocalMembership(cevent)
@ -547,28 +527,9 @@ func (s *OutputRoomEventConsumer) notifyLocal(ctx context.Context, event *rstype
if err != nil {
return fmt.Errorf("s.localPushDevices: %w", err)
}
sender := spec.UserID{}
validRoomID, err := spec.NewRoomID(event.RoomID())
if err != nil {
return err
}
userID, err := s.rsAPI.QueryUserIDForSender(ctx, *validRoomID, event.SenderID())
if err == nil && userID != nil {
sender = *userID
}
sk := event.StateKey()
if sk != nil && *sk != "" {
skUserID, queryErr := s.rsAPI.QueryUserIDForSender(ctx, *validRoomID, spec.SenderID(*event.StateKey()))
if queryErr == nil && skUserID != nil {
skString := skUserID.String()
sk = &skString
}
}
clientEvent, err := synctypes.ToClientEvent(event, synctypes.FormatSync, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
return s.rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
}, sender.String(), sk)
})
if err != nil {
return err
}

10
userapi/util/notify_test.go
View file

@ -23,7 +23,7 @@ import (
userUtil "github.com/matrix-org/dendrite/userapi/util"
)
func queryUserIDForSender(ctx context.Context, roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
func queryUserIDForSender(senderID spec.SenderID) (*spec.UserID, error) {
if senderID == "" {
return nil, nil
}
@ -108,14 +108,12 @@ func TestNotifyUserCountsAsync(t *testing.T) {
}
// Insert a dummy event
sender, err := spec.NewUserID(alice.ID, true)
ev, err := synctypes.ToClientEvent(dummyEvent, synctypes.FormatAll, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
return queryUserIDForSender(senderID)
})
if err != nil {
t.Error(err)
}
sk := ""
ev, err := synctypes.ToClientEvent(dummyEvent, synctypes.FormatAll, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
return queryUserIDForSender(context.Background(), roomID, senderID)
}, sender.String(), &sk)
if err := db.InsertNotification(ctx, aliceLocalpart, serverName, dummyEvent.EventID(), 0, nil, &api.Notification{
Event: *ev,
}); err != nil {