refactor: middleware call stack

Author: opensaucerer

barf.go

@@ -29,9 +29,9 @@ func createServer(a typing.Augment) error {
 
 	var r http.Handler = server.Mux
 
-	// wrap router into logger middleware
+	// enable logging
 	if *server.Augment.Logging {
-		r = logger.Morgan(r)
+		go logger.Winston()
 	}
 
 	// wrap router into router middleware
@@ -60,10 +60,7 @@ func createServer(a typing.Augment) error {
 	}
 
 	// this will load the CORS and Recovery middleware into the stack
-	if *server.Augment.Recovery {
-		Hippocampus().Hijack()
-		logger.Info("Recovery middleware added to base barf handler")
-	}
+	Hippocampus().Hijack()
 
 	return nil
 }

example/subroute/main.go

@@ -53,15 +53,27 @@ func main() {
 	// create a subrouter (retroframe)
 	var r *barf.SubRoute = barf.RetroFrame("/api")
 
-	// apply middleware to subrouter. note that the only difference between this and global middlewares is that you need to pass the
+	// apply middleware to subrouter. note that the only difference between this and global middlewares is that you need to pass the subrouter to Hippocampus()
 	barf.Hippocampus(r).Hijack(func(h http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			barf.Logger().Info("sub before 0")
+			// barf.Response(w).Status(http.StatusNotFound).JSON(barf.Res{
+			// 	Message: "Not found 0",
+			// })
+			// return
 			h.ServeHTTP(w, r)
 			barf.Logger().Info("sub after 0")
 		})
 	})
 
