mirror of
https://github.com/grafana/grafana.git
synced 2025-02-11 16:15:42 -06:00
534ece064b
* 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
78 lines
1.9 KiB
Go
78 lines
1.9 KiB
Go
//nolint:unused,deadcode
|
|
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 (
|
|
"fmt"
|
|
"net/http"
|
|
|
|
"github.com/grafana/grafana/pkg/models"
|
|
"github.com/grafana/grafana/pkg/services/contexthandler/ctxkey"
|
|
"github.com/grafana/grafana/pkg/web"
|
|
)
|
|
|
|
type (
|
|
handlerStd = func(http.ResponseWriter, *http.Request)
|
|
handlerStdCtx = func(http.ResponseWriter, *http.Request, *web.Context)
|
|
handlerStdReqCtx = func(http.ResponseWriter, *http.Request, *models.ReqContext)
|
|
handlerReqCtx = func(*models.ReqContext)
|
|
handlerReqCtxRes = func(*models.ReqContext) Response
|
|
handlerCtx = func(*web.Context)
|
|
)
|
|
|
|
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, webCtx(w, r))
|
|
}
|
|
case handlerStdReqCtx:
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
handle(w, r, reqCtx(w, r))
|
|
}
|
|
case handlerReqCtx:
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
handle(reqCtx(w, r))
|
|
}
|
|
case handlerReqCtxRes:
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
ctx := reqCtx(w, r)
|
|
res := handle(ctx)
|
|
if res != nil {
|
|
res.WriteTo(ctx)
|
|
}
|
|
}
|
|
case handlerCtx:
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
handle(webCtx(w, r))
|
|
}
|
|
}
|
|
|
|
panic(fmt.Sprintf("unexpected handler type: %T", h))
|
|
}
|
|
|
|
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")
|
|
}
|
|
return reqCtx
|
|
}
|