Small code enhancements

.golangci.toml

@@ -0,0 +1,30 @@
+[linters-settings]
+
+  [linters-settings.govet]
+    check-shadowing = true
+
+  [linters-settings.golint]
+    min-confidence = 0.0
+
+  [linters-settings.gocyclo]
+    min-complexity = 22.0
+
+  [linters-settings.maligned]
+    suggest-new = true
+
+  [linters-settings.goconst]
+    min-len = 2.0
+    min-occurrences = 2.0
+
+  [linters-settings.misspell]
+    locale = "US"
+
+[linters]
+  enable-all = true
+  disable = [
+      "maligned",
+      "lll",
+      "gas",
+      "dupl",
+      "prealloc"
+  ]

cluster/datastore.go

@@ -233,7 +233,7 @@ func (s *datastoreTransaction) Commit(object Object) error {
 	}
 	err = s.kv.StoreConfig(s.Datastore.meta)
 	if err != nil {
-		return fmt.Errorf("StoreConfig error: %s", err)
+		return fmt.Errorf("storeConfig error: %s", err)
 	}
 
 	err = s.remoteLock.Unlock()

cmd/context.go

@@ -7,7 +7,7 @@ import (
 	"syscall"
 )
 
-// ContextWithSignal create a context cancelled when SIGINT or SIGTERM are notified
+// ContextWithSignal creates a context canceled when SIGINT or SIGTERM are notified
 func ContextWithSignal(ctx context.Context) context.Context {
 	newCtx, cancel := context.WithCancel(ctx)
 	signals := make(chan os.Signal)

cmd/traefik/traefik.go

@@ -158,7 +158,9 @@ func runCmd(globalConfiguration *configuration.GlobalConfiguration, configFile s
 
 	http.DefaultTransport.(*http.Transport).Proxy = http.ProxyFromEnvironment
 
-	roundrobin.SetDefaultWeight(0)
+	if err := roundrobin.SetDefaultWeight(0); err != nil {
+		log.Error(err)
+	}
 
 	globalConfiguration.SetEffectiveConfiguration(configFile)
 	globalConfiguration.ValidateConfiguration()
@@ -182,8 +184,8 @@ func runCmd(globalConfiguration *configuration.GlobalConfiguration, configFile s
 
 	acmeprovider := globalConfiguration.InitACMEProvider()
 	if acmeprovider != nil {
-		err := providerAggregator.AddProvider(acmeprovider)
-		if err != nil {
+
+		if err := providerAggregator.AddProvider(acmeprovider); err != nil {
 			log.Errorf("Error initializing provider ACME: %v", err)
 			acmeprovider = nil
 		}

configuration/router/internal_router.go

@@ -79,7 +79,9 @@ func (wm *WithMiddleware) AddRoutes(systemRouter *mux.Router) {
 	wm.router.AddRoutes(realRouter)
 
 	if len(wm.routerMiddlewares) > 0 {
-		realRouter.Walk(wrapRoute(wm.routerMiddlewares))
+		if err := realRouter.Walk(wrapRoute(wm.routerMiddlewares)); err != nil {
+			log.Error(err)
+		}
 	}
 }
 

configuration/router/internal_router_test.go

@@ -9,6 +9,7 @@ import (
 	"github.com/containous/traefik/acme"
 	"github.com/containous/traefik/api"
 	"github.com/containous/traefik/configuration"
+	"github.com/containous/traefik/log"
 	"github.com/containous/traefik/ping"
 	acmeprovider "github.com/containous/traefik/provider/acme"
 	"github.com/containous/traefik/safe"
@@ -104,20 +105,35 @@ func TestWithMiddleware(t *testing.T) {
 	router := WithMiddleware{
 		router: MockInternalRouterFunc(func(systemRouter *mux.Router) {
 			systemRouter.Handle("/test", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				w.Write([]byte("router"))
+
+				if _, err := w.Write([]byte("router")); err != nil {
+					log.Error(err)
+				}
 			}))
 		}),
 		routerMiddlewares: []negroni.Handler{
 			negroni.HandlerFunc(func(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
-				rw.Write([]byte("before middleware1|"))
+				if _, err := rw.Write([]byte("before middleware1|")); err != nil {
+					log.Error(err)
+				}
+
 				next.ServeHTTP(rw, r)
-				rw.Write([]byte("|after middleware1"))
+
+				if _, err := rw.Write([]byte("|after middleware1")); err != nil {
+					log.Error(err)
+				}
 
 			}),
 			negroni.HandlerFunc(func(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
-				rw.Write([]byte("before middleware2|"))
+				if _, err := rw.Write([]byte("before middleware2|")); err != nil {
+					log.Error(err)
+				}
+
 				next.ServeHTTP(rw, r)
-				rw.Write([]byte("|after middleware2"))
+
+				if _, err := rw.Write([]byte("|after middleware2")); err != nil {
+					log.Error(err)
+				}
 			}),
 		},
 	}

docs/configuration/acme.md

@@ -328,7 +328,7 @@ It is not possible to request a double wildcard certificate for a domain (for ex
 Due to ACME limitation it is not possible to define wildcards in SANs (alternative domains). Thus, the wildcard domain has to be defined as a main domain.
 Most likely the root domain should receive a certificate too, so it needs to be specified as SAN and 2 `DNS-01` challenges are executed.
 In this case the generated DNS TXT record for both domains is the same.
-Eventhough this behaviour is [DNS RFC](https://community.letsencrypt.org/t/wildcard-issuance-two-txt-records-for-the-same-name/54528/2) compliant, it can lead to problems as all DNS providers keep DNS records cached for a certain time (TTL) and this TTL can be superior to the challenge timeout making the `DNS-01` challenge fail.
+Eventhough this behavior is [DNS RFC](https://community.letsencrypt.org/t/wildcard-issuance-two-txt-records-for-the-same-name/54528/2) compliant, it can lead to problems as all DNS providers keep DNS records cached for a certain time (TTL) and this TTL can be superior to the challenge timeout making the `DNS-01` challenge fail.
 The Træfik ACME client library [LEGO](https://github.com/xenolf/lego) supports some but not all DNS providers to work around this issue.
 The [`provider` table](/configuration/acme/#provider) indicates if they allow generating certificates for a wildcard domain and its root domain.
 

docs/configuration/backends/ecs.md

@@ -126,9 +126,9 @@ Træfik needs the following policy to read ECS information:
 }
 ```
 
-## Labels: overriding default behaviour
+## Labels: overriding default behavior
 
-Labels can be used on task containers to override default behaviour:
+Labels can be used on task containers to override default behavior:
 
 | Label                                                      | Description                                                                                                                                                                                                                   |
 |------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

healthcheck/healthcheck.go

@@ -130,30 +130,34 @@ func (hc *HealthCheck) execute(ctx context.Context, backend *BackendConfig) {
 func (hc *HealthCheck) checkBackend(backend *BackendConfig) {
 	enabledURLs := backend.LB.Servers()
 	var newDisabledURLs []*url.URL
-	for _, url := range backend.disabledURLs {
+	for _, disableURL := range backend.disabledURLs {
 		serverUpMetricValue := float64(0)
-		if err := checkHealth(url, backend); err == nil {
-			log.Warnf("Health check up: Returning to server list. Backend: %q URL: %q", backend.name, url.String())
-			backend.LB.UpsertServer(url, roundrobin.Weight(1))
+		if err := checkHealth(disableURL, backend); err == nil {
+			log.Warnf("Health check up: Returning to server list. Backend: %q URL: %q", backend.name, disableURL.String())
+			if err := backend.LB.UpsertServer(disableURL, roundrobin.Weight(1)); err != nil {
+				log.Error(err)
+			}
 			serverUpMetricValue = 1
 		} else {
-			log.Warnf("Health check still failing. Backend: %q URL: %q Reason: %s", backend.name, url.String(), err)
-			newDisabledURLs = append(newDisabledURLs, url)
+			log.Warnf("Health check still failing. Backend: %q URL: %q Reason: %s", backend.name, disableURL.String(), err)
+			newDisabledURLs = append(newDisabledURLs, disableURL)
 		}
-		labelValues := []string{"backend", backend.name, "url", url.String()}
+		labelValues := []string{"backend", backend.name, "url", disableURL.String()}
 		hc.metrics.BackendServerUpGauge().With(labelValues...).Set(serverUpMetricValue)
 	}
 	backend.disabledURLs = newDisabledURLs
 
-	for _, url := range enabledURLs {
+	for _, enableURL := range enabledURLs {
 		serverUpMetricValue := float64(1)
-		if err := checkHealth(url, backend); err != nil {
-			log.Warnf("Health check failed: Remove from server list. Backend: %q URL: %q Reason: %s", backend.name, url.String(), err)
-			backend.LB.RemoveServer(url)
-			backend.disabledURLs = append(backend.disabledURLs, url)
+		if err := checkHealth(enableURL, backend); err != nil {
+			log.Warnf("Health check failed: Remove from server list. Backend: %q URL: %q Reason: %s", backend.name, enableURL.String(), err)
+			if err := backend.LB.RemoveServer(enableURL); err != nil {
+				log.Error(err)
+			}
+			backend.disabledURLs = append(backend.disabledURLs, enableURL)
 			serverUpMetricValue = 0
 		}
-		labelValues := []string{"backend", backend.name, "url", url.String()}
+		labelValues := []string{"backend", backend.name, "url", enableURL.String()}
 		hc.metrics.BackendServerUpGauge().With(labelValues...).Set(serverUpMetricValue)
 	}
 }

healthcheck/healthcheck_test.go

@@ -94,7 +94,7 @@ func TestSetBackendsConfiguration(t *testing.T) {
 		t.Run(test.desc, func(t *testing.T) {
 			t.Parallel()
 
-			// The context is passed to the health check and canonically cancelled by
+			// The context is passed to the health check and canonically canceled by
 			// the test server once all expected requests have been received.
 			ctx, cancel := context.WithCancel(context.Background())
 			defer cancel()

hostresolver/hostresolver.go

@@ -63,7 +63,9 @@ func (hr *Resolver) CNAMEFlatten(host string) (string, string) {
 			request = resolv.Record
 		}
 
-		hr.cache.Add(host, strings.Join(result, ","), cacheDuration)
+		if err := hr.cache.Add(host, strings.Join(result, ","), cacheDuration); err != nil {
+			log.Error(err)
+		}
 	}
 
 	return result[0], result[len(result)-1]

integration/access_log_test.go

@@ -12,6 +12,7 @@ import (
 	"time"
 
 	"github.com/containous/traefik/integration/try"
+	"github.com/containous/traefik/log"
 	"github.com/containous/traefik/middlewares/accesslog"
 	"github.com/go-check/check"
 	checker "github.com/vdemeester/shakers"
@@ -324,13 +325,17 @@ func digestParts(resp *http.Response) map[string]string {
 
 func getMD5(data string) string {
 	digest := md5.New()
-	digest.Write([]byte(data))
+	if _, err := digest.Write([]byte(data)); err != nil {
+		log.Error(err)
+	}
 	return fmt.Sprintf("%x", digest.Sum(nil))
 }
 
 func getCnonce() string {
 	b := make([]byte, 8)
-	io.ReadFull(rand.Reader, b)
+	if _, err := io.ReadFull(rand.Reader, b); err != nil {
+		log.Error(err)
+	}
 	return fmt.Sprintf("%x", b)[:16]
 }
 

integration/consul_catalog_test.go

@@ -530,7 +530,8 @@ func (s *ConsulCatalogSuite) TestRetryWithConsulServer(c *check.C) {
 
 	// Scale consul to 1
 	s.composeProject.Scale(c, "consul", 1)
-	s.waitToElectConsulLeader()
+	err = s.waitToElectConsulLeader()
+	c.Assert(err, checker.IsNil)
 
 	whoami := s.composeProject.Container(c, "whoami1")
 	// Register service
@@ -576,7 +577,8 @@ func (s *ConsulCatalogSuite) TestServiceWithMultipleHealthCheck(c *check.C) {
 
 	// Scale consul to 1
 	s.composeProject.Scale(c, "consul", 1)
-	s.waitToElectConsulLeader()
+	err = s.waitToElectConsulLeader()
+	c.Assert(err, checker.IsNil)
 
 	whoami := s.composeProject.Container(c, "whoami1")
 	// Register service

integration/etcd3_test.go

@@ -404,7 +404,8 @@ func (s *Etcd3Suite) TestCommandStoreConfig(c *check.C) {
 	c.Assert(err, checker.IsNil)
 
 	// wait for traefik finish without error
-	cmd.Wait()
+	err = cmd.Wait()
+	c.Assert(err, checker.IsNil)
 
 	// CHECK
 	checkmap := map[string]string{

integration/etcd_test.go

@@ -411,8 +411,9 @@ func (s *EtcdSuite) TestCommandStoreConfig(c *check.C) {
 	err := cmd.Start()
 	c.Assert(err, checker.IsNil)
 
-	// wait for Træfik finish without error
-	cmd.Wait()
+	// wait for traefik finish without error
+	err = cmd.Wait()
+	c.Assert(err, checker.IsNil)
 
 	// CHECK
 	checkmap := map[string]string{

integration/fake_dns_server.go

@@ -93,7 +93,9 @@ func (s *handler) ServeDNS(w dns.ResponseWriter, r *dns.Msg) {
 	auth.Minttl = 1
 	m.Ns = append(m.Ns, auth)
 
-	w.WriteMsg(m)
+	if err := w.WriteMsg(m); err != nil {
+		log.Fatalf("Failed to write message %v", err)
+	}
 }
 
 func startFakeDNSServer() *dns.Server {

integration/grpc_test.go

@@ -13,6 +13,7 @@ import (
 
 	"github.com/containous/traefik/integration/helloworld"
 	"github.com/containous/traefik/integration/try"
+	"github.com/containous/traefik/log"
 	"github.com/go-check/check"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
@@ -47,7 +48,11 @@ func (s *myserver) StreamExample(in *helloworld.StreamExampleRequest, server hel
 	for i := range data {
 		data[i] = randCharset[rand.Intn(len(randCharset))]
 	}
-	server.Send(&helloworld.StreamExampleReply{Data: string(data)})
+
+	if err := server.Send(&helloworld.StreamExampleReply{Data: string(data)}); err != nil {
+		log.Error(err)
+	}
+
 	<-s.stopStreamExample
 	return nil
 }

integration/https_test.go

@@ -708,7 +708,10 @@ func modifyCertificateConfFileContent(c *check.C, certFileName, confFileName, en
 	defer func() {
 		f.Close()
 	}()
-	f.Truncate(0)
+
+	err = f.Truncate(0)
+	c.Assert(err, checker.IsNil)
+
 	// If certificate file is not provided, just truncate the configuration file
 	if len(certFileName) > 0 {
 		tlsConf := types.Configuration{

middlewares/accesslog/logger.go

@@ -26,10 +26,10 @@ const (
 	DataTableKey key = "LogDataTable"
 
 	// CommonFormat is the common logging format (CLF)
-	CommonFormat = "common"
+	CommonFormat string = "common"
 
 	// JSONFormat is the JSON logging format
-	JSONFormat = "json"
+	JSONFormat string = "json"
 )
 
 type logHandlerParams struct {

middlewares/accesslog/logger_test.go

@@ -15,6 +15,7 @@ import (
 	"time"
 
 	"github.com/containous/flaeg/parse"
+	"github.com/containous/traefik/log"
 	"github.com/containous/traefik/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -626,7 +627,10 @@ func doLogging(t *testing.T, config *types.AccessLog) {
 }
 
 func logWriterTestHandlerFunc(rw http.ResponseWriter, r *http.Request) {
-	rw.Write([]byte(testContent))
+	if _, err := rw.Write([]byte(testContent)); err != nil {
+		log.Error(err)
+	}
+
 	rw.WriteHeader(testStatus)
 
 	logDataTable := GetLogDataTable(r)

middlewares/auth/forward.go

@@ -90,7 +90,10 @@ func Forward(config *types.Forward, w http.ResponseWriter, r *http.Request, next
 
 		tracing.LogResponseCode(tracing.GetSpan(r), forwardResponse.StatusCode)
 		w.WriteHeader(forwardResponse.StatusCode)
-		w.Write(body)
+
+		if _, err = w.Write(body); err != nil {
+			log.Error(err)
+		}
 		return
 	}
 

middlewares/cbreaker.go

@@ -3,6 +3,7 @@ package middlewares
 import (
 	"net/http"
 
+	"github.com/containous/traefik/log"
 	"github.com/containous/traefik/middlewares/tracing"
 	"github.com/vulcand/oxy/cbreaker"
 )
@@ -27,7 +28,10 @@ func NewCircuitBreakerOptions(expression string) cbreaker.CircuitBreakerOption {
 		tracing.LogEventf(r, "blocked by circuit-breaker (%q)", expression)
 
 		w.WriteHeader(http.StatusServiceUnavailable)
-		w.Write([]byte(http.StatusText(http.StatusServiceUnavailable)))
+
+		if _, err := w.Write([]byte(http.StatusText(http.StatusServiceUnavailable))); err != nil {
+			log.Error(err)
+		}
 	}))
 }