Merge pull request #84 from netlify/add-router

Add a generic router interface

Author: rybit

go.mod

@@ -1,58 +1,41 @@
 module github.com/netlify/netlify-commons
 
 require (
-	github.com/BurntSushi/toml v0.3.0
-	github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da // indirect
+	github.com/BurntSushi/toml v0.3.1
 	github.com/bitly/go-simplejson v0.5.0 // indirect
 	github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869 // indirect
-	github.com/bugsnag/bugsnag-go v1.3.0
-	github.com/bugsnag/panicwrap v0.0.0-20180510051541-1d162ee1264c // indirect
+	github.com/bugsnag/bugsnag-go v1.5.1
+	github.com/bugsnag/panicwrap v1.2.0 // indirect
 	github.com/globalsign/mgo v0.0.0-20181015135952-eeefdecb41b8
-	github.com/go-sql-driver/mysql v1.4.1 // indirect
-	github.com/gogo/protobuf v1.2.1 // indirect
-	github.com/golang/protobuf v1.3.1 // indirect
-	github.com/hashicorp/go-immutable-radix v1.0.0 // indirect
-	github.com/hashicorp/go-msgpack v0.5.3 // indirect
-	github.com/hashicorp/hcl v0.0.0-20180906183839-65a6292f0157 // indirect
-	github.com/hashicorp/raft v1.0.0 // indirect
-	github.com/inconshreveable/mousetrap v1.0.0 // indirect
-	github.com/joho/godotenv v1.2.0
-	github.com/juju/loggo v0.0.0-20190212223446-d976af380377 // indirect
+	github.com/go-chi/chi v4.0.2+incompatible
+	github.com/gofrs/uuid v3.2.0+incompatible // indirect
+	github.com/joho/godotenv v1.3.0
 	github.com/kardianos/osext v0.0.0-20190222173326-2bc1f35cddc0 // indirect
 	github.com/kelseyhightower/envconfig v1.3.0
+	github.com/konsorten/go-windows-terminal-sequences v1.0.2 // indirect
 	github.com/kr/pretty v0.1.0 // indirect
-	github.com/lib/pq v1.0.0 // indirect
-	github.com/magiconair/properties v0.0.0-20190110142458-7757cc9fdb85 // indirect
-	github.com/mitchellh/mapstructure v1.1.2 // indirect
 	github.com/nats-io/gnatsd v1.4.1 // indirect
 	github.com/nats-io/go-nats v1.3.0
 	github.com/nats-io/go-nats-streaming v0.3.4
-	github.com/nats-io/nats-streaming-server v0.12.2 // indirect
-	github.com/nats-io/nuid v0.0.0-20180712044959-3024a71c3cbe // indirect
-	github.com/onsi/ginkgo v1.8.0 // indirect
-	github.com/onsi/gomega v1.5.0 // indirect
+	github.com/nats-io/nats-server v1.4.1 // indirect
+	github.com/nats-io/nats-streaming-server v0.15.1 // indirect
 	github.com/opentracing/opentracing-go v1.1.0
-	github.com/pascaldekloe/goe v0.1.0 // indirect
-	github.com/pelletier/go-toml v0.0.0-20181124002727-27c6b39a135b // indirect
+	github.com/pelletier/go-toml v1.3.0 // indirect
 	github.com/philhofer/fwd v1.0.0 // indirect
-	github.com/pkg/errors v0.8.0
-	github.com/prometheus/procfs v0.0.0-20190403104016-ea9eea638872 // indirect
+	github.com/pkg/errors v0.8.1
+	github.com/rs/cors v1.6.0
 	github.com/satori/go.uuid v1.2.0
+	github.com/sebest/xff v0.0.0-20160910043805-6c115e0ffa35
 	github.com/shopify/logrus-bugsnag v0.0.0-20171204204709-577dee27f20d
-	github.com/sirupsen/logrus v1.0.5
-	github.com/spf13/afero v1.2.1 // indirect
-	github.com/spf13/cast v1.3.0 // indirect
-	github.com/spf13/cobra v0.0.1
+	github.com/sirupsen/logrus v1.4.1
+	github.com/spf13/afero v1.2.2 // indirect
+	github.com/spf13/cobra v0.0.4-0.20190321000552-67fc4837d267
 	github.com/spf13/jwalterweatherman v1.1.0 // indirect
-	github.com/spf13/pflag v1.0.0 // indirect
-	github.com/spf13/viper v1.0.2
-	github.com/stretchr/testify v1.2.2
+	github.com/spf13/viper v1.3.2
+	github.com/stretchr/testify v1.3.0
 	github.com/tinylib/msgp v1.1.0 // indirect
-	go.etcd.io/bbolt v1.3.2 // indirect
-	golang.org/x/crypto v0.0.0-20161031180806-9477e0b78b9a // indirect
-	google.golang.org/appengine v1.5.0 // indirect
+	golang.org/x/sys v0.0.0-20190616124812-15dcb6c0061f // indirect
+	golang.org/x/text v0.3.2 // indirect
 	gopkg.in/DataDog/dd-trace-go.v1 v1.12.1
-	gopkg.in/airbrake/gobrake.v2 v2.0.9 // indirect
-	gopkg.in/gemnasium/logrus-airbrake-hook.v2 v2.1.2 // indirect
-	gopkg.in/yaml.v2 v2.2.2 // indirect
+	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
 )

