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

Merge branch 'master' into babolivier/view-memberships-after-leave

Browse source
This commit is contained in:
Brendan Abolivier 2017-08-23 15:41:45 +01:00 committed by GitHub
parent 8f452631b3 9c954501a2
commit 66498eec73
12 changed files with 250 additions and 31 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/github.com/matrix-org/dendrite/clientapi/auth/auth.go
View file

@ -41,7 +41,7 @@ var tokenByteLength = 32
// DeviceDatabase represents a device database.
type DeviceDatabase interface {
// Lookup the device matching the given access token.
// Look up the device matching the given access token.
GetDeviceByAccessToken(token string) (*authtypes.Device, error)
}

12
src/github.com/matrix-org/dendrite/clientapi/producers/roomserver.go
View file

@ -78,10 +78,18 @@ func (c *RoomserverProducer) SendEventWithState(state gomatrixserverlib.RespStat
return c.SendInputRoomEvents(ires)
}
// SendInputRoomEvents writes the given input room events to the roomserver input log. The length of both
// arrays must match, and each element must correspond to the same event.
// SendInputRoomEvents writes the given input room events to the roomserver input API.
func (c *RoomserverProducer) SendInputRoomEvents(ires []api.InputRoomEvent) error {
request := api.InputRoomEventsRequest{InputRoomEvents: ires}
var response api.InputRoomEventsResponse
return c.InputAPI.InputRoomEvents(&request, &response)
}
// SendInvite writes the invite event to the roomserver input API.
func (c *RoomserverProducer) SendInvite(inviteEvent gomatrixserverlib.Event) error {
request := api.InputRoomEventsRequest{
InputInviteEvents: []api.InputInviteEvent{{Event: inviteEvent}},
}
var response api.InputRoomEventsResponse
return c.InputAPI.InputRoomEvents(&request, &response)
}

13
src/github.com/matrix-org/dendrite/federationapi/routing/routing.go
View file

