Create a temporary context for the first middleware to run for not se…

…nding content to client if the middleware fail

middleware.go

@@ -16,10 +16,23 @@ func Mixed() func(handler1, handler2 echo.MiddlewareFunc) echo.MiddlewareFunc {
 			a2 := handler2(next)
 
 			return func(c echo.Context) error {
-				if a1(c) == nil {
+				tempContext := copyContext(c)
+				// tempContext.Set(ContextUserInfoKey, c.Get(ContextUserInfoKey))
+				defer tempContext.Echo().ReleaseContext(tempContext)
+				if a1(tempContext) == nil {
+					copyResponse(c, tempContext)
+
 					return nil
 				}
-				return a2(c)
+
+				// Try the second middleware
+				err := a2(c)
+				if err != nil {
+					// Return the first middleware error
+					copyResponse(c, tempContext)
+					c.Response().WriteHeader(tempContext.Response().Status)
+				}
+				return err
 			}
 		}
 	}

middleware_test.go

@@ -12,7 +12,7 @@ import (
 )
 
 func TestMixedAuthenticationSucceedsOnFirstAuth(t *testing.T) {
-	auth1 := succeedingMiddleware("hello")
+	auth1 := succeedingMiddleware(204)
 	auth2 := failingMiddleware(errors.New("boom"))
 
 	ctx := newContext()
@@ -22,12 +22,12 @@ func TestMixedAuthenticationSucceedsOnFirstAuth(t *testing.T) {
 	err := handlerFunc(ctx)
 
 	assert.NoError(t, err)
-	assert.Equal(t, "hello", ctx.Get("KEY"))
+	assert.Equal(t, 204, ctx.Response().Status)
 }
 
 func TestMixedAuthenticationSucceedsOnSecondAuth(t *testing.T) {
 	auth1 := failingMiddleware(errors.New("boom"))
-	auth2 := succeedingMiddleware("hello2")
+	auth2 := succeedingMiddleware(204)
 
 	ctx := newContext()
 	md := Mixed()(auth1, auth2)
@@ -36,7 +36,7 @@ func TestMixedAuthenticationSucceedsOnSecondAuth(t *testing.T) {
 	err := handlerFunc(ctx)
 
 	assert.NoError(t, err)
-	assert.Equal(t, "hello2", ctx.Get("KEY"))
+	assert.Equal(t, 204, ctx.Response().Status)
 }
 
 func TestMixedAuthenticationFailsOnBothFailedAuths(t *testing.T) {
@@ -52,10 +52,10 @@ func TestMixedAuthenticationFailsOnBothFailedAuths(t *testing.T) {
 	assert.Equal(t, "boom2", err.Error())
 }
 
-func succeedingMiddleware(succeedingValue string) echo.MiddlewareFunc {
+func succeedingMiddleware(status int) echo.MiddlewareFunc {
 	return func(next echo.HandlerFunc) echo.HandlerFunc {
 		return func(c echo.Context) error {
-			c.Set("KEY", succeedingValue)
+			c.NoContent(status)
 			return nil
 		}
 	}

tempresponsewriter.go

@@ -0,0 +1,24 @@
+package mixed
+
+import "net/http"
+
+// tempResponseWriter implement the http.ResponseWriter interface
+// It used when you need to temporary hold the content and use it later
+type tempResponseWriter struct {
+	header     http.Header
+	StatusCode int
+	Content    []byte
+}
+
+func (rw *tempResponseWriter) Header() http.Header {
+	return rw.header
+}
+
+func (rw *tempResponseWriter) Write(content []byte) (int, error) {
+	rw.Content = append(rw.Content, content...)
+	return len(content), nil
+}
+
+func (rw *tempResponseWriter) WriteHeader(code int) {
+	rw.StatusCode = code
+}

utils.go

@@ -0,0 +1,41 @@
+package mixed
+
+import (
+	"net/http"
+
+	echo "github.com/labstack/echo/v4"
+)
+
+// copyContext create a new echo.Context with the same Request, Path, Params and Handler
+// but with a Response that contain an in-memory ResponseWriter
+func copyContext(c echo.Context) echo.Context {
+	cc := c.Echo().AcquireContext()
+	cc.SetRequest(c.Request())
+	cc.SetPath(c.Path())
+	cc.SetParamNames(c.ParamNames()...)
+	cc.SetParamValues(c.ParamValues()...)
+	cc.SetHandler(c.Handler())
+
+	rw := tempResponseWriter{
+		header:  make(http.Header),
+		Content: []byte{},
+	}
+	resp := echo.NewResponse(&rw, c.Echo())
+	cc.SetResponse(resp)
+	return cc
+}
+
+// copyResponse copy c2 headers and content into c1
+func copyResponse(c1, c2 echo.Context) {
+	for k, v := range c2.Response().Header() {
+		for _, vv := range v {
+			c1.Response().Header().Set(k, vv)
+		}
+	}
+
+	if c2.Response().Status > 0 {
+		c1.Response().WriteHeader(c2.Response().Status)
+	}
+
+	c1.Response().Write(c2.Response().Writer.(*tempResponseWriter).Content)
+}