Initial commit

middleware/header.go

@@ -0,0 +1,49 @@
+package middleware
+
+import (
+	"net/http"
+	"time"
+)
+
+// Cache writes required cache headers to all requests.
+func Cache(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Cache-Control", "no-cache, no-store, max-age=0, must-revalidate, value")
+		w.Header().Set("Expires", "Thu, 01 Jan 1970 00:00:00 GMT")
+		w.Header().Set("Last-Modified", time.Now().UTC().Format(http.TimeFormat))
+
+		next.ServeHTTP(w, r)
+	})
+}
+
+// Cors writes required cors headers to all requests.
+func Cors(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != "OPTIONS" {
+			next.ServeHTTP(w, r)
+		} else {
+			w.Header().Set("Access-Control-Allow-Origin", "*")
+			w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS")
+			w.Header().Set("Access-Control-Allow-Headers", "authorization, origin, content-type, accept")
+			w.Header().Set("Allow", "HEAD, GET, POST, PUT, PATCH, DELETE, OPTIONS")
+
+			w.WriteHeader(http.StatusOK)
+		}
+	})
+}
+
+// Secure writes required access headers to all requests.
+func Secure(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("X-Frame-Options", "DENY")
+		w.Header().Set("X-Content-Type-Options", "nosniff")
+		w.Header().Set("X-XSS-Protection", "1; mode=block")
+
+		if r.TLS != nil {
+			w.Header().Set("Strict-Transport-Security", "max-age=31536000")
+		}
+
+		next.ServeHTTP(w, r)
+	})
+}

middleware/logger.go

@@ -0,0 +1,30 @@
+package middleware
+
+import (
+	"net/http"
+	"time"
+
+	"github.com/go-chi/chi/middleware"
+	"github.com/owncloud/ocis-pkg/log"
+)
+
+// Logger is a middleware to log http requests.
+func Logger(logger log.Logger) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			start := time.Now()
+			wrap := middleware.NewWrapResponseWriter(w, r.ProtoMajor)
+			next.ServeHTTP(wrap, r)
+
+			logger.Debug().
+				Str("request", r.Header.Get("X-Request-ID")).
+				Str("proto", r.Proto).
+				Str("method", r.Method).
+				Int("status", wrap.Status()).
+				Str("path", r.URL.Path).
+				Dur("duration", time.Since(start)).
+				Int("bytes", wrap.BytesWritten()).
+				Msg("")
+		})
+	}
+}

middleware/realip.go

@@ -0,0 +1,18 @@
+package middleware
+
+import (
+	"net/http"
+
+	"github.com/tomasen/realip"
+)
+
+// RealIP is a middleware that sets a http.Request RemoteAddr.
+func RealIP(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if ip := realip.RealIP(r); ip != "" {
+			r.RemoteAddr = ip
+		}
+
+		next.ServeHTTP(w, r)
+	})
+}

middleware/requestid.go

@@ -0,0 +1,12 @@
+package middleware
+
+import (
+	"net/http"
+
+	"github.com/ascarter/requestid"
+)
+
+// RequestID is a convenient middleware to inject a request id.
+func RequestID(next http.Handler) http.Handler {
+	return requestid.RequestIDHandler(next)
+}

middleware/static.go

@@ -0,0 +1,30 @@
+package middleware
+
+import (
+	"net/http"
+	"strings"
+)
+
+// Static is a middleware that serves static assets.
+func Static(fs http.FileSystem) func(http.Handler) http.Handler {
+	static := http.StripPrefix(
+		"/",
+		http.FileServer(
+			fs,
+		),
+	)
+
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if strings.HasPrefix(r.URL.Path, "/api") {
+				next.ServeHTTP(w, r)
+			} else {
+				if strings.HasSuffix(r.URL.Path, "/") {
+					http.NotFound(w, r)
+				} else {
+					static.ServeHTTP(w, r)
+				}
+			}
+		})
+	}
+}

middleware/token.go

@@ -0,0 +1,37 @@
+package middleware
+
+import (
+	"errors"
+	"net/http"
+)
+
+var (
+	// ErrInvalidToken is returned when the request token is invalid.
+	ErrInvalidToken = errors.New("invalid or missing token")
+)
+
+// Token provides a middleware to check access secured by a static token.
+func Token(token string) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if token == "" {
+				next.ServeHTTP(w, r)
+				return
+			}
+
+			header := r.Header.Get("Authorization")
+
+			if header == "" {
+				http.Error(w, ErrInvalidToken.Error(), http.StatusUnauthorized)
+				return
+			}
+
+			if header != "Bearer "+token {
+				http.Error(w, ErrInvalidToken.Error(), http.StatusUnauthorized)
+				return
+			}
+
+			next.ServeHTTP(w, r)
+		})
+	}
+}

middleware/version.go

@@ -0,0 +1,21 @@
+package middleware
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+)
+
+// Version writes the current version to the headers.
+func Version(name, version string) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set(
+				fmt.Sprintf("X-%s-VERSION", strings.ToUpper(name)),
+				version,
+			)
+
+			next.ServeHTTP(w, r)
+		})
+	}
+}