From dee3e6b4db47cb6e1b62466fba45a915e2847da1 Mon Sep 17 00:00:00 2001 From: "Gerasimos (Makis) Maropoulos" Date: Sat, 19 Jan 2019 23:33:33 +0200 Subject: [PATCH] init of v11.2.0: add context#FullRequestURI and NewConditionalHandler As requested at: https://github.com/kataras/iris/issues/1167 and https://github.com/kataras/iris/issues/1170 --- _examples/routing/conditional-chain/main.go | 49 +++++++++++++++++++ context/context.go | 30 ++++++++++-- context/handler.go | 52 +++++++++++++++++++++ go19.go | 6 +++ httptest/httptest.go | 3 +- iris.go | 18 +++++++ 6 files changed, 152 insertions(+), 6 deletions(-) create mode 100644 _examples/routing/conditional-chain/main.go diff --git a/_examples/routing/conditional-chain/main.go b/_examples/routing/conditional-chain/main.go new file mode 100644 index 000000000..ec2765f84 --- /dev/null +++ b/_examples/routing/conditional-chain/main.go @@ -0,0 +1,49 @@ +package main + +import ( + "github.com/kataras/iris" +) + +func main() { + app := iris.New() + v1 := app.Party("/api/v1") + + myFilter := func(ctx iris.Context) bool { + // don't do that on production, use session or/and database calls and etc. + ok, _ := ctx.URLParamBool("admin") + return ok + } + + onlyWhenFilter1 := func(ctx iris.Context) { + ctx.Application().Logger().Infof("admin: %s", ctx.Params()) + ctx.Next() + } + + onlyWhenFilter2 := func(ctx iris.Context) { + // You can always use the per-request storage + // to perform actions like this ofc. + // + // this handler: ctx.Values().Set("is_admin", true) + // next handler: isAdmin := ctx.Values().GetBoolDefault("is_admin", false) + // + // but, let's simplify it: + ctx.HTML("

Hello Admin