go.sum

@@ -0,0 +1,111 @@
+package router
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/netlify/netlify-commons/tracing"
+)
+
+// HTTPError is an error with a message and an HTTP status code.
+type HTTPError struct {
+	Code            int         `json:"code"`
+	Message         string      `json:"msg"`
+	JSON            interface{} `json:"json"`
+	InternalError   error       `json:"-"`
+	InternalMessage string      `json:"-"`
+	ErrorID         string      `json:"error_id,omitempty"`
+}
+
+// BadRequestError creates a 400 HTTP error
+func BadRequestError(fmtString string, args ...interface{}) *HTTPError {
+	return httpError(http.StatusBadRequest, fmtString, args...)
+}
+
+// InternalServerError creates a 500 HTTP error
+func InternalServerError(fmtString string, args ...interface{}) *HTTPError {
+	return httpError(http.StatusInternalServerError, fmtString, args...)
+}
+
+// NotFoundError creates a 404 HTTP error
+func NotFoundError(fmtString string, args ...interface{}) *HTTPError {
+	return httpError(http.StatusNotFound, fmtString, args...)
+}
+
+// UnauthorizedError creates a 401 HTTP error
+func UnauthorizedError(fmtString string, args ...interface{}) *HTTPError {
+	return httpError(http.StatusUnauthorized, fmtString, args...)
+}
+
+// UnavailableServiceError creates a 503 HTTP error
+func UnavailableServiceError(fmtString string, args ...interface{}) *HTTPError {
+	return httpError(http.StatusServiceUnavailable, fmtString, args...)
+}
+
+// Error will describe the HTTP error in text
+func (e *HTTPError) Error() string {
+	if e.InternalMessage != "" {
+		return e.InternalMessage
+	}
+	return fmt.Sprintf("%d: %s", e.Code, e.Message)
+}
+
+// Cause will return the root cause error
+func (e *HTTPError) Cause() error {
+	if e.InternalError != nil {
+		return e.InternalError
+	}
+	return e
+}
+
+// WithJSONError will add json details to the error
+func (e *HTTPError) WithJSONError(json interface{}) *HTTPError {
+	e.JSON = json
+	return e
+}
+
+// WithInternalError will add internal error information to an error
+func (e *HTTPError) WithInternalError(err error) *HTTPError {
+	e.InternalError = err
+	return e
+}
+
+// WithInternalMessage will add and internal message to an error
+func (e *HTTPError) WithInternalMessage(fmtString string, args ...interface{}) *HTTPError {
+	e.InternalMessage = fmt.Sprintf(fmtString, args...)
+	return e
+}
+
+func httpError(code int, fmtString string, args ...interface{}) *HTTPError {
+	return &HTTPError{
+		Code:    code,
+		Message: fmt.Sprintf(fmtString, args...),
+	}
+}
+
+// HandleError will handle an error
+func HandleError(err error, w http.ResponseWriter, r *http.Request) {
+	log := tracing.GetLogger(r)
+	errorID := tracing.RequestID(r)
+	switch e := err.(type) {
+	case *HTTPError:
+		if e.Code >= http.StatusInternalServerError {
+			e.ErrorID = errorID
+			// this will get us the stack trace too
+			log.WithError(e.Cause()).Error(e.Error())
+		} else {
+			log.WithError(e.Cause()).Info(e.Error())
+		}
+
+		if jsonErr := SendJSON(w, e.Code, e); jsonErr != nil {
+			HandleError(jsonErr, w, r)
+		}
+	default:
+		log.WithError(e).Errorf("Unhandled server error: %s", e.Error())
+		// hide real error details from response to prevent info leaks
+		w.WriteHeader(http.StatusInternalServerError)
+		if _, writeErr := w.Write([]byte(`{"code":500,"msg":"Internal server error","error_id":"` + errorID + `"}`)); writeErr != nil {
+			log.WithError(writeErr).Error("Error writing generic error message")
+		}
+	}
+}

