aboutsummaryrefslogtreecommitdiff
path: root/federationapi/inthttp
diff options
context:
space:
mode:
Diffstat (limited to 'federationapi/inthttp')
-rw-r--r--federationapi/inthttp/client.go437
-rw-r--r--federationapi/inthttp/server.go457
2 files changed, 282 insertions, 612 deletions
diff --git a/federationapi/inthttp/client.go b/federationapi/inthttp/client.go
index 295ddc49..812d3c6d 100644
--- a/federationapi/inthttp/client.go
+++ b/federationapi/inthttp/client.go
@@ -10,7 +10,6 @@ import (
"github.com/matrix-org/dendrite/internal/httputil"
"github.com/matrix-org/gomatrix"
"github.com/matrix-org/gomatrixserverlib"
- "github.com/opentracing/opentracing-go"
)
// HTTP paths for the internal HTTP API
@@ -48,7 +47,11 @@ func NewFederationAPIClient(federationSenderURL string, httpClient *http.Client,
if httpClient == nil {
return nil, errors.New("NewFederationInternalAPIHTTP: httpClient is <nil>")
}
- return &httpFederationInternalAPI{federationSenderURL, httpClient, cache}, nil
+ return &httpFederationInternalAPI{
+ federationAPIURL: federationSenderURL,
+ httpClient: httpClient,
+ cache: cache,
+ }, nil
}
type httpFederationInternalAPI struct {
@@ -63,11 +66,10 @@ func (h *httpFederationInternalAPI) PerformLeave(
request *api.PerformLeaveRequest,
response *api.PerformLeaveResponse,
) error {
- span, ctx := opentracing.StartSpanFromContext(ctx, "PerformLeaveRequest")
- defer span.Finish()
-
- apiURL := h.federationAPIURL + FederationAPIPerformLeaveRequestPath
- return httputil.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
+ return httputil.CallInternalRPCAPI(
+ "PerformLeave", h.federationAPIURL+FederationAPIPerformLeaveRequestPath,
+ h.httpClient, ctx, request, response,
+ )
}
// Handle sending an invite to a remote server.
@@ -76,11 +78,10 @@ func (h *httpFederationInternalAPI) PerformInvite(
request *api.PerformInviteRequest,
response *api.PerformInviteResponse,
) error {
- span, ctx := opentracing.StartSpanFromContext(ctx, "PerformInviteRequest")
- defer span.Finish()
-
- apiURL := h.federationAPIURL + FederationAPIPerformInviteRequestPath
- return httputil.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
+ return httputil.CallInternalRPCAPI(
+ "PerformInvite", h.federationAPIURL+FederationAPIPerformInviteRequestPath,
+ h.httpClient, ctx, request, response,
+ )
}
// Handle starting a peek on a remote server.
@@ -89,11 +90,10 @@ func (h *httpFederationInternalAPI) PerformOutboundPeek(
request *api.PerformOutboundPeekRequest,
response *api.PerformOutboundPeekResponse,
) error {
- span, ctx := opentracing.StartSpanFromContext(ctx, "PerformOutboundPeekRequest")
- defer span.Finish()
-
- apiURL := h.federationAPIURL + FederationAPIPerformOutboundPeekRequestPath
- return httputil.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
+ return httputil.CallInternalRPCAPI(
+ "PerformOutboundPeek", h.federationAPIURL+FederationAPIPerformOutboundPeekRequestPath,
+ h.httpClient, ctx, request, response,
+ )
}
// QueryJoinedHostServerNamesInRoom implements FederationInternalAPI
@@ -102,11 +102,10 @@ func (h *httpFederationInternalAPI) QueryJoinedHostServerNamesInRoom(
request *api.QueryJoinedHostServerNamesInRoomRequest,
response *api.QueryJoinedHostServerNamesInRoomResponse,
) error {
- span, ctx := opentracing.StartSpanFromContext(ctx, "QueryJoinedHostServerNamesInRoom")
- defer span.Finish()
-
- apiURL := h.federationAPIURL + FederationAPIQueryJoinedHostServerNamesInRoomPath
- return httputil.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
+ return httputil.CallInternalRPCAPI(
+ "QueryJoinedHostServerNamesInRoom", h.federationAPIURL+FederationAPIQueryJoinedHostServerNamesInRoomPath,
+ h.httpClient, ctx, request, response,
+ )
}
// Handle an instruction to make_join & send_join with a remote server.
@@ -115,12 +114,10 @@ func (h *httpFederationInternalAPI) PerformJoin(
request *api.PerformJoinRequest,
response *api.PerformJoinResponse,
) {
- span, ctx := opentracing.StartSpanFromContext(ctx, "PerformJoinRequest")
- defer span.Finish()
-
- apiURL := h.federationAPIURL + FederationAPIPerformJoinRequestPath
- err := httputil.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
- if err != nil {
+ if err := httputil.CallInternalRPCAPI(
+ "PerformJoinRequest", h.federationAPIURL+FederationAPIPerformJoinRequestPath,
+ h.httpClient, ctx, request, response,
+ ); err != nil {
response.LastError = &gomatrix.HTTPError{
Message: err.Error(),
Code: 0,
@@ -135,11 +132,10 @@ func (h *httpFederationInternalAPI) PerformDirectoryLookup(
request *api.PerformDirectoryLookupRequest,
response *api.PerformDirectoryLookupResponse,
) error {
- span, ctx := opentracing.StartSpanFromContext(ctx, "PerformDirectoryLookup")
- defer span.Finish()
-
- apiURL := h.federationAPIURL + FederationAPIPerformDirectoryLookupRequestPath
- return httputil.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
+ return httputil.CallInternalRPCAPI(
+ "PerformDirectoryLookup", h.federationAPIURL+FederationAPIPerformDirectoryLookupRequestPath,
+ h.httpClient, ctx, request, response,
+ )
}
// Handle an instruction to broadcast an EDU to all servers in rooms we are joined to.
@@ -148,101 +144,61 @@ func (h *httpFederationInternalAPI) PerformBroadcastEDU(
request *api.PerformBroadcastEDURequest,
response *api.PerformBroadcastEDUResponse,
) error {
- span, ctx := opentracing.StartSpanFromContext(ctx, "PerformBroadcastEDU")
- defer span.Finish()
-
- apiURL := h.federationAPIURL + FederationAPIPerformBroadcastEDUPath
- return httputil.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
+ return httputil.CallInternalRPCAPI(
+ "PerformBroadcastEDU", h.federationAPIURL+FederationAPIPerformBroadcastEDUPath,
+ h.httpClient, ctx, request, response,
+ )
}
type getUserDevices struct {
S gomatrixserverlib.ServerName
UserID string
- Res *gomatrixserverlib.RespUserDevices
- Err *api.FederationClientError
}
func (h *httpFederationInternalAPI) GetUserDevices(
ctx context.Context, s gomatrixserverlib.ServerName, userID string,
) (gomatrixserverlib.RespUserDevices, error) {
- span, ctx := opentracing.StartSpanFromContext(ctx, "GetUserDevices")
- defer span.Finish()
-
- var result gomatrixserverlib.RespUserDevices
- request := getUserDevices{
- S: s,
- UserID: userID,
- }
- var response getUserDevices
- apiURL := h.federationAPIURL + FederationAPIGetUserDevicesPath
- err := httputil.PostJSON(ctx, span, h.httpClient, apiURL, &request, &response)
- if err != nil {
- return result, err
- }
- if response.Err != nil {
- return result, response.Err
- }
- return *response.Res, nil
+ return httputil.CallInternalProxyAPI[getUserDevices, gomatrixserverlib.RespUserDevices, *api.FederationClientError](
+ "GetUserDevices", h.federationAPIURL+FederationAPIGetUserDevicesPath, h.httpClient,
+ ctx, &getUserDevices{
+ S: s,
+ UserID: userID,
+ },
+ )
}
type claimKeys struct {
S gomatrixserverlib.ServerName
OneTimeKeys map[string]map[string]string
- Res *gomatrixserverlib.RespClaimKeys
- Err *api.FederationClientError
}
func (h *httpFederationInternalAPI) ClaimKeys(
ctx context.Context, s gomatrixserverlib.ServerName, oneTimeKeys map[string]map[string]string,
) (gomatrixserverlib.RespClaimKeys, error) {
- span, ctx := opentracing.StartSpanFromContext(ctx, "ClaimKeys")
- defer span.Finish()
-
- var result gomatrixserverlib.RespClaimKeys
- request := claimKeys{
- S: s,
- OneTimeKeys: oneTimeKeys,
- }
- var response claimKeys
- apiURL := h.federationAPIURL + FederationAPIClaimKeysPath
- err := httputil.PostJSON(ctx, span, h.httpClient, apiURL, &request, &response)
- if err != nil {
- return result, err
- }
- if response.Err != nil {
- return result, response.Err
- }
- return *response.Res, nil
+ return httputil.CallInternalProxyAPI[claimKeys, gomatrixserverlib.RespClaimKeys, *api.FederationClientError](
+ "ClaimKeys", h.federationAPIURL+FederationAPIClaimKeysPath, h.httpClient,
+ ctx, &claimKeys{
+ S: s,
+ OneTimeKeys: oneTimeKeys,
+ },
+ )
}
type queryKeys struct {
S gomatrixserverlib.ServerName
Keys map[string][]string
- Res *gomatrixserverlib.RespQueryKeys
- Err *api.FederationClientError
}
func (h *httpFederationInternalAPI) QueryKeys(
ctx context.Context, s gomatrixserverlib.ServerName, keys map[string][]string,
) (gomatrixserverlib.RespQueryKeys, error) {
- span, ctx := opentracing.StartSpanFromContext(ctx, "QueryKeys")
- defer span.Finish()
-
- var result gomatrixserverlib.RespQueryKeys
- request := queryKeys{
- S: s,
- Keys: keys,
- }
- var response queryKeys
- apiURL := h.federationAPIURL + FederationAPIQueryKeysPath
- err := httputil.PostJSON(ctx, span, h.httpClient, apiURL, &request, &response)
- if err != nil {
- return result, err
- }
- if response.Err != nil {
- return result, response.Err
- }
- return *response.Res, nil
+ return httputil.CallInternalProxyAPI[queryKeys, gomatrixserverlib.RespQueryKeys, *api.FederationClientError](
+ "QueryKeys", h.federationAPIURL+FederationAPIQueryKeysPath, h.httpClient,
+ ctx, &queryKeys{
+ S: s,
+ Keys: keys,
+ },
+ )
}
type backfill struct {
@@ -250,32 +206,20 @@ type backfill struct {
RoomID string
Limit int
EventIDs []string
- Res *gomatrixserverlib.Transaction
- Err *api.FederationClientError
}
func (h *httpFederationInternalAPI) Backfill(
ctx context.Context, s gomatrixserverlib.ServerName, roomID string, limit int, eventIDs []string,
) (gomatrixserverlib.Transaction, error) {
- span, ctx := opentracing.StartSpanFromContext(ctx, "Backfill")
- defer span.Finish()
-
- request := backfill{
- S: s,
- RoomID: roomID,
- Limit: limit,
- EventIDs: eventIDs,
- }
- var response backfill
- apiURL := h.federationAPIURL + FederationAPIBackfillPath
- err := httputil.PostJSON(ctx, span, h.httpClient, apiURL, &request, &response)
- if err != nil {
- return gomatrixserverlib.Transaction{}, err
- }
- if response.Err != nil {
- return gomatrixserverlib.Transaction{}, response.Err
- }
- return *response.Res, nil
+ return httputil.CallInternalProxyAPI[backfill, gomatrixserverlib.Transaction, *api.FederationClientError](
+ "Backfill", h.federationAPIURL+FederationAPIBackfillPath, h.httpClient,
+ ctx, &backfill{
+ S: s,
+ RoomID: roomID,
+ Limit: limit,
+ EventIDs: eventIDs,
+ },
+ )
}
type lookupState struct {
@@ -283,63 +227,39 @@ type lookupState struct {
RoomID string
EventID string
RoomVersion gomatrixserverlib.RoomVersion
- Res *gomatrixserverlib.RespState
- Err *api.FederationClientError
}
func (h *httpFederationInternalAPI) LookupState(
ctx context.Context, s gomatrixserverlib.ServerName, roomID, eventID string, roomVersion gomatrixserverlib.RoomVersion,
) (gomatrixserverlib.RespState, error) {
- span, ctx := opentracing.StartSpanFromContext(ctx, "LookupState")
- defer span.Finish()
-
- request := lookupState{
- S: s,
- RoomID: roomID,
- EventID: eventID,
- RoomVersion: roomVersion,
- }
- var response lookupState
- apiURL := h.federationAPIURL + FederationAPILookupStatePath
- err := httputil.PostJSON(ctx, span, h.httpClient, apiURL, &request, &response)
- if err != nil {
- return gomatrixserverlib.RespState{}, err
- }
- if response.Err != nil {
- return gomatrixserverlib.RespState{}, response.Err
- }
- return *response.Res, nil
+ return httputil.CallInternalProxyAPI[lookupState, gomatrixserverlib.RespState, *api.FederationClientError](
+ "LookupState", h.federationAPIURL+FederationAPILookupStatePath, h.httpClient,
+ ctx, &lookupState{
+ S: s,
+ RoomID: roomID,
+ EventID: eventID,
+ RoomVersion: roomVersion,
+ },
+ )
}
type lookupStateIDs struct {
S gomatrixserverlib.ServerName
RoomID string
EventID string
- Res *gomatrixserverlib.RespStateIDs
- Err *api.FederationClientError
}
func (h *httpFederationInternalAPI) LookupStateIDs(
ctx context.Context, s gomatrixserverlib.ServerName, roomID, eventID string,
) (gomatrixserverlib.RespStateIDs, error) {
- span, ctx := opentracing.StartSpanFromContext(ctx, "LookupStateIDs")
- defer span.Finish()
-
- request := lookupStateIDs{
- S: s,
- RoomID: roomID,
- EventID: eventID,
- }
- var response lookupStateIDs
- apiURL := h.federationAPIURL + FederationAPILookupStateIDsPath
- err := httputil.PostJSON(ctx, span, h.httpClient, apiURL, &request, &response)
- if err != nil {
- return gomatrixserverlib.RespStateIDs{}, err
- }
- if response.Err != nil {
- return gomatrixserverlib.RespStateIDs{}, response.Err
- }
- return *response.Res, nil
+ return httputil.CallInternalProxyAPI[lookupStateIDs, gomatrixserverlib.RespStateIDs, *api.FederationClientError](
+ "LookupStateIDs", h.federationAPIURL+FederationAPILookupStateIDsPath, h.httpClient,
+ ctx, &lookupStateIDs{
+ S: s,
+ RoomID: roomID,
+ EventID: eventID,
+ },
+ )
}
type lookupMissingEvents struct {
@@ -347,64 +267,38 @@ type lookupMissingEvents struct {
RoomID string
Missing gomatrixserverlib.MissingEvents
RoomVersion gomatrixserverlib.RoomVersion
- Res struct {
- Events []gomatrixserverlib.RawJSON `json:"events"`
- }
- Err *api.FederationClientError
}
func (h *httpFederationInternalAPI) LookupMissingEvents(
ctx context.Context, s gomatrixserverlib.ServerName, roomID string,
missing gomatrixserverlib.MissingEvents, roomVersion gomatrixserverlib.RoomVersion,
) (res gomatrixserverlib.RespMissingEvents, err error) {
- span, ctx := opentracing.StartSpanFromContext(ctx, "LookupMissingEvents")
- defer span.Finish()
-
- request := lookupMissingEvents{
- S: s,
- RoomID: roomID,
- Missing: missing,
- RoomVersion: roomVersion,
- }
- apiURL := h.federationAPIURL + FederationAPILookupMissingEventsPath
- err = httputil.PostJSON(ctx, span, h.httpClient, apiURL, &request, &request)
- if err != nil {
- return res, err
- }
- if request.Err != nil {
- return res, request.Err
- }
- res.Events = request.Res.Events
- return res, nil
+ return httputil.CallInternalProxyAPI[lookupMissingEvents, gomatrixserverlib.RespMissingEvents, *api.FederationClientError](
+ "LookupMissingEvents", h.federationAPIURL+FederationAPILookupMissingEventsPath, h.httpClient,
+ ctx, &lookupMissingEvents{
+ S: s,
+ RoomID: roomID,
+ Missing: missing,
+ RoomVersion: roomVersion,
+ },
+ )
}
type getEvent struct {
S gomatrixserverlib.ServerName
EventID string
- Res *gomatrixserverlib.Transaction
- Err *api.FederationClientError
}
func (h *httpFederationInternalAPI) GetEvent(
ctx context.Context, s gomatrixserverlib.ServerName, eventID string,
) (gomatrixserverlib.Transaction, error) {
- span, ctx := opentracing.StartSpanFromContext(ctx, "GetEvent")
- defer span.Finish()
-
- request := getEvent{
- S: s,
- EventID: eventID,
- }
- var response getEvent
- apiURL := h.federationAPIURL + FederationAPIGetEventPath
- err := httputil.PostJSON(ctx, span, h.httpClient, apiURL, &request, &response)
- if err != nil {
- return gomatrixserverlib.Transaction{}, err
- }
- if response.Err != nil {
- return gomatrixserverlib.Transaction{}, response.Err
- }
- return *response.Res, nil
+ return httputil.CallInternalProxyAPI[getEvent, gomatrixserverlib.Transaction, *api.FederationClientError](
+ "GetEvent", h.federationAPIURL+FederationAPIGetEventPath, h.httpClient,
+ ctx, &getEvent{
+ S: s,
+ EventID: eventID,
+ },
+ )
}
type getEventAuth struct {
@@ -412,135 +306,86 @@ type getEventAuth struct {
RoomVersion gomatrixserverlib.RoomVersion
RoomID string
EventID string
- Res *gomatrixserverlib.RespEventAuth
- Err *api.FederationClientError
}
func (h *httpFederationInternalAPI) GetEventAuth(
ctx context.Context, s gomatrixserverlib.ServerName,
roomVersion gomatrixserverlib.RoomVersion, roomID, eventID string,
) (gomatrixserverlib.RespEventAuth, error) {
- span, ctx := opentracing.StartSpanFromContext(ctx, "GetEventAuth")
- defer span.Finish()
-
- request := getEventAuth{
- S: s,
- RoomVersion: roomVersion,
- RoomID: roomID,
- EventID: eventID,
- }
- var response getEventAuth
- apiURL := h.federationAPIURL + FederationAPIGetEventAuthPath
- err := httputil.PostJSON(ctx, span, h.httpClient, apiURL, &request, &response)
- if err != nil {
- return gomatrixserverlib.RespEventAuth{}, err
- }
- if response.Err != nil {
- return gomatrixserverlib.RespEventAuth{}, response.Err
- }
- return *response.Res, nil
+ return httputil.CallInternalProxyAPI[getEventAuth, gomatrixserverlib.RespEventAuth, *api.FederationClientError](
+ "GetEventAuth", h.federationAPIURL+FederationAPIGetEventAuthPath, h.httpClient,
+ ctx, &getEventAuth{
+ S: s,
+ RoomVersion: roomVersion,
+ RoomID: roomID,
+ EventID: eventID,
+ },
+ )
}
func (h *httpFederationInternalAPI) QueryServerKeys(
ctx context.Context, req *api.QueryServerKeysRequest, res *api.QueryServerKeysResponse,
) error {
- span, ctx := opentracing.StartSpanFromContext(ctx, "QueryServerKeys")
- defer span.Finish()
-
- apiURL := h.federationAPIURL + FederationAPIQueryServerKeysPath
- return httputil.PostJSON(ctx, span, h.httpClient, apiURL, req, res)
+ return httputil.CallInternalRPCAPI(
+ "QueryServerKeys", h.federationAPIURL+FederationAPIQueryServerKeysPath,
+ h.httpClient, ctx, req, res,
+ )
}
type lookupServerKeys struct {
S gomatrixserverlib.ServerName
KeyRequests map[gomatrixserverlib.PublicKeyLookupRequest]gomatrixserverlib.Timestamp
- ServerKeys []gomatrixserverlib.ServerKeys
- Err *api.FederationClientError
}
func (h *httpFederationInternalAPI) LookupServerKeys(
ctx context.Context, s gomatrixserverlib.ServerName, keyRequests map[gomatrixserverlib.PublicKeyLookupRequest]gomatrixserverlib.Timestamp,
) ([]gomatrixserverlib.ServerKeys, error) {
- span, ctx := opentracing.StartSpanFromContext(ctx, "LookupServerKeys")
- defer span.Finish()
-
- request := lookupServerKeys{
- S: s,
- KeyRequests: keyRequests,
- }
- var response lookupServerKeys
- apiURL := h.federationAPIURL + FederationAPILookupServerKeysPath
- err := httputil.PostJSON(ctx, span, h.httpClient, apiURL, &request, &response)
- if err != nil {
- return []gomatrixserverlib.ServerKeys{}, err
- }
- if response.Err != nil {
- return []gomatrixserverlib.ServerKeys{}, response.Err
- }
- return response.ServerKeys, nil
+ return httputil.CallInternalProxyAPI[lookupServerKeys, []gomatrixserverlib.ServerKeys, *api.FederationClientError](
+ "LookupServerKeys", h.federationAPIURL+FederationAPILookupServerKeysPath, h.httpClient,
+ ctx, &lookupServerKeys{
+ S: s,
+ KeyRequests: keyRequests,
+ },
+ )
}
type eventRelationships struct {
S gomatrixserverlib.ServerName
Req gomatrixserverlib.MSC2836EventRelationshipsRequest
RoomVer gomatrixserverlib.RoomVersion
- Res gomatrixserverlib.MSC2836EventRelationshipsResponse
- Err *api.FederationClientError
}
func (h *httpFederationInternalAPI) MSC2836EventRelationships(
ctx context.Context, s gomatrixserverlib.ServerName, r gomatrixserverlib.MSC2836EventRelationshipsRequest,
roomVersion gomatrixserverlib.RoomVersion,
) (res gomatrixserverlib.MSC2836EventRelationshipsResponse, err error) {
- span, ctx := opentracing.StartSpanFromContext(ctx, "MSC2836EventRelationships")
- defer span.Finish()
-
- request := eventRelationships{
- S: s,
- Req: r,
- RoomVer: roomVersion,
- }
- var response eventRelationships
- apiURL := h.federationAPIURL + FederationAPIEventRelationshipsPath
- err = httputil.PostJSON(ctx, span, h.httpClient, apiURL, &request, &response)
- if err != nil {
- return res, err
- }
- if response.Err != nil {
- return res, response.Err
- }
- return response.Res, nil
+ return httputil.CallInternalProxyAPI[eventRelationships, gomatrixserverlib.MSC2836EventRelationshipsResponse, *api.FederationClientError](
+ "MSC2836EventRelationships", h.federationAPIURL+FederationAPIEventRelationshipsPath, h.httpClient,
+ ctx, &eventRelationships{
+ S: s,
+ Req: r,
+ RoomVer: roomVersion,
+ },
+ )
}
type spacesReq struct {
S gomatrixserverlib.ServerName
SuggestedOnly bool
RoomID string
- Res gomatrixserverlib.MSC2946SpacesResponse
- Err *api.FederationClientError
}
func (h *httpFederationInternalAPI) MSC2946Spaces(
ctx context.Context, dst gomatrixserverlib.ServerName, roomID string, suggestedOnly bool,
) (res gomatrixserverlib.MSC2946SpacesResponse, err error) {
- span, ctx := opentracing.StartSpanFromContext(ctx, "MSC2946Spaces")
- defer span.Finish()
-
- request := spacesReq{
- S: dst,
- SuggestedOnly: suggestedOnly,
- RoomID: roomID,
- }
- var response spacesReq
- apiURL := h.federationAPIURL + FederationAPISpacesSummaryPath
- err = httputil.PostJSON(ctx, span, h.httpClient, apiURL, &request, &response)
- if err != nil {
- return res, err
- }
- if response.Err != nil {
- return res, response.Err
- }
- return response.Res, nil
+ return httputil.CallInternalProxyAPI[spacesReq, gomatrixserverlib.MSC2946SpacesResponse, *api.FederationClientError](
+ "MSC2836EventRelationships", h.federationAPIURL+FederationAPISpacesSummaryPath, h.httpClient,
+ ctx, &spacesReq{
+ S: dst,
+ SuggestedOnly: suggestedOnly,
+ RoomID: roomID,
+ },
+ )
}
func (s *httpFederationInternalAPI) KeyRing() *gomatrixserverlib.KeyRing {
@@ -614,11 +459,10 @@ func (h *httpFederationInternalAPI) InputPublicKeys(
request *api.InputPublicKeysRequest,
response *api.InputPublicKeysResponse,
) error {
- span, ctx := opentracing.StartSpanFromContext(ctx, "InputPublicKey")
- defer span.Finish()
-
- apiURL := h.federationAPIURL + FederationAPIInputPublicKeyPath
- return httputil.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
+ return httputil.CallInternalRPCAPI(
+ "InputPublicKey", h.federationAPIURL+FederationAPIInputPublicKeyPath,
+ h.httpClient, ctx, request, response,
+ )
}
func (h *httpFederationInternalAPI) QueryPublicKeys(
@@ -626,9 +470,8 @@ func (h *httpFederationInternalAPI) QueryPublicKeys(
request *api.QueryPublicKeysRequest,
response *api.QueryPublicKeysResponse,
) error {
- span, ctx := opentracing.StartSpanFromContext(ctx, "QueryPublicKey")
- defer span.Finish()
-
- apiURL := h.federationAPIURL + FederationAPIQueryPublicKeyPath
- return httputil.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
+ return httputil.CallInternalRPCAPI(
+ "QueryPublicKeys", h.federationAPIURL+FederationAPIQueryPublicKeyPath,
+ h.httpClient, ctx, request, response,
+ )
}
diff --git a/federationapi/inthttp/server.go b/federationapi/inthttp/server.go
index 28e52b32..a8b829a7 100644
--- a/federationapi/inthttp/server.go
+++ b/federationapi/inthttp/server.go
@@ -1,12 +1,14 @@
package inthttp
import (
+ "context"
"encoding/json"
"net/http"
"github.com/gorilla/mux"
"github.com/matrix-org/dendrite/federationapi/api"
"github.com/matrix-org/dendrite/internal/httputil"
+ "github.com/matrix-org/gomatrixserverlib"
"github.com/matrix-org/util"
)
@@ -15,372 +17,180 @@ import (
func AddRoutes(intAPI api.FederationInternalAPI, internalAPIMux *mux.Router) {
internalAPIMux.Handle(
FederationAPIQueryJoinedHostServerNamesInRoomPath,
- httputil.MakeInternalAPI("QueryJoinedHostServerNamesInRoom", func(req *http.Request) util.JSONResponse {
- var request api.QueryJoinedHostServerNamesInRoomRequest
- var response api.QueryJoinedHostServerNamesInRoomResponse
- if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
- return util.ErrorResponse(err)
- }
- if err := intAPI.QueryJoinedHostServerNamesInRoom(req.Context(), &request, &response); err != nil {
- return util.ErrorResponse(err)
- }
- return util.JSONResponse{Code: http.StatusOK, JSON: &response}
- }),
+ httputil.MakeInternalRPCAPI("FederationAPIQueryJoinedHostServerNamesInRoom", intAPI.QueryJoinedHostServerNamesInRoom),
)
+
internalAPIMux.Handle(
- FederationAPIPerformJoinRequestPath,
- httputil.MakeInternalAPI("PerformJoinRequest", func(req *http.Request) util.JSONResponse {
- var request api.PerformJoinRequest
- var response api.PerformJoinResponse
- if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
- return util.MessageResponse(http.StatusBadRequest, err.Error())
- }
- intAPI.PerformJoin(req.Context(), &request, &response)
- return util.JSONResponse{Code: http.StatusOK, JSON: &response}
- }),
+ FederationAPIPerformInviteRequestPath,
+ httputil.MakeInternalRPCAPI("FederationAPIPerformInvite", intAPI.PerformInvite),
)
+
internalAPIMux.Handle(
FederationAPIPerformLeaveRequestPath,
- httputil.MakeInternalAPI("PerformLeaveRequest", func(req *http.Request) util.JSONResponse {
- var request api.PerformLeaveRequest
- var response api.PerformLeaveResponse
- if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
- return util.MessageResponse(http.StatusBadRequest, err.Error())
- }
- if err := intAPI.PerformLeave(req.Context(), &request, &response); err != nil {
- return util.ErrorResponse(err)
- }
- return util.JSONResponse{Code: http.StatusOK, JSON: &response}
- }),
- )
- internalAPIMux.Handle(
- FederationAPIPerformInviteRequestPath,
- httputil.MakeInternalAPI("PerformInviteRequest", func(req *http.Request) util.JSONResponse {
- var request api.PerformInviteRequest
- var response api.PerformInviteResponse
- if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
- return util.MessageResponse(http.StatusBadRequest, err.Error())
- }
- if err := intAPI.PerformInvite(req.Context(), &request, &response); err != nil {
- return util.ErrorResponse(err)
- }
- return util.JSONResponse{Code: http.StatusOK, JSON: &response}
- }),
+ httputil.MakeInternalRPCAPI("FederationAPIPerformLeave", intAPI.PerformLeave),
)
+
internalAPIMux.Handle(
FederationAPIPerformDirectoryLookupRequestPath,
- httputil.MakeInternalAPI("PerformDirectoryLookupRequest", func(req *http.Request) util.JSONResponse {
- var request api.PerformDirectoryLookupRequest
- var response api.PerformDirectoryLookupResponse
- if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
- return util.MessageResponse(http.StatusBadRequest, err.Error())
- }
- if err := intAPI.PerformDirectoryLookup(req.Context(), &request, &response); err != nil {
- return util.ErrorResponse(err)
- }
- return util.JSONResponse{Code: http.StatusOK, JSON: &response}
- }),
+ httputil.MakeInternalRPCAPI("FederationAPIPerformDirectoryLookupRequest", intAPI.PerformDirectoryLookup),
)
+
internalAPIMux.Handle(
FederationAPIPerformBroadcastEDUPath,
- httputil.MakeInternalAPI("PerformBroadcastEDU", func(req *http.Request) util.JSONResponse {
- var request api.PerformBroadcastEDURequest
- var response api.PerformBroadcastEDUResponse
- if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
- return util.MessageResponse(http.StatusBadRequest, err.Error())
- }
- if err := intAPI.PerformBroadcastEDU(req.Context(), &request, &response); err != nil {
- return util.ErrorResponse(err)
- }
- return util.JSONResponse{Code: http.StatusOK, JSON: &response}
- }),
+ httputil.MakeInternalRPCAPI("FederationAPIPerformBroadcastEDU", intAPI.PerformBroadcastEDU),
)
+
+ internalAPIMux.Handle(
+ FederationAPIPerformJoinRequestPath,
+ httputil.MakeInternalRPCAPI(
+ "FederationAPIPerformJoinRequest",
+ func(ctx context.Context, req *api.PerformJoinRequest, res *api.PerformJoinResponse) error {
+ intAPI.PerformJoin(ctx, req, res)
+ return nil
+ },
+ ),
+ )
+
internalAPIMux.Handle(
FederationAPIGetUserDevicesPath,
- httputil.MakeInternalAPI("GetUserDevices", func(req *http.Request) util.JSONResponse {
- var request getUserDevices
- if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
- return util.MessageResponse(http.StatusBadRequest, err.Error())
- }
- res, err := intAPI.GetUserDevices(req.Context(), request.S, request.UserID)
- if err != nil {
- ferr, ok := err.(*api.FederationClientError)
- if ok {
- request.Err = ferr
- } else {
- request.Err = &api.FederationClientError{
- Err: err.Error(),
- }
- }
- }
- request.Res = &res
- return util.JSONResponse{Code: http.StatusOK, JSON: request}
- }),
+ httputil.MakeInternalProxyAPI(
+ "FederationAPIGetUserDevices",
+ func(ctx context.Context, req *getUserDevices) (*gomatrixserverlib.RespUserDevices, error) {
+ res, err := intAPI.GetUserDevices(ctx, req.S, req.UserID)
+ return &res, federationClientError(err)
+ },
+ ),
)
+
internalAPIMux.Handle(
FederationAPIClaimKeysPath,
- httputil.MakeInternalAPI("ClaimKeys", func(req *http.Request) util.JSONResponse {
- var request claimKeys
- if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
- return util.MessageResponse(http.StatusBadRequest, err.Error())
- }
- res, err := intAPI.ClaimKeys(req.Context(), request.S, request.OneTimeKeys)
- if err != nil {
- ferr, ok := err.(*api.FederationClientError)
- if ok {
- request.Err = ferr
- } else {
- request.Err = &api.FederationClientError{
- Err: err.Error(),
- }
- }
- }
- request.Res = &res
- return util.JSONResponse{Code: http.StatusOK, JSON: request}
- }),
+ httputil.MakeInternalProxyAPI(
+ "FederationAPIClaimKeys",
+ func(ctx context.Context, req *claimKeys) (*gomatrixserverlib.RespClaimKeys, error) {
+ res, err := intAPI.ClaimKeys(ctx, req.S, req.OneTimeKeys)
+ return &res, federationClientError(err)
+ },
+ ),
)
+
internalAPIMux.Handle(
FederationAPIQueryKeysPath,
- httputil.MakeInternalAPI("QueryKeys", func(req *http.Request) util.JSONResponse {
- var request queryKeys
- if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
- return util.MessageResponse(http.StatusBadRequest, err.Error())
- }
- res, err := intAPI.QueryKeys(req.Context(), request.S, request.Keys)
- if err != nil {
- ferr, ok := err.(*api.FederationClientError)
- if ok {
- request.Err = ferr
- } else {
- request.Err = &api.FederationClientError{
- Err: err.Error(),
- }
- }
- }
- request.Res = &res
- return util.JSONResponse{Code: http.StatusOK, JSON: request}
- }),
+ httputil.MakeInternalProxyAPI(
+ "FederationAPIQueryKeys",
+ func(ctx context.Context, req *queryKeys) (*gomatrixserverlib.RespQueryKeys, error) {
+ res, err := intAPI.QueryKeys(ctx, req.S, req.Keys)
+ return &res, federationClientError(err)
+ },
+ ),
)
+
internalAPIMux.Handle(
FederationAPIBackfillPath,
- httputil.MakeInternalAPI("Backfill", func(req *http.Request) util.JSONResponse {
- var request backfill
- if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
- return util.MessageResponse(http.StatusBadRequest, err.Error())
- }
- res, err := intAPI.Backfill(req.Context(), request.S, request.RoomID, request.Limit, request.EventIDs)
- if err != nil {
- ferr, ok := err.(*api.FederationClientError)
- if ok {
- request.Err = ferr
- } else {
- request.Err = &api.FederationClientError{
- Err: err.Error(),
- }
- }
- }
- request.Res = &res
- return util.JSONResponse{Code: http.StatusOK, JSON: request}
- }),
+ httputil.MakeInternalProxyAPI(
+ "FederationAPIBackfill",
+ func(ctx context.Context, req *backfill) (*gomatrixserverlib.Transaction, error) {
+ res, err := intAPI.Backfill(ctx, req.S, req.RoomID, req.Limit, req.EventIDs)
+ return &res, federationClientError(err)
+ },
+ ),
)
+
internalAPIMux.Handle(
FederationAPILookupStatePath,
- httputil.MakeInternalAPI("LookupState", func(req *http.Request) util.JSONResponse {
- var request lookupState
- if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
- return util.MessageResponse(http.StatusBadRequest, err.Error())
- }
- res, err := intAPI.LookupState(req.Context(), request.S, request.RoomID, request.EventID, request.RoomVersion)
- if err != nil {
- ferr, ok := err.(*api.FederationClientError)
- if ok {
- request.Err = ferr
- } else {
- request.Err = &api.FederationClientError{
- Err: err.Error(),
- }
- }
- }
- request.Res = &res
- return util.JSONResponse{Code: http.StatusOK, JSON: request}
- }),
+ httputil.MakeInternalProxyAPI(
+ "FederationAPILookupState",
+ func(ctx context.Context, req *lookupState) (*gomatrixserverlib.RespState, error) {
+ res, err := intAPI.LookupState(ctx, req.S, req.RoomID, req.EventID, req.RoomVersion)
+ return &res, federationClientError(err)
+ },
+ ),
)
+
internalAPIMux.Handle(
FederationAPILookupStateIDsPath,
- httputil.MakeInternalAPI("LookupStateIDs", func(req *http.Request) util.JSONResponse {
- var request lookupStateIDs
- if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
- return util.MessageResponse(http.StatusBadRequest, err.Error())
- }
- res, err := intAPI.LookupStateIDs(req.Context(), request.S, request.RoomID, request.EventID)
- if err != nil {
- ferr, ok := err.(*api.FederationClientError)
- if ok {
- request.Err = ferr
- } else {
- request.Err = &api.FederationClientError{
- Err: err.Error(),
- }
- }
- }
- request.Res = &res
- return util.JSONResponse{Code: http.StatusOK, JSON: request}
- }),
+ httputil.MakeInternalProxyAPI(
+ "FederationAPILookupStateIDs",
+ func(ctx context.Context, req *lookupStateIDs) (*gomatrixserverlib.RespStateIDs, error) {
+ res, err := intAPI.LookupStateIDs(ctx, req.S, req.RoomID, req.EventID)
+ return &res, federationClientError(err)
+ },
+ ),
)
+
internalAPIMux.Handle(
FederationAPILookupMissingEventsPath,
- httputil.MakeInternalAPI("LookupMissingEvents", func(req *http.Request) util.JSONResponse {
- var request lookupMissingEvents
- if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
- return util.MessageResponse(http.StatusBadRequest, err.Error())
- }
- res, err := intAPI.LookupMissingEvents(req.Context(), request.S, request.RoomID, request.Missing, request.RoomVersion)
- if err != nil {
- ferr, ok := err.(*api.FederationClientError)
- if ok {
- request.Err = ferr
- } else {
- request.Err = &api.FederationClientError{
- Err: err.Error(),
- }
- }
- }
- for _, event := range res.Events {
- js, err := json.Marshal(event)
- if err != nil {
- return util.MessageResponse(http.StatusInternalServerError, err.Error())
- }
- request.Res.Events = append(request.Res.Events, js)
- }
- return util.JSONResponse{Code: http.StatusOK, JSON: request}
- }),
+ httputil.MakeInternalProxyAPI(
+ "FederationAPILookupMissingEvents",
+ func(ctx context.Context, req *lookupMissingEvents) (*gomatrixserverlib.RespMissingEvents, error) {
+ res, err := intAPI.LookupMissingEvents(ctx, req.S, req.RoomID, req.Missing, req.RoomVersion)
+ return &res, federationClientError(err)
+ },
+ ),
)
+
internalAPIMux.Handle(
FederationAPIGetEventPath,
- httputil.MakeInternalAPI("GetEvent", func(req *http.Request) util.JSONResponse {
- var request getEvent
- if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
- return util.MessageResponse(http.StatusBadRequest, err.Error())
- }
- res, err := intAPI.GetEvent(req.Context(), request.S, request.EventID)
- if err != nil {
- ferr, ok := err.(*api.FederationClientError)
- if ok {
- request.Err = ferr
- } else {
- request.Err = &api.FederationClientError{
- Err: err.Error(),
- }
- }
- }
- request.Res = &res
- return util.JSONResponse{Code: http.StatusOK, JSON: request}
- }),
+ httputil.MakeInternalProxyAPI(
+ "FederationAPIGetEvent",
+ func(ctx context.Context, req *getEvent) (*gomatrixserverlib.Transaction, error) {
+ res, err := intAPI.GetEvent(ctx, req.S, req.EventID)
+ return &res, federationClientError(err)
+ },
+ ),
)
+
internalAPIMux.Handle(
FederationAPIGetEventAuthPath,
- httputil.MakeInternalAPI("GetEventAuth", func(req *http.Request) util.JSONResponse {
- var request getEventAuth
- if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
- return util.MessageResponse(http.StatusBadRequest, err.Error())
- }
- res, err := intAPI.GetEventAuth(req.Context(), request.S, request.RoomVersion, request.RoomID, request.EventID)
- if err != nil {
- ferr, ok := err.(*api.FederationClientError)
- if ok {
- request.Err = ferr
- } else {
- request.Err = &api.FederationClientError{
- Err: err.Error(),
- }
- }
- }
- request.Res = &res
- return util.JSONResponse{Code: http.StatusOK, JSON: request}
- }),
+ httputil.MakeInternalProxyAPI(
+ "FederationAPIGetEventAuth",
+ func(ctx context.Context, req *getEventAuth) (*gomatrixserverlib.RespEventAuth, error) {
+ res, err := intAPI.GetEventAuth(ctx, req.S, req.RoomVersion, req.RoomID, req.EventID)
+ return &res, federationClientError(err)
+ },
+ ),
)
+
internalAPIMux.Handle(
FederationAPIQueryServerKeysPath,
- httputil.MakeInternalAPI("QueryServerKeys", func(req *http.Request) util.JSONResponse {
- var request api.QueryServerKeysRequest
- var response api.QueryServerKeysResponse
- if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
- return util.MessageResponse(http.StatusBadRequest, err.Error())
- }
- if err := intAPI.QueryServerKeys(req.Context(), &request, &response); err != nil {
- return util.ErrorResponse(err)
- }
- return util.JSONResponse{Code: http.StatusOK, JSON: &response}
- }),
+ httputil.MakeInternalRPCAPI("FederationAPIQueryServerKeys", intAPI.QueryServerKeys),
)
+
internalAPIMux.Handle(
FederationAPILookupServerKeysPath,
- httputil.MakeInternalAPI("LookupServerKeys", func(req *http.Request) util.JSONResponse {
- var request lookupServerKeys
- if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
- return util.MessageResponse(http.StatusBadRequest, err.Error())
- }
- res, err := intAPI.LookupServerKeys(req.Context(), request.S, request.KeyRequests)
- if err != nil {
- ferr, ok := err.(*api.FederationClientError)
- if ok {
- request.Err = ferr
- } else {
- request.Err = &api.FederationClientError{
- Err: err.Error(),
- }
- }
- }
- request.ServerKeys = res
- return util.JSONResponse{Code: http.StatusOK, JSON: request}
- }),
+ httputil.MakeInternalProxyAPI(
+ "FederationAPILookupServerKeys",
+ func(ctx context.Context, req *lookupServerKeys) (*[]gomatrixserverlib.ServerKeys, error) {
+ res, err := intAPI.LookupServerKeys(ctx, req.S, req.KeyRequests)
+ return &res, federationClientError(err)
+ },
+ ),
)
+
internalAPIMux.Handle(
FederationAPIEventRelationshipsPath,
- httputil.MakeInternalAPI("MSC2836EventRelationships", func(req *http.Request) util.JSONResponse {
- var request eventRelationships
- if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
- return util.MessageResponse(http.StatusBadRequest, err.Error())
- }
- res, err := intAPI.MSC2836EventRelationships(req.Context(), request.S, request.Req, request.RoomVer)
- if err != nil {
- ferr, ok := err.(*api.FederationClientError)
- if ok {
- request.Err = ferr
- } else {
- request.Err = &api.FederationClientError{
- Err: err.Error(),
- }
- }
- }
- request.Res = res
- return util.JSONResponse{Code: http.StatusOK, JSON: request}
- }),
+ httputil.MakeInternalProxyAPI(
+ "FederationAPIMSC2836EventRelationships",
+ func(ctx context.Context, req *eventRelationships) (*gomatrixserverlib.MSC2836EventRelationshipsResponse, error) {
+ res, err := intAPI.MSC2836EventRelationships(ctx, req.S, req.Req, req.RoomVer)
+ return &res, federationClientError(err)
+ },
+ ),
)
+
internalAPIMux.Handle(
FederationAPISpacesSummaryPath,
- httputil.MakeInternalAPI("MSC2946SpacesSummary", func(req *http.Request) util.JSONResponse {
- var request spacesReq
- if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
- return util.MessageResponse(http.StatusBadRequest, err.Error())
- }
- res, err := intAPI.MSC2946Spaces(req.Context(), request.S, request.RoomID, request.SuggestedOnly)
- if err != nil {
- ferr, ok := err.(*api.FederationClientError)
- if ok {
- request.Err = ferr
- } else {
- request.Err = &api.FederationClientError{
- Err: err.Error(),
- }
- }
- }
- request.Res = res
- return util.JSONResponse{Code: http.StatusOK, JSON: request}
- }),
+ httputil.MakeInternalProxyAPI(
+ "FederationAPIMSC2946SpacesSummary",
+ func(ctx context.Context, req *spacesReq) (*gomatrixserverlib.MSC2946SpacesResponse, error) {
+ res, err := intAPI.MSC2946Spaces(ctx, req.S, req.RoomID, req.SuggestedOnly)
+ return &res, federationClientError(err)
+ },
+ ),
)
+
+ // TODO: Look at this shape
internalAPIMux.Handle(FederationAPIQueryPublicKeyPath,
- httputil.MakeInternalAPI("queryPublicKeys", func(req *http.Request) util.JSONResponse {
+ httputil.MakeInternalAPI("FederationAPIQueryPublicKeys", func(req *http.Request) util.JSONResponse {
request := api.QueryPublicKeysRequest{}
response := api.QueryPublicKeysResponse{}
if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
@@ -394,8 +204,10 @@ func AddRoutes(intAPI api.FederationInternalAPI, internalAPIMux *mux.Router) {
return util.JSONResponse{Code: http.StatusOK, JSON: &response}
}),
)
+
+ // TODO: Look at this shape
internalAPIMux.Handle(FederationAPIInputPublicKeyPath,
- httputil.MakeInternalAPI("inputPublicKeys", func(req *http.Request) util.JSONResponse {
+ httputil.MakeInternalAPI("FederationAPIInputPublicKeys", func(req *http.Request) util.JSONResponse {
request := api.InputPublicKeysRequest{}
response := api.InputPublicKeysResponse{}
if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
@@ -408,3 +220,18 @@ func AddRoutes(intAPI api.FederationInternalAPI, internalAPIMux *mux.Router) {
}),
)
}
+
+func federationClientError(err error) error {
+ switch ferr := err.(type) {
+ case nil:
+ return nil
+ case api.FederationClientError:
+ return &ferr
+ case *api.FederationClientError:
+ return ferr
+ default:
+ return &api.FederationClientError{
+ Err: err.Error(),
+ }
+ }
+}
generated by cgit v1.2.3 (git 2.26.2) at 2024-12-21 10:49:15 +0000