") + ctx.Next() + } + + // HERE: + // It can be registered anywhere, as a middleware. + // It will fire the `onlyWhenFilter1` and `onlyWhenFilter2` as middlewares (with ctx.Next()) + // if myFilter pass otherwise it will just continue the handler chain with ctx.Next() by ignoring + // the `onlyWhenFilter1` and `onlyWhenFilter2`. + myMiddleware := iris.NewConditionalHandler(myFilter, onlyWhenFilter1, onlyWhenFilter2) + + v1UsersRouter := v1.Party("/users", myMiddleware) + v1UsersRouter.Get("/", func(ctx iris.Context) { + ctx.HTML("requested: /api/v1/users") + }) + + // http://localhost:8080/api/v1/users + // http://localhost:8080/api/v1/users?admin=true + app.Run(iris.Addr(":8080")) +} diff --git a/context/context.go b/context/context.go index f437e4475..0b37b8d8a 100644 --- a/context/context.go +++ b/context/context.go @@ -292,7 +292,6 @@ type Context interface { // RequestPath returns the full request path, // based on the 'escape'. RequestPath(escape bool) string - // Host returns the host part of the current url. Host() string // Subdomain returns the subdomain of this request, if any. @@ -300,6 +299,9 @@ type Context interface { Subdomain() (subdomain string) // IsWWW returns true if the current subdomain (if any) is www. IsWWW() bool + // FullRqeuestURI returns the full URI, + // including the scheme, the host and the relative requested path/resource. + FullRequestURI() string // RemoteAddr tries to parse and return the real client's request IP. // // Based on allowed headers names that can be modified from Configuration.RemoteAddrHeaders. @@ -1465,11 +1467,11 @@ func (ctx *context) Host() string { // GetHost returns the host part of the current URI. func GetHost(r *http.Request) string { - h := r.URL.Host - if h == "" { - h = r.Host + if host := r.Host; host != "" { + return host } - return h + + return r.URL.Host } // Subdomain returns the subdomain of this request, if any. @@ -1502,6 +1504,24 @@ func (ctx *context) IsWWW() bool { return false } +// FullRqeuestURI returns the full URI, +// including the scheme, the host and the relative requested path/resource. +func (ctx *context) FullRequestURI() string { + scheme := ctx.request.URL.Scheme + if scheme == "" { + if ctx.request.TLS != nil { + scheme = "https:" + } else { + scheme = "http:" + } + } + + host := ctx.Host() + path := ctx.Path() + + return scheme + "//" + host + path +} + const xForwardedForHeaderKey = "X-Forwarded-For" // RemoteAddr tries to parse and return the real client's request IP. diff --git a/context/handler.go b/context/handler.go index 6d980513b..1dcf1a02d 100644 --- a/context/handler.go +++ b/context/handler.go @@ -34,3 +34,55 @@ func HandlerName(h Handler) string { // return fmt.Sprintf("%s:%d", l, n) return runtime.FuncForPC(pc).Name() } + +// Filter is just a type of func(Handler) bool which reports whether an action must be performed +// based on the incoming request. +// +// See `NewConditionalHandler` for more. +type Filter func(Context) bool + +// NewConditionalHandler returns a single Handler which can be registered +// as a middleware. +// Filter is just a type of Handler which returns a boolean. +// Handlers here should act like middleware, they should contain `ctx.Next` to proceed +// to the next handler of the chain. Those "handlers" are registed to the per-request context. +// +// +// It checks the "filter" and if passed then +// it, correctly, executes the "handlers". +// +// If passed, this function makes sure that the Context's information +// about its per-request handler chain based on the new "handlers" is always updated. +// +// If not passed, then simply the Next handler(if any) is executed and "handlers" are ignored. +// +// Example can be found at: _examples/routing/conditional-chain. +func NewConditionalHandler(filter Filter, handlers ...Handler) Handler { + return func(ctx Context) { + if filter(ctx) { + // Note that we don't want just to fire the incoming handlers, we must make sure + // that it won't break any further handler chain + // information that may be required for the next handlers. + // + // The below code makes sure that this conditional handler does not break + // the ability that iris provides to its end-devs + // to check and modify the per-request handlers chain at runtime. + currIdx := ctx.HandlerIndex(-1) + currHandlers := ctx.Handlers() + if currIdx == len(currHandlers)-1 { + // if this is the last handler of the chain + // just add to the last the new handlers and call Next to fire those. + ctx.AddHandler(handlers...) + ctx.Next() + return + } + // otherwise insert the new handlers in the middle of the current executed chain and the next chain. + newHandlers := append(currHandlers[:currIdx], append(handlers, currHandlers[currIdx+1:]...)...) + ctx.SetHandlers(newHandlers) + ctx.Next() + return + } + // if not pass, then just execute the next. + ctx.Next() + } +} diff --git a/go19.go b/go19.go index dd1961963..6d6c979e4 100644 --- a/go19.go +++ b/go19.go @@ -42,6 +42,12 @@ type ( // If Handler panics, the server (the caller of Handler) assumes that the effect of the panic was isolated to the active request. // It recovers the panic, logs a stack trace to the server error log, and hangs up the connection. Handler = context.Handler + // Filter is just a type of func(Handler) bool which reports whether an action must be performed + // based on the incoming request. + // + // See `NewConditionalHandler` for more. + // An alias for the `context/Filter`. + Filter = context.Filter // A Map is a shortcut of the map[string]interface{}. Map = context.Map diff --git a/httptest/httptest.go b/httptest/httptest.go index 50253c539..243f765b4 100644 --- a/httptest/httptest.go +++ b/httptest/httptest.go @@ -5,8 +5,9 @@ import ( "net/http" "testing" - "github.com/iris-contrib/httpexpect" "github.com/kataras/iris" + + "github.com/iris-contrib/httpexpect" ) type ( diff --git a/iris.go b/iris.go index d2e3e0df9..f899fcdfe 100644 --- a/iris.go +++ b/iris.go @@ -341,6 +341,24 @@ var ( // // A shortcut for the `context#LimitRequestBodySize`. LimitRequestBodySize = context.LimitRequestBodySize + // NewConditionalHandler returns a single Handler which can be registered + // as a middleware. + // Filter is just a type of Handler which returns a boolean. + // Handlers here should act like middleware, they should contain `ctx.Next` to proceed + // to the next handler of the chain. Those "handlers" are registed to the per-request context. + // + // + // It checks the "filter" and if passed then + // it, correctly, executes the "handlers". + // + // If passed, this function makes sure that the Context's information + // about its per-request handler chain based on the new "handlers" is always updated. + // + // If not passed, then simply the Next handler(if any) is executed and "handlers" are ignored. + // Example can be found at: _examples/routing/conditional-chain. + // + // A shortcut for the `context#NewConditionalHandler`. + NewConditionalHandler = context.NewConditionalHandler // StaticEmbeddedHandler returns a Handler which can serve // embedded into executable files. //