pkg/web: closure-style middlewares (#51238)

* pkg/web: closure-style middlewares

Switches the middleware execution model from web.Handlers in a slice to
web.Middleware.
Middlewares are temporarily kept in a slice to preserve ordering, but
prior to execution they are applied, forming a giant call-stack, giving
granular control over the execution flow.

* pkg/middleware: adapt to web.Middleware

* pkg/middleware/recovery: use c.Req over req

c.Req gets updated by future handlers, while req stays static.

The current recovery implementation needs this newer information

* pkg/web: correct middleware ordering

* pkg/webtest: adapt middleware

* pkg/web/hack: set w and r onto web.Context

By adopting std middlewares, it may happen they invoke next(w,r) without
putting their modified w,r into the web.Context, leading old-style
handlers to operate on outdated fields.

pkg/web now takes care of this

* pkg/middleware: selectively use future context

* pkg/web: accept closure-style on Use()

* webtest: Middleware testing

adds a utility function to web/webtest to obtain a http.ResponseWriter,
http.Request and http.Handler the same as a middleware that runs would receive

* *: cleanup

* pkg/web: don't wrap Middleware from Router

* pkg/web: require chain to write response

* *: remove temp files

* webtest: don't require chain write

* *: cleanup

pkg/api/response/web_hack.go

@@ -4,7 +4,6 @@ package response
 //NOTE: This file belongs into pkg/web, but due to cyclic imports that are hard to resolve at the current time, it temporarily lives here.
 
 import (
-	"context"
 	"fmt"
 	"net/http"
 
@@ -24,23 +23,25 @@ type (
 
 func wrap_handler(h web.Handler) http.HandlerFunc {
 	switch handle := h.(type) {
+	case http.HandlerFunc:
+		return handle
 	case handlerStd:
 		return handle
 	case handlerStdCtx:
 		return func(w http.ResponseWriter, r *http.Request) {
-			handle(w, r, web.FromContext(r.Context()))
+			handle(w, r, webCtx(w, r))
 		}
 	case handlerStdReqCtx:
 		return func(w http.ResponseWriter, r *http.Request) {
-			handle(w, r, getReqCtx(r.Context()))
+			handle(w, r, reqCtx(w, r))
 		}
 	case handlerReqCtx:
 		return func(w http.ResponseWriter, r *http.Request) {
-			handle(getReqCtx(r.Context()))
+			handle(reqCtx(w, r))
 		}
 	case handlerReqCtxRes:
 		return func(w http.ResponseWriter, r *http.Request) {
-			ctx := getReqCtx(r.Context())
+			ctx := reqCtx(w, r)
 			res := handle(ctx)
 			if res != nil {
 				res.WriteTo(ctx)
@@ -48,15 +49,27 @@ func wrap_handler(h web.Handler) http.HandlerFunc {
 		}
 	case handlerCtx:
 		return func(w http.ResponseWriter, r *http.Request) {
-			handle(web.FromContext(r.Context()))
+			handle(webCtx(w, r))
 		}
 	}
 
 	panic(fmt.Sprintf("unexpected handler type: %T", h))
 }
 
-func getReqCtx(ctx context.Context) *models.ReqContext {
-	reqCtx, ok := ctx.Value(ctxkey.Key{}).(*models.ReqContext)
+func webCtx(w http.ResponseWriter, r *http.Request) *web.Context {
+	ctx := web.FromContext(r.Context())
+	if ctx == nil {
+		panic("no *web.Context found")
+	}
+
+	ctx.Req = r
+	ctx.Resp = web.Rw(w, r)
+	return ctx
+}
+
+func reqCtx(w http.ResponseWriter, r *http.Request) *models.ReqContext {
+	wCtx := webCtx(w, r)
+	reqCtx, ok := wCtx.Req.Context().Value(ctxkey.Key{}).(*models.ReqContext)
 	if !ok {
 		panic("no *models.ReqContext found")
 	}