Remove direct dependency on gorilla mux (#384)

Signed-off-by: Daniel Weiße <[email protected]>

Author: daniel-weisse

Diff for: coordinator/server/client_api.go

@@ -409,6 +409,20 @@ func (s *clientAPIServer) secretsPost(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, nil)
 }
 
+func (s *clientAPIServer) handleGetPost(getHandler, postHandler func(http.ResponseWriter, *http.Request),
+) func(http.ResponseWriter, *http.Request) {
+	return func(w http.ResponseWriter, r *http.Request) {
+		switch r.Method {
+		case http.MethodGet:
+			getHandler(w, r)
+		case http.MethodPost:
+			postHandler(w, r)
+		default:
+			s.methodNotAllowedHandler(w, r)
+		}
+	}
+}
+
 func (s *clientAPIServer) methodNotAllowedHandler(w http.ResponseWriter, r *http.Request) {
 	writeJSONError(w, "", http.StatusMethodNotAllowed)
 }

Diff for: coordinator/server/metrics.go

@@ -9,22 +9,21 @@ package server
 import (
 	"net/http"
 
-	"github.com/gorilla/mux"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 )
 
 // serveMux is an interface of an HTTP request multiplexer.
 type serveMux interface {
-	Handle(pattern string, handler http.Handler) *mux.Route
-	HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request)) *mux.Route
+	Handle(pattern string, handler http.Handler)
+	HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request))
 	ServeHTTP(w http.ResponseWriter, r *http.Request)
 }
 
 // httpMetrics is a struct of metrics for Prometheus to collect for each endpoint.
 type httpMetrics struct {
-	reqest       *prometheus.CounterVec
+	request      *prometheus.CounterVec
 	duration     *prometheus.HistogramVec
 	requestSize  *prometheus.HistogramVec
 	responseSize *prometheus.HistogramVec
@@ -35,7 +34,7 @@ type httpMetrics struct {
 // and registres them using the given factory.
 func newHTTPMetrics(factory *promauto.Factory, namespace string, subsystem string, constLabels map[string]string) *httpMetrics {
 	return &httpMetrics{
-		reqest: factory.NewCounterVec(
+		request: factory.NewCounterVec(
 			prometheus.CounterOpts{
 				Namespace:   namespace,
 				Subsystem:   subsystem,
@@ -93,7 +92,7 @@ func newHTTPMetrics(factory *promauto.Factory, namespace string, subsystem strin
 // promServeMux is a wrapper around mux.Router with additional instrumentation to
 // gather Prometheus metrics.
 type promServeMux struct {
-	router      *mux.Router
+	router      *http.ServeMux
 	promFactory *promauto.Factory
 	metrics     map[string]*httpMetrics
 	namespace   string
@@ -104,7 +103,7 @@ type promServeMux struct {
 // namespace and subsystem are used to name the exposed metrics.
 func newPromServeMux(factory *promauto.Factory, namespace string, subsystem string) *promServeMux {
 	return &promServeMux{
-		router:      mux.NewRouter(),
+		router:      http.NewServeMux(),
 		promFactory: factory,
 		metrics:     make(map[string]*httpMetrics),
 		namespace:   namespace,
@@ -114,22 +113,22 @@ func newPromServeMux(factory *promauto.Factory, namespace string, subsystem stri
 
 // Handle is a wrapper around (*mux.Router) Handle form the http package
 // A chain of prometheus instrumentation collects metrics for the given handler.
-func (p *promServeMux) Handle(pattern string, handler http.Handler) *mux.Route {
+func (p *promServeMux) Handle(pattern string, handler http.Handler) {
 	if p.metrics[pattern] == nil {
 		constLabels := map[string]string{
 			"path": pattern,
 		}
 		p.metrics[pattern] = newHTTPMetrics(p.promFactory, p.namespace, p.subsystem, constLabels)
 	}
-	return p.router.Handle(pattern, p.metricsMiddleware(pattern, handler))
+	p.router.Handle(pattern, p.metricsMiddleware(pattern, handler))
 }
 
 // HandleFunc registers the handler function for the given pattern.
-func (p *promServeMux) HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request)) *mux.Route {
+func (p *promServeMux) HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request)) {
 	if handler == nil {
 		panic("promServerMux: http: nil handler")
 	}
-	return p.Handle(pattern, http.HandlerFunc(handler))
+	p.Handle(pattern, http.HandlerFunc(handler))
 }
 
 // ServeHTTP is a wrapper around (*mux.Router) ServeHttp form the http package.
@@ -140,7 +139,7 @@ func (p *promServeMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 // metricsMiddelware returns the handed next handler wrapped in a bunch of prometheus metric handlers.
 func (p *promServeMux) metricsMiddleware(pattern string, next http.Handler) http.Handler {
 	return promhttp.InstrumentHandlerDuration(p.metrics[pattern].duration,
-		promhttp.InstrumentHandlerCounter(p.metrics[pattern].reqest,
+		promhttp.InstrumentHandlerCounter(p.metrics[pattern].request,
 			promhttp.InstrumentHandlerRequestSize(p.metrics[pattern].requestSize,
 				promhttp.InstrumentHandlerResponseSize(p.metrics[pattern].responseSize,
 					promhttp.InstrumentHandlerInFlight(p.metrics[pattern].inflight, next),
@@ -152,9 +151,11 @@ func (p *promServeMux) metricsMiddleware(pattern string, next http.Handler) http
 
 // setMethodNOtAllowedHandler sets f as instrumented handler for the mux.Router.
 func (p *promServeMux) setMethodNotAllowedHandler(f func(http.ResponseWriter, *http.Request)) {
-	p.router.MethodNotAllowedHandler = http.HandlerFunc(
+	p.router.HandleFunc(
+		"/",
 		func(w http.ResponseWriter, r *http.Request) {
 			handler := p.metricsMiddleware(r.URL.Path, http.HandlerFunc(f))
 			handler.ServeHTTP(w, r)
-		})
+		},
+	)
 }

Diff for: coordinator/server/metrics_test.go

@@ -69,15 +69,15 @@ func TestClientApiRequestMetrics(t *testing.T) {
 			mux := CreateServeMux(api, &fac)
 
 			metrics := mux.(*promServeMux).metrics[tc.target]
-			assert.Equal(0, promtest.CollectAndCount(metrics.reqest))
-			assert.Equal(float64(0), promtest.ToFloat64(metrics.reqest.WithLabelValues(tc.expectedStatusCode, strings.ToLower(tc.method))))
+			assert.Equal(0, promtest.CollectAndCount(metrics.request))
+			assert.Equal(float64(0), promtest.ToFloat64(metrics.request.WithLabelValues(tc.expectedStatusCode, strings.ToLower(tc.method))))
 
 			for i := 1; i < 6; i++ {
 				req := httptest.NewRequest(tc.method, tc.target, nil)
 				resp := httptest.NewRecorder()
 				mux.ServeHTTP(resp, req)
-				assert.Equal(1, promtest.CollectAndCount(metrics.reqest))
-				assert.Equal(float64(i), promtest.ToFloat64(metrics.reqest.WithLabelValues(tc.expectedStatusCode, strings.ToLower(tc.method))))
+				assert.Equal(1, promtest.CollectAndCount(metrics.request))
+				assert.Equal(float64(i), promtest.ToFloat64(metrics.request.WithLabelValues(tc.expectedStatusCode, strings.ToLower(tc.method))))
 			}
 		})
 	}

Diff for: coordinator/server/server.go

@@ -19,7 +19,6 @@ import (
 	"github.com/edgelesssys/marblerun/coordinator/rpc"
 	"github.com/edgelesssys/marblerun/coordinator/state"
 	"github.com/edgelesssys/marblerun/coordinator/user"
-	"github.com/gorilla/mux"
 	grpc_middleware "github.com/grpc-ecosystem/go-grpc-middleware"
 	grpc_zap "github.com/grpc-ecosystem/go-grpc-middleware/logging/zap"
 	grpc_ctxtags "github.com/grpc-ecosystem/go-grpc-middleware/tags"
@@ -96,21 +95,21 @@ func CreateServeMux(api clientAPI, promFactory *promauto.Factory) serveMux {
 	server := clientAPIServer{api}
 	var router serveMux
 	if promFactory != nil {
-		router = newPromServeMux(promFactory, "server", "client_api")
-		router.(*promServeMux).setMethodNotAllowedHandler(server.methodNotAllowedHandler)
+		muxRouter := newPromServeMux(promFactory, "server", "client_api")
+		muxRouter.setMethodNotAllowedHandler(server.methodNotAllowedHandler)
+		router = muxRouter
 	} else {
-		router = mux.NewRouter()
-		router.(*mux.Router).MethodNotAllowedHandler = http.HandlerFunc(server.methodNotAllowedHandler)
+		muxRouter := http.NewServeMux()
+		muxRouter.HandleFunc("/", server.methodNotAllowedHandler)
+		router = muxRouter
 	}
-	router.HandleFunc("/status", server.statusGet).Methods("GET")
-	router.HandleFunc("/manifest", server.manifestGet).Methods("GET")
-	router.HandleFunc("/manifest", server.manifestPost).Methods("POST")
-	router.HandleFunc("/quote", server.quoteGet).Methods("GET")
-	router.HandleFunc("/recover", server.recoverPost).Methods("POST")
-	router.HandleFunc("/update", server.updateGet).Methods("GET")
-	router.HandleFunc("/update", server.updatePost).Methods("POST")
-	router.HandleFunc("/secrets", server.secretsPost).Methods("POST")
-	router.HandleFunc("/secrets", server.secretsGet).Methods("GET")
+
+	router.HandleFunc("/manifest", server.handleGetPost(server.manifestGet, server.manifestPost))
+	router.HandleFunc("/update", server.handleGetPost(server.updateGet, server.updatePost))
+	router.HandleFunc("/secrets", server.handleGetPost(server.secretsGet, server.secretsPost))
+	router.HandleFunc("/status", server.handleGetPost(server.statusGet, server.methodNotAllowedHandler))
+	router.HandleFunc("/quote", server.handleGetPost(server.quoteGet, server.methodNotAllowedHandler))
+	router.HandleFunc("/recover", server.handleGetPost(server.methodNotAllowedHandler, server.recoverPost))
 	return router
 }
 

Diff for: go.mod

@@ -9,7 +9,6 @@ require (
 	github.com/gofrs/flock v0.8.1
 	github.com/google/go-cmp v0.5.9
 	github.com/google/uuid v1.3.0
-	github.com/gorilla/mux v1.8.0
 	github.com/grpc-ecosystem/go-grpc-middleware v1.3.0
 	github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0
 	github.com/prometheus/client_golang v1.14.0
@@ -76,6 +75,7 @@ require (
 	github.com/google/gnostic v0.6.9 // indirect
 	github.com/google/gofuzz v1.2.0 // indirect
 	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect
+	github.com/gorilla/mux v1.8.0 // indirect
 	github.com/gosuri/uitable v0.0.4 // indirect
 	github.com/gregjones/httpcache v0.0.0-20190611155906-901d90724c79 // indirect
 	github.com/huandu/xstrings v1.3.3 // indirect