@ -57,7 +57,7 @@ func Setup(
v2keysmux.Handle("/server/{keyID}", localKeys)
v2keysmux.Handle("/server/", localKeys)
v1fedmux.Handle("/send/{txnID}/", makeAPI("send",
v1fedmux.Handle("/send/{txnID}/", makeAPI("federation_send",
func(req *http.Request) util.JSONResponse {
vars := mux.Vars(req)
return writers.Send(
@ -67,6 +67,17 @@ func Setup(
)
},
))
v1fedmux.Handle("/invite/{roomID}/{eventID}", makeAPI("federation_invite",
func(req *http.Request) util.JSONResponse {
vars := mux.Vars(req)
return writers.Invite(
req, vars["roomID"], vars["eventID"],
time.Now(),
cfg, producer, keys,
)
},
))
}
func makeAPI(metricsName string, f func(*http.Request) util.JSONResponse) http.Handler {

98
src/github.com/matrix-org/dendrite/federationapi/writers/invite.go Normal file
View file

@ -0,0 +1,98 @@
package writers
import (
"encoding/json"
"net/http"
"time"
"github.com/matrix-org/util"
"github.com/matrix-org/dendrite/clientapi/httputil"
"github.com/matrix-org/dendrite/clientapi/jsonerror"
"github.com/matrix-org/dendrite/clientapi/producers"
"github.com/matrix-org/dendrite/common/config"
"github.com/matrix-org/gomatrixserverlib"
)
// Invite implements /_matrix/federation/v1/invite/{roomID}/{eventID}
func Invite(
req *http.Request,
roomID string,
eventID string,
now time.Time,
cfg config.Dendrite,
producer *producers.RoomserverProducer,
keys gomatrixserverlib.KeyRing,
) util.JSONResponse {
request, errResp := gomatrixserverlib.VerifyHTTPRequest(req, now, cfg.Matrix.ServerName, keys)
if request == nil {
return errResp
}
// Decode the event JSON from the request.
var event gomatrixserverlib.Event
if err := json.Unmarshal(request.Content(), &event); err != nil {
return util.JSONResponse{
Code: 400,
JSON: jsonerror.NotJSON("The request body could not be decoded into valid JSON. " + err.Error()),
}
}
// Check that the room ID is correct.
if event.RoomID() != roomID {
return util.JSONResponse{
Code: 400,
JSON: jsonerror.BadJSON("The room ID in the request path must match the room ID in the invite event JSON"),
}
}
// Check that the event ID is correct.
if event.EventID() != eventID {
return util.JSONResponse{
Code: 400,
JSON: jsonerror.BadJSON("The event ID in the request path must match the event ID in the invite event JSON"),
}
}
// Check that the event is from the server sending the request.
if event.Origin() != request.Origin() {
return util.JSONResponse{
Code: 403,
JSON: jsonerror.Forbidden("The invite must be sent by the server it originated on"),
}
}
// Check that the event is signed by the server sending the request.
verifyRequests := []gomatrixserverlib.VerifyJSONRequest{{
ServerName: event.Origin(),
Message: event.JSON(),
AtTS: event.OriginServerTS(),
}}
verifyResults, err := keys.VerifyJSONs(verifyRequests)
if err != nil {
return httputil.LogThenError(req, err)
}
if verifyResults[0].Error != nil {
return util.JSONResponse{
Code: 403,
JSON: jsonerror.Forbidden("The invite must be signed by the server it originated on"),
}
}
// Sign the event so that other servers will know that we have received the invite.
signedEvent := event.Sign(
string(cfg.Matrix.ServerName), cfg.Matrix.KeyID, cfg.Matrix.PrivateKey,
)
// Add the invite event to the roomserver.
if err = producer.SendInvite(signedEvent); err != nil {
return httputil.LogThenError(req, err)
}
// Return the signed event to the originating server, it should then tell
// the other servers in the room that we have been invited.
return util.JSONResponse{
Code: 200,
JSON: &signedEvent,
}
}

7
src/github.com/matrix-org/dendrite/federationapi/writers/send.go
View file

@ -3,6 +3,9 @@ package writers
import (
"encoding/json"
"fmt"
"net/http"
"time"
"github.com/matrix-org/dendrite/clientapi/httputil"
"github.com/matrix-org/dendrite/clientapi/jsonerror"
"github.com/matrix-org/dendrite/clientapi/producers"
@ -10,8 +13,6 @@ import (
"github.com/matrix-org/dendrite/roomserver/api"
"github.com/matrix-org/gomatrixserverlib"
"github.com/matrix-org/util"
"net/http"
"time"
)
// Send implements /_matrix/federation/v1/send/{txnID}
@ -39,7 +40,7 @@ func Send(
if err := json.Unmarshal(request.Content(), &t); err != nil {
return util.JSONResponse{
Code: 400,
JSON: jsonerror.BadJSON("The request body could not be decoded into valid JSON. " + err.Error()),
JSON: jsonerror.NotJSON("The request body could not be decoded into valid JSON. " + err.Error()),
}
}

8
src/github.com/matrix-org/dendrite/roomserver/alias/alias.go
View file

@ -32,10 +32,10 @@ type RoomserverAliasAPIDatabase interface {
// Save a given room alias with the room ID it refers to.
// Returns an error if there was a problem talking to the database.
SetRoomAlias(alias string, roomID string) error
// Lookup the room ID a given alias refers to.
// Look up the room ID a given alias refers to.
// Returns an error if there was a problem talking to the database.
GetRoomIDFromAlias(alias string) (string, error)
// Lookup all aliases referring to a given room ID.
// Look up all aliases referring to a given room ID.
// Returns an error if there was a problem talking to the database.
GetAliasesFromRoomID(roomID string) ([]string, error)
// Remove a given room alias.
@ -86,7 +86,7 @@ func (r *RoomserverAliasAPI) GetAliasRoomID(
request *api.GetAliasRoomIDRequest,
response *api.GetAliasRoomIDResponse,
) error {
// Lookup the room ID in the database
// Look up the room ID in the database
roomID, err := r.DB.GetRoomIDFromAlias(request.Alias)
if err != nil {
return err
@ -101,7 +101,7 @@ func (r *RoomserverAliasAPI) RemoveRoomAlias(
request *api.RemoveRoomAliasRequest,
response *api.RemoveRoomAliasResponse,
) error {
// Lookup the room ID in the database
// Look up the room ID in the database
roomID, err := r.DB.GetRoomIDFromAlias(request.Alias)
if err != nil {
return err

35
src/github.com/matrix-org/dendrite/roomserver/api/query.go
View file

@ -117,6 +117,23 @@ type QueryMembershipsForRoomResponse struct {
HasBeenInRoom bool `json:"has_been_in_room"`
}
// QueryInvitesForUserRequest is a request to QueryInvitesForUser
type QueryInvitesForUserRequest struct {
// The room ID to look up invites in.
RoomID string `json:"room_id"`
// The User ID to look up invites for.
TargetUserID string `json:"target_user_id"`
}
// QueryInvitesForUserResponse is a response to QueryInvitesForUser
// This is used when accepting an invite or rejecting a invite to tell which
// remote matrix servers to contact.
type QueryInvitesForUserResponse struct {
// A list of matrix user IDs for each sender of an active invite targeting
// the requested user ID.
InviteSenderUserIDs []string `json:"invite_sender_user_ids"`
}
// RoomserverQueryAPI is used to query information from the room server.
type RoomserverQueryAPI interface {
// Query the latest events and state for a room from the room server.
@ -142,6 +159,12 @@ type RoomserverQueryAPI interface {
request *QueryMembershipsForRoomRequest,
response *QueryMembershipsForRoomResponse,
) error
// Query a list of invite event senders for a user in a room.
QueryInvitesForUser(
request *QueryInvitesForUserRequest,
response *QueryInvitesForUserResponse,
) error
}
// RoomserverQueryLatestEventsAndStatePath is the HTTP path for the QueryLatestEventsAndState API.
@ -156,6 +179,9 @@ const RoomserverQueryEventsByIDPath = "/api/roomserver/queryEventsByID"
// RoomserverQueryMembershipsForRoomPath is the HTTP path for the QueryMembershipsForRoom API
const RoomserverQueryMembershipsForRoomPath = "/api/roomserver/queryMembershipsForRoom"
// RoomserverQueryInvitesForUserPath is the HTTP path for the QueryInvitesForUser API
const RoomserverQueryInvitesForUserPath = "/api/roomserver/queryInvitesForUser"
// NewRoomserverQueryAPIHTTP creates a RoomserverQueryAPI implemented by talking to a HTTP POST API.
// If httpClient is nil then it uses the http.DefaultClient
func NewRoomserverQueryAPIHTTP(roomserverURL string, httpClient *http.Client) RoomserverQueryAPI {
@ -206,6 +232,15 @@ func (h *httpRoomserverQueryAPI) QueryMembershipsForRoom(
return postJSON(h.httpClient, apiURL, request, response)
}
// QueryInvitesForUser implements RoomserverQueryAPI
func (h *httpRoomserverQueryAPI) QueryInvitesForUser(
request *QueryInvitesForUserRequest,
response *QueryInvitesForUserResponse,
) error {
apiURL := h.roomserverURL + RoomserverQueryInvitesForUserPath
return postJSON(h.httpClient, apiURL, request, response)
}
func postJSON(httpClient *http.Client, apiURL string, request, response interface{}) error {
jsonBytes, err := json.Marshal(request)
if err != nil {

2
src/github.com/matrix-org/dendrite/roomserver/input/authevents.go
View file

@ -117,7 +117,7 @@ func loadAuthEvents(
needed gomatrixserverlib.StateNeeded,
state []types.StateEntry,
) (result authEvents, err error) {
// Lookup the numeric IDs for the state keys needed for auth.
// Look up the numeric IDs for the state keys needed for auth.
var neededStateKeys []string
neededStateKeys = append(neededStateKeys, needed.Member...)
neededStateKeys = append(neededStateKeys, needed.ThirdPartyInvite...)

6
src/github.com/matrix-org/dendrite/roomserver/input/events.go
View file

@ -29,18 +29,18 @@ type RoomEventDatabase interface {
state.RoomStateDatabase
// Stores a matrix room event in the database
StoreEvent(event gomatrixserverlib.Event, authEventNIDs []types.EventNID) (types.RoomNID, types.StateAtEvent, error)
// Lookup the state entries for a list of string event IDs
// Look up the state entries for a list of string event IDs
// Returns an error if the there is an error talking to the database
// Returns a types.MissingEventError if the event IDs aren't in the database.
StateEntriesForEventIDs(eventIDs []string) ([]types.StateEntry, error)
// Set the state at an event.
SetState(eventNID types.EventNID, stateNID types.StateSnapshotNID) error
// Lookup the latest events in a room in preparation for an update.
// Look up the latest events in a room in preparation for an update.
// The RoomRecentEventsUpdater must have Commit or Rollback called on it if this doesn't return an error.
// Returns the latest events in the room and the last eventID sent to the log along with an updater.
// If this returns an error then no further action is required.
GetLatestEventsForUpdate(roomNID types.RoomNID) (updater types.RoomRecentEventsUpdater, err error)
// Lookup the string event IDs for a list of numeric event IDs
// Look up the string event IDs for a list of numeric event IDs
EventIDs(eventNIDs []types.EventNID) (map[types.EventNID]string, error)
// Build a membership updater for the target user in a room.
MembershipUpdater(roomID, targerUserID string) (types.MembershipUpdater, error)

64
src/github.com/matrix-org/dendrite/roomserver/query/query.go
View file

@ -29,15 +29,15 @@ import (
// RoomserverQueryAPIDatabase has the storage APIs needed to implement the query API.
type RoomserverQueryAPIDatabase interface {
state.RoomStateDatabase
// Lookup the numeric ID for the room.
// Look up the numeric ID for the room.
// Returns 0 if the room doesn't exists.
// Returns an error if there was a problem talking to the database.
RoomNID(roomID string) (types.RoomNID, error)
// Lookup event references for the latest events in the room and the current state snapshot.
// Look up event references for the latest events in the room and the current state snapshot.
// Returns the latest events, the current state and the maximum depth of the latest events plus 1.
// Returns an error if there was a problem talking to the database.
LatestEventIDs(roomNID types.RoomNID) ([]gomatrixserverlib.EventReference, types.StateSnapshotNID, int64, error)
// Lookup the numeric IDs for a list of events.
// Look up the numeric IDs for a list of events.
// Returns an error if there was a problem talking to the database.
EventNIDs(eventIDs []string) (map[string]types.EventNID, error)
// Lookup the event IDs for a batch of event numeric IDs.
@ -65,6 +65,13 @@ type RoomserverQueryAPIDatabase interface {
// currently members of a given room.
// Returns an error if there was a problem talking to the database.
GetJoinMembershipEventNIDsForRoom(roomNID types.RoomNID) ([]types.EventNID, error)
// Look up the active invites targeting a user in a room and return the
// numeric state key IDs for the user IDs who sent them.
// Returns an error if there was a problem talking to the database.
GetInvitesForUser(roomNID types.RoomNID, targetUserNID types.EventStateKeyNID) (senderUserNIDs []types.EventStateKeyNID, err error)
// Look up the string event state keys for a list of numeric event state keys
// Returns an error if there was a problem talking to the database.
EventStateKeys([]types.EventStateKeyNID) (map[types.EventStateKeyNID]string, error)
}
// RoomserverQueryAPI is an implementation of api.RoomserverQueryAPI
@ -92,7 +99,7 @@ func (r *RoomserverQueryAPI) QueryLatestEventsAndState(
return err
}
// Lookup the currrent state for the requested tuples.
// Look up the currrent state for the requested tuples.
stateEntries, err := state.LoadStateAtSnapshotForStringTuples(r.DB, currentStateSnapshotNID, request.StateToFetch)
if err != nil {
return err
@ -133,7 +140,7 @@ func (r *RoomserverQueryAPI) QueryStateAfterEvents(
}
response.PrevEventsExist = true
// Lookup the currrent state for the requested tuples.
// Look up the currrent state for the requested tuples.
stateEntries, err := state.LoadStateAfterEventsForStringTuples(r.DB, prevStates, request.StateToFetch)
if err != nil {
return err
@ -297,6 +304,39 @@ func (r *RoomserverQueryAPI) getMembershipsBeforeEventNID(eventNID types.EventNI
return events, nil
}
// QueryInvitesForUser implements api.RoomserverQueryAPI
func (r *RoomserverQueryAPI) QueryInvitesForUser(
request *api.QueryInvitesForUserRequest,
response *api.QueryInvitesForUserResponse,
) error {
roomNID, err := r.DB.RoomNID(request.RoomID)
if err != nil {
return err
}
targetUserNIDs, err := r.DB.EventStateKeyNIDs([]string{request.TargetUserID})
if err != nil {
return err
}
targetUserNID := targetUserNIDs[request.TargetUserID]
senderUserNIDs, err := r.DB.GetInvitesForUser(roomNID, targetUserNID)
if err != nil {
return err
}
senderUserIDs, err := r.DB.EventStateKeys(senderUserNIDs)
if err != nil {
return err
}
for _, senderUserID := range senderUserIDs {
response.InviteSenderUserIDs = append(response.InviteSenderUserIDs, senderUserID)
}
return nil
}
// SetupHTTP adds the RoomserverQueryAPI handlers to the http.ServeMux.
func (r *RoomserverQueryAPI) SetupHTTP(servMux *http.ServeMux) {
servMux.Handle(
@ -355,4 +395,18 @@ func (r *RoomserverQueryAPI) SetupHTTP(servMux *http.ServeMux) {
return util.JSONResponse{Code: 200, JSON: &response}
}),
)
servMux.Handle(
api.RoomserverQueryInvitesForUserPath,
common.MakeAPI("queryInvitesForUser", func(req *http.Request) util.JSONResponse {
var request api.QueryInvitesForUserRequest
var response api.QueryInvitesForUserResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err)
}
if err := r.QueryInvitesForUser(&request, &response); err != nil {
return util.ErrorResponse(err)
}
return util.JSONResponse{Code: 200, JSON: &response}
}),
)
}

14
src/github.com/matrix-org/dendrite/roomserver/state/state.go
View file

@ -30,30 +30,30 @@ import (
type RoomStateDatabase interface {
// Store the room state at an event in the database
AddState(roomNID types.RoomNID, stateBlockNIDs []types.StateBlockNID, state []types.StateEntry) (types.StateSnapshotNID, error)
// Lookup the state of a room at each event for a list of string event IDs.
// Look up the state of a room at each event for a list of string event IDs.
// Returns an error if there is an error talking to the database
// Returns a types.MissingEventError if the room state for the event IDs aren't in the database
StateAtEventIDs(eventIDs []string) ([]types.StateAtEvent, error)
// Lookup the numeric IDs for a list of string event types.
// Look up the numeric IDs for a list of string event types.
// Returns a map from string event type to numeric ID for the event type.
EventTypeNIDs(eventTypes []string) (map[string]types.EventTypeNID, error)
// Lookup the numeric IDs for a list of string event state keys.
// Look up the numeric IDs for a list of string event state keys.
// Returns a map from string state key to numeric ID for the state key.
EventStateKeyNIDs(eventStateKeys []string) (map[string]types.EventStateKeyNID, error)
// Lookup the numeric state data IDs for each numeric state snapshot ID
// Look up the numeric state data IDs for each numeric state snapshot ID
// The returned slice is sorted by numeric state snapshot ID.
StateBlockNIDs(stateNIDs []types.StateSnapshotNID) ([]types.StateBlockNIDList, error)
// Lookup the state data for each numeric state data ID
// Look up the state data for each numeric state data ID
// The returned slice is sorted by numeric state data ID.
StateEntries(stateBlockNIDs []types.StateBlockNID) ([]types.StateEntryList, error)
// Lookup the state data for the state key tuples for each numeric state block ID
// Look up the state data for the state key tuples for each numeric state block ID
// This is used to fetch a subset of the room state at a snapshot.
// If a block doesn't contain any of the requested tuples then it can be discarded from the result.
// The returned slice is sorted by numeric state block ID.
StateEntriesForTuples(stateBlockNIDs []types.StateBlockNID, stateKeyTuples []types.StateKeyTuple) (
[]types.StateEntryList, error,
)
// Lookup the Events for a list of numeric event IDs.
// Look up the Events for a list of numeric event IDs.
// Returns a sorted list of events.
Events(eventNIDs []types.EventNID) ([]types.Event, error)
}

20
src/github.com/matrix-org/dendrite/roomserver/storage/storage.go
View file

@ -161,7 +161,12 @@ func (d *Database) EventStateKeyNIDs(eventStateKeys []string) (map[string]types.
return d.statements.bulkSelectEventStateKeyNID(eventStateKeys)
}
// EventNIDs implements query.RoomQueryDatabase
// EventStateKeys implements query.RoomserverQueryAPIDatabase
func (d *Database) EventStateKeys(eventStateKeyNIDs []types.EventStateKeyNID) (map[types.EventStateKeyNID]string, error) {
return d.statements.bulkSelectEventStateKey(eventStateKeyNIDs)
}
// EventNIDs implements query.RoomserverQueryAPIDatabase
func (d *Database) EventNIDs(eventIDs []string) (map[string]types.EventNID, error) {
return d.statements.bulkSelectEventNID(eventIDs)
}
@ -336,7 +341,7 @@ func (d *Database) RoomNID(roomID string) (types.RoomNID, error) {
return roomNID, err
}
// LatestEventIDs implements query.RoomserverQueryAPIDB
// LatestEventIDs implements query.RoomserverQueryAPIDatabase
func (d *Database) LatestEventIDs(roomNID types.RoomNID) ([]gomatrixserverlib.EventReference, types.StateSnapshotNID, int64, error) {
eventNIDs, currentStateSnapshotNID, err := d.statements.selectLatestEventNIDs(roomNID)
if err != nil {
@ -353,6 +358,13 @@ func (d *Database) LatestEventIDs(roomNID types.RoomNID) ([]gomatrixserverlib.Ev
return references, currentStateSnapshotNID, depth, nil
}
// GetInvitesForUser implements query.RoomserverQueryAPIDatabase
func (d *Database) GetInvitesForUser(
roomNID types.RoomNID, targetUserNID types.EventStateKeyNID,
) (senderUserIDs []types.EventStateKeyNID, err error) {
return d.statements.selectInviteActiveForUserInRoom(targetUserNID, roomNID)
}
// SetRoomAlias implements alias.RoomserverAliasAPIDB
func (d *Database) SetRoomAlias(alias string, roomID string) error {
return d.statements.insertRoomAlias(alias, roomID)
@ -494,7 +506,7 @@ func (u *membershipUpdater) SetToJoin(senderUserID string, eventID string, isUpd
}
}
// Lookup the NID of the new join event
// Look up the NID of the new join event
nIDs, err := u.d.EventNIDs([]string{eventID})
if err != nil {
return nil, err
@ -524,7 +536,7 @@ func (u *membershipUpdater) SetToLeave(senderUserID string, eventID string) ([]s
return nil, err
}
// Lookup the NID of the new leave event
// Look up the NID of the new leave event
nIDs, err := u.d.EventNIDs([]string{eventID})
if err != nil {
return nil, err