From 1c2cb219358efb5a29be16297450fd8ba5fa621b Mon Sep 17 00:00:00 2001 From: Andrew Morgan Date: Fri, 8 Jun 2018 13:58:47 +0100 Subject: [PATCH] Query whether a room alias exists on app services Signed-off-by: Andrew Morgan --- dendrite-config.yaml | 2 +- .../dendrite/appservice/api/query.go | 95 +++++++++++++++ .../dendrite/appservice/appservice.go | 33 +++-- .../appservice/consumers/roomserver.go | 26 ++-- .../dendrite/appservice/query/query.go | 114 +++++++++++++++++ .../dendrite/clientapi/clientapi.go | 18 +-- .../dendrite/clientapi/routing/directory.go | 115 ++++++++++++------ .../dendrite/clientapi/routing/register.go | 15 +-- .../dendrite/clientapi/routing/routing.go | 11 +- .../cmd/dendrite-app-service-server/main.go | 38 ------ .../cmd/dendrite-client-api-server/main.go | 3 +- .../cmd/dendrite-monolith-server/main.go | 6 +- .../dendrite/common/basecomponent/base.go | 23 +++- .../dendrite/common/config/appservice.go | 52 +++++++- .../dendrite/common/config/config.go | 12 +- .../matrix-org/dendrite/common/http/http.go | 57 +++++++++ .../dendrite/roomserver/alias/alias.go | 10 +- .../dendrite/roomserver/api/alias.go | 9 +- .../dendrite/roomserver/api/input.go | 3 +- .../dendrite/roomserver/api/query.go | 66 ++-------- 20 files changed, 506 insertions(+), 202 deletions(-) create mode 100644 src/github.com/matrix-org/dendrite/appservice/api/query.go create mode 100644 src/github.com/matrix-org/dendrite/appservice/query/query.go delete mode 100644 src/github.com/matrix-org/dendrite/cmd/dendrite-app-service-server/main.go create mode 100644 src/github.com/matrix-org/dendrite/common/http/http.go diff --git a/dendrite-config.yaml b/dendrite-config.yaml index 44441787..b99a7c71 100644 --- a/dendrite-config.yaml +++ b/dendrite-config.yaml @@ -113,7 +113,7 @@ listen: media_api: "localhost:7774" public_rooms_api: "localhost:7775" federation_sender: "localhost:7776" - appservice: "localhost:7777" + appservice_api: "localhost:7777" # The configuration for tracing the dendrite components. tracing: diff --git a/src/github.com/matrix-org/dendrite/appservice/api/query.go b/src/github.com/matrix-org/dendrite/appservice/api/query.go new file mode 100644 index 00000000..3eadfc9a --- /dev/null +++ b/src/github.com/matrix-org/dendrite/appservice/api/query.go @@ -0,0 +1,95 @@ +// Copyright 2018 New Vector Ltd +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package api contains methods used by dendrite components in multi-process +// mode to send requests to the appservice component, typically in order to ask +// an application service for some information. +package api + +import ( + "context" + "net/http" + + commonHTTP "github.com/matrix-org/dendrite/common/http" + opentracing "github.com/opentracing/opentracing-go" +) + +// RoomAliasExistsRequest is a request to an application service +// about whether a room alias exists +type RoomAliasExistsRequest struct { + // Alias we want to lookup + Alias string `json:"alias"` +} + +// RoomAliasExistsRequestAccessToken is a request to an application service +// about whether a room alias exists. Includes an access token +type RoomAliasExistsRequestAccessToken struct { + // Alias we want to lookup + Alias string `json:"alias"` + AccessToken string `json:"access_token"` +} + +// RoomAliasExistsResponse is a response from an application service +// about whether a room alias exists +type RoomAliasExistsResponse struct { + AliasExists bool `json:"exists"` +} + +// AppServiceQueryAPI is used to query user and room alias data from application +// services +type AppServiceQueryAPI interface { + // Check whether a room alias exists within any application service namespaces + RoomAliasExists( + ctx context.Context, + req *RoomAliasExistsRequest, + response *RoomAliasExistsResponse, + ) error + // TODO: QueryUserIDExists +} + +// AppServiceRoomAliasExistsPath is the HTTP path for the RoomAliasExists API +const AppServiceRoomAliasExistsPath = "/api/appservice/RoomAliasExists" + +// httpAppServiceQueryAPI contains the URL to an appservice query API and a +// reference to a httpClient used to reach it +type httpAppServiceQueryAPI struct { + appserviceURL string + httpClient *http.Client +} + +// NewAppServiceQueryAPIHTTP creates a AppServiceQueryAPI implemented by talking +// to a HTTP POST API. +// If httpClient is nil then it uses http.DefaultClient +func NewAppServiceQueryAPIHTTP( + appserviceURL string, + httpClient *http.Client, +) AppServiceQueryAPI { + if httpClient == nil { + httpClient = http.DefaultClient + } + return &httpAppServiceQueryAPI{appserviceURL, httpClient} +} + +// RoomAliasExists implements AppServiceQueryAPI +func (h *httpAppServiceQueryAPI) RoomAliasExists( + ctx context.Context, + request *RoomAliasExistsRequest, + response *RoomAliasExistsResponse, +) error { + span, ctx := opentracing.StartSpanFromContext(ctx, "appserviceRoomAliasExists") + defer span.Finish() + + apiURL := h.appserviceURL + AppServiceRoomAliasExistsPath + return commonHTTP.PostJSON(ctx, span, h.httpClient, apiURL, request, response) +} diff --git a/src/github.com/matrix-org/dendrite/appservice/appservice.go b/src/github.com/matrix-org/dendrite/appservice/appservice.go index 23474b60..58d0542a 100644 --- a/src/github.com/matrix-org/dendrite/appservice/appservice.go +++ b/src/github.com/matrix-org/dendrite/appservice/appservice.go @@ -15,9 +15,13 @@ package appservice import ( + "net/http" "sync" + "time" + appserviceAPI "github.com/matrix-org/dendrite/appservice/api" "github.com/matrix-org/dendrite/appservice/consumers" + "github.com/matrix-org/dendrite/appservice/query" "github.com/matrix-org/dendrite/appservice/routing" "github.com/matrix-org/dendrite/appservice/storage" "github.com/matrix-org/dendrite/appservice/types" @@ -25,7 +29,7 @@ import ( "github.com/matrix-org/dendrite/clientapi/auth/storage/accounts" "github.com/matrix-org/dendrite/common/basecomponent" "github.com/matrix-org/dendrite/common/transactions" - "github.com/matrix-org/dendrite/roomserver/api" + roomserverAPI "github.com/matrix-org/dendrite/roomserver/api" "github.com/matrix-org/gomatrixserverlib" "github.com/sirupsen/logrus" ) @@ -36,10 +40,10 @@ func SetupAppServiceAPIComponent( base *basecomponent.BaseDendrite, accountsDB *accounts.Database, federation *gomatrixserverlib.FederationClient, - aliasAPI api.RoomserverAliasAPI, - queryAPI api.RoomserverQueryAPI, + roomserverAliasAPI roomserverAPI.RoomserverAliasAPI, + roomserverQueryAPI roomserverAPI.RoomserverQueryAPI, transactionsCache *transactions.Cache, -) { +) appserviceAPI.AppServiceQueryAPI { // Create a connection to the appservice postgres DB appserviceDB, err := storage.NewDatabase(string(base.Cfg.Database.AppService)) if err != nil { @@ -62,9 +66,22 @@ func SetupAppServiceAPIComponent( workerStates = append(workerStates, ws) } + // Create a HTTP client that this component will use for all outbound and + // inbound requests (inbound only for the internal API) + httpClient := &http.Client{ + Timeout: time.Second * 30, + } + + appserviceQueryAPI := query.AppServiceQueryAPI{ + HTTPClient: httpClient, + Cfg: base.Cfg, + } + + appserviceQueryAPI.SetupHTTP(http.DefaultServeMux) + consumer := consumers.NewOutputRoomEventConsumer( base.Cfg, base.KafkaConsumer, accountsDB, appserviceDB, - queryAPI, aliasAPI, workerStates, + roomserverQueryAPI, roomserverAliasAPI, workerStates, ) if err := consumer.Start(); err != nil { logrus.WithError(err).Panicf("failed to start app service roomserver consumer") @@ -77,7 +94,9 @@ func SetupAppServiceAPIComponent( // Set up HTTP Endpoints routing.Setup( - base.APIMux, *base.Cfg, queryAPI, aliasAPI, accountsDB, - federation, transactionsCache, + base.APIMux, *base.Cfg, roomserverQueryAPI, roomserverAliasAPI, + accountsDB, federation, transactionsCache, ) + + return &appserviceQueryAPI } diff --git a/src/github.com/matrix-org/dendrite/appservice/consumers/roomserver.go b/src/github.com/matrix-org/dendrite/appservice/consumers/roomserver.go index 6403e603..b2df008f 100644 --- a/src/github.com/matrix-org/dendrite/appservice/consumers/roomserver.go +++ b/src/github.com/matrix-org/dendrite/appservice/consumers/roomserver.go @@ -175,7 +175,7 @@ func (s *OutputRoomEventConsumer) filterRoomserverEvents( for _, event := range events { for _, ws := range s.workerStates { // Check if this event is interesting to this application service - if s.appserviceIsInterestedInEvent(ctx, &event, ws.AppService) { + if s.appserviceIsInterestedInEvent(ctx, event, ws.AppService) { // Queue this event to be sent off to the application service if err := s.asDB.StoreEvent(ctx, ws.AppService.ID, &event); err != nil { log.WithError(err).Warn("failed to insert incoming event into appservices database") @@ -196,19 +196,11 @@ func (s *OutputRoomEventConsumer) filterRoomserverEvents( // appserviceIsInterestedInEvent returns a boolean depending on whether a given // event falls within one of a given application service's namespaces. -func (s *OutputRoomEventConsumer) appserviceIsInterestedInEvent(ctx context.Context, event *gomatrixserverlib.Event, appservice config.ApplicationService) bool { - // Check sender of the event - for _, userNamespace := range appservice.NamespaceMap["users"] { - if userNamespace.RegexpObject.MatchString(event.Sender()) { - return true - } - } - - // Check room id of the event - for _, roomNamespace := range appservice.NamespaceMap["rooms"] { - if roomNamespace.RegexpObject.MatchString(event.RoomID()) { - return true - } +func (s *OutputRoomEventConsumer) appserviceIsInterestedInEvent(ctx context.Context, event gomatrixserverlib.Event, appservice config.ApplicationService) bool { + // Check room_id and sender of the event + if appservice.IsInterestedInUserID(event.Sender()) || + appservice.IsInterestedInRoomID(event.RoomID()) { + return true } // Check all known room aliases of the room the event came from @@ -216,10 +208,8 @@ func (s *OutputRoomEventConsumer) appserviceIsInterestedInEvent(ctx context.Cont var queryRes api.GetAliasesForRoomIDResponse if err := s.alias.GetAliasesForRoomID(ctx, &queryReq, &queryRes); err == nil { for _, alias := range queryRes.Aliases { - for _, aliasNamespace := range appservice.NamespaceMap["aliases"] { - if aliasNamespace.RegexpObject.MatchString(alias) { - return true - } + if appservice.IsInterestedInRoomAlias(alias) { + return true } } } else { diff --git a/src/github.com/matrix-org/dendrite/appservice/query/query.go b/src/github.com/matrix-org/dendrite/appservice/query/query.go new file mode 100644 index 00000000..3298661f --- /dev/null +++ b/src/github.com/matrix-org/dendrite/appservice/query/query.go @@ -0,0 +1,114 @@ +// Copyright 2018 New Vector Ltd +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package query handles requests from other internal dendrite components when +// they interact with the AppServiceQueryAPI. +package query + +import ( + "context" + "encoding/json" + "net/http" + + "github.com/matrix-org/dendrite/appservice/api" + "github.com/matrix-org/dendrite/common" + "github.com/matrix-org/dendrite/common/config" + "github.com/matrix-org/util" + opentracing "github.com/opentracing/opentracing-go" + log "github.com/sirupsen/logrus" +) + +const remoteAppServiceRoomAliasExistsPath = "/rooms/" + +// AppServiceQueryAPI is an implementation of api.AppServiceQueryAPI +type AppServiceQueryAPI struct { + HTTPClient *http.Client + Cfg *config.Dendrite +} + +// RoomAliasExists performs a request to '/room/{roomAlias}' on all known +// handling application services until one admits to owning the room +func (a *AppServiceQueryAPI) RoomAliasExists( + ctx context.Context, + request *api.RoomAliasExistsRequest, + response *api.RoomAliasExistsResponse, +) error { + span, ctx := opentracing.StartSpanFromContext(ctx, "ApplicationServiceRoomAlias") + defer span.Finish() + + // Determine which application service should handle this request + for _, appservice := range a.Cfg.Derived.ApplicationServices { + if appservice.URL != "" && appservice.IsInterestedInRoomAlias(request.Alias) { + // The full path to the rooms API, includes hs token + apiURL := appservice.URL + + remoteAppServiceRoomAliasExistsPath + request.Alias + "?access_token=" + appservice.HSToken + + // Send a request to each application service. If one responds that it has + // created the room, immediately return. + req, err := http.NewRequest(http.MethodGet, apiURL, nil) + if err != nil { + return err + } + resp, err := a.HTTPClient.Do(req.WithContext(ctx)) + if resp != nil { + defer func() { + err = resp.Body.Close() + if err != nil { + log.WithFields(log.Fields{ + "appservice_id": appservice.ID, + "status_code": resp.StatusCode, + }).Error("Unable to close application service response body") + } + }() + } + if err != nil { + log.WithError(err).Errorf("Issue querying room alias on application service %s", appservice.ID) + return err + } + if resp.StatusCode == http.StatusOK { + // StatusOK received from appservice. Room exists + response.AliasExists = true + return nil + } + + // Log non OK + log.WithFields(log.Fields{ + "appservice_id": appservice.ID, + "status_code": resp.StatusCode, + }).Warn("Application service responded with non-OK status code") + } + } + + response.AliasExists = false + return nil +} + +// SetupHTTP adds the AppServiceQueryPAI handlers to the http.ServeMux. This +// handles and muxes incoming api requests the to internal AppServiceQueryAPI. +func (a *AppServiceQueryAPI) SetupHTTP(servMux *http.ServeMux) { + servMux.Handle( + api.AppServiceRoomAliasExistsPath, + common.MakeInternalAPI("appserviceRoomAliasExists", func(req *http.Request) util.JSONResponse { + var request api.RoomAliasExistsRequest + var response api.RoomAliasExistsResponse + if err := json.NewDecoder(req.Body).Decode(&request); err != nil { + return util.ErrorResponse(err) + } + if err := a.RoomAliasExists(req.Context(), &request, &response); err != nil { + return util.ErrorResponse(err) + } + return util.JSONResponse{Code: http.StatusOK, JSON: &response} + }), + ) +} diff --git a/src/github.com/matrix-org/dendrite/clientapi/clientapi.go b/src/github.com/matrix-org/dendrite/clientapi/clientapi.go index 6f31ca75..6f72e162 100644 --- a/src/github.com/matrix-org/dendrite/clientapi/clientapi.go +++ b/src/github.com/matrix-org/dendrite/clientapi/clientapi.go @@ -15,6 +15,7 @@ package clientapi import ( + appserviceAPI "github.com/matrix-org/dendrite/appservice/api" "github.com/matrix-org/dendrite/clientapi/auth/storage/accounts" "github.com/matrix-org/dendrite/clientapi/auth/storage/devices" "github.com/matrix-org/dendrite/clientapi/consumers" @@ -22,7 +23,7 @@ import ( "github.com/matrix-org/dendrite/clientapi/routing" "github.com/matrix-org/dendrite/common/basecomponent" "github.com/matrix-org/dendrite/common/transactions" - "github.com/matrix-org/dendrite/roomserver/api" + roomserverAPI "github.com/matrix-org/dendrite/roomserver/api" "github.com/matrix-org/gomatrixserverlib" "github.com/sirupsen/logrus" ) @@ -35,9 +36,10 @@ func SetupClientAPIComponent( accountsDB *accounts.Database, federation *gomatrixserverlib.FederationClient, keyRing *gomatrixserverlib.KeyRing, - aliasAPI api.RoomserverAliasAPI, - inputAPI api.RoomserverInputAPI, - queryAPI api.RoomserverQueryAPI, + aliasAPI roomserverAPI.RoomserverAliasAPI, + inputAPI roomserverAPI.RoomserverInputAPI, + queryAPI roomserverAPI.RoomserverQueryAPI, + asAPI appserviceAPI.AppServiceQueryAPI, transactionsCache *transactions.Cache, ) { roomserverProducer := producers.NewRoomserverProducer(inputAPI) @@ -60,10 +62,8 @@ func SetupClientAPIComponent( } routing.Setup( - base.APIMux, *base.Cfg, roomserverProducer, - queryAPI, aliasAPI, accountsDB, deviceDB, - federation, *keyRing, - userUpdateProducer, syncProducer, - transactionsCache, + base.APIMux, *base.Cfg, roomserverProducer, queryAPI, asAPI, aliasAPI, + accountsDB, deviceDB, federation, *keyRing, userUpdateProducer, + syncProducer, transactionsCache, ) } diff --git a/src/github.com/matrix-org/dendrite/clientapi/routing/directory.go b/src/github.com/matrix-org/dendrite/clientapi/routing/directory.go index dc720fe0..44600131 100644 --- a/src/github.com/matrix-org/dendrite/clientapi/routing/directory.go +++ b/src/github.com/matrix-org/dendrite/clientapi/routing/directory.go @@ -15,25 +15,29 @@ package routing import ( + "fmt" "net/http" + appserviceAPI "github.com/matrix-org/dendrite/appservice/api" "github.com/matrix-org/dendrite/clientapi/auth/authtypes" "github.com/matrix-org/dendrite/clientapi/httputil" "github.com/matrix-org/dendrite/clientapi/jsonerror" "github.com/matrix-org/dendrite/common/config" - "github.com/matrix-org/dendrite/roomserver/api" + roomserverAPI "github.com/matrix-org/dendrite/roomserver/api" "github.com/matrix-org/gomatrix" "github.com/matrix-org/gomatrixserverlib" "github.com/matrix-org/util" ) // DirectoryRoom looks up a room alias +// nolint: gocyclo func DirectoryRoom( req *http.Request, roomAlias string, federation *gomatrixserverlib.FederationClient, cfg *config.Dendrite, - aliasAPI api.RoomserverAliasAPI, + rsAPI roomserverAPI.RoomserverAliasAPI, + asAPI appserviceAPI.AppServiceQueryAPI, ) util.JSONResponse { _, domain, err := gomatrixserverlib.SplitID('#', roomAlias) if err != nil { @@ -43,52 +47,91 @@ func DirectoryRoom( } } - var resp gomatrixserverlib.RespDirectory - if domain == cfg.Matrix.ServerName { - queryReq := api.GetRoomIDForAliasRequest{Alias: roomAlias} - var queryRes api.GetRoomIDForAliasResponse - if err = aliasAPI.GetRoomIDForAlias(req.Context(), &queryReq, &queryRes); err != nil { + queryResp, err := getRoomIDForAlias(req, rsAPI, roomAlias) + if err != nil { return httputil.LogThenError(req, err) } - if len(queryRes.RoomID) > 0 { - // TODO: List servers that are aware of this room alias - resp = gomatrixserverlib.RespDirectory{ - RoomID: queryRes.RoomID, - Servers: []gomatrixserverlib.ServerName{}, - } - } else { - // If the response doesn't contain a non-empty string, return an error + // List any roomIDs found associated with this alias + if len(queryResp.RoomID) > 0 { return util.JSONResponse{ - Code: http.StatusNotFound, - JSON: jsonerror.NotFound("Room alias " + roomAlias + " not found."), + Code: http.StatusOK, + JSON: queryResp, + } + } + + // No rooms found locally, try our application services by making a call to + // the appservice component + aliasReq := appserviceAPI.RoomAliasExistsRequest{Alias: roomAlias} + var aliasResp appserviceAPI.RoomAliasExistsResponse + err = asAPI.RoomAliasExists(req.Context(), &aliasReq, &aliasResp) + if err != nil { + return httputil.LogThenError(req, err) + } + + if aliasResp.AliasExists { + // Query the roomserver API again. We should have the room now + queryResp, err = getRoomIDForAlias(req, rsAPI, roomAlias) + if err != nil { + return httputil.LogThenError(req, err) + } + + // List any roomIDs found associated with this alias + if len(queryResp.RoomID) > 0 { + return util.JSONResponse{ + Code: http.StatusOK, + JSON: queryResp, + } } } } else { - resp, err = federation.LookupRoomAlias(req.Context(), domain, roomAlias) + // Query the federation for this room alias + resp, err := federation.LookupRoomAlias(req.Context(), domain, roomAlias) if err != nil { - switch x := err.(type) { + switch err.(type) { case gomatrix.HTTPError: - if x.Code == http.StatusNotFound { - return util.JSONResponse{ - Code: http.StatusNotFound, - JSON: jsonerror.NotFound("Room alias not found"), - } - } + default: + // TODO: Return 502 if the remote server errored. + // TODO: Return 504 if the remote server timed out. + return httputil.LogThenError(req, err) + } + } + if len(resp.RoomID) > 0 { + return util.JSONResponse{ + Code: http.StatusOK, + JSON: resp, } - // TODO: Return 502 if the remote server errored. - // TODO: Return 504 if the remote server timed out. - return httputil.LogThenError(req, err) } } return util.JSONResponse{ - Code: http.StatusOK, - JSON: resp, + Code: http.StatusNotFound, + JSON: jsonerror.NotFound( + fmt.Sprintf("Room alias %s not found", roomAlias), + ), } } +// getRoomIDForAlias queries the roomserver API and returns a Directory Response +// on a successful query +func getRoomIDForAlias( + req *http.Request, + rsAPI roomserverAPI.RoomserverAliasAPI, + roomAlias string, +) (resp gomatrixserverlib.RespDirectory, err error) { + // Query the roomserver API to check if the alias exists locally + queryReq := roomserverAPI.GetRoomIDForAliasRequest{Alias: roomAlias} + var queryRes roomserverAPI.GetRoomIDForAliasResponse + if err = rsAPI.GetRoomIDForAlias(req.Context(), &queryReq, &queryRes); err != nil { + return + } + return gomatrixserverlib.RespDirectory{ + RoomID: queryRes.RoomID, + Servers: []gomatrixserverlib.ServerName{}, + }, nil +} + // SetLocalAlias implements PUT /directory/room/{roomAlias} // TODO: Check if the user has the power level to set an alias func SetLocalAlias( @@ -96,7 +139,7 @@ func SetLocalAlias( device *authtypes.Device, alias string, cfg *config.Dendrite, - aliasAPI api.RoomserverAliasAPI, + aliasAPI roomserverAPI.RoomserverAliasAPI, ) util.JSONResponse { _, domain, err := gomatrixserverlib.SplitID('#', alias) if err != nil { @@ -120,12 +163,12 @@ func SetLocalAlias( return *resErr } - queryReq := api.SetRoomAliasRequest{ + queryReq := roomserverAPI.SetRoomAliasRequest{ UserID: device.UserID, RoomID: r.RoomID, Alias: alias, } - var queryRes api.SetRoomAliasResponse + var queryRes roomserverAPI.SetRoomAliasResponse if err := aliasAPI.SetRoomAlias(req.Context(), &queryReq, &queryRes); err != nil { return httputil.LogThenError(req, err) } @@ -149,13 +192,13 @@ func RemoveLocalAlias( req *http.Request, device *authtypes.Device, alias string, - aliasAPI api.RoomserverAliasAPI, + aliasAPI roomserverAPI.RoomserverAliasAPI, ) util.JSONResponse { - queryReq := api.RemoveRoomAliasRequest{ + queryReq := roomserverAPI.RemoveRoomAliasRequest{ Alias: alias, UserID: device.UserID, } - var queryRes api.RemoveRoomAliasResponse + var queryRes roomserverAPI.RemoveRoomAliasResponse if err := aliasAPI.RemoveRoomAlias(req.Context(), &queryReq, &queryRes); err != nil { return httputil.LogThenError(req, err) } diff --git a/src/github.com/matrix-org/dendrite/clientapi/routing/register.go b/src/github.com/matrix-org/dendrite/clientapi/routing/register.go index 4a9c9d3e..804858fc 100644 --- a/src/github.com/matrix-org/dendrite/clientapi/routing/register.go +++ b/src/github.com/matrix-org/dendrite/clientapi/routing/register.go @@ -301,8 +301,8 @@ func UsernameIsWithinApplicationServiceNamespace( } // Loop through all known application service's namespaces and see if any match - for _, knownAppservice := range cfg.Derived.ApplicationServices { - for _, namespace := range knownAppservice.NamespaceMap["users"] { + for _, knownAppService := range cfg.Derived.ApplicationServices { + for _, namespace := range knownAppService.NamespaceMap["users"] { // AS namespaces are checked for validity in config if namespace.RegexpObject.MatchString(username) { return true @@ -321,16 +321,13 @@ func UsernameMatchesMultipleExclusiveNamespaces( // Check namespaces and see if more than one match matchCount := 0 for _, appservice := range cfg.Derived.ApplicationServices { - for _, namespaceSlice := range appservice.NamespaceMap { - for _, namespace := range namespaceSlice { - // Check if we have a match on this username - if namespace.RegexpObject.MatchString(username) { - matchCount++ - } + if appservice.IsInterestedInUserID(username) { + if matchCount++; matchCount > 1 { + return true } } } - return matchCount > 1 + return false } // validateApplicationService checks if a provided application service token diff --git a/src/github.com/matrix-org/dendrite/clientapi/routing/routing.go b/src/github.com/matrix-org/dendrite/clientapi/routing/routing.go index ee593c68..6620f062 100644 --- a/src/github.com/matrix-org/dendrite/clientapi/routing/routing.go +++ b/src/github.com/matrix-org/dendrite/clientapi/routing/routing.go @@ -20,6 +20,7 @@ import ( "strings" "github.com/gorilla/mux" + appserviceAPI "github.com/matrix-org/dendrite/appservice/api" "github.com/matrix-org/dendrite/clientapi/auth" "github.com/matrix-org/dendrite/clientapi/auth/authtypes" "github.com/matrix-org/dendrite/clientapi/auth/storage/accounts" @@ -29,7 +30,7 @@ import ( "github.com/matrix-org/dendrite/common" "github.com/matrix-org/dendrite/common/config" "github.com/matrix-org/dendrite/common/transactions" - "github.com/matrix-org/dendrite/roomserver/api" + roomserverAPI "github.com/matrix-org/dendrite/roomserver/api" "github.com/matrix-org/gomatrixserverlib" "github.com/matrix-org/util" ) @@ -42,8 +43,8 @@ const pathPrefixUnstable = "/_matrix/client/unstable" // to clients which need to make outbound HTTP requests. func Setup( apiMux *mux.Router, cfg config.Dendrite, - producer *producers.RoomserverProducer, queryAPI api.RoomserverQueryAPI, - aliasAPI api.RoomserverAliasAPI, + producer *producers.RoomserverProducer, queryAPI roomserverAPI.RoomserverQueryAPI, + appserviceAPI appserviceAPI.AppServiceQueryAPI, aliasAPI roomserverAPI.RoomserverAliasAPI, accountDB *accounts.Database, deviceDB *devices.Database, federation *gomatrixserverlib.FederationClient, @@ -141,9 +142,9 @@ func Setup( })).Methods(http.MethodGet, http.MethodOptions) r0mux.Handle("/directory/room/{roomAlias}", - common.MakeAuthAPI("directory_room", authData, func(req *http.Request, device *authtypes.Device) util.JSONResponse { + common.MakeExternalAPI("directory_room", func(req *http.Request) util.JSONResponse { vars := mux.Vars(req) - return DirectoryRoom(req, vars["roomAlias"], federation, &cfg, aliasAPI) + return DirectoryRoom(req, vars["roomAlias"], federation, &cfg, aliasAPI, appserviceAPI) }), ).Methods(http.MethodGet, http.MethodOptions) diff --git a/src/github.com/matrix-org/dendrite/cmd/dendrite-app-service-server/main.go b/src/github.com/matrix-org/dendrite/cmd/dendrite-app-service-server/main.go deleted file mode 100644 index 3c537bea..00000000 --- a/src/github.com/matrix-org/dendrite/cmd/dendrite-app-service-server/main.go +++ /dev/null @@ -1,38 +0,0 @@ -// Copyright 2018 Vector Creations Ltd -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package main - -import ( - "github.com/matrix-org/dendrite/appservice" - "github.com/matrix-org/dendrite/common/basecomponent" - "github.com/matrix-org/dendrite/common/transactions" -) - -func main() { - cfg := basecomponent.ParseFlags() - base := basecomponent.NewBaseDendrite(cfg, "AppService") - - defer base.Close() // nolint: errcheck - accountDB := base.CreateAccountsDB() - federation := base.CreateFederationClient() - alias, _, query := base.CreateHTTPRoomserverAPIs() - cache := transactions.New() - - appservice.SetupAppServiceAPIComponent( - base, accountDB, federation, alias, query, cache, - ) - - base.SetupAndServeHTTP(string(base.Cfg.Listen.FederationSender)) -} diff --git a/src/github.com/matrix-org/dendrite/cmd/dendrite-client-api-server/main.go b/src/github.com/matrix-org/dendrite/cmd/dendrite-client-api-server/main.go index be04a89e..2b6f2f20 100644 --- a/src/github.com/matrix-org/dendrite/cmd/dendrite-client-api-server/main.go +++ b/src/github.com/matrix-org/dendrite/cmd/dendrite-client-api-server/main.go @@ -34,11 +34,12 @@ func main() { keyRing := keydb.CreateKeyRing(federation.Client, keyDB) alias, input, query := base.CreateHTTPRoomserverAPIs() + asQuery := base.CreateHTTPAppServiceAPIs() cache := transactions.New() clientapi.SetupClientAPIComponent( base, deviceDB, accountDB, federation, &keyRing, - alias, input, query, cache, + alias, input, query, asQuery, cache, ) base.SetupAndServeHTTP(string(base.Cfg.Listen.ClientAPI)) diff --git a/src/github.com/matrix-org/dendrite/cmd/dendrite-monolith-server/main.go b/src/github.com/matrix-org/dendrite/cmd/dendrite-monolith-server/main.go index 2d3bc09e..fb310996 100644 --- a/src/github.com/matrix-org/dendrite/cmd/dendrite-monolith-server/main.go +++ b/src/github.com/matrix-org/dendrite/cmd/dendrite-monolith-server/main.go @@ -55,10 +55,13 @@ func main() { keyRing := keydb.CreateKeyRing(federation.Client, keyDB) alias, input, query := roomserver.SetupRoomServerComponent(base) + asQuery := appservice.SetupAppServiceAPIComponent( + base, accountDB, federation, alias, query, transactions.New(), + ) clientapi.SetupClientAPIComponent( base, deviceDB, accountDB, - federation, &keyRing, alias, input, query, + federation, &keyRing, alias, input, query, asQuery, transactions.New(), ) federationapi.SetupFederationAPIComponent(base, accountDB, federation, &keyRing, alias, input, query) @@ -66,7 +69,6 @@ func main() { mediaapi.SetupMediaAPIComponent(base, deviceDB) publicroomsapi.SetupPublicRoomsAPIComponent(base, deviceDB) syncapi.SetupSyncAPIComponent(base, deviceDB, accountDB, query) - appservice.SetupAppServiceAPIComponent(base, accountDB, federation, alias, query, transactions.New()) httpHandler := common.WrapHandlerInCORS(base.APIMux) diff --git a/src/github.com/matrix-org/dendrite/common/basecomponent/base.go b/src/github.com/matrix-org/dendrite/common/basecomponent/base.go index ed7cb7ab..e97d49b0 100644 --- a/src/github.com/matrix-org/dendrite/common/basecomponent/base.go +++ b/src/github.com/matrix-org/dendrite/common/basecomponent/base.go @@ -30,8 +30,9 @@ import ( "github.com/gorilla/mux" sarama "gopkg.in/Shopify/sarama.v1" + appserviceAPI "github.com/matrix-org/dendrite/appservice/api" "github.com/matrix-org/dendrite/common/config" - "github.com/matrix-org/dendrite/roomserver/api" + roomserverAPI "github.com/matrix-org/dendrite/roomserver/api" "github.com/sirupsen/logrus" ) @@ -80,12 +81,22 @@ func (b *BaseDendrite) Close() error { return b.tracerCloser.Close() } -// CreateHTTPRoomserverAPIs returns the AliasAPI, InputAPI and QueryAPI to hit +// CreateHTTPAppServiceAPIs returns the QueryAPI for hitting the appservice +// component over HTTP. +func (b *BaseDendrite) CreateHTTPAppServiceAPIs() appserviceAPI.AppServiceQueryAPI { + return appserviceAPI.NewAppServiceQueryAPIHTTP(b.Cfg.AppServiceURL(), nil) +} + +// CreateHTTPRoomserverAPIs returns the AliasAPI, InputAPI and QueryAPI for hitting // the roomserver over HTTP. -func (b *BaseDendrite) CreateHTTPRoomserverAPIs() (api.RoomserverAliasAPI, api.RoomserverInputAPI, api.RoomserverQueryAPI) { - alias := api.NewRoomserverAliasAPIHTTP(b.Cfg.RoomServerURL(), nil) - input := api.NewRoomserverInputAPIHTTP(b.Cfg.RoomServerURL(), nil) - query := api.NewRoomserverQueryAPIHTTP(b.Cfg.RoomServerURL(), nil) +func (b *BaseDendrite) CreateHTTPRoomserverAPIs() ( + roomserverAPI.RoomserverAliasAPI, + roomserverAPI.RoomserverInputAPI, + roomserverAPI.RoomserverQueryAPI, +) { + alias := roomserverAPI.NewRoomserverAliasAPIHTTP(b.Cfg.RoomServerURL(), nil) + input := roomserverAPI.NewRoomserverInputAPIHTTP(b.Cfg.RoomServerURL(), nil) + query := roomserverAPI.NewRoomserverQueryAPIHTTP(b.Cfg.RoomServerURL(), nil) return alias, input, query } diff --git a/src/github.com/matrix-org/dendrite/common/config/appservice.go b/src/github.com/matrix-org/dendrite/common/config/appservice.go index 0d266ae8..56b01611 100644 --- a/src/github.com/matrix-org/dendrite/common/config/appservice.go +++ b/src/github.com/matrix-org/dendrite/common/config/appservice.go @@ -53,9 +53,57 @@ type ApplicationService struct { NamespaceMap map[string][]ApplicationServiceNamespace `yaml:"namespaces"` } -// loadAppservices iterates through all application service config files +// IsInterestedInRoomID returns a bool on whether an application service's +// namespace includes the given room ID +func (a *ApplicationService) IsInterestedInRoomID( + roomID string, +) bool { + if namespaceSlice, ok := a.NamespaceMap["users"]; ok { + for _, namespace := range namespaceSlice { + if namespace.RegexpObject.MatchString(roomID) { + return true + } + } + } + + return false +} + +// IsInterestedInUserID returns a bool on whether an application service's +// namespace includes the given user ID +func (a *ApplicationService) IsInterestedInUserID( + userID string, +) bool { + if namespaceSlice, ok := a.NamespaceMap["users"]; ok { + for _, namespace := range namespaceSlice { + if namespace.RegexpObject.MatchString(userID) { + return true + } + } + } + + return false +} + +// IsInterestedInRoomAlias returns a bool on whether an application service's +// namespace includes the given room alias +func (a *ApplicationService) IsInterestedInRoomAlias( + roomAlias string, +) bool { + if namespaceSlice, ok := a.NamespaceMap["aliases"]; ok { + for _, namespace := range namespaceSlice { + if namespace.RegexpObject.MatchString(roomAlias) { + return true + } + } + } + + return false +} + +// loadAppServices iterates through all application service config files // and loads their data into the config object for later access. -func loadAppservices(config *Dendrite) error { +func loadAppServices(config *Dendrite) error { for _, configPath := range config.ApplicationServices.ConfigFiles { // Create a new application service var appservice ApplicationService diff --git a/src/github.com/matrix-org/dendrite/common/config/config.go b/src/github.com/matrix-org/dendrite/common/config/config.go index bd6e361d..86dd2770 100644 --- a/src/github.com/matrix-org/dendrite/common/config/config.go +++ b/src/github.com/matrix-org/dendrite/common/config/config.go @@ -198,6 +198,7 @@ type Dendrite struct { MediaAPI Address `yaml:"media_api"` ClientAPI Address `yaml:"client_api"` FederationAPI Address `yaml:"federation_api"` + AppServiceAPI Address `yaml:"appservice_api"` SyncAPI Address `yaml:"sync_api"` RoomServer Address `yaml:"room_server"` FederationSender Address `yaml:"federation_sender"` @@ -408,7 +409,7 @@ func (config *Dendrite) derive() error { } // Load application service configuration files - if err := loadAppservices(config); err != nil { + if err := loadAppServices(config); err != nil { return err } @@ -640,6 +641,15 @@ func fingerprintPEM(data []byte) *gomatrixserverlib.TLSFingerprint { } } +// AppServiceURL returns a HTTP URL for where the appservice component is listening. +func (config *Dendrite) AppServiceURL() string { + // Hard code the roomserver to talk HTTP for now. + // If we support HTTPS we need to think of a practical way to do certificate validation. + // People setting up servers shouldn't need to get a certificate valid for the public + // internet for an internal API. + return "http://" + string(config.Listen.AppServiceAPI) +} + // RoomServerURL returns an HTTP URL for where the roomserver is listening. func (config *Dendrite) RoomServerURL() string { // Hard code the roomserver to talk HTTP for now. diff --git a/src/github.com/matrix-org/dendrite/common/http/http.go b/src/github.com/matrix-org/dendrite/common/http/http.go new file mode 100644 index 00000000..3c647544 --- /dev/null +++ b/src/github.com/matrix-org/dendrite/common/http/http.go @@ -0,0 +1,57 @@ +package http + +import ( + "bytes" + "context" + "encoding/json" + "fmt" + "net/http" + + opentracing "github.com/opentracing/opentracing-go" + "github.com/opentracing/opentracing-go/ext" +) + +// PostJSON performs a POST request with JSON on an internal HTTP API +func PostJSON( + ctx context.Context, span opentracing.Span, httpClient *http.Client, + apiURL string, request, response interface{}, +) error { + jsonBytes, err := json.Marshal(request) + if err != nil { + return err + } + + req, err := http.NewRequest(http.MethodPost, apiURL, bytes.NewReader(jsonBytes)) + if err != nil { + return err + } + + // Mark the span as being an RPC client. + ext.SpanKindRPCClient.Set(span) + carrier := opentracing.HTTPHeadersCarrier(req.Header) + tracer := opentracing.GlobalTracer() + + if err = tracer.Inject(span.Context(), opentracing.HTTPHeaders, carrier); err != nil { + return err + } + + req.Header.Set("Content-Type", "application/json") + + res, err := httpClient.Do(req.WithContext(ctx)) + if res != nil { + defer (func() { err = res.Body.Close() })() + } + if err != nil { + return err + } + if res.StatusCode != http.StatusOK { + var errorBody struct { + Message string `json:"message"` + } + if err = json.NewDecoder(res.Body).Decode(&errorBody); err != nil { + return err + } + return fmt.Errorf("api: %d: %s", res.StatusCode, errorBody.Message) + } + return json.NewDecoder(res.Body).Decode(response) +} diff --git a/src/github.com/matrix-org/dendrite/roomserver/alias/alias.go b/src/github.com/matrix-org/dendrite/roomserver/alias/alias.go index a00ad027..e918d443 100644 --- a/src/github.com/matrix-org/dendrite/roomserver/alias/alias.go +++ b/src/github.com/matrix-org/dendrite/roomserver/alias/alias.go @@ -44,7 +44,7 @@ type RoomserverAliasAPIDatabase interface { RemoveRoomAlias(ctx context.Context, alias string) error } -// RoomserverAliasAPI is an implementation of api.RoomserverAliasAPI +// RoomserverAliasAPI is an implementation of alias.RoomserverAliasAPI type RoomserverAliasAPI struct { DB RoomserverAliasAPIDatabase Cfg *config.Dendrite @@ -52,7 +52,7 @@ type RoomserverAliasAPI struct { QueryAPI api.RoomserverQueryAPI } -// SetRoomAlias implements api.RoomserverAliasAPI +// SetRoomAlias implements alias.RoomserverAliasAPI func (r *RoomserverAliasAPI) SetRoomAlias( ctx context.Context, request *api.SetRoomAliasRequest, @@ -82,7 +82,7 @@ func (r *RoomserverAliasAPI) SetRoomAlias( return r.sendUpdatedAliasesEvent(context.TODO(), request.UserID, request.RoomID) } -// GetRoomIDForAlias implements api.RoomserverAliasAPI +// GetRoomIDForAlias implements alias.RoomserverAliasAPI func (r *RoomserverAliasAPI) GetRoomIDForAlias( ctx context.Context, request *api.GetRoomIDForAliasRequest, @@ -98,7 +98,7 @@ func (r *RoomserverAliasAPI) GetRoomIDForAlias( return nil } -// GetAliasesForRoomID implements api.RoomserverAliasAPI +// GetAliasesForRoomID implements alias.RoomserverAliasAPI func (r *RoomserverAliasAPI) GetAliasesForRoomID( ctx context.Context, request *api.GetAliasesForRoomIDRequest, @@ -114,7 +114,7 @@ func (r *RoomserverAliasAPI) GetAliasesForRoomID( return nil } -// RemoveRoomAlias implements api.RoomserverAliasAPI +// RemoveRoomAlias implements alias.RoomserverAliasAPI func (r *RoomserverAliasAPI) RemoveRoomAlias( ctx context.Context, request *api.RemoveRoomAliasRequest, diff --git a/src/github.com/matrix-org/dendrite/roomserver/api/alias.go b/src/github.com/matrix-org/dendrite/roomserver/api/alias.go index 16760da6..57671071 100644 --- a/src/github.com/matrix-org/dendrite/roomserver/api/alias.go +++ b/src/github.com/matrix-org/dendrite/roomserver/api/alias.go @@ -18,6 +18,7 @@ import ( "context" "net/http" + commonHTTP "github.com/matrix-org/dendrite/common/http" opentracing "github.com/opentracing/opentracing-go" ) @@ -139,7 +140,7 @@ func (h *httpRoomserverAliasAPI) SetRoomAlias( defer span.Finish() apiURL := h.roomserverURL + RoomserverSetRoomAliasPath - return postJSON(ctx, span, h.httpClient, apiURL, request, response) + return commonHTTP.PostJSON(ctx, span, h.httpClient, apiURL, request, response) } // GetRoomIDForAlias implements RoomserverAliasAPI @@ -152,7 +153,7 @@ func (h *httpRoomserverAliasAPI) GetRoomIDForAlias( defer span.Finish() apiURL := h.roomserverURL + RoomserverGetRoomIDForAliasPath - return postJSON(ctx, span, h.httpClient, apiURL, request, response) + return commonHTTP.PostJSON(ctx, span, h.httpClient, apiURL, request, response) } // GetAliasesForRoomID implements RoomserverAliasAPI @@ -165,7 +166,7 @@ func (h *httpRoomserverAliasAPI) GetAliasesForRoomID( defer span.Finish() apiURL := h.roomserverURL + RoomserverGetAliasesForRoomIDPath - return postJSON(ctx, span, h.httpClient, apiURL, request, response) + return commonHTTP.PostJSON(ctx, span, h.httpClient, apiURL, request, response) } // RemoveRoomAlias implements RoomserverAliasAPI @@ -178,5 +179,5 @@ func (h *httpRoomserverAliasAPI) RemoveRoomAlias( defer span.Finish() apiURL := h.roomserverURL + RoomserverRemoveRoomAliasPath - return postJSON(ctx, span, h.httpClient, apiURL, request, response) + return commonHTTP.PostJSON(ctx, span, h.httpClient, apiURL, request, response) } diff --git a/src/github.com/matrix-org/dendrite/roomserver/api/input.go b/src/github.com/matrix-org/dendrite/roomserver/api/input.go index e81e7920..2c2e27c6 100644 --- a/src/github.com/matrix-org/dendrite/roomserver/api/input.go +++ b/src/github.com/matrix-org/dendrite/roomserver/api/input.go @@ -19,6 +19,7 @@ import ( "context" "net/http" + commonHTTP "github.com/matrix-org/dendrite/common/http" "github.com/matrix-org/gomatrixserverlib" opentracing "github.com/opentracing/opentracing-go" ) @@ -134,5 +135,5 @@ func (h *httpRoomserverInputAPI) InputRoomEvents( defer span.Finish() apiURL := h.roomserverURL + RoomserverInputRoomEventsPath - return postJSON(ctx, span, h.httpClient, apiURL, request, response) + return commonHTTP.PostJSON(ctx, span, h.httpClient, apiURL, request, response) } diff --git a/src/github.com/matrix-org/dendrite/roomserver/api/query.go b/src/github.com/matrix-org/dendrite/roomserver/api/query.go index aea7face..56547496 100644 --- a/src/github.com/matrix-org/dendrite/roomserver/api/query.go +++ b/src/github.com/matrix-org/dendrite/roomserver/api/query.go @@ -15,16 +15,12 @@ package api import ( - "bytes" "context" - "encoding/json" - "fmt" "net/http" - opentracing "github.com/opentracing/opentracing-go" - "github.com/opentracing/opentracing-go/ext" - + commonHTTP "github.com/matrix-org/dendrite/common/http" "github.com/matrix-org/gomatrixserverlib" + opentracing "github.com/opentracing/opentracing-go" ) // QueryLatestEventsAndStateRequest is a request to QueryLatestEventsAndState @@ -280,7 +276,7 @@ func (h *httpRoomserverQueryAPI) QueryLatestEventsAndState( defer span.Finish() apiURL := h.roomserverURL + RoomserverQueryLatestEventsAndStatePath - return postJSON(ctx, span, h.httpClient, apiURL, request, response) + return commonHTTP.PostJSON(ctx, span, h.httpClient, apiURL, request, response) } // QueryStateAfterEvents implements RoomserverQueryAPI @@ -293,7 +289,7 @@ func (h *httpRoomserverQueryAPI) QueryStateAfterEvents( defer span.Finish() apiURL := h.roomserverURL + RoomserverQueryStateAfterEventsPath - return postJSON(ctx, span, h.httpClient, apiURL, request, response) + return commonHTTP.PostJSON(ctx, span, h.httpClient, apiURL, request, response) } // QueryEventsByID implements RoomserverQueryAPI @@ -306,7 +302,7 @@ func (h *httpRoomserverQueryAPI) QueryEventsByID( defer span.Finish() apiURL := h.roomserverURL + RoomserverQueryEventsByIDPath - return postJSON(ctx, span, h.httpClient, apiURL, request, response) + return commonHTTP.PostJSON(ctx, span, h.httpClient, apiURL, request, response) } // QueryMembershipsForRoom implements RoomserverQueryAPI @@ -319,7 +315,7 @@ func (h *httpRoomserverQueryAPI) QueryMembershipsForRoom( defer span.Finish() apiURL := h.roomserverURL + RoomserverQueryMembershipsForRoomPath - return postJSON(ctx, span, h.httpClient, apiURL, request, response) + return commonHTTP.PostJSON(ctx, span, h.httpClient, apiURL, request, response) } // QueryInvitesForUser implements RoomserverQueryAPI @@ -332,7 +328,7 @@ func (h *httpRoomserverQueryAPI) QueryInvitesForUser( defer span.Finish() apiURL := h.roomserverURL + RoomserverQueryInvitesForUserPath - return postJSON(ctx, span, h.httpClient, apiURL, request, response) + return commonHTTP.PostJSON(ctx, span, h.httpClient, apiURL, request, response) } // QueryServerAllowedToSeeEvent implements RoomserverQueryAPI @@ -345,7 +341,7 @@ func (h *httpRoomserverQueryAPI) QueryServerAllowedToSeeEvent( defer span.Finish() apiURL := h.roomserverURL + RoomserverQueryServerAllowedToSeeEventPath - return postJSON(ctx, span, h.httpClient, apiURL, request, response) + return commonHTTP.PostJSON(ctx, span, h.httpClient, apiURL, request, response) } // QueryStateAndAuthChain implements RoomserverQueryAPI @@ -358,49 +354,5 @@ func (h *httpRoomserverQueryAPI) QueryStateAndAuthChain( defer span.Finish() apiURL := h.roomserverURL + RoomserverQueryStateAndAuthChainPath - return postJSON(ctx, span, h.httpClient, apiURL, request, response) -} - -func postJSON( - ctx context.Context, span opentracing.Span, httpClient *http.Client, - apiURL string, request, response interface{}, -) error { - jsonBytes, err := json.Marshal(request) - if err != nil { - return err - } - - req, err := http.NewRequest(http.MethodPost, apiURL, bytes.NewReader(jsonBytes)) - if err != nil { - return err - } - - // Mark the span as being an RPC client. - ext.SpanKindRPCClient.Set(span) - carrier := opentracing.HTTPHeadersCarrier(req.Header) - tracer := opentracing.GlobalTracer() - - if err = tracer.Inject(span.Context(), opentracing.HTTPHeaders, carrier); err != nil { - return err - } - - req.Header.Set("Content-Type", "application/json") - - res, err := httpClient.Do(req.WithContext(ctx)) - if res != nil { - defer (func() { err = res.Body.Close() })() - } - if err != nil { - return err - } - if res.StatusCode != http.StatusOK { - var errorBody struct { - Message string `json:"message"` - } - if err = json.NewDecoder(res.Body).Decode(&errorBody); err != nil { - return err - } - return fmt.Errorf("api: %d: %s", res.StatusCode, errorBody.Message) - } - return json.NewDecoder(res.Body).Decode(response) + return commonHTTP.PostJSON(ctx, span, h.httpClient, apiURL, request, response) }