✨ feature: add initial support for hooks

app.go

@@ -114,6 +114,9 @@ type App struct {
 
 	// Mounted and main apps
 	appList map[string]*App
+
+	// Hooks
+	hooks Hooks
 }
 
 // Config is a struct holding the server settings.
@@ -466,6 +469,13 @@ func New(config ...Config) *App {
 		getString: utils.UnsafeString,
 		appList:   make(map[string]*App),
 	}
+
+	// Define hooks
+	app.hooks = Hooks{
+		app:      app,
+		hookList: make(map[string][]HookHandler),
+	}
+
 	// Override config if provided
 	if len(config) > 0 {
 		app.config = config[0]
@@ -575,7 +585,12 @@ func (app *App) Name(name string) Router {
 	} else {
 		latestRoute.route.Name = name
 	}
+
+	if err := app.hooks.executeOnNameHooks(*latestRoute.route); err != nil {
+		panic(err)
+	}
 	latestRoute.mu.Unlock()
+
 	return app
 }
 
@@ -859,6 +874,8 @@ func (app *App) HandlersCount() uint32 {
 //
 // Shutdown does not close keepalive connections so its recommended to set ReadTimeout to something else than 0.
 func (app *App) Shutdown() error {
+	defer app.hooks.executeOnShutdownHooks()
+
 	app.mutex.Lock()
 	defer app.mutex.Unlock()
 	if app.server == nil {
@@ -872,6 +889,11 @@ func (app *App) Server() *fasthttp.Server {
 	return app.server
 }
 
+// Hooks returns the hook struct to register hooks.
+func (app *App) Hooks() *Hooks {
+	return &app.hooks
+}
+
 // Test is used for internal debugging by passing a *http.Request.
 // Timeout is optional and defaults to 1s, -1 will disable it completely.
 func (app *App) Test(req *http.Request, msTimeout ...int) (resp *http.Response, err error) {
@@ -1038,6 +1060,10 @@ func (app *App) serverErrorHandler(fctx *fasthttp.RequestCtx, err error) {
 
 // startupProcess Is the method which executes all the necessary processes just before the start of the server.
 func (app *App) startupProcess() *App {
+	if err := app.hooks.executeOnListenHooks(); err != nil {
+		panic(err)
+	}
+
 	app.mutex.Lock()
 	app.buildTree()
 	app.mutex.Unlock()

app_test.go

@@ -33,6 +33,10 @@ var testEmptyHandler = func(c *Ctx) error {
 	return nil
 }
 
+var testSimpleHandler = func(c *Ctx) error {
+	return c.SendString("simple")
+}
+
 func testStatus200(t *testing.T, app *App, url string, method string) {
 	t.Helper()
 

group.go

@@ -54,6 +54,10 @@ func (grp *Group) Name(name string) Router {
 
 	latestGroup = *grp
 
+	if err := grp.app.hooks.executeOnGroupNameHooks(latestGroup); err != nil {
+		panic(err)
+	}
+
 	return grp
 }
 

hooks.go

@@ -0,0 +1,118 @@
+package fiber
+
+import (
+	"github.com/valyala/fasthttp"
+)
+
+// Handler defines a function to create hooks for Fiber.
+type HookHandler = func(*Ctx, Map) error
+
+type Hooks struct {
+	app      *App
+	hookList map[string][]HookHandler
+}
+
+// OnRoute is a hook to execute user functions on each route registeration.
+// Also you can get route properties by "route" key of map.
+func (h *Hooks) OnRoute(handler ...HookHandler) {
+	h.app.mutex.Lock()
+	h.hookList["onRoute"] = append(h.hookList["onRoute"], handler...)
+	h.app.mutex.Unlock()
+}
+
+// OnName is a hook to execute user functions on each route naming.
+// Also you can get route properties by "route" key of map.
+//
+// WARN: OnName only works with naming routes, not groups.
+func (h *Hooks) OnName(handler ...HookHandler) {
+	h.app.mutex.Lock()
+	h.hookList["onName"] = append(h.hookList["onName"], handler...)
+	h.app.mutex.Unlock()
+}
+
+// OnGroupName is a hook to execute user functions on each group naming.
+// Also you can get group properties by "group" key of map.
+//
+// WARN: OnGroupName only works with naming groups, not routes.
+func (h *Hooks) OnGroupName(handler ...HookHandler) {
+	h.app.mutex.Lock()
+	h.hookList["onGroupName"] = append(h.hookList["onGroupName"], handler...)
+	h.app.mutex.Unlock()
+}
+
+// OnListen is a hook to execute user functions on Listen, ListenTLS, Listener.
+func (h *Hooks) OnListen(handler ...HookHandler) {
+	h.app.mutex.Lock()
+	h.hookList["onListen"] = append(h.hookList["onListen"], handler...)
+	h.app.mutex.Unlock()
+}
+
+// OnShutdown is a hook to execute user functions after Shutdown.
+func (h *Hooks) OnShutdown(handler ...HookHandler) {
+	h.app.mutex.Lock()
+	h.hookList["onShutdown"] = append(h.hookList["onShutdown"], handler...)
+	h.app.mutex.Unlock()
+}
+
+func (h *Hooks) executeOnRouteHooks(route Route) error {
+	for _, v := range h.hookList["onRoute"] {
+		ctx := h.app.AcquireCtx(&fasthttp.RequestCtx{})
+		defer h.app.ReleaseCtx(ctx)
+
+		if err := v(ctx, Map{"route": route}); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (h *Hooks) executeOnNameHooks(route Route) error {
+	for _, v := range h.hookList["onName"] {
+		ctx := h.app.AcquireCtx(&fasthttp.RequestCtx{})
+		defer h.app.ReleaseCtx(ctx)
+
+		if err := v(ctx, Map{"route": route}); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (h *Hooks) executeOnGroupNameHooks(group Group) error {
+	for _, v := range h.hookList["onGroupName"] {
+		ctx := h.app.AcquireCtx(&fasthttp.RequestCtx{})
+		defer h.app.ReleaseCtx(ctx)
+
+		if err := v(ctx, Map{"group": group}); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (h *Hooks) executeOnListenHooks() error {
+	for _, v := range h.hookList["onListen"] {
+		ctx := h.app.AcquireCtx(&fasthttp.RequestCtx{})
+		defer h.app.ReleaseCtx(ctx)
+
+		if err := v(ctx, Map{}); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (h *Hooks) executeOnShutdownHooks() {
+	if len(h.hookList["onShutdown"]) > 0 {
+		for _, v := range h.hookList["onShutdown"] {
+			ctx := h.app.AcquireCtx(&fasthttp.RequestCtx{})
+			defer h.app.ReleaseCtx(ctx)
+
+			_ = v(ctx, Map{})
+		}
+	}
+}

hooks_test.go

@@ -0,0 +1,140 @@
+package fiber
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/gofiber/fiber/v2/internal/bytebufferpool"
+	"github.com/gofiber/fiber/v2/utils"
+)
+
+func Test_Hook_OnRoute(t *testing.T) {
+	app := New()
+
+	app.Hooks().OnRoute(func(c *Ctx, m Map) error {
+		utils.AssertEqual(t, "", m["route"].(Route).Name)
+
+		return nil
+	})
+
+	app.Get("/", testSimpleHandler).Name("x")
+
+	subApp := New()
+	subApp.Get("/test", testSimpleHandler)
+
+	app.Mount("/sub", subApp)
+}
+
+func Test_Hook_OnName(t *testing.T) {
+	app := New()
+
+	buf := bytebufferpool.Get()
+	defer bytebufferpool.Put(buf)
+
+	app.Hooks().OnName(func(c *Ctx, m Map) error {
+		buf.WriteString(m["route"].(Route).Name)
+
+		return nil
+	})
+
+	app.Get("/", testSimpleHandler).Name("index")
+
+	subApp := New()
+	subApp.Get("/test", testSimpleHandler)
+	subApp.Get("/test2", testSimpleHandler)
+
+	app.Mount("/sub", subApp)
+
+	utils.AssertEqual(t, "index", buf.String())
+}
+
+func Test_Hook_OnName_Error(t *testing.T) {
+	app := New()
+	defer func() {
+		if err := recover(); err != nil {
+			utils.AssertEqual(t, "unknown error", fmt.Sprintf("%v", err))
+		}
+	}()
+
+	app.Hooks().OnName(func(c *Ctx, m Map) error {
+		return errors.New("unknown error")
+	})
+
+	app.Get("/", testSimpleHandler).Name("index")
+}
+
+func Test_Hook_OnGroupName(t *testing.T) {
+	app := New()
+
+	buf := bytebufferpool.Get()
+	defer bytebufferpool.Put(buf)
+
+	app.Hooks().OnGroupName(func(c *Ctx, m Map) error {
+		buf.WriteString(m["group"].(Group).name)
+
+		return nil
+	})
+
+	grp := app.Group("/x").Name("x.")
+	grp.Get("/test", testSimpleHandler)
+	grp.Get("/test2", testSimpleHandler)
+
+	utils.AssertEqual(t, "x.", buf.String())
+}
+
+func Test_Hook_OnGroupName_Error(t *testing.T) {
+	app := New()
+	defer func() {
+		if err := recover(); err != nil {
+			utils.AssertEqual(t, "unknown error", fmt.Sprintf("%v", err))
+		}
+	}()
+
+	app.Hooks().OnGroupName(func(c *Ctx, m Map) error {
+		return errors.New("unknown error")
+	})
+
+	grp := app.Group("/x").Name("x.")
+	grp.Get("/test", testSimpleHandler)
+}
+
+func Test_Hook_OnShutdown(t *testing.T) {
+	app := New()
+
+	buf := bytebufferpool.Get()
+	defer bytebufferpool.Put(buf)
+
+	app.Hooks().OnShutdown(func(c *Ctx, m Map) error {
+		buf.WriteString("shutdowning")
+
+		return nil
+	})
+
+	utils.AssertEqual(t, nil, app.Shutdown())
+	utils.AssertEqual(t, "shutdowning", buf.String())
+}
+
+func Test_Hook_OnListen(t *testing.T) {
+	app := New(Config{
+		DisableStartupMessage: true,
+	})
+
+	buf := bytebufferpool.Get()
+	defer bytebufferpool.Put(buf)
+
+	app.Hooks().OnListen(func(c *Ctx, m Map) error {
+		buf.WriteString("ready")
+
+		return nil
+	})
+
+	go func() {
+		time.Sleep(1000 * time.Millisecond)
+		utils.AssertEqual(t, nil, app.Shutdown())
+	}()
+	utils.AssertEqual(t, nil, app.Listen(":9000"))
+
+	utils.AssertEqual(t, "ready", buf.String())
+}

router.go

@@ -167,6 +167,7 @@ func (app *App) handler(rctx *fasthttp.RequestCtx) {
 	if match && app.config.ETag {
 		setETag(c, false)
 	}
+
 	// Release Ctx
 	app.ReleaseCtx(c)
 }
@@ -437,6 +438,9 @@ func (app *App) addRoute(method string, route *Route) {
 
 	latestRoute.mu.Lock()
 	latestRoute.route = route
+	if err := app.hooks.executeOnRouteHooks(*route); err != nil {
+		panic(err)
+	}
 	latestRoute.mu.Unlock()
 }