Update linter

pkg/middlewares/accesslog/capture_response_writer.go

@@ -28,7 +28,7 @@ func newCaptureResponseWriter(rw http.ResponseWriter) capturer {
 }
 
 // captureResponseWriter is a wrapper of type http.ResponseWriter
-// that tracks request status and size
+// that tracks request status and size.
 type captureResponseWriter struct {
 	rw     http.ResponseWriter
 	status int

pkg/middlewares/accesslog/field_middleware.go

@@ -7,7 +7,7 @@ import (
 	"github.com/vulcand/oxy/utils"
 )
 
-// FieldApply function hook to add data in accesslog
+// FieldApply function hook to add data in accesslog.
 type FieldApply func(rw http.ResponseWriter, r *http.Request, next http.Handler, data *LogData)
 
 // FieldHandler sends a new field to the logger.
@@ -39,7 +39,7 @@ func (f *FieldHandler) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
 	}
 }
 
-// AddServiceFields add service fields
+// AddServiceFields add service fields.
 func AddServiceFields(rw http.ResponseWriter, req *http.Request, next http.Handler, data *LogData) {
 	data.Core[ServiceURL] = req.URL // note that this is *not* the original incoming URL
 	data.Core[ServiceAddr] = req.URL.Host
@@ -47,7 +47,7 @@ func AddServiceFields(rw http.ResponseWriter, req *http.Request, next http.Handl
 	next.ServeHTTP(rw, req)
 }
 
-// AddOriginFields add origin fields
+// AddOriginFields add origin fields.
 func AddOriginFields(rw http.ResponseWriter, req *http.Request, next http.Handler, data *LogData) {
 	crw := newCaptureResponseWriter(rw)
 	start := time.Now().UTC()

pkg/middlewares/accesslog/logger.go

@@ -75,7 +75,7 @@ func NewHandler(config *types.AccessLog) (*Handler, error) {
 	if len(config.FilePath) > 0 {
 		f, err := openAccessLogFile(config.FilePath)
 		if err != nil {
-			return nil, fmt.Errorf("error opening access log file: %s", err)
+			return nil, fmt.Errorf("error opening access log file: %w", err)
 		}
 		file = f
 	}
@@ -132,12 +132,12 @@ func openAccessLogFile(filePath string) (*os.File, error) {
 	dir := filepath.Dir(filePath)
 
 	if err := os.MkdirAll(dir, 0755); err != nil {
-		return nil, fmt.Errorf("failed to create log path %s: %s", dir, err)
+		return nil, fmt.Errorf("failed to create log path %s: %w", dir, err)
 	}
 
 	file, err := os.OpenFile(filePath, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0664)
 	if err != nil {
-		return nil, fmt.Errorf("error opening file %s: %s", filePath, err)
+		return nil, fmt.Errorf("error opening file %s: %w", filePath, err)
 	}
 
 	return file, nil

pkg/middlewares/accesslog/parser.go

@@ -5,7 +5,7 @@ import (
 	"regexp"
 )
 
-// ParseAccessLog parse line of access log and return a map with each fields
+// ParseAccessLog parse line of access log and return a map with each fields.
 func ParseAccessLog(data string) (map[string]string, error) {
 	var buffer bytes.Buffer
 	buffer.WriteString(`(\S+)`)                  // 1 - ClientHost

pkg/middlewares/auth/digest_auth_request_test.go

@@ -20,7 +20,7 @@ const (
 	wwwAuthenticate = "Www-Authenticate"
 )
 
-// DigestRequest is a client for digest authentication requests
+// DigestRequest is a client for digest authentication requests.
 type digestRequest struct {
 	client             *http.Client
 	username, password string
@@ -35,7 +35,7 @@ func (nc nonceCount) String() string {
 
 var wanted = []string{algorithm, nonce, opaque, qop, realm}
 
-// New makes a DigestRequest instance
+// New makes a DigestRequest instance.
 func newDigestRequest(username, password string, client *http.Client) *digestRequest {
 	return &digestRequest{
 		client:   client,
@@ -44,7 +44,7 @@ func newDigestRequest(username, password string, client *http.Client) *digestReq
 	}
 }
 
-// Do does requests as http.Do does
+// Do does requests as http.Do does.
 func (r *digestRequest) Do(req *http.Request) (*http.Response, error) {
 	parts, err := r.makeParts(req)
 	if err != nil {
@@ -133,7 +133,7 @@ func (r *digestRequest) makeAuthorization(req *http.Request, parts map[string]st
 	)
 }
 
-// GenerateRandom generates random string
+// GenerateRandom generates random string.
 func generateRandom(n int) string {
 	b := make([]byte, 8)
 	_, _ = io.ReadFull(rand.Reader, b)

pkg/middlewares/chain/chain.go

@@ -18,7 +18,7 @@ type chainBuilder interface {
 	BuildChain(ctx context.Context, middlewares []string) *alice.Chain
 }
 
-// New creates a chain middleware
+// New creates a chain middleware.
 func New(ctx context.Context, next http.Handler, config dynamic.Chain, builder chainBuilder, name string) (http.Handler, error) {
 	log.FromContext(middlewares.GetLoggerCtx(ctx, name, typeName)).Debug("Creating middleware")
 

pkg/middlewares/circuitbreaker/circuit_breaker.go

@@ -39,7 +39,7 @@ func New(ctx context.Context, next http.Handler, confCircuitBreaker dynamic.Circ
 	}, nil
 }
 
-// NewCircuitBreakerOptions returns a new CircuitBreakerOption
+// NewCircuitBreakerOptions returns a new CircuitBreakerOption.
 func createCircuitBreakerOptions(expression string) cbreaker.CircuitBreakerOption {
 	return cbreaker.Fallback(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
 		tracing.SetErrorWithEvent(req, "blocked by circuit-breaker (%q)", expression)

pkg/middlewares/customerrors/custom_errors.go

@@ -131,12 +131,12 @@ func (c *customErrors) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
 func newRequest(baseURL string) (*http.Request, error) {
 	u, err := url.Parse(baseURL)
 	if err != nil {
-		return nil, fmt.Errorf("error pages: error when parse URL: %v", err)
+		return nil, fmt.Errorf("error pages: error when parse URL: %w", err)
 	}
 
 	req, err := http.NewRequest(http.MethodGet, u.String(), nil)
 	if err != nil {
-		return nil, fmt.Errorf("error pages: error when create query: %v", err)
+		return nil, fmt.Errorf("error pages: error when create query: %w", err)
 	}
 
 	req.RequestURI = u.RequestURI()
@@ -250,7 +250,7 @@ func (cc *codeCatcher) WriteHeader(code int) {
 	cc.headersSent = true
 }
 
-// Hijack hijacks the connection
+// Hijack hijacks the connection.
 func (cc *codeCatcher) Hijack() (net.Conn, *bufio.ReadWriter, error) {
 	if hj, ok := cc.responseWriter.(http.Hijacker); ok {
 		return hj.Hijack()
@@ -349,7 +349,7 @@ func (r *responseRecorderWithoutCloseNotify) WriteHeader(code int) {
 	r.Code = code
 }
 
-// Hijack hijacks the connection
+// Hijack hijacks the connection.
 func (r *responseRecorderWithoutCloseNotify) Hijack() (net.Conn, *bufio.ReadWriter, error) {
 	return r.responseWriter.(http.Hijacker).Hijack()
 }

pkg/middlewares/forwardedheaders/forwarded_header.go

@@ -37,9 +37,10 @@ var xHeaders = []string{
 	xRealIP,
 }
 
-// XForwarded is an HTTP handler wrapper that sets the X-Forwarded headers, and other relevant headers for a
-// reverse-proxy. Unless insecure is set, it first removes all the existing values for those headers if the remote
-// address is not one of the trusted ones.
+// XForwarded is an HTTP handler wrapper that sets the X-Forwarded headers,
+// and other relevant headers for a reverse-proxy.
+// Unless insecure is set,
+// it first removes all the existing values for those headers if the remote address is not one of the trusted ones.
 type XForwarded struct {
 	insecure   bool
 	trustedIps []string
@@ -80,15 +81,13 @@ func (x *XForwarded) isTrustedIP(ip string) bool {
 	return x.ipChecker.IsAuthorized(ip) == nil
 }
 
-// removeIPv6Zone removes the zone if the given IP is an ipv6 address and it has
-// {zone} information in it, like "[fe80::d806:a55d:eb1b:49cc%vEthernet (vmxnet3
-// Ethernet Adapter - Virtual Switch)]:64692"
+// removeIPv6Zone removes the zone if the given IP is an ipv6 address and it has {zone} information in it,
+// like "[fe80::d806:a55d:eb1b:49cc%vEthernet (vmxnet3 Ethernet Adapter - Virtual Switch)]:64692".
 func removeIPv6Zone(clientIP string) string {
 	return strings.Split(clientIP, "%")[0]
 }
 
-// isWebsocketRequest returns whether the specified HTTP request is a
-// websocket handshake request
+// isWebsocketRequest returns whether the specified HTTP request is a websocket handshake request.
 func isWebsocketRequest(req *http.Request) bool {
 	containsHeader := func(name, value string) bool {
 		items := strings.Split(req.Header.Get(name), ",")
@@ -161,7 +160,7 @@ func (x *XForwarded) rewrite(outreq *http.Request) {
 	}
 }
 
-// ServeHTTP implements http.Handler
+// ServeHTTP implements http.Handler.
 func (x *XForwarded) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	if !x.insecure && !x.isTrustedIP(r.RemoteAddr) {
 		for _, h := range xHeaders {

pkg/middlewares/handler_switcher.go

@@ -6,12 +6,12 @@ import (
 	"github.com/containous/traefik/v2/pkg/safe"
 )
 
-// HTTPHandlerSwitcher allows hot switching of http.ServeMux
+// HTTPHandlerSwitcher allows hot switching of http.ServeMux.
 type HTTPHandlerSwitcher struct {
 	handler *safe.Safe
 }
 
-// NewHandlerSwitcher builds a new instance of HTTPHandlerSwitcher
+// NewHandlerSwitcher builds a new instance of HTTPHandlerSwitcher.
 func NewHandlerSwitcher(newHandler http.Handler) (hs *HTTPHandlerSwitcher) {
 	return &HTTPHandlerSwitcher{
 		handler: safe.New(newHandler),
@@ -23,13 +23,13 @@ func (h *HTTPHandlerSwitcher) ServeHTTP(rw http.ResponseWriter, req *http.Reques
 	handlerBackup.ServeHTTP(rw, req)
 }
 
-// GetHandler returns the current http.ServeMux
+// GetHandler returns the current http.ServeMux.
 func (h *HTTPHandlerSwitcher) GetHandler() (newHandler http.Handler) {
 	handler := h.handler.Get().(http.Handler)
 	return handler
 }
 
-// UpdateHandler safely updates the current http.ServeMux with a new one
+// UpdateHandler safely updates the current http.ServeMux with a new one.
 func (h *HTTPHandlerSwitcher) UpdateHandler(newHandler http.Handler) {
 	h.handler.Set(newHandler)
 }

pkg/middlewares/inflightreq/inflight_req.go

@@ -38,12 +38,12 @@ func New(ctx context.Context, next http.Handler, config dynamic.InFlightReq, nam
 
 	sourceMatcher, err := middlewares.GetSourceExtractor(ctxLog, config.SourceCriterion)
 	if err != nil {
-		return nil, fmt.Errorf("error creating requests limiter: %v", err)
+		return nil, fmt.Errorf("error creating requests limiter: %w", err)
 	}
 
 	handler, err := connlimit.New(next, sourceMatcher, config.Amount)
 	if err != nil {
-		return nil, fmt.Errorf("error creating connection limit: %v", err)
+		return nil, fmt.Errorf("error creating connection limit: %w", err)
 	}
 
 	return &inFlightReq{handler: handler, name: name}, nil

pkg/middlewares/ipwhitelist/ip_whitelist.go

@@ -18,7 +18,7 @@ const (
 	typeName = "IPWhiteLister"
 )
 
-// ipWhiteLister is a middleware that provides Checks of the Requesting IP against a set of Whitelists
+// ipWhiteLister is a middleware that provides Checks of the Requesting IP against a set of Whitelists.
 type ipWhiteLister struct {
 	next        http.Handler
 	whiteLister *ip.Checker
@@ -26,7 +26,7 @@ type ipWhiteLister struct {
 	name        string
 }
 
-// New builds a new IPWhiteLister given a list of CIDR-Strings to whitelist
+// New builds a new IPWhiteLister given a list of CIDR-Strings to whitelist.
 func New(ctx context.Context, next http.Handler, config dynamic.IPWhiteList, name string) (http.Handler, error) {
 	logger := log.FromContext(middlewares.GetLoggerCtx(ctx, name, typeName))
 	logger.Debug("Creating middleware")
@@ -37,7 +37,7 @@ func New(ctx context.Context, next http.Handler, config dynamic.IPWhiteList, nam
 
 	checker, err := ip.NewChecker(config.SourceRange)
 	if err != nil {
-		return nil, fmt.Errorf("cannot parse CIDR whitelist %s: %v", config.SourceRange, err)
+		return nil, fmt.Errorf("cannot parse CIDR whitelist %s: %w", config.SourceRange, err)
 	}
 
 	strategy, err := config.IPStrategy.Get()

pkg/middlewares/metrics/recorder.go

@@ -50,7 +50,7 @@ func (r *responseRecorder) WriteHeader(status int) {
 	r.statusCode = status
 }
 
-// Hijack hijacks the connection
+// Hijack hijacks the connection.
 func (r *responseRecorder) Hijack() (net.Conn, *bufio.ReadWriter, error) {
 	return r.ResponseWriter.(http.Hijacker).Hijack()
 }

pkg/middlewares/passtlsclientcert/pass_tls_client_cert.go

@@ -139,7 +139,7 @@ func (p *passTLSClientCert) ServeHTTP(rw http.ResponseWriter, req *http.Request)
 // - the `,` is used to separate certificates
 // - the `;` is used to separate root fields
 // - the value of root fields is always wrapped by double quote
-// - if a field is empty, the field is ignored
+// - if a field is empty, the field is ignored.
 func (p *passTLSClientCert) getCertInfo(ctx context.Context, certs []*x509.Certificate) string {
 	var headerValues []string
 

pkg/middlewares/pipelining/pipelining.go

@@ -14,12 +14,12 @@ const (
 	typeName = "Pipelining"
 )
 
-// pipelining returns a middleware
+// pipelining returns a middleware.
 type pipelining struct {
 	next http.Handler
 }
 
-// New returns a new pipelining instance
+// New returns a new pipelining instance.
 func New(ctx context.Context, next http.Handler, name string) http.Handler {
 	log.FromContext(middlewares.GetLoggerCtx(ctx, name, typeName)).Debug("Creating middleware")
 
@@ -37,7 +37,7 @@ func (p *pipelining) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
 	}
 }
 
-// writerWithoutCloseNotify helps to disable closeNotify
+// writerWithoutCloseNotify helps to disable closeNotify.
 type writerWithoutCloseNotify struct {
 	W http.ResponseWriter
 }
@@ -52,8 +52,7 @@ func (w *writerWithoutCloseNotify) Write(buf []byte) (int, error) {
 	return w.W.Write(buf)
 }
 
-// WriteHeader sends an HTTP response header with the provided
-// status code.
+// WriteHeader sends an HTTP response header with the provided status code.
 func (w *writerWithoutCloseNotify) WriteHeader(code int) {
 	w.W.WriteHeader(code)
 }

pkg/middlewares/replacepathregex/replace_path_regex.go

@@ -34,7 +34,7 @@ func New(ctx context.Context, next http.Handler, config dynamic.ReplacePathRegex
 
 	exp, err := regexp.Compile(strings.TrimSpace(config.Regex))
 	if err != nil {
-		return nil, fmt.Errorf("error compiling regular expression %s: %s", config.Regex, err)
+		return nil, fmt.Errorf("error compiling regular expression %s: %w", config.Regex, err)
 	}
 
 	return &replacePathRegex{

pkg/middlewares/requestdecorator/hostresolver.go

@@ -105,7 +105,7 @@ func cnameResolve(ctx context.Context, host string, resolvPath string) (*cnameRe
 func getRecord(client *dns.Client, msg *dns.Msg, server string, port string) (*cnameResolv, error) {
 	resp, _, err := client.Exchange(msg, net.JoinHostPort(server, port))
 	if err != nil {
-		return nil, fmt.Errorf("exchange error for server %s: %v", server, err)
+		return nil, fmt.Errorf("exchange error for server %s: %w", server, err)
 	}
 
 	if resp == nil || len(resp.Answer) == 0 {

pkg/middlewares/stateful.go

@@ -3,7 +3,7 @@ package middlewares
 import "net/http"
 
 // Stateful interface groups all http interfaces that must be
-// implemented by a stateful middleware (ie: recorders)
+// implemented by a stateful middleware (ie: recorders).
 type Stateful interface {
 	http.ResponseWriter
 	http.Hijacker

pkg/middlewares/tracing/mock_tracing_test.go

@@ -27,12 +27,12 @@ func (n MockTracer) Extract(format interface{}, carrier interface{}) (opentracin
 	return nil, opentracing.ErrSpanContextNotFound
 }
 
-// MockSpanContext
+// MockSpanContext.
 type MockSpanContext struct{}
 
 func (n MockSpanContext) ForeachBaggageItem(handler func(k, v string) bool) {}
 
-// MockSpan
+// MockSpan.
 type MockSpan struct {
 	OpName string
 	Tags   map[string]interface{}

pkg/middlewares/tracing/status_code.go

@@ -22,12 +22,12 @@ func (s *statusCodeWithoutCloseNotify) WriteHeader(status int) {
 	s.ResponseWriter.WriteHeader(status)
 }
 
-// Status get response status
+// Status get response status.
 func (s *statusCodeWithoutCloseNotify) Status() int {
 	return s.status
 }
 
-// Hijack hijacks the connection
+// Hijack hijacks the connection.
 func (s *statusCodeWithoutCloseNotify) Hijack() (net.Conn, *bufio.ReadWriter, error) {
 	return s.ResponseWriter.(http.Hijacker).Hijack()
 }

pkg/middlewares/tracing/wrapper.go

@@ -35,7 +35,7 @@ func Wrap(ctx context.Context, constructor alice.Constructor) alice.Constructor
 	}
 }
 
-// NewWrapper returns a http.Handler struct
+// NewWrapper returns a http.Handler struct.
 func NewWrapper(next http.Handler, name string, spanKind ext.SpanKindEnum) http.Handler {
 	return &Wrapper{
 		next:     next,