traefik/configuration/router/internal_router.go

package router

import (
	"github.com/containous/mux"
	"github.com/containous/traefik/configuration"
	"github.com/containous/traefik/log"
	"github.com/containous/traefik/metrics"
	"github.com/containous/traefik/middlewares"
	mauth "github.com/containous/traefik/middlewares/auth"
	"github.com/containous/traefik/types"
	"github.com/urfave/negroni"
)

// NewInternalRouterAggregator Create a new internalRouterAggregator
func NewInternalRouterAggregator(globalConfiguration configuration.GlobalConfiguration, entryPointName string) *InternalRouterAggregator {
	var serverMiddlewares []negroni.Handler

	if globalConfiguration.EntryPoints[entryPointName].WhiteList != nil {
		ipStrategy := globalConfiguration.EntryPoints[entryPointName].ClientIPStrategy
		if globalConfiguration.EntryPoints[entryPointName].WhiteList.IPStrategy != nil {
			ipStrategy = globalConfiguration.EntryPoints[entryPointName].WhiteList.IPStrategy
		}

		strategy, err := ipStrategy.Get()
		if err != nil {
			log.Fatalf("Error creating whitelist middleware: %s", err)
		}

		ipWhitelistMiddleware, err := middlewares.NewIPWhiteLister(globalConfiguration.EntryPoints[entryPointName].WhiteList.SourceRange, strategy)
		if err != nil {
			log.Fatalf("Error creating whitelist middleware: %s", err)
		}
		if ipWhitelistMiddleware != nil {
			serverMiddlewares = append(serverMiddlewares, ipWhitelistMiddleware)
		}
	}

	if globalConfiguration.EntryPoints[entryPointName].Auth != nil {
		authMiddleware, err := mauth.NewAuthenticator(globalConfiguration.EntryPoints[entryPointName].Auth, nil)
		if err != nil {
			log.Fatalf("Error creating authenticator middleware: %s", err)
		}
		serverMiddlewares = append(serverMiddlewares, authMiddleware)
	}

	router := InternalRouterAggregator{}
	routerWithPrefix := InternalRouterAggregator{}
	routerWithPrefixAndMiddleware := InternalRouterAggregator{}

	if globalConfiguration.Metrics != nil && globalConfiguration.Metrics.Prometheus != nil && globalConfiguration.Metrics.Prometheus.EntryPoint == entryPointName {
		routerWithPrefixAndMiddleware.AddRouter(metrics.PrometheusHandler{})
	}

	if globalConfiguration.Rest != nil && globalConfiguration.Rest.EntryPoint == entryPointName {
		routerWithPrefixAndMiddleware.AddRouter(globalConfiguration.Rest)
	}

	if globalConfiguration.API != nil && globalConfiguration.API.EntryPoint == entryPointName {
		routerWithPrefixAndMiddleware.AddRouter(globalConfiguration.API)
	}

	if globalConfiguration.Ping != nil && globalConfiguration.Ping.EntryPoint == entryPointName {
		routerWithPrefix.AddRouter(globalConfiguration.Ping)
	}

	if globalConfiguration.ACME != nil && globalConfiguration.ACME.HTTPChallenge != nil && globalConfiguration.ACME.HTTPChallenge.EntryPoint == entryPointName {
		router.AddRouter(globalConfiguration.ACME)
	}

	realRouterWithMiddleware := WithMiddleware{router: &routerWithPrefixAndMiddleware, routerMiddlewares: serverMiddlewares}
	router.AddRouter(&routerWithPrefix)
	router.AddRouter(&realRouterWithMiddleware)

	return &router
}

// WithMiddleware router with internal middleware
type WithMiddleware struct {
	router            types.InternalRouter
	routerMiddlewares []negroni.Handler
}

// AddRoutes Add routes to the router
func (wm *WithMiddleware) AddRoutes(systemRouter *mux.Router) {
	realRouter := systemRouter.PathPrefix("/").Subrouter()

	wm.router.AddRoutes(realRouter)

	if len(wm.routerMiddlewares) > 0 {
		if err := realRouter.Walk(wrapRoute(wm.routerMiddlewares)); err != nil {
			log.Error(err)
		}
	}
}

// WithPrefix router which add a prefix
type WithPrefix struct {
	Router     types.InternalRouter
	PathPrefix string
}

// AddRoutes Add routes to the router
func (wp *WithPrefix) AddRoutes(systemRouter *mux.Router) {
	realRouter := systemRouter.PathPrefix("/").Subrouter()
	if wp.PathPrefix != "" {
		realRouter = systemRouter.PathPrefix(wp.PathPrefix).Subrouter()
		realRouter.StrictSlash(true)
		realRouter.SkipClean(true)
	}
	wp.Router.AddRoutes(realRouter)
}

// InternalRouterAggregator InternalRouter that aggregate other internalRouter
type InternalRouterAggregator struct {
	internalRouters []types.InternalRouter
}

// AddRouter add a router in the aggregator
func (r *InternalRouterAggregator) AddRouter(router types.InternalRouter) {
	r.internalRouters = append(r.internalRouters, router)
}

// AddRoutes Add routes to the router
func (r *InternalRouterAggregator) AddRoutes(systemRouter *mux.Router) {
	for _, router := range r.internalRouters {
		router.AddRoutes(systemRouter)
	}
}

// wrapRoute with middlewares
func wrapRoute(middlewares []negroni.Handler) func(*mux.Route, *mux.Router, []*mux.Route) error {
	return func(route *mux.Route, router *mux.Router, ancestors []*mux.Route) error {
		middles := append(middlewares, negroni.Wrap(route.GetHandler()))
		route.Handler(negroni.New(middles...))
		return nil
	}
}