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

Change actions

Browse source
This commit is contained in:
Abhishek Kumar 2020-01-22 22:58:37 +05:30
parent bd2ec72250
commit 87e727f817
1 changed files with 41 additions and 168 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

209
roomserver/canonical_alias/canonical_alias.go
View file

@ -60,13 +60,13 @@ type RoomserverCanonicalAliasAPI struct {
// SetRoomCanonicalAlias implements alias.RoomserverCanonicalAliasAPI // SetRoomCanonicalAlias implements alias.RoomserverCanonicalAliasAPI
func (r *RoomserverCanonicalAliasAPI) SetRoomAlias( func (r *RoomserverCanonicalAliasAPI) SetRoomAlias(
ctx context.Context, ctx context.Context,
request *roomserverAPI.SetRoomAliasRequest, request *roomserverAPI.SetRoomCanonicalAliasRequest,
response *roomserverAPI.SetRoomAliasResponse, response *roomserverAPI.SetRoomCanonicalAliasResponse,
) error { ) error {
// SPEC: Room with `m.room.canonical_alias` with empty alias field should be // SPEC: Room with `m.room.canonical_alias` with empty alias field should be
// treated same as room without a canonical alias. // treated same as room without a canonical alias.
if request.CanonicalAlias == "" { if request.CanonicalAlias == "" {
return r.RemoveCanonicalAlias(ctx, request, response) return r.db.RemoveCanonicalAlias(ctx, request.RoomID)
} }
roomID, err := r.DB.GetRoomIDForAlias(ctx, request.CanonicalAlias) roomID, err := r.DB.GetRoomIDForAlias(ctx, request.CanonicalAlias)
@ -98,18 +98,19 @@ func (r *RoomserverCanonicalAliasAPI) SetRoomAlias(
return nil return nil
} }
// GetRoomIDForAlias implements alias.RoomserverCanonicalAliasAPI // GetRoomIDForCanonicalAlias implements alias.RoomserverCanonicalAliasAPI
func (r *RoomserverCanonicalAliasAPI) GetRoomIDForAlias( func (r *RoomserverCanonicalAliasAPI) GetRoomIDForCanonicalAlias(
ctx context.Context, ctx context.Context,
request *roomserverAPI.GetRoomIDForAliasRequest, request *roomserverAPI.GetRoomIDForCanonicalAliasRequest,
response *roomserverAPI.GetRoomIDForAliasResponse, response *roomserverAPI.GetRoomIDForCanonicalAliasResponse,
) error { ) error {
// Look up the room ID in the database // Look up the room ID in the database
roomID, err := r.DB.GetRoomIDForAlias(ctx, request.Alias) roomID, err := r.DB.GetRoomIDForCanonicalAlias(ctx, request.Alias)
if err != nil { if err != nil {
return err return err
} }
// RFC: Should we search in application service for canonical aliases?`
if roomID == "" { if roomID == "" {
// No room found locally, try our application services by making a call to // No room found locally, try our application services by making a call to
// the appservice component // the appservice component
@ -131,30 +132,30 @@ func (r *RoomserverCanonicalAliasAPI) GetRoomIDForAlias(
return nil return nil
} }
// GetAliasesForRoomID implements alias.RoomserverCanonicalAliasAPI // GetCanonicalAliasForRoomID implements alias.RoomserverCanonicalAliasAPI
func (r *RoomserverCanonicalAliasAPI) GetAliasesForRoomID( func (r *RoomserverCanonicalAliasAPI) GetCanonicalAliasForRoomID(
ctx context.Context, ctx context.Context,
request *roomserverAPI.GetAliasesForRoomIDRequest, request *roomserverAPI.GetCanonicalAliasForRoomIDRequest,
response *roomserverAPI.GetAliasesForRoomIDResponse, response *roomserverAPI.GetCanonicalAliasForRoomIDResponse,
) error { ) error {
// Look up the aliases in the database for the given RoomID // Look up the canonical alias in the database for the given RoomID
aliases, err := r.DB.GetAliasesForRoomID(ctx, request.RoomID) canonicalAlias, err := r.DB.GetCanonicalAliasForRoomID(ctx, request.RoomID)
if err != nil { if err != nil {
return err return err
} }
response.Aliases = aliases response.CanonicalAlias = canonicalAlias
return nil return nil
} }
// GetCreatorIDForAlias implements alias.RoomserverCanonicalAliasAPI // GetCreatorIDForCanonicalAlias implements alias.RoomserverCanonicalAliasAPI
func (r *RoomserverCanonicalAliasAPI) GetCreatorIDForAlias( func (r *RoomserverCanonicalAliasAPI) GetCreatorIDForCanonicalAlias(
ctx context.Context, ctx context.Context,
request *roomserverAPI.GetCreatorIDForAliasRequest, request *roomserverAPI.GetCreatorIDForCanonicalAliasRequest,
response *roomserverAPI.GetCreatorIDForAliasResponse, response *roomserverAPI.GetCreatorIDForCanonicalAliasResponse,
) error { ) error {
// Look up the aliases in the database for the given RoomID // Look up the aliases in the database for the given RoomID
creatorID, err := r.DB.GetCreatorIDForAlias(ctx, request.Alias) creatorID, err := r.DB.GetCreatorIDForCanonicalAlias(ctx, request.CanonicalAlias)
if err != nil { if err != nil {
return err return err
} }
@ -163,187 +164,59 @@ func (r *RoomserverCanonicalAliasAPI) GetCreatorIDForAlias(
return nil return nil
} }
// RemoveRoomAlias implements alias.RoomserverCanonicalAliasAPI
func (r *RoomserverCanonicalAliasAPI) RemoveRoomAlias(
ctx context.Context,
request *roomserverAPI.RemoveRoomAliasRequest,
response *roomserverAPI.RemoveRoomAliasResponse,
) error {
// Look up the room ID in the database
roomID, err := r.DB.GetRoomIDForAlias(ctx, request.Alias)
if err != nil {
return err
}
// Remove the dalias from the database
if err := r.DB.RemoveRoomAlias(ctx, request.Alias); err != nil {
return err
}
// Send an updated m.room.aliases event
// At this point we've already committed the alias to the database so we
// shouldn't cancel this request.
// TODO: Ensure that we send unsent events when if server restarts.
return r.sendUpdatedAliasesEvent(context.TODO(), request.UserID, roomID)
}
type roomAliasesContent struct {
Aliases []string `json:"aliases"`
}
// Build the updated m.room.aliases event to send to the room after addition or
// removal of an alias
func (r *RoomserverCanonicalAliasAPI) sendUpdatedAliasesEvent(
ctx context.Context, userID string, roomID string,
) error {
serverName := string(r.Cfg.Matrix.ServerName)
builder := gomatrixserverlib.EventBuilder{
Sender: userID,
RoomID: roomID,
Type: "m.room.aliases",
StateKey: &serverName,
}
// Retrieve the updated list of aliases, marhal it and set it as the
// event's content
aliases, err := r.DB.GetAliasesForRoomID(ctx, roomID)
if err != nil {
return err
}
content := roomAliasesContent{Aliases: aliases}
rawContent, err := json.Marshal(content)
if err != nil {
return err
}
err = builder.SetContent(json.RawMessage(rawContent))
if err != nil {
return err
}
// Get needed state events and depth
eventsNeeded, err := gomatrixserverlib.StateNeededForEventBuilder(&builder)
if err != nil {
return err
}
req := roomserverAPI.QueryLatestEventsAndStateRequest{
RoomID: roomID,
StateToFetch: eventsNeeded.Tuples(),
}
var res roomserverAPI.QueryLatestEventsAndStateResponse
if err = r.QueryAPI.QueryLatestEventsAndState(ctx, &req, &res); err != nil {
return err
}
builder.Depth = res.Depth
builder.PrevEvents = res.LatestEvents
// Add auth events
authEvents := gomatrixserverlib.NewAuthEvents(nil)
for i := range res.StateEvents {
err = authEvents.AddEvent(&res.StateEvents[i])
if err != nil {
return err
}
}
refs, err := eventsNeeded.AuthEventReferences(&authEvents)
if err != nil {
return err
}
builder.AuthEvents = refs
// Build the event
eventID := fmt.Sprintf("$%s:%s", util.RandomString(16), r.Cfg.Matrix.ServerName)
now := time.Now()
event, err := builder.Build(
eventID, now, r.Cfg.Matrix.ServerName, r.Cfg.Matrix.KeyID, r.Cfg.Matrix.PrivateKey,
)
if err != nil {
return err
}
// Create the request
ire := roomserverAPI.InputRoomEvent{
Kind: roomserverAPI.KindNew,
Event: event,
AuthEventIDs: event.AuthEventIDs(),
SendAsServer: serverName,
}
inputReq := roomserverAPI.InputRoomEventsRequest{
InputRoomEvents: []roomserverAPI.InputRoomEvent{ire},
}
var inputRes roomserverAPI.InputRoomEventsResponse
// Send the request
return r.InputAPI.InputRoomEvents(ctx, &inputReq, &inputRes)
}
// SetupHTTP adds the RoomserverCanonicalAliasAPI handlers to the http.ServeMux. // SetupHTTP adds the RoomserverCanonicalAliasAPI handlers to the http.ServeMux.
func (r *RoomserverCanonicalAliasAPI) SetupHTTP(servMux *http.ServeMux) { func (r *RoomserverCanonicalAliasAPI) SetupHTTP(servMux *http.ServeMux) {
servMux.Handle( servMux.Handle(
roomserverAPI.RoomserverSetRoomAliasPath, roomserverAPI.RoomserverSetRoomCanonicalAliasPath,
common.MakeInternalAPI("setRoomAlias", func(req *http.Request) util.JSONResponse { common.MakeInternalAPI("setRoomCanonicalAlias", func(req *http.Request) util.JSONResponse {
var request roomserverAPI.SetRoomAliasRequest var request roomserverAPI.SetRoomCanonicalAliasRequest
var response roomserverAPI.SetRoomAliasResponse var response roomserverAPI.SetRoomCanonicalAliasResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := r.SetRoomAlias(req.Context(), &request, &response); err != nil { if err := r.SetRoomCanonicalAlias(req.Context(), &request, &response); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
return util.JSONResponse{Code: http.StatusOK, JSON: &response} return util.JSONResponse{Code: http.StatusOK, JSON: &response}
}), }),
) )
servMux.Handle( servMux.Handle(
roomserverAPI.RoomserverGetRoomIDForAliasPath, roomserverAPI.RoomserverGetRoomIDForCanonicalAliasPath,
common.MakeInternalAPI("GetRoomIDForAlias", func(req *http.Request) util.JSONResponse { common.MakeInternalAPI("GetRoomIDForCanonicalAlias", func(req *http.Request) util.JSONResponse {
var request roomserverAPI.GetRoomIDForAliasRequest var request roomserverAPI.GetRoomIDForCanonicalAliasRequest
var response roomserverAPI.GetRoomIDForAliasResponse var response roomserverAPI.GetRoomIDForCanonicalAliasResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := r.GetRoomIDForAlias(req.Context(), &request, &response); err != nil { if err := r.GetRoomIDForCanonicalAlias(req.Context(), &request, &response); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
return util.JSONResponse{Code: http.StatusOK, JSON: &response} return util.JSONResponse{Code: http.StatusOK, JSON: &response}
}), }),
) )
servMux.Handle( servMux.Handle(
roomserverAPI.RoomserverGetCreatorIDForAliasPath, roomserverAPI.RoomserverGetCreatorIDForCanonicalAliasPath,
common.MakeInternalAPI("GetCreatorIDForAlias", func(req *http.Request) util.JSONResponse { common.MakeInternalAPI("GetCreatorIDForCanonicalAlias", func(req *http.Request) util.JSONResponse {
var request roomserverAPI.GetCreatorIDForAliasRequest var request roomserverAPI.GetCreatorIDForCanonicalAliasRequest
var response roomserverAPI.GetCreatorIDForAliasResponse var response roomserverAPI.GetCreatorIDForCanonicalAliasResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := r.GetCreatorIDForAlias(req.Context(), &request, &response); err != nil { if err := r.GetCreatorIDForCanonicalAlias(req.Context(), &request, &response); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
return util.JSONResponse{Code: http.StatusOK, JSON: &response} return util.JSONResponse{Code: http.StatusOK, JSON: &response}
}), }),
) )
servMux.Handle( servMux.Handle(
roomserverAPI.RoomserverGetAliasesForRoomIDPath, roomserverAPI.RoomserverGetCanonicalAliasForRoomIDPath,
common.MakeInternalAPI("getAliasesForRoomID", func(req *http.Request) util.JSONResponse { common.MakeInternalAPI("getCanonicalAliasForRoomID", func(req *http.Request) util.JSONResponse {
var request roomserverAPI.GetAliasesForRoomIDRequest var request roomserverAPI.GetCanonicalAliasForRoomIDRequest
var response roomserverAPI.GetAliasesForRoomIDResponse var response roomserverAPI.GetCanonicalAliasForRoomIDResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := r.GetAliasesForRoomID(req.Context(), &request, &response); err != nil { if err := r.GetCanonicalAliasForRoomID(req.Context(), &request, &response); err != nil {
return util.ErrorResponse(err)
}
return util.JSONResponse{Code: http.StatusOK, JSON: &response}
}),
)
servMux.Handle(
roomserverAPI.RoomserverRemoveRoomAliasPath,
common.MakeInternalAPI("removeRoomAlias", func(req *http.Request) util.JSONResponse {
var request roomserverAPI.RemoveRoomAliasRequest
var response roomserverAPI.RemoveRoomAliasResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err)
}
if err := r.RemoveRoomAlias(req.Context(), &request, &response); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
return util.JSONResponse{Code: http.StatusOK, JSON: &response} return util.JSONResponse{Code: http.StatusOK, JSON: &response}