Move code to pkg

2019-03-15 09:42:03 +01:00 · 2019-03-15 09:42:03 +01:00 · f1b085fa36
commit f1b085fa36
parent bd4c822670
465 changed files with 656 additions and 680 deletions
--- a/pkg/api/dashboard.go
+++ b/pkg/api/dashboard.go
@ -0,0 +1,39 @@
+package api
+
+import (
+	"net/http"
+
+	"github.com/containous/mux"
+	"github.com/containous/traefik/pkg/log"
+	assetfs "github.com/elazarl/go-bindata-assetfs"
+)
+
+// DashboardHandler expose dashboard routes
+type DashboardHandler struct {
+	Assets *assetfs.AssetFS
+}
+
+// Append add dashboard routes on a router
+func (g DashboardHandler) Append(router *mux.Router) {
+	if g.Assets == nil {
+		log.WithoutContext().Error("No assets for dashboard")
+		return
+	}
+
+	// Expose dashboard
+	router.Methods(http.MethodGet).
+		Path("/").
+		HandlerFunc(func(response http.ResponseWriter, request *http.Request) {
+			http.Redirect(response, request, request.Header.Get("X-Forwarded-Prefix")+"/dashboard/", http.StatusFound)
+		})
+
+	router.Methods(http.MethodGet).
+		Path("/dashboard/status").
+		HandlerFunc(func(response http.ResponseWriter, request *http.Request) {
+			http.Redirect(response, request, "/dashboard/", http.StatusFound)
+		})
+
+	router.Methods(http.MethodGet).
+		PathPrefix("/dashboard/").
+		Handler(http.StripPrefix("/dashboard/", http.FileServer(g.Assets)))
+}
--- a/pkg/api/debug.go
+++ b/pkg/api/debug.go
@ -0,0 +1,49 @@
+package api
+
+import (
+	"expvar"
+	"fmt"
+	"net/http"
+	"net/http/pprof"
+	"runtime"
+
+	"github.com/containous/mux"
+)
+
+func init() {
+	// FIXME Goroutines2 -> Goroutines
+	expvar.Publish("Goroutines2", expvar.Func(goroutines))
+}
+
+func goroutines() interface{} {
+	return runtime.NumGoroutine()
+}
+
+// DebugHandler expose debug routes
+type DebugHandler struct{}
+
+// Append add debug routes on a router
+func (g DebugHandler) Append(router *mux.Router) {
+	router.Methods(http.MethodGet).Path("/debug/vars").
+		HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+			w.Header().Set("Content-Type", "application/json; charset=utf-8")
+			fmt.Fprint(w, "{\n")
+			first := true
+			expvar.Do(func(kv expvar.KeyValue) {
+				if !first {
+					fmt.Fprint(w, ",\n")
+				}
+				first = false
+				fmt.Fprintf(w, "%q: %s", kv.Key, kv.Value)
+			})
+			fmt.Fprint(w, "\n}\n")
+		})
+
+	runtime.SetBlockProfileRate(1)
+	runtime.SetMutexProfileFraction(5)
+	router.Methods(http.MethodGet).PathPrefix("/debug/pprof/cmdline").HandlerFunc(pprof.Cmdline)
+	router.Methods(http.MethodGet).PathPrefix("/debug/pprof/profile").HandlerFunc(pprof.Profile)
+	router.Methods(http.MethodGet).PathPrefix("/debug/pprof/symbol").HandlerFunc(pprof.Symbol)
+	router.Methods(http.MethodGet).PathPrefix("/debug/pprof/trace").HandlerFunc(pprof.Trace)
+	router.Methods(http.MethodGet).PathPrefix("/debug/pprof/").HandlerFunc(pprof.Index)
+}
--- a/pkg/api/handler.go
+++ b/pkg/api/handler.go
@ -0,0 +1,355 @@
+package api
+
+import (
+	"io"
+	"net/http"
+
+	"github.com/containous/mux"
+	"github.com/containous/traefik/pkg/config"
+	"github.com/containous/traefik/pkg/log"
+	"github.com/containous/traefik/pkg/safe"
+	"github.com/containous/traefik/pkg/types"
+	"github.com/containous/traefik/pkg/version"
+	assetfs "github.com/elazarl/go-bindata-assetfs"
+	thoasstats "github.com/thoas/stats"
+	"github.com/unrolled/render"
+)
+
+// ResourceIdentifier a resource identifier
+type ResourceIdentifier struct {
+	ID   string `json:"id"`
+	Path string `json:"path"`
+}
+
+// ProviderRepresentation a provider with resource identifiers
+type ProviderRepresentation struct {
+	Routers     []ResourceIdentifier `json:"routers,omitempty"`
+	Middlewares []ResourceIdentifier `json:"middlewares,omitempty"`
+	Services    []ResourceIdentifier `json:"services,omitempty"`
+}
+
+// RouterRepresentation extended version of a router configuration with an ID
+type RouterRepresentation struct {
+	*config.Router
+	ID string `json:"id"`
+}
+
+// MiddlewareRepresentation extended version of a middleware configuration with an ID
+type MiddlewareRepresentation struct {
+	*config.Middleware
+	ID string `json:"id"`
+}
+
+// ServiceRepresentation extended version of a service configuration with an ID
+type ServiceRepresentation struct {
+	*config.Service
+	ID string `json:"id"`
+}
+
+// Handler expose api routes
+type Handler struct {
+	EntryPoint            string
+	Dashboard             bool
+	Debug                 bool
+	CurrentConfigurations *safe.Safe
+	Statistics            *types.Statistics
+	Stats                 *thoasstats.Stats
+	// StatsRecorder         *middlewares.StatsRecorder // FIXME stats
+	DashboardAssets *assetfs.AssetFS
+}
+
+var templateRenderer jsonRenderer = render.New(render.Options{Directory: "nowhere"})
+
+type jsonRenderer interface {
+	JSON(w io.Writer, status int, v interface{}) error
+}
+
+// Append add api routes on a router
+func (h Handler) Append(router *mux.Router) {
+	if h.Debug {
+		DebugHandler{}.Append(router)
+	}
+
+	router.Methods(http.MethodGet).Path("/api/rawdata").HandlerFunc(h.getRawData)
+	router.Methods(http.MethodGet).Path("/api/providers").HandlerFunc(h.getProvidersHandler)
+	router.Methods(http.MethodGet).Path("/api/providers/{provider}").HandlerFunc(h.getProviderHandler)
+	router.Methods(http.MethodGet).Path("/api/providers/{provider}/routers").HandlerFunc(h.getRoutersHandler)
+	router.Methods(http.MethodGet).Path("/api/providers/{provider}/routers/{router}").HandlerFunc(h.getRouterHandler)
+	router.Methods(http.MethodGet).Path("/api/providers/{provider}/middlewares").HandlerFunc(h.getMiddlewaresHandler)
+	router.Methods(http.MethodGet).Path("/api/providers/{provider}/middlewares/{middleware}").HandlerFunc(h.getMiddlewareHandler)
+	router.Methods(http.MethodGet).Path("/api/providers/{provider}/services").HandlerFunc(h.getServicesHandler)
+	router.Methods(http.MethodGet).Path("/api/providers/{provider}/services/{service}").HandlerFunc(h.getServiceHandler)
+
+	// FIXME stats
+	// health route
+	//router.Methods(http.MethodGet).Path("/health").HandlerFunc(p.getHealthHandler)
+
+	version.Handler{}.Append(router)
+
+	if h.Dashboard {
+		DashboardHandler{Assets: h.DashboardAssets}.Append(router)
+	}
+}
+
+func (h Handler) getRawData(rw http.ResponseWriter, request *http.Request) {
+	if h.CurrentConfigurations != nil {
+		currentConfigurations, ok := h.CurrentConfigurations.Get().(config.Configurations)
+		if !ok {
+			rw.WriteHeader(http.StatusOK)
+			return
+		}
+		err := templateRenderer.JSON(rw, http.StatusOK, currentConfigurations)
+		if err != nil {
+			log.FromContext(request.Context()).Error(err)
+			http.Error(rw, err.Error(), http.StatusInternalServerError)
+		}
+	}
+}
+
+func (h Handler) getProvidersHandler(rw http.ResponseWriter, request *http.Request) {
+	// FIXME handle currentConfiguration
+	if h.CurrentConfigurations != nil {
+		currentConfigurations, ok := h.CurrentConfigurations.Get().(config.Configurations)
+		if !ok {
+			rw.WriteHeader(http.StatusOK)
+			return
+		}
+
+		var providers []ResourceIdentifier
+		for name := range currentConfigurations {
+			providers = append(providers, ResourceIdentifier{
+				ID:   name,
+				Path: "/api/providers/" + name,
+			})
+		}
+
+		err := templateRenderer.JSON(rw, http.StatusOK, providers)
+		if err != nil {
+			log.FromContext(request.Context()).Error(err)
+			http.Error(rw, err.Error(), http.StatusInternalServerError)
+		}
+	}
+}
+
+func (h Handler) getProviderHandler(rw http.ResponseWriter, request *http.Request) {
+	providerID := mux.Vars(request)["provider"]
+
+	currentConfigurations := h.CurrentConfigurations.Get().(config.Configurations)
+
+	provider, ok := currentConfigurations[providerID]
+	if !ok {
+		http.NotFound(rw, request)
+		return
+	}
+
+	if provider.HTTP == nil {
+		http.NotFound(rw, request)
+		return
+	}
+
+	var routers []ResourceIdentifier
+	for name := range provider.HTTP.Routers {
+		routers = append(routers, ResourceIdentifier{
+			ID:   name,
+			Path: "/api/providers/" + providerID + "/routers",
+		})
+	}
+
+	var services []ResourceIdentifier
+	for name := range provider.HTTP.Services {
+		services = append(services, ResourceIdentifier{
+			ID:   name,
+			Path: "/api/providers/" + providerID + "/services",
+		})
+	}
+
+	var middlewares []ResourceIdentifier
+	for name := range provider.HTTP.Middlewares {
+		middlewares = append(middlewares, ResourceIdentifier{
+			ID:   name,
+			Path: "/api/providers/" + providerID + "/middlewares",
+		})
+	}
+
+	providers := ProviderRepresentation{Routers: routers, Middlewares: middlewares, Services: services}
+
+	err := templateRenderer.JSON(rw, http.StatusOK, providers)
+	if err != nil {
+		log.FromContext(request.Context()).Error(err)
+		http.Error(rw, err.Error(), http.StatusInternalServerError)
+	}
+}
+
+func (h Handler) getRoutersHandler(rw http.ResponseWriter, request *http.Request) {
+	providerID := mux.Vars(request)["provider"]
+
+	currentConfigurations := h.CurrentConfigurations.Get().(config.Configurations)
+
+	provider, ok := currentConfigurations[providerID]
+	if !ok {
+		http.NotFound(rw, request)
+		return
+	}
+
+	if provider.HTTP == nil {
+		http.NotFound(rw, request)
+		return
+	}
+
+	var routers []RouterRepresentation
+	for name, router := range provider.HTTP.Routers {
+		routers = append(routers, RouterRepresentation{Router: router, ID: name})
+	}
+
+	err := templateRenderer.JSON(rw, http.StatusOK, routers)
+	if err != nil {
+		log.FromContext(request.Context()).Error(err)
+		http.Error(rw, err.Error(), http.StatusInternalServerError)
+	}
+}
+
+func (h Handler) getRouterHandler(rw http.ResponseWriter, request *http.Request) {
+	providerID := mux.Vars(request)["provider"]
+	routerID := mux.Vars(request)["router"]
+
+	currentConfigurations := h.CurrentConfigurations.Get().(config.Configurations)
+
+	provider, ok := currentConfigurations[providerID]
+	if !ok {
+		http.NotFound(rw, request)
+		return
+	}
+
+	if provider.HTTP == nil {
+		http.NotFound(rw, request)
+		return
+	}
+
+	router, ok := provider.HTTP.Routers[routerID]
+	if !ok {
+		http.NotFound(rw, request)
+		return
+	}
+
+	err := templateRenderer.JSON(rw, http.StatusOK, router)
+	if err != nil {
+		log.FromContext(request.Context()).Error(err)
+		http.Error(rw, err.Error(), http.StatusInternalServerError)
+	}
+}
+
+func (h Handler) getMiddlewaresHandler(rw http.ResponseWriter, request *http.Request) {
+	providerID := mux.Vars(request)["provider"]
+
+	currentConfigurations := h.CurrentConfigurations.Get().(config.Configurations)
+
+	provider, ok := currentConfigurations[providerID]
+	if !ok {
+		http.NotFound(rw, request)
+		return
+	}
+
+	if provider.HTTP == nil {
+		http.NotFound(rw, request)
+		return
+	}
+
+	var middlewares []MiddlewareRepresentation
+	for name, middleware := range provider.HTTP.Middlewares {
+		middlewares = append(middlewares, MiddlewareRepresentation{Middleware: middleware, ID: name})
+	}
+
+	err := templateRenderer.JSON(rw, http.StatusOK, middlewares)
+	if err != nil {
+		log.FromContext(request.Context()).Error(err)
+		http.Error(rw, err.Error(), http.StatusInternalServerError)
+	}
+}
+
+func (h Handler) getMiddlewareHandler(rw http.ResponseWriter, request *http.Request) {
+	providerID := mux.Vars(request)["provider"]
+	middlewareID := mux.Vars(request)["middleware"]
+
+	currentConfigurations := h.CurrentConfigurations.Get().(config.Configurations)
+
+	provider, ok := currentConfigurations[providerID]
+	if !ok {
+		http.NotFound(rw, request)
+		return
+	}
+
+	if provider.HTTP == nil {
+		http.NotFound(rw, request)
+		return
+	}
+
+	middleware, ok := provider.HTTP.Middlewares[middlewareID]
+	if !ok {
+		http.NotFound(rw, request)
+		return
+	}
+
+	err := templateRenderer.JSON(rw, http.StatusOK, middleware)
+	if err != nil {
+		log.FromContext(request.Context()).Error(err)
+		http.Error(rw, err.Error(), http.StatusInternalServerError)
+	}
+}
+
+func (h Handler) getServicesHandler(rw http.ResponseWriter, request *http.Request) {
+	providerID := mux.Vars(request)["provider"]
+
+	currentConfigurations := h.CurrentConfigurations.Get().(config.Configurations)
+
+	provider, ok := currentConfigurations[providerID]
+	if !ok {
+		http.NotFound(rw, request)
+		return
+	}
+
+	if provider.HTTP == nil {
+		http.NotFound(rw, request)
+		return
+	}
+
+	var services []ServiceRepresentation
+	for name, service := range provider.HTTP.Services {
+		services = append(services, ServiceRepresentation{Service: service, ID: name})
+	}
+
+	err := templateRenderer.JSON(rw, http.StatusOK, services)
+	if err != nil {
+		log.FromContext(request.Context()).Error(err)
+		http.Error(rw, err.Error(), http.StatusInternalServerError)
+	}
+}
+
+func (h Handler) getServiceHandler(rw http.ResponseWriter, request *http.Request) {
+	providerID := mux.Vars(request)["provider"]
+	serviceID := mux.Vars(request)["service"]
+
+	currentConfigurations := h.CurrentConfigurations.Get().(config.Configurations)
+
+	provider, ok := currentConfigurations[providerID]
+	if !ok {
+		http.NotFound(rw, request)
+		return
+	}
+
+	if provider.HTTP == nil {
+		http.NotFound(rw, request)
+		return
+	}
+
+	service, ok := provider.HTTP.Services[serviceID]
+	if !ok {
+		http.NotFound(rw, request)
+		return
+	}
+
+	err := templateRenderer.JSON(rw, http.StatusOK, service)
+	if err != nil {
+		log.FromContext(request.Context()).Error(err)
+		http.Error(rw, err.Error(), http.StatusInternalServerError)
+	}
+}
--- a/pkg/api/handler_test.go
+++ b/pkg/api/handler_test.go
@ -0,0 +1,226 @@
+package api
+
+import (
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/containous/mux"
+	"github.com/containous/traefik/pkg/config"
+	"github.com/containous/traefik/pkg/safe"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestHandler_Configuration(t *testing.T) {
+	type expected struct {
+		statusCode int
+		body       string
+	}
+
+	testCases := []struct {
+		desc          string
+		path          string
+		configuration config.Configurations
+		expected      expected
+	}{
+		{
+			desc: "Get all the providers",
+			path: "/api/providers",
+			configuration: config.Configurations{
+				"foo": {
+					HTTP: &config.HTTPConfiguration{
+						Routers: map[string]*config.Router{
+							"bar": {EntryPoints: []string{"foo", "bar"}},
+						},
+					},
+				},
+			},
+			expected: expected{statusCode: http.StatusOK, body: `[{"id":"foo","path":"/api/providers/foo"}]`},
+		},
+		{
+			desc: "Get a provider",
+			path: "/api/providers/foo",
+			configuration: config.Configurations{
+				"foo": {
+					HTTP: &config.HTTPConfiguration{
+						Routers: map[string]*config.Router{
+							"bar": {EntryPoints: []string{"foo", "bar"}},
+						},
+						Middlewares: map[string]*config.Middleware{
+							"bar": {
+								AddPrefix: &config.AddPrefix{Prefix: "bar"},
+							},
+						},
+						Services: map[string]*config.Service{
+							"foo": {
+								LoadBalancer: &config.LoadBalancerService{
+									Method: "wrr",
+								},
+							},
+						},
+					},
+				},
+			},
+			expected: expected{statusCode: http.StatusOK, body: `{"routers":[{"id":"bar","path":"/api/providers/foo/routers"}],"middlewares":[{"id":"bar","path":"/api/providers/foo/middlewares"}],"services":[{"id":"foo","path":"/api/providers/foo/services"}]}`},
+		},
+		{
+			desc:          "Provider not found",
+			path:          "/api/providers/foo",
+			configuration: config.Configurations{},
+			expected:      expected{statusCode: http.StatusNotFound, body: "404 page not found\n"},
+		},
+		{
+			desc: "Get all routers",
+			path: "/api/providers/foo/routers",
+			configuration: config.Configurations{
+				"foo": {
+					HTTP: &config.HTTPConfiguration{
+						Routers: map[string]*config.Router{
+							"bar": {EntryPoints: []string{"foo", "bar"}},
+						},
+					},
+				},
+			},
+			expected: expected{statusCode: http.StatusOK, body: `[{"entryPoints":["foo","bar"],"id":"bar"}]`},
+		},
+		{
+			desc: "Get a router",
+			path: "/api/providers/foo/routers/bar",
+			configuration: config.Configurations{
+				"foo": {
+					HTTP: &config.HTTPConfiguration{
+						Routers: map[string]*config.Router{
+							"bar": {EntryPoints: []string{"foo", "bar"}},
+						},
+					},
+				},
+			},
+			expected: expected{statusCode: http.StatusOK, body: `{"entryPoints":["foo","bar"]}`},
+		},
+		{
+			desc: "Router not found",
+			path: "/api/providers/foo/routers/bar",
+			configuration: config.Configurations{
+				"foo": {},
+			},
+			expected: expected{statusCode: http.StatusNotFound, body: "404 page not found\n"},
+		},
+		{
+			desc: "Get all services",
+			path: "/api/providers/foo/services",
+			configuration: config.Configurations{
+				"foo": {
+					HTTP: &config.HTTPConfiguration{
+						Services: map[string]*config.Service{
+							"foo": {
+								LoadBalancer: &config.LoadBalancerService{
+									Method: "wrr",
+								},
+							},
+						},
+					},
+				},
+			},
+			expected: expected{statusCode: http.StatusOK, body: `[{"loadbalancer":{"method":"wrr","passHostHeader":false},"id":"foo"}]`},
+		},
+		{
+			desc: "Get a service",
+			path: "/api/providers/foo/services/foo",
+			configuration: config.Configurations{
+				"foo": {
+					HTTP: &config.HTTPConfiguration{
+						Services: map[string]*config.Service{
+							"foo": {
+								LoadBalancer: &config.LoadBalancerService{
+									Method: "wrr",
+								},
+							},
+						},
+					},
+				},
+			},
+			expected: expected{statusCode: http.StatusOK, body: `{"loadbalancer":{"method":"wrr","passHostHeader":false}}`},
+		},
+		{
+			desc: "Service not found",
+			path: "/api/providers/foo/services/bar",
+			configuration: config.Configurations{
+				"foo": {},
+			},
+			expected: expected{statusCode: http.StatusNotFound, body: "404 page not found\n"},
+		},
+		{
+			desc: "Get all middlewares",
+			path: "/api/providers/foo/middlewares",
+			configuration: config.Configurations{
+				"foo": {
+					HTTP: &config.HTTPConfiguration{
+						Middlewares: map[string]*config.Middleware{
+							"bar": {
+								AddPrefix: &config.AddPrefix{Prefix: "bar"},
+							},
+						},
+					},
+				},
+			},
+			expected: expected{statusCode: http.StatusOK, body: `[{"addPrefix":{"prefix":"bar"},"id":"bar"}]`},
+		},
+		{
+			desc: "Get a middleware",
+			path: "/api/providers/foo/middlewares/bar",
+			configuration: config.Configurations{
+				"foo": {
+					HTTP: &config.HTTPConfiguration{
+						Middlewares: map[string]*config.Middleware{
+							"bar": {
+								AddPrefix: &config.AddPrefix{Prefix: "bar"},
+							},
+						},
+					},
+				},
+			},
+			expected: expected{statusCode: http.StatusOK, body: `{"addPrefix":{"prefix":"bar"}}`},
+		},
+		{
+			desc: "Middleware not found",
+			path: "/api/providers/foo/middlewares/bar",
+			configuration: config.Configurations{
+				"foo": {},
+			},
+			expected: expected{statusCode: http.StatusNotFound, body: "404 page not found\n"},
+		},
+	}
+
+	for _, test := range testCases {
+		test := test
+		t.Run(test.desc, func(t *testing.T) {
+			t.Parallel()
+
+			currentConfiguration := &safe.Safe{}
+			currentConfiguration.Set(test.configuration)
+
+			handler := Handler{
+				CurrentConfigurations: currentConfiguration,
+			}
+
+			router := mux.NewRouter()
+			handler.Append(router)
+
+			server := httptest.NewServer(router)
+
+			resp, err := http.DefaultClient.Get(server.URL + test.path)
+			require.NoError(t, err)
+
+			assert.Equal(t, test.expected.statusCode, resp.StatusCode)
+
+			content, err := ioutil.ReadAll(resp.Body)
+			require.NoError(t, err)
+			err = resp.Body.Close()
+			require.NoError(t, err)
+
+			assert.Equal(t, test.expected.body, string(content))
+		})
+	}
+}