Remove dead code.

integration/consul_test.go

@@ -194,12 +194,14 @@ func (s *ConsulSuite) TestNominalConfiguration(c *check.C) {
 	c.Assert(err, checker.IsNil)
 
 	req, err = http.NewRequest(http.MethodGet, "http://127.0.0.1:8000/test2", nil)
-	try.Request(req, 500*time.Millisecond, try.StatusCodeIs(http.StatusNotFound))
+	c.Assert(err, checker.IsNil)
+	err = try.Request(req, 500*time.Millisecond, try.StatusCodeIs(http.StatusNotFound))
 	c.Assert(err, checker.IsNil)
 
 	req, err = http.NewRequest(http.MethodGet, "http://127.0.0.1:8000/", nil)
+	c.Assert(err, checker.IsNil)
 	req.Host = "test2.localhost"
-	try.Request(req, 500*time.Millisecond, try.StatusCodeIs(http.StatusNotFound))
+	err = try.Request(req, 500*time.Millisecond, try.StatusCodeIs(http.StatusNotFound))
 	c.Assert(err, checker.IsNil)
 }
 

middlewares/accesslog/logger.go

@@ -267,23 +267,26 @@ func (l *LogHandler) redactHeaders(headers http.Header, fields logrus.Fields, pr
 }
 
 func (l *LogHandler) keepAccessLog(statusCode, retryAttempts int) bool {
-	switch {
+	if l.config.Filters == nil {
-	case l.config.Filters == nil:
 		// no filters were specified
 		return true
-	case len(l.httpCodeRanges) == 0 && l.config.Filters.RetryAttempts == false:
+	}
+
+	if len(l.httpCodeRanges) == 0 && !l.config.Filters.RetryAttempts {
 		// empty filters were specified, e.g. by passing --accessLog.filters only (without other filter options)
 		return true
-	case l.httpCodeRanges.Contains(statusCode):
-		return true
-	case l.config.Filters.RetryAttempts == true && retryAttempts > 0:
-		return true
-	default:
-		return false
 	}
-}
 
-//-------------------------------------------------------------------------------------------------
+	if l.httpCodeRanges.Contains(statusCode) {
+		return true
+	}
+
+	if l.config.Filters.RetryAttempts && retryAttempts > 0 {
+		return true
+	}
+
+	return false
+}
 
 var requestCounter uint64 // Request ID
 

middlewares/tracing/tracing.go

