Convert func(next http.Handler) http.Handler middleware

[gf3]

Is there a straightforward way to convert middleware that follows the pattern func(next http.Handler) http.Handler? It's not accounted for by iris.FromStd and didn't see anything in the middleware conversion docs. This style of middleware is pretty common.

See:

• https://github.com/go-chi/chi#middleware-handlers
• https://github.com/gorilla/mux#middleware
• https://www.alexedwards.net/blog/making-and-using-middleware

E.g.:

// Decode JWT from an HTTP request.
func AuthMiddleware(log *zerolog.Logger) func(http.Handler) http.Handler {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			req, err := ExtractTokenWithClaimsIntoRequest(r)

			if err == request.ErrNoTokenInRequest {
				next.ServeHTTP(w, r)
				return
			}

			if err != nil {
				log.Error().Err(err).Msg("Extract token with claims failed")
				http.Error(w, http.StatusText(http.StatusUnauthorized), http.StatusUnauthorized)
				return
			}

			next.ServeHTTP(w, req)
		})
	}
}

[kataras]

Hello @gf3,

It's easy to conver such middlewares to Iris but if you don't want and you just want to wrap it, then use the WrapRouter, example:

app := iris.New()
// ...

loggerMiddleware := AuthMiddleware(logger)
app.WrapRouter(func(w http.ResponseWriter, r *http.Request, router http.HandlerFunc) {
	loggerMiddleware(router).ServeHTTP(w, r)
})

Full code example:

package main

import (
	"context"
	"net/http"

	"github.com/kataras/iris/v12"
)

func main() {
	app := iris.New()

	httpThirdPartyWrapper := StandardWrapper(Options{
		Message: "test_value",
	})
	app.WrapRouter(func(w http.ResponseWriter, r *http.Request, router http.HandlerFunc) {
		httpThirdPartyWrapper(router).ServeHTTP(w, r)
	})

	app.Get("/", index)
	app.Listen(":8080")
}

func index(ctx iris.Context) {
	ctx.Writef("Message: %s\n", ctx.Value(msgContextKey))
}

type Options struct {
	Message string
}

type contextKey uint8

var (
	msgContextKey contextKey = 1
)

func StandardWrapper(opts Options) func(http.Handler) http.Handler {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			// ...
			req := r.WithContext(context.WithValue(r.Context(), msgContextKey, opts.Message))
			next.ServeHTTP(w, req)
		})
	}
}

[zaibon]

What is the solution if you want to only apply this middleware on a router.Party object and not on the all App?

[kataras]

Use the iris.FromStd or convert the handler to be Iris-compatible ( which is super easy as it's 100% compatible with the standard net/http package: ctx.ResponseWriter(), ctx.Request() ).