Don't add TCP proxy when error occurs during creation.

pkg/server/service/tcp/service.go

@@ -25,31 +25,40 @@ func NewManager(configs map[string]*config.TCPService) *Manager {
 
 // BuildTCP Creates a tcp.Handler for a service configuration.
 func (m *Manager) BuildTCP(rootCtx context.Context, serviceName string) (tcp.Handler, error) {
-	ctx := log.With(rootCtx, log.Str(log.ServiceName, serviceName))
+	serviceQualifiedName := internal.GetQualifiedName(rootCtx, serviceName)
+	ctx := internal.AddProviderInContext(rootCtx, serviceQualifiedName)
+	ctx = log.With(ctx, log.Str(log.ServiceName, serviceName))
 
-	serviceName = internal.GetQualifiedName(ctx, serviceName)
-	ctx = internal.AddProviderInContext(ctx, serviceName)
-
-	if conf, ok := m.configs[serviceName]; ok {
-		// FIXME Check if the service is declared multiple times with different types
-		if conf.LoadBalancer != nil {
-			loadBalancer := tcp.NewRRLoadBalancer()
-
-			var handler tcp.Handler
-			for _, server := range conf.LoadBalancer.Servers {
-				_, err := parseIP(server.Address)
-				if err == nil {
-					handler, _ = tcp.NewProxy(server.Address)
-					loadBalancer.AddServer(handler)
-				} else {
-					log.FromContext(ctx).Errorf("Invalid IP address for a %s server %s: %v", serviceName, server.Address, err)
-				}
-			}
-			return loadBalancer, nil
-		}
-		return nil, fmt.Errorf("the service %q doesn't have any TCP load balancer", serviceName)
+	conf, ok := m.configs[serviceQualifiedName]
+	if !ok {
+		return nil, fmt.Errorf("the service %q does not exits", serviceQualifiedName)
 	}
-	return nil, fmt.Errorf("the service %q does not exits", serviceName)
+
+	if conf.LoadBalancer == nil {
+		return nil, fmt.Errorf("the service %q doesn't have any TCP load balancer", serviceQualifiedName)
+	}
+
+	logger := log.FromContext(ctx)
+
+	// FIXME Check if the service is declared multiple times with different types
+	loadBalancer := tcp.NewRRLoadBalancer()
+
+	for _, server := range conf.LoadBalancer.Servers {
+		if _, err := parseIP(server.Address); err != nil {
+			logger.Errorf("Invalid IP address for a %q server %q: %v", serviceQualifiedName, server.Address, err)
+			continue
+		}
+
+		handler, err := tcp.NewProxy(server.Address)
+		if err != nil {
+			logger.Errorf("In service %q server %q: %v", serviceQualifiedName, server.Address, err)
+			continue
+		}
+
+		loadBalancer.AddServer(handler)
+	}
+
+	return loadBalancer, nil
 }
 
 func parseIP(s string) (string, error) {

pkg/server/service/tcp/service_test.go

@@ -0,0 +1,82 @@
+package tcp
+
+import (
+	"context"
+	"testing"
+
+	"github.com/containous/traefik/pkg/config"
+	"github.com/stretchr/testify/require"
+)
+
+func TestManager_BuildTCP(t *testing.T) {
+	testCases := []struct {
+		desc          string
+		serviceName   string
+		configs       map[string]*config.TCPService
+		expectedError string
+	}{
+		{
+			desc:          "without configuration",
+			serviceName:   "test",
+			configs:       nil,
+			expectedError: `the service "test" does not exits`,
+		},
+		{
+			desc:        "missing lb configuration",
+			serviceName: "test",
+			configs: map[string]*config.TCPService{
+				"test": {},
+			},
+			expectedError: `the service "test" doesn't have any TCP load balancer`,
+		},
+		{
+			desc:        "no such host",
+			serviceName: "test",
+			configs: map[string]*config.TCPService{
+				"test": {
+					LoadBalancer: &config.TCPLoadBalancerService{
+						Servers: []config.TCPServer{
+							{Address: "test:31"},
+						},
+					},
+				},
+			},
+		},
+		{
+			desc:        "invalid IP address",
+			serviceName: "test",
+			configs: map[string]*config.TCPService{
+				"test": {
+					LoadBalancer: &config.TCPLoadBalancerService{
+						Servers: []config.TCPServer{
+							{Address: "foobar"},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	for _, test := range testCases {
+		test := test
+		t.Run(test.desc, func(t *testing.T) {
+			t.Parallel()
+
+			manager := NewManager(test.configs)
+
+			handler, err := manager.BuildTCP(context.Background(), test.serviceName)
+
+			if test.expectedError != "" {
+				if err == nil {
+					require.Error(t, err)
+				} else {
+					require.EqualError(t, err, test.expectedError)
+					require.Nil(t, handler)
+				}
+			} else {
+				require.NoError(t, err)
+				require.NotNil(t, handler)
+			}
+		})
+	}
+}