+	barf.Hippocampus(r).Hijack(func(h http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			barf.Logger().Info("sub before 1")
+			h.ServeHTTP(w, r)
+			barf.Logger().Info("sub after 1")
+		})
+	})
+
 	r.Get("/home", func(w http.ResponseWriter, r *http.Request) {
 		barf.Response(w).Status(http.StatusOK).JSON(barf.Res{
 			Status:  true,

log/middleware.go

@@ -0,0 +1,30 @@
+package logger
+
+import (
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/opensaucerer/barf/server"
+	"github.com/opensaucerer/barf/typing"
+)
+
+// Morgan logs the request to the console
+func Morgan(rr typing.RequestResponse) {
+
+	// format: utc timestamp: user-agent - http/version: method - path - status code - status text
+	msg := time.Now().UTC().Format(time.RFC3339) + ": " + rr.Request.UserAgent() + " - " + rr.Request.Proto + ": " + rr.Request.Method + " - " + rr.Request.URL.Path + " - " + strconv.Itoa(rr.Code) + " - " + http.StatusText(rr.Code)
+	// log request
+	Code(msg, rr.Code)
+
+	// call next middleware? (the logger is the last middleware in the stack)
+	// next.ServeHTTP(w, r)
+
+}
+
+// Winston listens on a channel for log messages and calls morgan for each message
+func Winston() {
+	for msg := range server.RequestResponseChan {
+		Morgan(msg)
+	}
+}

log/morgan.go

@@ -2,6 +2,8 @@ package router
 
 import (
 	"github.com/opensaucerer/barf/cors"
+	logger "github.com/opensaucerer/barf/log"
+
 	"github.com/opensaucerer/barf/server"
 
 	"github.com/opensaucerer/barf/typing"
@@ -51,11 +53,19 @@ func (h *hippocampus) Hijack(m ...typing.Middleware) {
 			for i := range h.stack {
 				r = h.stack[len(h.stack)-1-i](r)
 			}
-			// add cors middleware such that it is called first before any user-defined middleware
-			r = cors.CORS(cors.Prepare(*server.Augment.CORS))(r)
-			// add recovery middleware
-			if server.Augment.Recovery != nil && *server.Augment.Recovery {
-				r = server.Recover(server.JSON)(r)
+
+			if !server.Hijacked {
+				// add cors middleware such that it is called first before any user-defined middleware
+				r = cors.CORS(cors.Prepare(*server.Augment.CORS))(r)
+				// add recovery middleware
+				if server.Augment.Recovery != nil && *server.Augment.Recovery {
+					r = server.Recover(server.JSON)(r)
+					logger.Info("Recovery middleware added to base barf handler")
+				} else {
+					logger.Warn("Recovery middleware is disabled. This is not recommended for production environments!")
+					logger.Warn("Consider enabling it by passing barf.Augment{Recovery: barf.Allow()} to barf.Stark()")
+				}
+				server.Hijacked = true
 			}
 			server.HTTP.Handler = r
 		}

router/hippocampus.go

@@ -3,6 +3,7 @@ package router
 import (
 	"context"
 	"fmt"
+	"log"
 	"net/http"
 	"regexp"
 	"strings"
@@ -33,11 +34,19 @@ func Router(respond func(w http.ResponseWriter, status bool, statusCode int, mes
 
 			// check if route exists
 			if !route.Exists() {
+				log.Println("route not found", route.Path, route.Method)
 				respond(w, false, http.StatusNotFound, fmt.Sprintf("Path /%s for method %s not found", regexp.MustCompile("^/+|/+$").ReplaceAllString(route.Path, ""), strings.ToUpper(route.Method)), nil)
 			} else {
 				// load params into context if any
 				ctx := context.WithValue(r.Context(), typing.ParamsCtxKey{}, route.Params)
 
+				r = r.WithContext(ctx)
+
+				// call route specific middleware(s)
+				for i := range route.stack {
+					sh = route.stack[len(route.stack)-1-i](sh)
+				}
+
 				// call middleware stack if route is registered on a SubRoute
 				if route.RetroFrame {
 					s := route.Reframe()
@@ -47,16 +56,15 @@ func Router(respond func(w http.ResponseWriter, status bool, statusCode int, mes
 						}
 					}
 				}
+			}
 
-				// call route specific middleware(s)
-				for i := range route.stack {
-					sh = route.stack[len(route.stack)-1-i](sh)
-				}
-
-				// call route handler
-				route.Handler(w, r.WithContext(ctx))
+			// make request/response available globally
+			server.RequestResponse = &typing.RequestResponse{
+				Request:  r,
+				Response: w,
 			}
-			// call the next middleware
+
+			// call the next middleware (if no route was found)
 			sh.ServeHTTP(w, r)
 		})
 	}

router/middleware.go

@@ -1,6 +1,7 @@
 package router
 
 import (
+	"net/http"
 	"regexp"
 )
 
@@ -15,4 +16,11 @@ func (r *Route) Register() {
 		rtable[r.Path] = make(map[string]*Route)
 	}
 	rtable[r.Path][r.Method] = r
+	// the handler is added as just another middleware
+	r.stack = append(r.stack, func(h http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+			r.Handler(w, req)
+			h.ServeHTTP(w, req)
+		})
+	})
 }

router/register.go

@@ -14,4 +14,10 @@ var (
 	Augment *typing.Augment
 
 	Beckoned *bool
+
+	Hijacked bool
+
+	RequestResponse *typing.RequestResponse
+
+	RequestResponseChan = make(chan typing.RequestResponse)
 )

server/http.go

@@ -24,10 +24,12 @@ type response struct {
 
 // JSON writes a JSON response to the response writer
 func (r *response) JSON(data interface{}) {
-	r.rw.Header().Set(constant.ContentType, constant.ApplicationJSON)
-	r.rw.WriteHeader(r.code)
-	json.NewEncoder(r.rw).Encode(data)
-	Write(r.rw) // write to underlying response writer
+	if Loaded(r.rw) && !Written(r.rw) {
+		r.rw.Header().Set(constant.ContentType, constant.ApplicationJSON)
+		r.rw.WriteHeader(r.code)
+		json.NewEncoder(r.rw).Encode(data)
+		Write(r.rw) // write to underlying response writer
+	}
 }
 
 // Status loads a barf response with the given status code
@@ -110,6 +112,13 @@ func Write(w http.ResponseWriter) {
 		}
 		w.(*ResponseWriter).rw.WriteHeader(w.(*ResponseWriter).Code)
 		w.(*ResponseWriter).rw.Write(w.(*ResponseWriter).Body)
+
+		// signal the logger middleware that the response has been written to
+		RequestResponseChan <- typing.RequestResponse{
+			Request:  RequestResponse.Request,
+			Response: w.(*ResponseWriter),
+			Code:     w.(*ResponseWriter).Code,
+		}
 	}
 }
 

server/response.go

@@ -81,3 +81,10 @@ type CORS struct {
 	// AllowedOriginWithRequestFunc is a callback for handling user defined origin checks with access to the http request object.
 	AllowedOriginWithRequestFunc func(origin string, r *http.Request) bool
 }
+
+// RequestResponse holds the request and response objects
+type RequestResponse struct {
+	Request  *http.Request
+	Response http.ResponseWriter
+	Code     int
+}