router/errors.go

@@ -0,0 +1,21 @@
+package router
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"github.com/pkg/errors"
+)
+
+// SendJSON will write the response object as JSON
+func SendJSON(w http.ResponseWriter, status int, obj interface{}) error {
+	w.Header().Set("Content-Type", "application/json")
+	b, err := json.Marshal(obj)
+	if err != nil {
+		return errors.Wrap(err, fmt.Sprintf("Error encoding json response: %v", obj))
+	}
+	w.WriteHeader(status)
+	_, err = w.Write(b)
+	return err
+}

router/helpers.go

@@ -0,0 +1,95 @@
+package router
+
+import (
+	"fmt"
+	"net/http"
+	"os"
+	"regexp"
+	"runtime/debug"
+	"strings"
+
+	"github.com/netlify/netlify-commons/tracing"
+)
+
+var bearerRegexp = regexp.MustCompile(`^(?:B|b)earer (\S+$)`)
+
+const versionHeaderTempl = "X-NF-%s-Version"
+
+type Middleware func(http.Handler) http.Handler
+
+func MiddlewareFunc(f func(w http.ResponseWriter, r *http.Request, next http.Handler)) Middleware {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			f(w, r, next)
+		})
+	}
+}
+
+func VersionHeader(serviceName, version string) Middleware {
+	return MiddlewareFunc(func(w http.ResponseWriter, r *http.Request, next http.Handler) {
+		next.ServeHTTP(w, r)
+		w.Header().Set(fmt.Sprintf(versionHeaderTempl, strings.ToUpper(serviceName)), version)
+	})
+}
+
+func CheckAuth(secret string) Middleware {
+	return MiddlewareFunc(func(w http.ResponseWriter, r *http.Request, next http.Handler) {
+		if secret != "" {
+			authHeader := r.Header.Get("Authorization")
+			if authHeader == "" {
+				HandleError(UnauthorizedError("This endpoint requires a Bearer token"), w, r)
+			}
+
+			matches := bearerRegexp.FindStringSubmatch(authHeader)
+			if len(matches) != 2 {
+				HandleError(UnauthorizedError("This endpoint requires a Bearer token"), w, r)
+			}
+
+			if secret != matches[1] {
+				HandleError(UnauthorizedError("This endpoint requires a Bearer token"), w, r)
+			}
+		}
+
+		next.ServeHTTP(w, r)
+	})
+}
+
+// Recoverer is a middleware that recovers from panics, logs the panic (and a
+// backtrace), and returns a HTTP 500 (Internal Server Error) status if
+// possible. Recoverer prints a request ID if one is provided.
+func Recoverer(w http.ResponseWriter, r *http.Request, next http.Handler) {
+	defer func() {
+		if rvr := recover(); rvr != nil {
+
+			log := tracing.GetLogger(r)
+			if log != nil {
+				log.Errorf("Panic: %+v\n%s", rvr, debug.Stack())
+			} else {
+				fmt.Fprintf(os.Stderr, "Panic: %+v\n", rvr)
+				debug.PrintStack()
+			}
+
+			se := &HTTPError{
+				Code:    http.StatusInternalServerError,
+				Message: http.StatusText(http.StatusInternalServerError),
+			}
+			HandleError(se, w, r)
+		}
+	}()
+
+	next.ServeHTTP(w, r)
+}
+
+func HealthCheck(route string, f APIHandler) Middleware {
+	return MiddlewareFunc(func(w http.ResponseWriter, r *http.Request, next http.Handler) {
+		if r.URL.Path == route {
+			if f == nil {
+				w.WriteHeader(http.StatusOK)
+				return
+			}
+			HandleError(f(w, r), w, r)
+			return
+		}
+		next.ServeHTTP(w, r)
+	})
+}

router/middleware.go

@@ -0,0 +1,35 @@
+package router
+
+import (
+	"github.com/sirupsen/logrus"
+)
+
+type Option func(r *chiWrapper)
+
+func OptEnableCORS(r *chiWrapper) {
+	r.enableCORS = true
+}
+
+func OptHealthCheck(path string, checker APIHandler) Option {
+	return func(r *chiWrapper) {
+		r.healthEndpoint = path
+		r.healthHandler = checker
+	}
+}
+
+func OptVersionHeader(svcName, version string) Option {
+	return func(r *chiWrapper) {
+		if version == "" {
+			version = "unknown"
+		}
+		r.version = version
+		r.svcName = svcName
+	}
+}
+
+func OptTracingMiddleware(log logrus.FieldLogger, svcName string) Option {
+	return func(r *chiWrapper) {
+		r.svcName = svcName
+		r.enableTracing = true
+	}
+}