fix golint issues in rest (#529)

rest/handler/authhandler.go

@@ -28,15 +28,19 @@ var (
 )
 
 type (
+	// A AuthorizeOptions is authorize options.
 	AuthorizeOptions struct {
 		PrevSecret string
 		Callback   UnauthorizedCallback
 	}
 
+	// UnauthorizedCallback defines the method of unauthorized callback.
 	UnauthorizedCallback func(w http.ResponseWriter, r *http.Request, err error)
-	AuthorizeOption      func(opts *AuthorizeOptions)
+	// AuthorizeOption defines the method to customize an AuthorizeOptions.
+	AuthorizeOption func(opts *AuthorizeOptions)
 )
 
+// Authorize returns an authorize middleware.
 func Authorize(secret string, opts ...AuthorizeOption) func(http.Handler) http.Handler {
 	var authOpts AuthorizeOptions
 	for _, opt := range opts {
@@ -78,12 +82,14 @@ func Authorize(secret string, opts ...AuthorizeOption) func(http.Handler) http.H
 	}
 }
 
+// WithPrevSecret returns an AuthorizeOption with setting previous secret.
 func WithPrevSecret(secret string) AuthorizeOption {
 	return func(opts *AuthorizeOptions) {
 		opts.PrevSecret = secret
 	}
 }
 
+// WithUnauthorizedCallback returns an AuthorizeOption with setting unauthorized callback.
 func WithUnauthorizedCallback(callback UnauthorizedCallback) AuthorizeOption {
 	return func(opts *AuthorizeOptions) {
 		opts.Callback = callback

rest/handler/breakerhandler.go

@@ -14,6 +14,7 @@ import (
 
 const breakerSeparator = "://"
 
+// BreakerHandler returns a break circuit middleware.
 func BreakerHandler(method, path string, metrics *stat.Metrics) func(http.Handler) http.Handler {
 	brk := breaker.NewBreaker(breaker.WithName(strings.Join([]string{method, path}, breakerSeparator)))
 	return func(next http.Handler) http.Handler {

rest/handler/contentsecurityhandler.go

@@ -12,8 +12,10 @@ import (
 
 const contentSecurity = "X-Content-Security"
 
+// UnsignedCallback defines the method of the unsigned callback.
 type UnsignedCallback func(w http.ResponseWriter, r *http.Request, next http.Handler, strict bool, code int)
 
+// ContentSecurityHandler returns a middleware to verify content security.
 func ContentSecurityHandler(decrypters map[string]codec.RsaDecrypter, tolerance time.Duration,
 	strict bool, callbacks ...UnsignedCallback) func(http.Handler) http.Handler {
 	if len(callbacks) == 0 {

rest/handler/cryptionhandler.go

@@ -16,6 +16,7 @@ const maxBytes = 1 << 20 // 1 MiB
 
 var errContentLengthExceeded = errors.New("content length exceeded")
 
+// CryptionHandler returns a middleware to handle cryption.
 func CryptionHandler(key []byte) func(http.Handler) http.Handler {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

rest/handler/gunziphandler.go

@@ -10,6 +10,7 @@ import (
 
 const gzipEncoding = "gzip"
 
+// GunzipHandler returns a middleware to gunzip http request body.
 func GunzipHandler(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		if strings.Contains(r.Header.Get(httpx.ContentEncoding), gzipEncoding) {

rest/handler/loghandler.go

@@ -19,36 +19,37 @@ import (
 
 const slowThreshold = time.Millisecond * 500
 
-type LoggedResponseWriter struct {
+type loggedResponseWriter struct {
 	w    http.ResponseWriter
 	r    *http.Request
 	code int
 }
 
-func (w *LoggedResponseWriter) Header() http.Header {
+func (w *loggedResponseWriter) Header() http.Header {
 	return w.w.Header()
 }
 
-func (w *LoggedResponseWriter) Write(bytes []byte) (int, error) {
+func (w *loggedResponseWriter) Write(bytes []byte) (int, error) {
 	return w.w.Write(bytes)
 }
 
-func (w *LoggedResponseWriter) WriteHeader(code int) {
+func (w *loggedResponseWriter) WriteHeader(code int) {
 	w.w.WriteHeader(code)
 	w.code = code
 }
 
-func (w *LoggedResponseWriter) Flush() {
+func (w *loggedResponseWriter) Flush() {
 	if flusher, ok := w.w.(http.Flusher); ok {
 		flusher.Flush()
 	}
 }
 
+// LogHandler returns a middleware that logs http request and response.
 func LogHandler(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		timer := utils.NewElapsedTimer()
 		logs := new(internal.LogCollector)
-		lrw := LoggedResponseWriter{
+		lrw := loggedResponseWriter{
 			w:    w,
 			r:    r,
 			code: http.StatusOK,
@@ -62,40 +63,41 @@ func LogHandler(next http.Handler) http.Handler {
 	})
 }
 
-type DetailLoggedResponseWriter struct {
-	writer *LoggedResponseWriter
+type detailLoggedResponseWriter struct {
+	writer *loggedResponseWriter
 	buf    *bytes.Buffer
 }
 
-func newDetailLoggedResponseWriter(writer *LoggedResponseWriter, buf *bytes.Buffer) *DetailLoggedResponseWriter {
-	return &DetailLoggedResponseWriter{
+func newDetailLoggedResponseWriter(writer *loggedResponseWriter, buf *bytes.Buffer) *detailLoggedResponseWriter {
+	return &detailLoggedResponseWriter{
 		writer: writer,
 		buf:    buf,
 	}
 }
 
-func (w *DetailLoggedResponseWriter) Flush() {
+func (w *detailLoggedResponseWriter) Flush() {
 	w.writer.Flush()
 }
 
-func (w *DetailLoggedResponseWriter) Header() http.Header {
+func (w *detailLoggedResponseWriter) Header() http.Header {
 	return w.writer.Header()
 }
 
-func (w *DetailLoggedResponseWriter) Write(bs []byte) (int, error) {
+func (w *detailLoggedResponseWriter) Write(bs []byte) (int, error) {
 	w.buf.Write(bs)
 	return w.writer.Write(bs)
 }
 
-func (w *DetailLoggedResponseWriter) WriteHeader(code int) {
+func (w *detailLoggedResponseWriter) WriteHeader(code int) {
 	w.writer.WriteHeader(code)
 }
 
+// DetailedLogHandler returns a middleware that logs http request and response in details.
 func DetailedLogHandler(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		timer := utils.NewElapsedTimer()
 		var buf bytes.Buffer
-		lrw := newDetailLoggedResponseWriter(&LoggedResponseWriter{
+		lrw := newDetailLoggedResponseWriter(&loggedResponseWriter{
 			w:    w,
 			r:    r,
 			code: http.StatusOK,
@@ -146,7 +148,7 @@ func logBrief(r *http.Request, code int, timer *utils.ElapsedTimer, logs *intern
 	}
 }
 
-func logDetails(r *http.Request, response *DetailLoggedResponseWriter, timer *utils.ElapsedTimer,
+func logDetails(r *http.Request, response *detailLoggedResponseWriter, timer *utils.ElapsedTimer,
 	logs *internal.LogCollector) {
 	var buf bytes.Buffer
 	duration := timer.Duration()

rest/handler/maxbyteshandler.go

@@ -6,6 +6,7 @@ import (
 	"github.com/tal-tech/go-zero/rest/internal"
 )
 
+// MaxBytesHandler returns a middleware that limit reading of http request body.
 func MaxBytesHandler(n int64) func(http.Handler) http.Handler {
 	if n <= 0 {
 		return func(next http.Handler) http.Handler {

rest/handler/maxconnshandler.go

@@ -8,6 +8,7 @@ import (
 	"github.com/tal-tech/go-zero/rest/internal"
 )
 
+// MaxConns returns a middleware that limit the concurrent connections.
 func MaxConns(n int) func(http.Handler) http.Handler {
 	if n <= 0 {
 		return func(next http.Handler) http.Handler {

rest/handler/metrichandler.go

@@ -7,6 +7,7 @@ import (
 	"github.com/tal-tech/go-zero/core/timex"
 )
 
+// MetricHandler returns a middleware that stat the metrics.
 func MetricHandler(metrics *stat.Metrics) func(http.Handler) http.Handler {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

rest/handler/prometheushandler.go

@@ -31,7 +31,8 @@ var (
 	})
 )
 
-func PromethousHandler(path string) func(http.Handler) http.Handler {
+// PrometheusHandler returns a middleware that reports stats to prometheus.
+func PrometheusHandler(path string) func(http.Handler) http.Handler {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			startTime := timex.Now()

rest/handler/prometheushandler_test.go

@@ -9,7 +9,7 @@ import (
 )
 
 func TestPromMetricHandler(t *testing.T) {
-	promMetricHandler := PromethousHandler("/user/login")
+	promMetricHandler := PrometheusHandler("/user/login")
 	handler := promMetricHandler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusOK)
 	}))

rest/handler/recoverhandler.go

@@ -8,6 +8,7 @@ import (
 	"github.com/tal-tech/go-zero/rest/internal"
 )
 
+// RecoverHandler returns a middleware that recovers if panic happens.
 func RecoverHandler(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		defer func() {

rest/handler/sheddinghandler.go

@@ -18,6 +18,7 @@ var (
 	lock         sync.Mutex
 )
 
+// SheddingHandler returns a middleware that does load shedding.
 func SheddingHandler(shedder load.Shedder, metrics *stat.Metrics) func(http.Handler) http.Handler {
 	if shedder == nil {
 		return func(next http.Handler) http.Handler {

rest/handler/tracinghandler.go

@@ -8,6 +8,7 @@ import (
 	"github.com/tal-tech/go-zero/core/trace"
 )
 
+// TracingHandler returns a middleware that traces the request.
 func TracingHandler(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		carrier, err := trace.Extract(trace.HttpFormat, r.Header)