Convert eduserver to new inthttp format

cmd/dendrite-monolith-server/main.go

@@ -90,7 +90,7 @@ func main() {
 		base, cache.New(), deviceDB,
 	)
 	if base.UseHTTPAPIs {
-		eduInputAPI = base.CreateHTTPEDUServerAPIs()
+		eduInputAPI = base.EDUServerClient()
 	}
 
 	asAPI := appservice.SetupAppServiceAPIComponent(

eduserver/api/input.go

@@ -19,12 +19,8 @@ package api
 
 import (
 	"context"
-	"errors"
-	"net/http"
 
-	internalHTTP "github.com/matrix-org/dendrite/internal/http"
 	"github.com/matrix-org/gomatrixserverlib"
-	opentracing "github.com/opentracing/opentracing-go"
 )
 
 // InputTypingEvent is an event for notifying the typing server about typing updates.
@@ -77,48 +73,3 @@ type EDUServerInputAPI interface {
 		response *InputSendToDeviceEventResponse,
 	) error
 }
-
-// EDUServerInputTypingEventPath is the HTTP path for the InputTypingEvent API.
-const EDUServerInputTypingEventPath = "/eduserver/input"
-
-// EDUServerInputSendToDeviceEventPath is the HTTP path for the InputSendToDeviceEvent API.
-const EDUServerInputSendToDeviceEventPath = "/eduserver/sendToDevice"
-
-// NewEDUServerInputAPIHTTP creates a EDUServerInputAPI implemented by talking to a HTTP POST API.
-func NewEDUServerInputAPIHTTP(eduServerURL string, httpClient *http.Client) (EDUServerInputAPI, error) {
-	if httpClient == nil {
-		return nil, errors.New("NewTypingServerInputAPIHTTP: httpClient is <nil>")
-	}
-	return &httpEDUServerInputAPI{eduServerURL, httpClient}, nil
-}
-
-type httpEDUServerInputAPI struct {
-	eduServerURL string
-	httpClient   *http.Client
-}
-
-// InputTypingEvent implements EDUServerInputAPI
-func (h *httpEDUServerInputAPI) InputTypingEvent(
-	ctx context.Context,
-	request *InputTypingEventRequest,
-	response *InputTypingEventResponse,
-) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "InputTypingEvent")
-	defer span.Finish()
-
-	apiURL := h.eduServerURL + EDUServerInputTypingEventPath
-	return internalHTTP.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
-}
-
-// InputSendToDeviceEvent implements EDUServerInputAPI
-func (h *httpEDUServerInputAPI) InputSendToDeviceEvent(
-	ctx context.Context,
-	request *InputSendToDeviceEventRequest,
-	response *InputSendToDeviceEventResponse,
-) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "InputSendToDeviceEvent")
-	defer span.Finish()
-
-	apiURL := h.eduServerURL + EDUServerInputSendToDeviceEventPath
-	return internalHTTP.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
-}

eduserver/eduserver.go

@@ -21,6 +21,7 @@ import (
 	"github.com/matrix-org/dendrite/eduserver/api"
 	"github.com/matrix-org/dendrite/eduserver/cache"
 	"github.com/matrix-org/dendrite/eduserver/input"
+	"github.com/matrix-org/dendrite/eduserver/inthttp"
 	"github.com/matrix-org/dendrite/internal/basecomponent"
 )
 
@@ -42,7 +43,7 @@ func SetupEDUServerComponent(
 		ServerName:                   base.Cfg.Matrix.ServerName,
 	}
 
-	inputAPI.SetupHTTP(base.InternalAPIMux)
+	inthttp.AddRoutes(inputAPI, base.InternalAPIMux)
 
 	return inputAPI
 }

eduserver/input/input.go

