Rework servers load-balancer to use the WRR

Co-authored-by: Kevin Pollet <pollet.kevin@gmail.com>

pkg/middlewares/metrics/metrics.go

@@ -104,13 +104,6 @@ func WrapRouterHandler(ctx context.Context, registry metrics.Registry, routerNam
 	}
 }
 
-// WrapServiceHandler Wraps metrics service to alice.Constructor.
-func WrapServiceHandler(ctx context.Context, registry metrics.Registry, serviceName string) alice.Constructor {
-	return func(next http.Handler) (http.Handler, error) {
-		return NewServiceMiddleware(ctx, next, registry, serviceName), nil
-	}
-}
-
 func (m *metricsMiddleware) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
 	proto := getRequestProtocol(req)
 

pkg/middlewares/metrics/metrics_test.go

@@ -60,47 +60,6 @@ func (m *collectingRetryMetrics) ServiceRetriesCounter() metrics.Counter {
 	return m.retriesCounter
 }
 
-type rwWithCloseNotify struct {
-	*httptest.ResponseRecorder
-}
-
-func (r *rwWithCloseNotify) CloseNotify() <-chan bool {
-	panic("implement me")
-}
-
-func TestCloseNotifier(t *testing.T) {
-	testCases := []struct {
-		rw                      http.ResponseWriter
-		desc                    string
-		implementsCloseNotifier bool
-	}{
-		{
-			rw:                      httptest.NewRecorder(),
-			desc:                    "does not implement CloseNotifier",
-			implementsCloseNotifier: false,
-		},
-		{
-			rw:                      &rwWithCloseNotify{httptest.NewRecorder()},
-			desc:                    "implements CloseNotifier",
-			implementsCloseNotifier: true,
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			_, ok := test.rw.(http.CloseNotifier)
-			assert.Equal(t, test.implementsCloseNotifier, ok)
-
-			rw := newResponseRecorder(test.rw)
-			_, impl := rw.(http.CloseNotifier)
-			assert.Equal(t, test.implementsCloseNotifier, impl)
-		})
-	}
-}
-
 func Test_getMethod(t *testing.T) {
 	testCases := []struct {
 		method   string

pkg/middlewares/metrics/recorder.go

@@ -1,63 +0,0 @@
-package metrics
-
-import (
-	"bufio"
-	"net"
-	"net/http"
-)
-
-type recorder interface {
-	http.ResponseWriter
-	http.Flusher
-	getCode() int
-}
-
-func newResponseRecorder(rw http.ResponseWriter) recorder {
-	rec := &responseRecorder{
-		ResponseWriter: rw,
-		statusCode:     http.StatusOK,
-	}
-	if _, ok := rw.(http.CloseNotifier); !ok {
-		return rec
-	}
-	return &responseRecorderWithCloseNotify{rec}
-}
-
-// responseRecorder captures information from the response and preserves it for
-// later analysis.
-type responseRecorder struct {
-	http.ResponseWriter
-	statusCode int
-}
-
-type responseRecorderWithCloseNotify struct {
-	*responseRecorder
-}
-
-// CloseNotify returns a channel that receives at most a
-// single value (true) when the client connection has gone away.
-func (r *responseRecorderWithCloseNotify) CloseNotify() <-chan bool {
-	return r.ResponseWriter.(http.CloseNotifier).CloseNotify()
-}
-
-func (r *responseRecorder) getCode() int {
-	return r.statusCode
-}
-
-// WriteHeader captures the status code for later retrieval.
-func (r *responseRecorder) WriteHeader(status int) {
-	r.ResponseWriter.WriteHeader(status)
-	r.statusCode = status
-}
-
-// Hijack hijacks the connection.
-func (r *responseRecorder) Hijack() (net.Conn, *bufio.ReadWriter, error) {
-	return r.ResponseWriter.(http.Hijacker).Hijack()
-}
-
-// Flush sends any buffered data to the client.
-func (r *responseRecorder) Flush() {
-	if f, ok := r.ResponseWriter.(http.Flusher); ok {
-		f.Flush()
-	}
-}