@@ -73,7 +73,10 @@ func (t *Tracing) IsEnabled() bool {
 // Close tracer
 func (t *Tracing) Close() {
 	if t.closer != nil {
-		t.closer.Close()
+		err := t.closer.Close()
+		if err != nil {
+			log.Warn(err)
+		}
 	}
 }
 
@@ -104,10 +107,13 @@ func GetSpan(r *http.Request) opentracing.Span {
 // InjectRequestHeaders used to inject OpenTracing headers into the request
 func InjectRequestHeaders(r *http.Request) {
 	if span := GetSpan(r); span != nil {
-		opentracing.GlobalTracer().Inject(
+		err := opentracing.GlobalTracer().Inject(
 			span.Context(),
 			opentracing.HTTPHeaders,
 			opentracing.HTTPHeadersCarrier(r.Header))
+		if err != nil {
+			log.Error(err)
+		}
 	}
 }
 

provider/acme/provider.go

@@ -347,7 +347,6 @@ func (p *Provider) Provide(configurationChan chan<- types.ConfigMessage, pool *s
 		safe.Go(func() {
 			if _, err := p.resolveCertificate(domain, true); err != nil {
 				log.Errorf("Unable to obtain ACME certificate for domains %q : %v", strings.Join(domain.ToStrArray(), ","), err)
-			} else {
 			}
 		})
 	}
@@ -401,15 +400,6 @@ func (p *Provider) watchCertificate() {
 	})
 }
 
-func (p *Provider) deleteCertificateForDomain(domain types.Domain) {
-	for k, cert := range p.certificates {
-		if reflect.DeepEqual(cert.Domain, domain) {
-			p.certificates = append(p.certificates[:k], p.certificates[k+1:]...)
-		}
-	}
-	p.saveCertificates()
-}
-
 func (p *Provider) saveCertificates() {
 	err := p.Store.SaveCertificates(p.certificates)
 	if err != nil {

provider/consulcatalog/config.go

@@ -237,19 +237,6 @@ func hasTag(name string, tags []string) bool {
 	return false
 }
 
-func hasTagPrefix(name string, tags []string) bool {
-	lowerName := strings.ToLower(name)
-
-	for _, tag := range tags {
-		lowerTag := strings.ToLower(tag)
-
-		if strings.HasPrefix(lowerTag, lowerName) {
-			return true
-		}
-	}
-	return false
-}
-
 func getTag(name string, tags []string, defaultValue string) string {
 	lowerName := strings.ToLower(name)
 

provider/consulcatalog/deprecated_config.go

@@ -156,17 +156,6 @@ func (p *Provider) getFuncSliceAttribute(name string) func(tags []string) []stri
 	}
 }
 
-// Deprecated
-func (p *Provider) getMapAttribute(name string, tags []string) map[string]string {
-	rawValue := getTag(p.getPrefixedName(name), tags, "")
-
-	if len(rawValue) == 0 {
-		return nil
-	}
-
-	return label.ParseMapValue(p.getPrefixedName(name), rawValue)
-}
-
 // Deprecated
 func (p *Provider) getFuncIntAttribute(name string, defaultValue int) func(tags []string) int {
 	return func(tags []string) int {
@@ -180,13 +169,6 @@ func (p *Provider) getFuncBoolAttribute(name string, defaultValue bool) func(tag
 	}
 }
 
-// Deprecated
-func (p *Provider) getFuncHasAttributePrefix(name string) func(tags []string) bool {
-	return func(tags []string) bool {
-		return p.hasAttributePrefix(name, tags)
-	}
-}
-
 // Deprecated
 func (p *Provider) getInt64Attribute(name string, tags []string, defaultValue int64) int64 {
 	rawValue := getTag(p.getPrefixedName(name), tags, "")
@@ -244,7 +226,3 @@ func (p *Provider) getBoolAttribute(name string, tags []string, defaultValue boo
 	}
 	return value
 }
-
-func (p *Provider) hasAttributePrefix(name string, tags []string) bool {
-	return hasTagPrefix(p.getPrefixedName(name), tags)
-}

provider/docker/deprecated_service.go

@@ -136,12 +136,6 @@ func getFuncServiceIntLabelV1(labelSuffix string, defaultValue int) func(contain
 	}
 }
 
-// Deprecated
-func hasStrictServiceLabelV1(serviceLabels map[string]string, labelSuffix string) bool {
-	value, ok := serviceLabels[labelSuffix]
-	return ok && len(value) > 0
-}
-
 // Deprecated
 func getServiceStringValueV1(container dockerData, serviceLabels map[string]string, labelSuffix string, defaultValue string) string {
 	if value, ok := serviceLabels[labelSuffix]; ok {
@@ -150,23 +144,6 @@ func getServiceStringValueV1(container dockerData, serviceLabels map[string]stri
 	return label.GetStringValue(container.Labels, label.Prefix+labelSuffix, defaultValue)
 }
 
-// Deprecated
-func getStrictServiceStringValueV1(serviceLabels map[string]string, labelSuffix string, defaultValue string) string {
-	if value, ok := serviceLabels[labelSuffix]; ok {
-		return value
-	}
-	return defaultValue
-}
-
-// Deprecated
-func getServiceMapValueV1(container dockerData, serviceLabels map[string]string, serviceName string, labelSuffix string) map[string]string {
-	if value, ok := serviceLabels[labelSuffix]; ok {
-		lblName := label.GetServiceLabel(labelSuffix, serviceName)
-		return label.ParseMapValue(lblName, value)
-	}
-	return label.GetMapValue(container.Labels, label.Prefix+labelSuffix)
-}
-
 // Deprecated
 func getServiceSliceValueV1(container dockerData, serviceLabels map[string]string, labelSuffix string) []string {
 	if value, ok := serviceLabels[labelSuffix]; ok {
@@ -197,17 +174,6 @@ func getServiceIntLabelV1(container dockerData, serviceName string, labelSuffix
 	return label.GetIntValue(container.Labels, label.Prefix+labelSuffix, defaultValue)
 }
 
-// Deprecated
-func getServiceInt64ValueV1(container dockerData, serviceLabels map[string]string, labelSuffix string, defaultValue int64) int64 {
-	if rawValue, ok := serviceLabels[labelSuffix]; ok {
-		value, err := strconv.ParseInt(rawValue, 10, 64)
-		if err == nil {
-			return value
-		}
-	}
-	return label.GetInt64Value(container.Labels, label.Prefix+labelSuffix, defaultValue)
-}
-
 // Deprecated
 func getServiceLabelsV1(container dockerData, serviceName string) label.SegmentPropertyValues {
 	return label.ExtractServiceProperties(container.Labels)[serviceName]

provider/docker/deprecated_service_test.go

@@ -405,154 +405,6 @@ func TestDockerGetServiceStringValueV1(t *testing.T) {
 	}
 }
 
-func TestDockerHasStrictServiceLabelV1(t *testing.T) {
-	testCases := []struct {
-		desc          string
-		serviceLabels map[string]string
-		labelSuffix   string
-		expected      bool
-	}{
-		{
-			desc:          "should return false when service don't have label",
-			serviceLabels: map[string]string{},
-			labelSuffix:   "",
-			expected:      false,
-		},
-		{
-			desc: "should return true when service have label",
-			serviceLabels: map[string]string{
-				"foo": "bar",
-			},
-			labelSuffix: "foo",
-			expected:    true,
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			actual := hasStrictServiceLabelV1(test.serviceLabels, test.labelSuffix)
-
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestDockerGetStrictServiceStringValueV1(t *testing.T) {
-	testCases := []struct {
-		desc          string
-		serviceLabels map[string]string
-		labelSuffix   string
-		defaultValue  string
-		expected      string
-	}{
-		{
-			desc: "should return a string when the label exists",
-			serviceLabels: map[string]string{
-				"foo": "bar",
-			},
-			labelSuffix: "foo",
-			expected:    "bar",
-		},
-		{
-			desc: "should return a string when the label exists and value empty",
-			serviceLabels: map[string]string{
-				"foo": "",
-			},
-			labelSuffix:  "foo",
-			defaultValue: "cube",
-			expected:     "",
-		},
-		{
-			desc:          "should return the default value when the label doesn't exist",
-			serviceLabels: map[string]string{},
-			labelSuffix:   "foo",
-			defaultValue:  "cube",
-			expected:      "cube",
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			actual := getStrictServiceStringValueV1(test.serviceLabels, test.labelSuffix, test.defaultValue)
-
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestDockerGetServiceMapValueV1(t *testing.T) {
-	testCases := []struct {
-		desc          string
-		container     docker.ContainerJSON
-		serviceLabels map[string]string
-		serviceName   string
-		labelSuffix   string
-		expected      map[string]string
-	}{
-		{
-			desc: "should return when no labels",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{})),
-			serviceLabels: map[string]string{},
-			serviceName:   "soo",
-			labelSuffix:   "foo",
-			expected:      nil,
-		},
-		{
-			desc: "should return a map when label exists",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{
-					"traefik.foo": "bir:fii",
-				})),
-			serviceLabels: map[string]string{
-				"foo": "bar:foo",
-			},
-			serviceName: "soo",
-			labelSuffix: "foo",
-			expected: map[string]string{
-				"Bar": "foo",
-			},
-		},
-		{
-			desc: "should return a map when label exists (fallback to container labels)",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{
-					"traefik.foo": "bir:fii",
-				})),
-			serviceLabels: map[string]string{
-				"fo": "bar:foo",
-			},
-			serviceName: "soo",
-			labelSuffix: "foo",
-			expected: map[string]string{
-				"Bir": "fii",
-			},
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			dData := parseContainer(test.container)
-
-			actual := getServiceMapValueV1(dData, test.serviceLabels, test.serviceName, test.labelSuffix)
-
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
 func TestDockerGetServiceSliceValueV1(t *testing.T) {
 	testCases := []struct {
 		desc          string
@@ -672,67 +524,6 @@ func TestDockerGetServiceBoolValueV1(t *testing.T) {
 	}
 }
 
-func TestDockerGetServiceInt64ValueV1(t *testing.T) {
-	testCases := []struct {
-		desc          string
-		container     docker.ContainerJSON
-		serviceLabels map[string]string
-		labelSuffix   string
-		defaultValue  int64
-		expected      int64
-	}{
-		{
-			desc: "should return default value when no label",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{})),
-			serviceLabels: map[string]string{},
-			labelSuffix:   "foo",
-			defaultValue:  666,
-			expected:      666,
-		},
-		{
-			desc: "should return a int64 when label",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{
-					"traefik.foo": "20",
-				})),
-			serviceLabels: map[string]string{
-				"foo": "10",
-			},
-			labelSuffix: "foo",
-			expected:    10,
-		},
-		{
-			desc: "should return a int64 when label (fallback to container labels)",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{
-					"traefik.foo": "20",
-				})),
-			serviceLabels: map[string]string{
-				"fo": "10",
-			},
-			labelSuffix: "foo",
-			expected:    20,
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			dData := parseContainer(test.container)
-
-			actual := getServiceInt64ValueV1(dData, test.serviceLabels, test.labelSuffix, test.defaultValue)
-
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
 func TestDockerCheckPortLabelsV1(t *testing.T) {
 	testCases := []struct {
 		container     docker.ContainerJSON

tls/certificate.go

@@ -90,12 +90,15 @@ func (f FileOrContent) Read() ([]byte, error) {
 func (c *Certificates) CreateTLSConfig(entryPointName string) (*tls.Config, error) {
 	config := &tls.Config{}
 	domainsCertificates := make(map[string]map[string]*tls.Certificate)
+
 	if c.isEmpty() {
 		config.Certificates = []tls.Certificate{}
+
 		cert, err := generate.DefaultCertificate()
 		if err != nil {
 			return nil, err
 		}
+
 		config.Certificates = append(config.Certificates, *cert)
 	} else {
 		for _, certificate := range *c {
@@ -104,8 +107,9 @@ func (c *Certificates) CreateTLSConfig(entryPointName string) (*tls.Config, erro
 				log.Errorf("Unable to add a certificate to the entryPoint %q : %v", entryPointName, err)
 				continue
 			}
+
 			for _, certDom := range domainsCertificates {
-				for _, cert := range map[string]*tls.Certificate(certDom) {
+				for _, cert := range certDom {
 					config.Certificates = append(config.Certificates, *cert)
 				}
 			}

types/logs.go

@@ -28,34 +28,21 @@ type AccessLog struct {
 	Fields   *AccessLogFields  `json:"fields,omitempty" description:"AccessLogFields" export:"true"`
 }
 
-// StatusCodes holds status codes ranges to filter access log
-type StatusCodes []string
-
 // AccessLogFilters holds filters configuration
 type AccessLogFilters struct {
 	StatusCodes   StatusCodes `json:"statusCodes,omitempty" description:"Keep access logs with status codes in the specified range" export:"true"`
 	RetryAttempts bool        `json:"retryAttempts,omitempty" description:"Keep access logs when at least one retry happened" export:"true"`
 }
 
-// FieldNames holds maps of fields with specific mode
-type FieldNames map[string]string
-
-// AccessLogFields holds configuration for access log fields
-type AccessLogFields struct {
-	DefaultMode string        `json:"defaultMode,omitempty" description:"Default mode for fields: keep | drop" export:"true"`
-	Names       FieldNames    `json:"names,omitempty" description:"Override mode for fields" export:"true"`
-	Headers     *FieldHeaders `json:"headers,omitempty" description:"Headers to keep, drop or redact" export:"true"`
-}
-
-// FieldHeaderNames holds maps of fields with specific mode
-type FieldHeaderNames map[string]string
-
 // FieldHeaders holds configuration for access log headers
 type FieldHeaders struct {
 	DefaultMode string           `json:"defaultMode,omitempty" description:"Default mode for fields: keep | drop | redact" export:"true"`
 	Names       FieldHeaderNames `json:"names,omitempty" description:"Override mode for headers" export:"true"`
 }
 
+// StatusCodes holds status codes ranges to filter access log
+type StatusCodes []string
+
 // Set adds strings elem into the the parser
 // it splits str on , and ;
 func (s *StatusCodes) Set(str string) error {
@@ -79,6 +66,9 @@ func (s *StatusCodes) SetValue(val interface{}) {
 	*s = val.(StatusCodes)
 }
 
+// FieldNames holds maps of fields with specific mode
+type FieldNames map[string]string
+
 // String is the method to format the flag's value, part of the flag.Value interface.
 // The String method's output will be used in diagnostics.
 func (f *FieldNames) String() string {
@@ -111,6 +101,9 @@ func (f *FieldNames) SetValue(val interface{}) {
 	*f = val.(FieldNames)
 }
 
+// FieldHeaderNames holds maps of fields with specific mode
+type FieldHeaderNames map[string]string
+
 // String is the method to format the flag's value, part of the flag.Value interface.
 // The String method's output will be used in diagnostics.
 func (f *FieldHeaderNames) String() string {
@@ -141,6 +134,13 @@ func (f *FieldHeaderNames) SetValue(val interface{}) {
 	*f = val.(FieldHeaderNames)
 }
 
+// AccessLogFields holds configuration for access log fields
+type AccessLogFields struct {
+	DefaultMode string        `json:"defaultMode,omitempty" description:"Default mode for fields: keep | drop" export:"true"`
+	Names       FieldNames    `json:"names,omitempty" description:"Override mode for fields" export:"true"`
+	Headers     *FieldHeaders `json:"headers,omitempty" description:"Headers to keep, drop or redact" export:"true"`
+}
+
 // Keep check if the field need to be kept or dropped
 func (f *AccessLogFields) Keep(field string) bool {
 	defaultKeep := true
@@ -154,17 +154,6 @@ func (f *AccessLogFields) Keep(field string) bool {
 	return defaultKeep
 }
 
-func checkFieldValue(value string, defaultKeep bool) bool {
-	switch value {
-	case AccessLogKeep:
-		return true
-	case AccessLogDrop:
-		return false
-	default:
-		return defaultKeep
-	}
-}
-
 // KeepHeader checks if the headers need to be kept, dropped or redacted and returns the status
 func (f *AccessLogFields) KeepHeader(header string) string {
 	defaultValue := AccessLogKeep
@@ -178,6 +167,17 @@ func (f *AccessLogFields) KeepHeader(header string) string {
 	return defaultValue
 }
 
+func checkFieldValue(value string, defaultKeep bool) bool {
+	switch value {
+	case AccessLogKeep:
+		return true
+	case AccessLogDrop:
+		return false
+	default:
+		return defaultKeep
+	}
+}
+
 func checkFieldHeaderValue(value string, defaultValue string) string {
 	if value == AccessLogKeep || value == AccessLogDrop || value == AccessLogRedact {
 		return value