@@ -19,17 +19,13 @@ package input
 import (
 	"context"
 	"encoding/json"
-	"net/http"
 	"time"
 
 	"github.com/Shopify/sarama"
-	"github.com/gorilla/mux"
 	"github.com/matrix-org/dendrite/clientapi/auth/storage/devices"
 	"github.com/matrix-org/dendrite/eduserver/api"
 	"github.com/matrix-org/dendrite/eduserver/cache"
-	"github.com/matrix-org/dendrite/internal"
 	"github.com/matrix-org/gomatrixserverlib"
-	"github.com/matrix-org/util"
 	"github.com/sirupsen/logrus"
 )
 
@@ -170,33 +166,3 @@ func (t *EDUServerInputAPI) sendToDeviceEvent(ise *api.InputSendToDeviceEvent) e
 
 	return nil
 }
-
-// SetupHTTP adds the EDUServerInputAPI handlers to the http.ServeMux.
-func (t *EDUServerInputAPI) SetupHTTP(internalAPIMux *mux.Router) {
-	internalAPIMux.Handle(api.EDUServerInputTypingEventPath,
-		internal.MakeInternalAPI("inputTypingEvents", func(req *http.Request) util.JSONResponse {
-			var request api.InputTypingEventRequest
-			var response api.InputTypingEventResponse
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := t.InputTypingEvent(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
-	)
-	internalAPIMux.Handle(api.EDUServerInputSendToDeviceEventPath,
-		internal.MakeInternalAPI("inputSendToDeviceEvents", func(req *http.Request) util.JSONResponse {
-			var request api.InputSendToDeviceEventRequest
-			var response api.InputSendToDeviceEventResponse
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := t.InputSendToDeviceEvent(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
-	)
-}

eduserver/inthttp/client.go

@@ -0,0 +1,56 @@
+package inthttp
+
+import (
+	"context"
+	"errors"
+	"net/http"
+
+	"github.com/matrix-org/dendrite/eduserver/api"
+	internalHTTP "github.com/matrix-org/dendrite/internal/http"
+	"github.com/opentracing/opentracing-go"
+)
+
+// HTTP paths for the internal HTTP APIs
+const (
+	EDUServerInputTypingEventPath       = "/eduserver/input"
+	EDUServerInputSendToDeviceEventPath = "/eduserver/sendToDevice"
+)
+
+// NewEDUServerClient creates a EDUServerInputAPI implemented by talking to a HTTP POST API.
+func NewEDUServerClient(eduServerURL string, httpClient *http.Client) (api.EDUServerInputAPI, error) {
+	if httpClient == nil {
+		return nil, errors.New("NewEDUServerClient: httpClient is <nil>")
+	}
+	return &httpEDUServerInputAPI{eduServerURL, httpClient}, nil
+}
+
+type httpEDUServerInputAPI struct {
+	eduServerURL string
+	httpClient   *http.Client
+}
+
+// InputTypingEvent implements EDUServerInputAPI
+func (h *httpEDUServerInputAPI) InputTypingEvent(
+	ctx context.Context,
+	request *api.InputTypingEventRequest,
+	response *api.InputTypingEventResponse,
+) error {
+	span, ctx := opentracing.StartSpanFromContext(ctx, "InputTypingEvent")
+	defer span.Finish()
+
+	apiURL := h.eduServerURL + EDUServerInputTypingEventPath
+	return internalHTTP.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
+}
+
+// InputSendToDeviceEvent implements EDUServerInputAPI
+func (h *httpEDUServerInputAPI) InputSendToDeviceEvent(
+	ctx context.Context,
+	request *api.InputSendToDeviceEventRequest,
+	response *api.InputSendToDeviceEventResponse,
+) error {
+	span, ctx := opentracing.StartSpanFromContext(ctx, "InputSendToDeviceEvent")
+	defer span.Finish()
+
+	apiURL := h.eduServerURL + EDUServerInputSendToDeviceEventPath
+	return internalHTTP.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
+}

eduserver/inthttp/server.go

@@ -0,0 +1,41 @@
+package inthttp
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"github.com/gorilla/mux"
+	"github.com/matrix-org/dendrite/eduserver/api"
+	"github.com/matrix-org/dendrite/internal"
+	"github.com/matrix-org/util"
+)
+
+// AddRoutes adds the EDUServerInputAPI handlers to the http.ServeMux.
+func AddRoutes(t api.EDUServerInputAPI, internalAPIMux *mux.Router) {
+	internalAPIMux.Handle(EDUServerInputTypingEventPath,
+		internal.MakeInternalAPI("inputTypingEvents", func(req *http.Request) util.JSONResponse {
+			var request api.InputTypingEventRequest
+			var response api.InputTypingEventResponse
+			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
+				return util.MessageResponse(http.StatusBadRequest, err.Error())
+			}
+			if err := t.InputTypingEvent(req.Context(), &request, &response); err != nil {
+				return util.ErrorResponse(err)
+			}
+			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
+		}),
+	)
+	internalAPIMux.Handle(EDUServerInputSendToDeviceEventPath,
+		internal.MakeInternalAPI("inputSendToDeviceEvents", func(req *http.Request) util.JSONResponse {
+			var request api.InputSendToDeviceEventRequest
+			var response api.InputSendToDeviceEventResponse
+			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
+				return util.MessageResponse(http.StatusBadRequest, err.Error())
+			}
+			if err := t.InputSendToDeviceEvent(req.Context(), &request, &response); err != nil {
+				return util.ErrorResponse(err)
+			}
+			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
+		}),
+	)
+}

internal/basecomponent/base.go

@@ -37,6 +37,7 @@ import (
 
 	appserviceAPI "github.com/matrix-org/dendrite/appservice/api"
 	eduServerAPI "github.com/matrix-org/dendrite/eduserver/api"
+	eduinthttp "github.com/matrix-org/dendrite/eduserver/inthttp"
 	federationSenderAPI "github.com/matrix-org/dendrite/federationsender/api"
 	"github.com/matrix-org/dendrite/federationsender/inthttp"
 	"github.com/matrix-org/dendrite/internal/config"
@@ -151,17 +152,16 @@ func (b *BaseDendrite) CreateHTTPAppServiceAPIs() appserviceAPI.AppServiceQueryA
 func (b *BaseDendrite) RoomserverHTTPClient() roomserverAPI.RoomserverInternalAPI {
 	rsAPI, err := rsinthttp.NewRoomserverClient(b.Cfg.RoomServerURL(), b.httpClient, b.ImmutableCache)
 	if err != nil {
-		logrus.WithError(err).Panic("NewRoomserverInternalAPIHTTP failed", b.httpClient)
+		logrus.WithError(err).Panic("RoomserverHTTPClient failed", b.httpClient)
 	}
 	return rsAPI
 }
 
-// CreateHTTPEDUServerAPIs returns eduInputAPI for hitting the EDU
+// EDUServerClient returns EDUServerInputAPI for hitting the EDU server over HTTP
-// server over HTTP
+func (b *BaseDendrite) EDUServerClient() eduServerAPI.EDUServerInputAPI {
-func (b *BaseDendrite) CreateHTTPEDUServerAPIs() eduServerAPI.EDUServerInputAPI {
+	e, err := eduinthttp.NewEDUServerClient(b.Cfg.EDUServerURL(), b.httpClient)
-	e, err := eduServerAPI.NewEDUServerInputAPIHTTP(b.Cfg.EDUServerURL(), b.httpClient)
 	if err != nil {
-		logrus.WithError(err).Panic("NewEDUServerInputAPIHTTP failed", b.httpClient)
+		logrus.WithError(err).Panic("EDUServerClient failed", b.httpClient)
 	}
 	return e
 }
@@ -171,7 +171,7 @@ func (b *BaseDendrite) CreateHTTPEDUServerAPIs() eduServerAPI.EDUServerInputAPI
 func (b *BaseDendrite) FederationSenderHTTPClient() federationSenderAPI.FederationSenderInternalAPI {
 	f, err := inthttp.NewFederationSenderClient(b.Cfg.FederationSenderURL(), b.httpClient)
 	if err != nil {
-		logrus.WithError(err).Panic("NewFederationSenderInternalAPIHTTP failed", b.httpClient)
+		logrus.WithError(err).Panic("FederationSenderHTTPClient failed", b.httpClient)
 	}
 	return f
 }

syncapi/api/query.go

@@ -1,123 +0,0 @@
-// Copyright 2020 The Matrix.org Foundation C.I.C.
-//
-// 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
-
-import (
-	"context"
-	"net/http"
-
-	internalHTTP "github.com/matrix-org/dendrite/internal/http"
-	"github.com/matrix-org/util"
-	opentracing "github.com/opentracing/opentracing-go"
-)
-
-const (
-	SyncAPIQuerySyncPath      = "/syncapi/querySync"
-	SyncAPIQueryStatePath     = "/syncapi/queryState"
-	SyncAPIQueryStateTypePath = "/syncapi/queryStateType"
-	SyncAPIQueryMessagesPath  = "/syncapi/queryMessages"
-)
-
-func NewSyncQueryAPIHTTP(syncapiURL string, httpClient *http.Client) SyncQueryAPI {
-	if httpClient == nil {
-		httpClient = http.DefaultClient
-	}
-	return &httpSyncQueryAPI{syncapiURL, httpClient}
-}
-
-type httpSyncQueryAPI struct {
-	syncapiURL string
-	httpClient *http.Client
-}
-
-type SyncQueryAPI interface {
-	QuerySync(ctx context.Context, request *QuerySyncRequest, response *QuerySyncResponse) error
-	QueryState(ctx context.Context, request *QueryStateRequest, response *QueryStateResponse) error
-	QueryStateType(ctx context.Context, request *QueryStateTypeRequest, response *QueryStateTypeResponse) error
-	QueryMessages(ctx context.Context, request *QueryMessagesRequest, response *QueryMessagesResponse) error
-}
-
-type QuerySyncRequest struct{}
-
-type QueryStateRequest struct {
-	RoomID string
-}
-
-type QueryStateTypeRequest struct {
-	RoomID    string
-	EventType string
-	StateKey  string
-}
-
-type QueryMessagesRequest struct {
-	RoomID string
-}
-
-type QuerySyncResponse util.JSONResponse
-type QueryStateResponse util.JSONResponse
-type QueryStateTypeResponse util.JSONResponse
-type QueryMessagesResponse util.JSONResponse
-
-// QueryLatestEventsAndState implements SyncQueryAPI
-func (h *httpSyncQueryAPI) QuerySync(
-	ctx context.Context,
-	request *QuerySyncRequest,
-	response *QuerySyncResponse,
-) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "QuerySync")
-	defer span.Finish()
-
-	apiURL := h.syncapiURL + SyncAPIQuerySyncPath
-	return internalHTTP.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
-}
-
-// QueryStateAfterEvents implements SyncQueryAPI
-func (h *httpSyncQueryAPI) QueryState(
-	ctx context.Context,
-	request *QueryStateRequest,
-	response *QueryStateResponse,
-) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "QueryState")
-	defer span.Finish()
-
-	apiURL := h.syncapiURL + SyncAPIQueryStatePath
-	return internalHTTP.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
-}
-
-// QueryEventsByID implements SyncQueryAPI
-func (h *httpSyncQueryAPI) QueryStateType(
-	ctx context.Context,
-	request *QueryStateTypeRequest,
-	response *QueryStateTypeResponse,
-) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "QueryStateType")
-	defer span.Finish()
-
-	apiURL := h.syncapiURL + SyncAPIQueryStateTypePath
-	return internalHTTP.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
-}
-
-// QueryMembershipForUser implements SyncQueryAPI
-func (h *httpSyncQueryAPI) QueryMessages(
-	ctx context.Context,
-	request *QueryMessagesRequest,
-	response *QueryMessagesResponse,
-) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "QueryMessages")
-	defer span.Finish()
-
-	apiURL := h.syncapiURL + SyncAPIQueryMessagesPath
-	return internalHTTP.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
-}