API: expose runtime representation

Co-authored-by: Julien Salleyron <julien.salleyron@gmail.com>
Co-authored-by: Jean-Baptiste Doumenjou <jb.doumenjou@gmail.com>

pkg/server/router/route_appender_aggregator.go

@@ -6,10 +6,10 @@ import (
 	"github.com/containous/alice"
 	"github.com/containous/mux"
 	"github.com/containous/traefik/pkg/api"
+	"github.com/containous/traefik/pkg/config"
 	"github.com/containous/traefik/pkg/config/static"
 	"github.com/containous/traefik/pkg/log"
 	"github.com/containous/traefik/pkg/metrics"
-	"github.com/containous/traefik/pkg/safe"
 	"github.com/containous/traefik/pkg/types"
 )
 
@@ -19,7 +19,8 @@ type chainBuilder interface {
 }
 
 // NewRouteAppenderAggregator Creates a new RouteAppenderAggregator
-func NewRouteAppenderAggregator(ctx context.Context, chainBuilder chainBuilder, conf static.Configuration, entryPointName string, currentConfiguration *safe.Safe) *RouteAppenderAggregator {
+func NewRouteAppenderAggregator(ctx context.Context, chainBuilder chainBuilder, conf static.Configuration,
+	entryPointName string, runtimeConfiguration *config.RuntimeConfiguration) *RouteAppenderAggregator {
 	aggregator := &RouteAppenderAggregator{}
 
 	if conf.Providers != nil && conf.Providers.Rest != nil {
@@ -29,17 +30,9 @@ func NewRouteAppenderAggregator(ctx context.Context, chainBuilder chainBuilder,
 	if conf.API != nil && conf.API.EntryPoint == entryPointName {
 		chain := chainBuilder.BuildChain(ctx, conf.API.Middlewares)
 		aggregator.AddAppender(&WithMiddleware{
-			appender: api.Handler{
-				EntryPoint:            conf.API.EntryPoint,
-				Dashboard:             conf.API.Dashboard,
-				Statistics:            conf.API.Statistics,
-				DashboardAssets:       conf.API.DashboardAssets,
-				CurrentConfigurations: currentConfiguration,
-				Debug:                 conf.Global.Debug,
-			},
+			appender:          api.New(conf, runtimeConfiguration),
 			routerMiddlewares: chain,
 		})
-
 	}
 
 	if conf.Ping != nil && conf.Ping.EntryPoint == entryPointName {

pkg/server/router/route_appender_aggregator_test.go

@@ -62,7 +62,7 @@ func TestNewRouteAppenderAggregator(t *testing.T) {
 				"/wrong": http.StatusBadGateway,
 				"/ping":  http.StatusOK,
 				// "/.well-known/acme-challenge/token": http.StatusNotFound, // FIXME
-				"/api/providers": http.StatusUnauthorized,
+				"/api/rawdata": http.StatusUnauthorized,
 			},
 		},
 		{

pkg/server/router/route_appender_factory.go

@@ -3,9 +3,9 @@ package router
 import (
 	"context"
 
+	"github.com/containous/traefik/pkg/config"
 	"github.com/containous/traefik/pkg/config/static"
 	"github.com/containous/traefik/pkg/provider/acme"
-	"github.com/containous/traefik/pkg/safe"
 	"github.com/containous/traefik/pkg/server/middleware"
 	"github.com/containous/traefik/pkg/types"
 )
@@ -27,8 +27,8 @@ type RouteAppenderFactory struct {
 }
 
 // NewAppender Creates a new RouteAppender
-func (r *RouteAppenderFactory) NewAppender(ctx context.Context, middlewaresBuilder *middleware.Builder, currentConfiguration *safe.Safe) types.RouteAppender {
-	aggregator := NewRouteAppenderAggregator(ctx, middlewaresBuilder, r.staticConfiguration, r.entryPointName, currentConfiguration)
+func (r *RouteAppenderFactory) NewAppender(ctx context.Context, middlewaresBuilder *middleware.Builder, runtimeConfiguration *config.RuntimeConfiguration) types.RouteAppender {
+	aggregator := NewRouteAppenderAggregator(ctx, middlewaresBuilder, r.staticConfiguration, r.entryPointName, runtimeConfiguration)
 
 	if r.acmeProvider != nil && r.acmeProvider.HTTPChallenge != nil && r.acmeProvider.HTTPChallenge.EntryPoint == r.entryPointName {
 		aggregator.AddAppender(r.acmeProvider)

pkg/server/router/router.go

@@ -23,7 +23,7 @@ const (
 )
 
 // NewManager Creates a new Manager
-func NewManager(routers map[string]*config.Router,
+func NewManager(routers map[string]*config.RouterInfo,
 	serviceManager *service.Manager, middlewaresBuilder *middleware.Builder, modifierBuilder *responsemodifiers.Builder,
 ) *Manager {
 	return &Manager{
@@ -38,7 +38,7 @@ func NewManager(routers map[string]*config.Router,
 // Manager A route/router manager
 type Manager struct {
 	routerHandlers     map[string]http.Handler
-	configs            map[string]*config.Router
+	configs            map[string]*config.RouterInfo
 	serviceManager     *service.Manager
 	middlewaresBuilder *middleware.Builder
 	modifierBuilder    *responsemodifiers.Builder
@@ -75,8 +75,17 @@ func (m *Manager) BuildHandlers(rootCtx context.Context, entryPoints []string, t
 	return entryPointHandlers
 }
 
-func (m *Manager) filteredRouters(ctx context.Context, entryPoints []string, tls bool) map[string]map[string]*config.Router {
-	entryPointsRouters := make(map[string]map[string]*config.Router)
+func contains(entryPoints []string, entryPointName string) bool {
+	for _, name := range entryPoints {
+		if name == entryPointName {
+			return true
+		}
+	}
+	return false
+}
+
+func (m *Manager) filteredRouters(ctx context.Context, entryPoints []string, tls bool) map[string]map[string]*config.RouterInfo {
+	entryPointsRouters := make(map[string]map[string]*config.RouterInfo)
 
 	for rtName, rt := range m.configs {
 		if (tls && rt.TLS == nil) || (!tls && rt.TLS != nil) {
@@ -95,7 +104,7 @@ func (m *Manager) filteredRouters(ctx context.Context, entryPoints []string, tls
 			}
 
 			if _, ok := entryPointsRouters[entryPointName]; !ok {
-				entryPointsRouters[entryPointName] = make(map[string]*config.Router)
+				entryPointsRouters[entryPointName] = make(map[string]*config.RouterInfo)
 			}
 
 			entryPointsRouters[entryPointName][rtName] = rt
@@ -105,7 +114,7 @@ func (m *Manager) filteredRouters(ctx context.Context, entryPoints []string, tls
 	return entryPointsRouters
 }
 
-func (m *Manager) buildEntryPointHandler(ctx context.Context, configs map[string]*config.Router) (http.Handler, error) {
+func (m *Manager) buildEntryPointHandler(ctx context.Context, configs map[string]*config.RouterInfo) (http.Handler, error) {
 	router, err := rules.NewRouter()
 	if err != nil {
 		return nil, err
@@ -117,12 +126,14 @@ func (m *Manager) buildEntryPointHandler(ctx context.Context, configs map[string
 
 		handler, err := m.buildRouterHandler(ctxRouter, routerName)
 		if err != nil {
+			routerConfig.Err = err.Error()
 			logger.Error(err)
 			continue
 		}
 
 		err = router.AddRoute(routerConfig.Rule, routerConfig.Priority, handler)
 		if err != nil {
+			routerConfig.Err = err.Error()
 			logger.Error(err)
 			continue
 		}
@@ -166,7 +177,7 @@ func (m *Manager) buildRouterHandler(ctx context.Context, routerName string) (ht
 	return m.routerHandlers[routerName], nil
 }
 
-func (m *Manager) buildHTTPHandler(ctx context.Context, router *config.Router, routerName string) (http.Handler, error) {
+func (m *Manager) buildHTTPHandler(ctx context.Context, router *config.RouterInfo, routerName string) (http.Handler, error) {
 	qualifiedNames := make([]string, len(router.Middlewares))
 	for i, name := range router.Middlewares {
 		qualifiedNames[i] = internal.GetQualifiedName(ctx, name)
@@ -186,12 +197,3 @@ func (m *Manager) buildHTTPHandler(ctx context.Context, router *config.Router, r
 
 	return alice.New().Extend(*mHandler).Append(tHandler).Then(sHandler)
 }
-
-func contains(entryPoints []string, entryPointName string) bool {
-	for _, name := range entryPoints {
-		if name == entryPointName {
-			return true
-		}
-	}
-	return false
-}

pkg/server/router/router_test.go

@@ -314,11 +314,17 @@ func TestRouterManager_Get(t *testing.T) {
 		t.Run(test.desc, func(t *testing.T) {
 			t.Parallel()
 
-			serviceManager := service.NewManager(test.serviceConfig, http.DefaultTransport)
-			middlewaresBuilder := middleware.NewBuilder(test.middlewaresConfig, serviceManager)
-			responseModifierFactory := responsemodifiers.NewBuilder(test.middlewaresConfig)
-
-			routerManager := NewManager(test.routersConfig, serviceManager, middlewaresBuilder, responseModifierFactory)
+			rtConf := config.NewRuntimeConfig(config.Configuration{
+				HTTP: &config.HTTPConfiguration{
+					Services:    test.serviceConfig,
+					Routers:     test.routersConfig,
+					Middlewares: test.middlewaresConfig,
+				},
+			})
+			serviceManager := service.NewManager(rtConf.Services, http.DefaultTransport)
+			middlewaresBuilder := middleware.NewBuilder(rtConf.Middlewares, serviceManager)
+			responseModifierFactory := responsemodifiers.NewBuilder(rtConf.Middlewares)
+			routerManager := NewManager(rtConf.Routers, serviceManager, middlewaresBuilder, responseModifierFactory)
 
 			handlers := routerManager.BuildHandlers(context.Background(), test.entryPoints, false)
 
@@ -413,11 +419,17 @@ func TestAccessLog(t *testing.T) {
 	for _, test := range testCases {
 		t.Run(test.desc, func(t *testing.T) {
 
-			serviceManager := service.NewManager(test.serviceConfig, http.DefaultTransport)
-			middlewaresBuilder := middleware.NewBuilder(test.middlewaresConfig, serviceManager)
-			responseModifierFactory := responsemodifiers.NewBuilder(test.middlewaresConfig)
-
-			routerManager := NewManager(test.routersConfig, serviceManager, middlewaresBuilder, responseModifierFactory)
+			rtConf := config.NewRuntimeConfig(config.Configuration{
+				HTTP: &config.HTTPConfiguration{
+					Services:    test.serviceConfig,
+					Routers:     test.routersConfig,
+					Middlewares: test.middlewaresConfig,
+				},
+			})
+			serviceManager := service.NewManager(rtConf.Services, http.DefaultTransport)
+			middlewaresBuilder := middleware.NewBuilder(rtConf.Middlewares, serviceManager)
+			responseModifierFactory := responsemodifiers.NewBuilder(rtConf.Middlewares)
+			routerManager := NewManager(rtConf.Routers, serviceManager, middlewaresBuilder, responseModifierFactory)
 
 			handlers := routerManager.BuildHandlers(context.Background(), test.entryPoints, false)
 
@@ -443,6 +455,310 @@ func TestAccessLog(t *testing.T) {
 	}
 }
 
+func TestRuntimeConfiguration(t *testing.T) {
+	testCases := []struct {
+		desc             string
+		serviceConfig    map[string]*config.Service
+		routerConfig     map[string]*config.Router
+		middlewareConfig map[string]*config.Middleware
+		expectedError    int
+	}{
+		{
+			desc: "No error",
+			serviceConfig: map[string]*config.Service{
+				"foo-service": {
+					LoadBalancer: &config.LoadBalancerService{
+						Servers: []config.Server{
+							{
+								URL:    "http://127.0.0.1:8085",
+								Weight: 1,
+							},
+							{
+								URL:    "http://127.0.0.1:8086",
+								Weight: 1,
+							},
+						},
+						Method: "wrr",
+						HealthCheck: &config.HealthCheck{
+							Interval: "500ms",
+							Path:     "/health",
+						},
+					},
+				},
+			},
+			routerConfig: map[string]*config.Router{
+				"foo": {
+					EntryPoints: []string{"web"},
+					Service:     "foo-service",
+					Rule:        "Host(`bar.foo`)",
+				},
+				"bar": {
+					EntryPoints: []string{"web"},
+					Service:     "foo-service",
+					Rule:        "Host(`foo.bar`)",
+				},
+			},
+			expectedError: 0,
+		},
+		{
+			desc: "One router with wrong rule",
+			serviceConfig: map[string]*config.Service{
+				"foo-service": {
+					LoadBalancer: &config.LoadBalancerService{
+						Servers: []config.Server{
+							{
+								URL:    "http://127.0.0.1",
+								Weight: 1,
+							},
+						},
+						Method: "wrr",
+					},
+				},
+			},
+			routerConfig: map[string]*config.Router{
+				"foo": {
+					EntryPoints: []string{"web"},
+					Service:     "foo-service",
+					Rule:        "WrongRule(`bar.foo`)",
+				},
+				"bar": {
+					EntryPoints: []string{"web"},
+					Service:     "foo-service",
+					Rule:        "Host(`foo.bar`)",
+				},
+			},
+			expectedError: 1,
+		},
+		{
+			desc: "All router with wrong rule",
+			serviceConfig: map[string]*config.Service{
+				"foo-service": {
+					LoadBalancer: &config.LoadBalancerService{
+						Servers: []config.Server{
+							{
+								URL:    "http://127.0.0.1",
+								Weight: 1,
+							},
+						},
+						Method: "wrr",
+					},
+				},
+			},
+			routerConfig: map[string]*config.Router{
+				"foo": {
+					EntryPoints: []string{"web"},
+					Service:     "foo-service",
+					Rule:        "WrongRule(`bar.foo`)",
+				},
+				"bar": {
+					EntryPoints: []string{"web"},
+					Service:     "foo-service",
+					Rule:        "WrongRule(`foo.bar`)",
+				},
+			},
+			expectedError: 2,
+		},
+		{
+			desc: "Router with unknown service",
+			serviceConfig: map[string]*config.Service{
+				"foo-service": {
+					LoadBalancer: &config.LoadBalancerService{
+						Servers: []config.Server{
+							{
+								URL:    "http://127.0.0.1",
+								Weight: 1,
+							},
+						},
+						Method: "wrr",
+					},
+				},
+			},
+			routerConfig: map[string]*config.Router{
+				"foo": {
+					EntryPoints: []string{"web"},
+					Service:     "wrong-service",
+					Rule:        "Host(`bar.foo`)",
+				},
+				"bar": {
+					EntryPoints: []string{"web"},
+					Service:     "foo-service",
+					Rule:        "Host(`foo.bar`)",
+				},
+			},
+			expectedError: 1,
+		},
+		{
+			desc: "Router with broken service",
+			serviceConfig: map[string]*config.Service{
+				"foo-service": {
+					LoadBalancer: nil,
+				},
+			},
+			routerConfig: map[string]*config.Router{
+				"bar": {
+					EntryPoints: []string{"web"},
+					Service:     "foo-service",
+					Rule:        "Host(`foo.bar`)",
+				},
+			},
+			expectedError: 2,
+		},
+		{
+			desc: "Router with middleware",
+			serviceConfig: map[string]*config.Service{
+				"foo-service": {
+					LoadBalancer: &config.LoadBalancerService{
+						Servers: []config.Server{
+							{
+								URL:    "http://127.0.0.1",
+								Weight: 1,
+							},
+						},
+						Method: "wrr",
+					},
+				},
+			},
+			middlewareConfig: map[string]*config.Middleware{
+				"auth": {
+					BasicAuth: &config.BasicAuth{
+						Users: []string{"admin:admin"},
+					},
+				},
+				"addPrefixTest": {
+					AddPrefix: &config.AddPrefix{
+						Prefix: "/toto",
+					},
+				},
+			},
+			routerConfig: map[string]*config.Router{
+				"bar": {
+					EntryPoints: []string{"web"},
+					Service:     "foo-service",
+					Rule:        "Host(`foo.bar`)",
+					Middlewares: []string{"auth", "addPrefixTest"},
+				},
+				"test": {
+					EntryPoints: []string{"web"},
+					Service:     "foo-service",
+					Rule:        "Host(`foo.bar.other`)",
+					Middlewares: []string{"addPrefixTest", "auth"},
+				},
+			},
+		},
+		{
+			desc: "Router with unknown middleware",
+			serviceConfig: map[string]*config.Service{
+				"foo-service": {
+					LoadBalancer: &config.LoadBalancerService{
+						Servers: []config.Server{
+							{
+								URL:    "http://127.0.0.1",
+								Weight: 1,
+							},
+						},
+						Method: "wrr",
+					},
+				},
+			},
+			middlewareConfig: map[string]*config.Middleware{
+				"auth": {
+					BasicAuth: &config.BasicAuth{
+						Users: []string{"admin:admin"},
+					},
+				},
+			},
+			routerConfig: map[string]*config.Router{
+				"bar": {
+					EntryPoints: []string{"web"},
+					Service:     "foo-service",
+					Rule:        "Host(`foo.bar`)",
+					Middlewares: []string{"unknown"},
+				},
+			},
+			expectedError: 1,
+		},
+
+		{
+			desc: "Router with broken middleware",
+			serviceConfig: map[string]*config.Service{
+				"foo-service": {
+					LoadBalancer: &config.LoadBalancerService{
+						Servers: []config.Server{
+							{
+								URL:    "http://127.0.0.1",
+								Weight: 1,
+							},
+						},
+						Method: "wrr",
+					},
+				},
+			},
+			middlewareConfig: map[string]*config.Middleware{
+				"auth": {
+					BasicAuth: &config.BasicAuth{
+						Users: []string{"foo"},
+					},
+				},
+			},
+			routerConfig: map[string]*config.Router{
+				"bar": {
+					EntryPoints: []string{"web"},
+					Service:     "foo-service",
+					Rule:        "Host(`foo.bar`)",
+					Middlewares: []string{"auth"},
+				},
+			},
+			expectedError: 2,
+		},
+	}
+
+	for _, test := range testCases {
+		test := test
+
+		t.Run(test.desc, func(t *testing.T) {
+			t.Parallel()
+
+			entryPoints := []string{"web"}
+
+			rtConf := config.NewRuntimeConfig(config.Configuration{
+				HTTP: &config.HTTPConfiguration{
+					Services:    test.serviceConfig,
+					Routers:     test.routerConfig,
+					Middlewares: test.middlewareConfig,
+				},
+			})
+			serviceManager := service.NewManager(rtConf.Services, http.DefaultTransport)
+			middlewaresBuilder := middleware.NewBuilder(rtConf.Middlewares, serviceManager)
+			responseModifierFactory := responsemodifiers.NewBuilder(map[string]*config.MiddlewareInfo{})
+			routerManager := NewManager(rtConf.Routers, serviceManager, middlewaresBuilder, responseModifierFactory)
+
+			_ = routerManager.BuildHandlers(context.Background(), entryPoints, false)
+
+			// even though rtConf was passed by argument to the manager builders above,
+			// it's ok to use it as the result we check, because everything worth checking
+			// can be accessed by pointers in it.
+			var allErrors int
+			for _, v := range rtConf.Services {
+				if v.Err != nil {
+					allErrors++
+				}
+			}
+			for _, v := range rtConf.Routers {
+				if v.Err != "" {
+					allErrors++
+				}
+			}
+			for _, v := range rtConf.Middlewares {
+				if v.Err != nil {
+					allErrors++
+				}
+			}
+			assert.Equal(t, test.expectedError, allErrors)
+		})
+	}
+
+}
+
 type staticTransport struct {
 	res *http.Response
 }
@@ -480,11 +796,17 @@ func BenchmarkRouterServe(b *testing.B) {
 	}
 	entryPoints := []string{"web"}
 
-	serviceManager := service.NewManager(serviceConfig, &staticTransport{res})
-	middlewaresBuilder := middleware.NewBuilder(map[string]*config.Middleware{}, serviceManager)
-	responseModifierFactory := responsemodifiers.NewBuilder(map[string]*config.Middleware{})
-
-	routerManager := NewManager(routersConfig, serviceManager, middlewaresBuilder, responseModifierFactory)
+	rtConf := config.NewRuntimeConfig(config.Configuration{
+		HTTP: &config.HTTPConfiguration{
+			Services:    serviceConfig,
+			Routers:     routersConfig,
+			Middlewares: map[string]*config.Middleware{},
+		},
+	})
+	serviceManager := service.NewManager(rtConf.Services, &staticTransport{res})
+	middlewaresBuilder := middleware.NewBuilder(rtConf.Middlewares, serviceManager)
+	responseModifierFactory := responsemodifiers.NewBuilder(rtConf.Middlewares)
+	routerManager := NewManager(rtConf.Routers, serviceManager, middlewaresBuilder, responseModifierFactory)
 
 	handlers := routerManager.BuildHandlers(context.Background(), entryPoints, false)
 
@@ -498,6 +820,7 @@ func BenchmarkRouterServe(b *testing.B) {
 	}
 
 }
+
 func BenchmarkService(b *testing.B) {
 	res := &http.Response{
 		StatusCode: 200,
@@ -518,7 +841,12 @@ func BenchmarkService(b *testing.B) {
 		},
 	}
 
-	serviceManager := service.NewManager(serviceConfig, &staticTransport{res})
+	rtConf := config.NewRuntimeConfig(config.Configuration{
+		HTTP: &config.HTTPConfiguration{
+			Services: serviceConfig,
+		},
+	})
+	serviceManager := service.NewManager(rtConf.Services, &staticTransport{res})
 	w := httptest.NewRecorder()
 	req := testhelpers.MustNewRequest(http.MethodGet, "http://foo.bar/", nil)
 

pkg/server/router/tcp/router.go

@@ -3,6 +3,7 @@ package tcp
 import (
 	"context"
 	"crypto/tls"
+	"fmt"
 	"net/http"
 
 	"github.com/containous/traefik/pkg/config"
@@ -14,14 +15,14 @@ import (
 )
 
 // NewManager Creates a new Manager
-func NewManager(routers map[string]*config.TCPRouter,
+func NewManager(conf *config.RuntimeConfiguration,
 	serviceManager *tcpservice.Manager,
 	httpHandlers map[string]http.Handler,
 	httpsHandlers map[string]http.Handler,
 	tlsConfig *tls.Config,
 ) *Manager {
 	return &Manager{
-		configs:        routers,
+		configs:        conf.TCPRouters,
 		serviceManager: serviceManager,
 		httpHandlers:   httpHandlers,
 		httpsHandlers:  httpsHandlers,
@@ -31,7 +32,7 @@ func NewManager(routers map[string]*config.TCPRouter,
 
 // Manager is a route/router manager
 type Manager struct {
-	configs        map[string]*config.TCPRouter
+	configs        map[string]*config.TCPRouterInfo
 	serviceManager *tcpservice.Manager
 	httpHandlers   map[string]http.Handler
 	httpsHandlers  map[string]http.Handler
@@ -60,7 +61,7 @@ func (m *Manager) BuildHandlers(rootCtx context.Context, entryPoints []string) m
 	return entryPointHandlers
 }
 
-func (m *Manager) buildEntryPointHandler(ctx context.Context, configs map[string]*config.TCPRouter, handlerHTTP http.Handler, handlerHTTPS http.Handler) (*tcp.Router, error) {
+func (m *Manager) buildEntryPointHandler(ctx context.Context, configs map[string]*config.TCPRouterInfo, handlerHTTP http.Handler, handlerHTTPS http.Handler) (*tcp.Router, error) {
 	router := &tcp.Router{}
 	router.HTTPHandler(handlerHTTP)
 	router.HTTPSHandler(handlerHTTPS, m.tlsConfig)
@@ -71,18 +72,21 @@ func (m *Manager) buildEntryPointHandler(ctx context.Context, configs map[string
 
 		handler, err := m.serviceManager.BuildTCP(ctxRouter, routerConfig.Service)
 		if err != nil {
+			routerConfig.Err = err.Error()
 			logger.Error(err)
 			continue
 		}
 
 		domains, err := rules.ParseHostSNI(routerConfig.Rule)
 		if err != nil {
-			logger.Debugf("Unknown rule %s", routerConfig.Rule)
+			routerErr := fmt.Errorf("unknown rule %s", routerConfig.Rule)
+			routerConfig.Err = routerErr.Error()
+			logger.Debug(routerErr)
 			continue
 		}
 
 		for _, domain := range domains {
-			logger.Debugf("Add route %s on TCP", domain)
+			logger.Debugf("Adding route %s on TCP", domain)
 			switch {
 			case routerConfig.TLS != nil:
 				if routerConfig.TLS.Passthrough {
@@ -101,8 +105,17 @@ func (m *Manager) buildEntryPointHandler(ctx context.Context, configs map[string
 	return router, nil
 }
 
-func (m *Manager) filteredRouters(ctx context.Context, entryPoints []string) map[string]map[string]*config.TCPRouter {
-	entryPointsRouters := make(map[string]map[string]*config.TCPRouter)
+func contains(entryPoints []string, entryPointName string) bool {
+	for _, name := range entryPoints {
+		if name == entryPointName {
+			return true
+		}
+	}
+	return false
+}
+
+func (m *Manager) filteredRouters(ctx context.Context, entryPoints []string) map[string]map[string]*config.TCPRouterInfo {
+	entryPointsRouters := make(map[string]map[string]*config.TCPRouterInfo)
 
 	for rtName, rt := range m.configs {
 		eps := rt.EntryPoints
@@ -118,7 +131,7 @@ func (m *Manager) filteredRouters(ctx context.Context, entryPoints []string) map
 			}
 
 			if _, ok := entryPointsRouters[entryPointName]; !ok {
-				entryPointsRouters[entryPointName] = make(map[string]*config.TCPRouter)
+				entryPointsRouters[entryPointName] = make(map[string]*config.TCPRouterInfo)
 			}
 
 			entryPointsRouters[entryPointName][rtName] = rt
@@ -127,12 +140,3 @@ func (m *Manager) filteredRouters(ctx context.Context, entryPoints []string) map
 
 	return entryPointsRouters
 }
-
-func contains(entryPoints []string, entryPointName string) bool {
-	for _, name := range entryPoints {
-		if name == entryPointName {
-			return true
-		}
-	}
-	return false
-}

pkg/server/router/tcp/router_test.go

@@ -0,0 +1,223 @@
+package tcp
+
+import (
+	"context"
+	"testing"
+
+	"github.com/containous/traefik/pkg/config"
+	"github.com/containous/traefik/pkg/server/service/tcp"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRuntimeConfiguration(t *testing.T) {
+	testCases := []struct {
+		desc          string
+		serviceConfig map[string]*config.TCPServiceInfo
+		routerConfig  map[string]*config.TCPRouterInfo
+		expectedError int
+	}{
+		{
+			desc: "No error",
+			serviceConfig: map[string]*config.TCPServiceInfo{
+				"foo-service": {
+					TCPService: &config.TCPService{
+						LoadBalancer: &config.TCPLoadBalancerService{
+							Servers: []config.TCPServer{
+								{
+									Port:    "8085",
+									Address: "127.0.0.1:8085",
+								},
+								{
+									Address: "127.0.0.1:8086",
+									Port:    "8086",
+								},
+							},
+							Method: "wrr",
+						},
+					},
+				},
+			},
+			routerConfig: map[string]*config.TCPRouterInfo{
+				"foo": {
+					TCPRouter: &config.TCPRouter{
+						EntryPoints: []string{"web"},
+						Service:     "foo-service",
+						Rule:        "HostSNI(`bar.foo`)",
+					},
+				},
+				"bar": {
+					TCPRouter: &config.TCPRouter{
+
+						EntryPoints: []string{"web"},
+						Service:     "foo-service",
+						Rule:        "HostSNI(`foo.bar`)",
+					},
+				},
+			},
+			expectedError: 0,
+		},
+		{
+			desc: "One router with wrong rule",
+			serviceConfig: map[string]*config.TCPServiceInfo{
+				"foo-service": {
+					TCPService: &config.TCPService{
+						LoadBalancer: &config.TCPLoadBalancerService{
+							Servers: []config.TCPServer{
+								{
+									Address: "127.0.0.1:80",
+								},
+							},
+							Method: "wrr",
+						},
+					},
+				},
+			},
+			routerConfig: map[string]*config.TCPRouterInfo{
+				"foo": {
+					TCPRouter: &config.TCPRouter{
+						EntryPoints: []string{"web"},
+						Service:     "foo-service",
+						Rule:        "WrongRule(`bar.foo`)",
+					},
+				},
+
+				"bar": {
+					TCPRouter: &config.TCPRouter{
+						EntryPoints: []string{"web"},
+						Service:     "foo-service",
+						Rule:        "HostSNI(`foo.bar`)",
+					},
+				},
+			},
+			expectedError: 1,
+		},
+		{
+			desc: "All router with wrong rule",
+			serviceConfig: map[string]*config.TCPServiceInfo{
+				"foo-service": {
+					TCPService: &config.TCPService{
+						LoadBalancer: &config.TCPLoadBalancerService{
+							Servers: []config.TCPServer{
+								{
+									Address: "127.0.0.1:80",
+									Weight:  1,
+								},
+							},
+							Method: "wrr",
+						},
+					},
+				},
+			},
+			routerConfig: map[string]*config.TCPRouterInfo{
+				"foo": {
+					TCPRouter: &config.TCPRouter{
+						EntryPoints: []string{"web"},
+						Service:     "foo-service",
+						Rule:        "WrongRule(`bar.foo`)",
+					},
+				},
+				"bar": {
+					TCPRouter: &config.TCPRouter{
+						EntryPoints: []string{"web"},
+						Service:     "foo-service",
+						Rule:        "WrongRule(`foo.bar`)",
+					},
+				},
+			},
+			expectedError: 2,
+		},
+		{
+			desc: "Router with unknown service",
+			serviceConfig: map[string]*config.TCPServiceInfo{
+				"foo-service": {
+					TCPService: &config.TCPService{
+						LoadBalancer: &config.TCPLoadBalancerService{
+							Servers: []config.TCPServer{
+								{
+									Address: "127.0.0.1:80",
+									Weight:  1,
+								},
+							},
+							Method: "wrr",
+						},
+					},
+				},
+			},
+			routerConfig: map[string]*config.TCPRouterInfo{
+				"foo": {
+					TCPRouter: &config.TCPRouter{
+						EntryPoints: []string{"web"},
+						Service:     "wrong-service",
+						Rule:        "HostSNI(`bar.foo`)",
+					},
+				},
+				"bar": {
+					TCPRouter: &config.TCPRouter{
+
+						EntryPoints: []string{"web"},
+						Service:     "foo-service",
+						Rule:        "HostSNI(`foo.bar`)",
+					},
+				},
+			},
+			expectedError: 1,
+		},
+		{
+			desc: "Router with broken service",
+			serviceConfig: map[string]*config.TCPServiceInfo{
+				"foo-service": {
+					TCPService: &config.TCPService{
+						LoadBalancer: nil,
+					},
+				},
+			},
+			routerConfig: map[string]*config.TCPRouterInfo{
+				"bar": {
+					TCPRouter: &config.TCPRouter{
+						EntryPoints: []string{"web"},
+						Service:     "foo-service",
+						Rule:        "HostSNI(`foo.bar`)",
+					},
+				},
+			},
+			expectedError: 2,
+		},
+	}
+
+	for _, test := range testCases {
+		test := test
+
+		t.Run(test.desc, func(t *testing.T) {
+			t.Parallel()
+
+			entryPoints := []string{"web"}
+
+			conf := &config.RuntimeConfiguration{
+				TCPServices: test.serviceConfig,
+				TCPRouters:  test.routerConfig,
+			}
+			serviceManager := tcp.NewManager(conf)
+			routerManager := NewManager(conf, serviceManager,
+				nil, nil, nil)
+
+			_ = routerManager.BuildHandlers(context.Background(), entryPoints)
+
+			// even though conf was passed by argument to the manager builders above,
+			// it's ok to use it as the result we check, because everything worth checking
+			// can be accessed by pointers in it.
+			var allErrors int
+			for _, v := range conf.TCPServices {
+				if v.Err != nil {
+					allErrors++
+				}
+			}
+			for _, v := range conf.TCPRouters {
+				if v.Err != "" {
+					allErrors++
+				}
+			}
+			assert.Equal(t, test.expectedError, allErrors)
+		})
+	}
+
+}