stop: use graceful shutdown for 5s

To package the internal context and other common structs, especially
http.Request and http.ResponseWriter.

Provides helper functìons.

framework/context.go

@@ -0,0 +1,124 @@
+package framework
+
+import (
+	"context"
+	"net/http"
+	"sync"
+	"time"
+)
+
+// Context type is the customized context of Araneae framework
+//
+// It packages the internal context.Context with basic "wr" couple.
+type Context struct {
+	ctx            context.Context
+	request        *http.Request
+	responseWriter http.ResponseWriter
+
+	handlers []ControllerHandler
+	// current handler index
+	index int
+
+	params map[string]string
+
+	hasTimeout bool
+	writerMux  *sync.Mutex
+}
+
+// NewContext create a new context
+func NewContext(w http.ResponseWriter, r *http.Request) *Context {
+	return &Context{
+		ctx:            r.Context(),
+		request:        r,
+		responseWriter: w,
+		writerMux:      &sync.Mutex{},
+		index:          -1, // will be set to 0 when at the beginning
+	}
+}
+
+// {{{ Basic functions
+
+// WriterMux returns the writer mutex.
+//
+// This is useful when goroutines concurrently write into responseWriter,
+// while at the same time we are writing into the responseWriter for a
+// panic or timeout.
+// We can protect it at the context level.
+func (ctx *Context) WriterMux() *sync.Mutex {
+	return ctx.writerMux
+}
+
+// GetRequest returns the original request
+func (ctx *Context) GetRequest() *http.Request {
+	return ctx.request
+}
+
+// GetResponseWriter returns the original response writer
+func (ctx *Context) GetResponseWriter() http.ResponseWriter {
+	return ctx.responseWriter
+}
+
+// SetHasTimeout indicates that the context has timeout.
+//
+// So that other goroutines won't write into the responseWriter anymore
+func (ctx *Context) SetHasTimeout() {
+	ctx.hasTimeout = true
+}
+
+// HasTimeout returns whether the context has timeout.
+func (ctx *Context) HasTimeout() bool {
+	return ctx.hasTimeout
+}
+
+// }}}
+// {{{ Implements context interface
+
+// BaseContext return a request default Context
+func (ctx *Context) BaseContext() context.Context {
+	return ctx.request.Context()
+}
+
+// Done calls the base function
+func (ctx *Context) Done() <-chan struct{} {
+	return ctx.BaseContext().Done()
+}
+
+// Deadline calls the base function
+func (ctx *Context) Deadline() (deadline time.Time, ok bool) {
+	return ctx.BaseContext().Deadline()
+}
+
+// Err calls the base function
+func (ctx *Context) Err() error {
+	return ctx.BaseContext().Err()
+}
+
+// Value calls the base function
+func (ctx *Context) Value(key any) any {
+	return ctx.BaseContext().Value(key)
+}
+
+// Next runs the next function in the function chain
+func (ctx *Context) Next() error {
+	ctx.index++
+	if ctx.index >= len(ctx.handlers) {
+		// This is the end of the chain
+		return nil
+	}
+	// Run this handler
+	if err := ctx.handlers[ctx.index](ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+// SetHandlers sets handlers for context
+func (ctx *Context) SetHandlers(handlers []ControllerHandler) {
+	ctx.handlers = handlers
+}
+
+func (ctx *Context) SetParams(params map[string]string) {
+	ctx.params = params
+}
+
+// }}}

framework/controller.go

@@ -0,0 +1,3 @@
+package framework
+
+type ControllerHandler func(c *Context) error

framework/core.go

@@ -0,0 +1,115 @@
+package framework
+
+import (
+	"log"
+	"net/http"
+	"strings"
+)
+
+// Core is the core struct of the framework
+type Core struct {
+	router      map[string]*Trie
+	middlewares []ControllerHandler
+}
+
+// NewCore initialize the Core.
+func NewCore() *Core {
+	getRouter := NewTrie()
+	postRouter := NewTrie()
+	putRouter := NewTrie()
+	deleteRouter := NewTrie()
+
+	router := map[string]*Trie{}
+	router["GET"] = getRouter
+	router["POST"] = postRouter
+	router["PUT"] = putRouter
+	router["DELETE"] = deleteRouter
+
+	return &Core{router: router}
+}
+
+// Get is a simple get router
+func (c *Core) Get(url string, handlers ...ControllerHandler) {
+	allHandlers := append(c.middlewares, handlers...)
+	if err := c.router["GET"].AddRouter(url, allHandlers); err != nil {
+		log.Println(err)
+	}
+}
+
+// Post is a simple post router
+func (c *Core) Post(url string, handlers ...ControllerHandler) {
+	allHandlers := append(c.middlewares, handlers...)
+	if err := c.router["POST"].AddRouter(url, allHandlers); err != nil {
+		log.Println(err)
+	}
+}
+
+// Put is a simple put router
+func (c *Core) Put(url string, handlers ...ControllerHandler) {
+	allHandlers := append(c.middlewares, handlers...)
+	if err := c.router["PUT"].AddRouter(url, allHandlers); err != nil {
+		log.Println(err)
+	}
+}
+
+// Delete is a simple delete router
+func (c *Core) Delete(url string, handlers ...ControllerHandler) {
+	allHandlers := append(c.middlewares, handlers...)
+	if err := c.router["DELETE"].AddRouter(url, allHandlers); err != nil {
+		log.Println(err)
+	}
+}
+
+// Use registers middlewares
+func (c *Core) Use(middlewares ...ControllerHandler) {
+	c.middlewares = append(c.middlewares, middlewares...)
+}
+
+// FindRouteByRequest finds route using the request
+func (c *Core) FindRouteByRequest(r *http.Request) *node {
+	upperMethod := strings.ToUpper(r.Method)
+
+	mapper, ok := c.router[upperMethod]
+	if !ok {
+		log.Printf("Method %q is not recognized\n", upperMethod)
+		return nil
+	}
+
+	node := mapper.FindRoute(r.URL.Path)
+	if node == nil {
+		log.Printf("URI %q is not recognized\n", r.URL.Path)
+		return nil
+	}
+
+	return node
+}
+
+func (c *Core) Group(prefix string) IGroup {
+	return &Group{
+		core:   c,
+		prefix: prefix,
+	}
+}
+
+// ServeHTTP implements the Handler interface
+func (c *Core) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	log.Println("Welcome to the Araneae framework")
+
+	ctx := NewContext(w, r)
+
+	node := c.FindRouteByRequest(r)
+	if node == nil {
+		ctx.WriteJSON(http.StatusNotFound, "Request not found")
+		return
+	}
+
+	params := node.ParseParamsFromEndNode(r.URL.Path)
+
+	ctx.SetParams(params)
+	ctx.SetHandlers(node.handlers)
+
+	if err := ctx.Next(); err != nil {
+		ctx.WriteJSON(http.StatusInternalServerError, "Internal error")
+		return
+	}
+}

framework/group.go

@@ -0,0 +1,54 @@
+package framework
+
+// IGroup prefix routes
+type IGroup interface {
+	Get(string, ...ControllerHandler)
+	Post(string, ...ControllerHandler)
+	Put(string, ...ControllerHandler)
+	Delete(string, ...ControllerHandler)
+	Use(...ControllerHandler)
+}
+
+// Group is the implementation of IGroup interface
+type Group struct {
+	core        *Core
+	prefix      string
+	middlewares []ControllerHandler
+}
+
+// NewGroup create a new prefix group
+func NewGroup(core *Core, prefix string) *Group {
+	return &Group{
+		core:   core,
+		prefix: prefix,
+	}
+}
+
+// Get is a simple get router of the group
+func (g *Group) Get(url string, handlers ...ControllerHandler) {
+	allHandlers := append(g.middlewares, handlers...)
+	g.core.Get(g.prefix+url, allHandlers...)
+}
+
+// Post is a simple post router of the group
+func (g *Group) Post(url string, handlers ...ControllerHandler) {
+	allHandlers := append(g.middlewares, handlers...)
+	g.core.Post(g.prefix+url, allHandlers...)
+}
+
+// Put is a simple put router of the group
+func (g *Group) Put(url string, handlers ...ControllerHandler) {
+	allHandlers := append(g.middlewares, handlers...)
+	g.core.Put(g.prefix+url, allHandlers...)
+}
+
+// Delete is a simple delete router of the group
+func (g *Group) Delete(url string, handlers ...ControllerHandler) {
+	allHandlers := append(g.middlewares, handlers...)
+	g.core.Delete(g.prefix+url, allHandlers...)
+}
+
+// Use registers middlewares
+func (g *Group) Use(middlewares ...ControllerHandler) {
+	g.middlewares = append(g.middlewares, middlewares...)
+}

framework/middleware/recovery.go

@@ -0,0 +1,21 @@
+package middleware
+
+import (
+	"net/http"
+
+	"git.vinchent.xyz/vinchent/go-web/framework"
+)
+
+// Recovery is a middleware that recovers from the panic
+func Recovery() framework.ControllerHandler {
+	return func(c *framework.Context) error {
+		defer func() {
+			if err := recover(); err != nil {
+				c.WriteJSON(http.StatusInternalServerError, err)
+			}
+		}()
+
+		c.Next()
+		return nil
+	}
+}

framework/middleware/test.go

@@ -0,0 +1,34 @@
+package middleware
+
+import (
+	"log"
+
+	"git.vinchent.xyz/vinchent/go-web/framework"
+)
+
+func Test1() framework.ControllerHandler {
+	return func(c *framework.Context) error {
+		log.Println("middleware test1 pre")
+		c.Next()
+		log.Println("middleware test1 post")
+		return nil
+	}
+}
+
+func Test2() framework.ControllerHandler {
+	return func(c *framework.Context) error {
+		log.Println("middleware test2 pre")
+		c.Next()
+		log.Println("middleware test2 post")
+		return nil
+	}
+}
+
+func Test3() framework.ControllerHandler {
+	return func(c *framework.Context) error {
+		log.Println("middleware test3 pre")
+		c.Next()
+		log.Println("middleware test3 post")
+		return nil
+	}
+}

framework/middleware/timeout.go

@@ -0,0 +1,49 @@
+package middleware
+
+import (
+	"context"
+	"log"
+	"net/http"
+	"time"
+
+	"git.vinchent.xyz/vinchent/go-web/framework"
+)
+
+func Timeout(d time.Duration) framework.ControllerHandler {
+	return func(c *framework.Context) error {
+		finish := make(chan struct{}, 1)
+		panicChan := make(chan interface{}, 1)
+
+		durationCtx, cancel := context.WithTimeout(c.BaseContext(), d)
+		defer cancel()
+
+		go func() {
+			// Handle panic
+			defer func() {
+				if p := recover(); p != nil {
+					panicChan <- p
+				}
+			}()
+
+			// Run the next middleware or the business logic
+			c.Next()
+
+			finish <- struct{}{}
+		}()
+
+		select {
+		case p := <-panicChan:
+			// panic
+			log.Println(p)
+			c.GetResponseWriter().WriteHeader(http.StatusInternalServerError)
+		case <-finish:
+			// finish normally
+			log.Println("finish")
+		case <-durationCtx.Done():
+			c.SetHasTimeout()
+			c.GetResponseWriter().WriteHeader(http.StatusRequestTimeout)
+			c.GetResponseWriter().Write([]byte("time out"))
+		}
+		return nil
+	}
+}

framework/middleware/timeout_test.go

@@ -0,0 +1,103 @@
+package middleware
+
+import (
+	"bytes"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"git.vinchent.xyz/vinchent/go-web/framework"
+)
+
+func TestTimeout(t *testing.T) {
+	t.Run("Test timeout handler", func(t *testing.T) {
+		timeoutHandler := Timeout(1 * time.Millisecond)
+
+		longHandler := func(c *framework.Context) error {
+			time.Sleep(2 * time.Millisecond)
+			return nil
+		}
+
+		res := prepareMiddlewareTest(t, timeoutHandler, longHandler)
+
+		assertCode(t, res.StatusCode, http.StatusRequestTimeout)
+		assertBody(t, res.Body, "time out")
+	})
+	t.Run("Test no timeout", func(t *testing.T) {
+		timeoutHandler := Timeout(2 * time.Millisecond)
+
+		quickHandler := func(c *framework.Context) error {
+			// time.Sleep(1 * time.Millisecond)
+			c.WriteJSON(http.StatusOK, "ok")
+			return nil
+		}
+
+		res := prepareMiddlewareTest(t, timeoutHandler, quickHandler)
+
+		assertCode(t, res.StatusCode, http.StatusOK)
+	})
+}
+
+func TestRecover(t *testing.T) {
+	t.Run("Test panic", func(t *testing.T) {
+		recoverer := Recovery()
+
+		panicHandler := func(c *framework.Context) error {
+			panic("panic")
+		}
+
+		res := prepareMiddlewareTest(t, recoverer, panicHandler)
+
+		assertCode(t, res.StatusCode, http.StatusInternalServerError)
+	})
+	t.Run("Test no panic", func(t *testing.T) {
+		recoverer := Recovery()
+
+		normalHandler := func(c *framework.Context) error {
+			c.WriteJSON(http.StatusOK, "ok")
+			return nil
+		}
+
+		res := prepareMiddlewareTest(t, recoverer, normalHandler)
+
+		assertCode(t, res.StatusCode, http.StatusOK)
+	})
+}
+
+func prepareMiddlewareTest(
+	t testing.TB,
+	mid framework.ControllerHandler,
+	in framework.ControllerHandler,
+) *http.Response {
+	t.Helper()
+	request := httptest.NewRequest(http.MethodGet, "/", nil)
+	response := httptest.NewRecorder()
+	c := framework.NewContext(response, request)
+
+	c.SetHandlers([]framework.ControllerHandler{in})
+
+	err := mid(c)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	res := response.Result()
+	return res
+}
+
+func assertCode(t testing.TB, got int, want int) {
+	t.Helper()
+	if got != want {
+		t.Errorf("status code got %d, want %d", got, want)
+	}
+}
+
+func assertBody(t testing.TB, got io.Reader, want string) {
+	t.Helper()
+	buf, _ := io.ReadAll(got)
+	if cmp := bytes.Compare(buf, []byte(want)); cmp != 0 {
+		t.Errorf("got %q, want %q", string(buf), want)
+	}
+}

framework/request.go

@@ -0,0 +1,411 @@
+package framework
+
+import (
+	"bytes"
+	"encoding/json"
+	"encoding/xml"
+	"errors"
+	"io"
+	"mime/multipart"
+	"net/url"
+
+	"github.com/spf13/cast"
+)
+
+type IRequest interface {
+	// url query
+	// e.g. foo.com?a=1&b=bar&c[]=bar
+	QueryAll(key string) url.Values
+	QueryInt(key string, defval int) (int, bool)
+	QueryInt64(key string, defval int64) (int64, bool)
+	QueryFloat32(key string, defval float32) (float32, bool)
+	QueryFloat64(key string, defval float64) (float64, bool)
+	QueryBool(key string, defval bool) (bool, bool)
+	QueryString(key string, defval string) (string, bool)
+	QueryStringSlice(key string, defval []string) ([]string, bool)
+
+	// url params
+	// e.g. /book/:id
+	Param(key string) any
+	ParamInt(key string, defval int) (int, bool)
+	ParamInt64(key string, defval int64) (int64, bool)
+	ParamFloat32(key string, defval float32) (float32, bool)
+	ParamFloat64(key string, defval float64) (float64, bool)
+	ParamBool(key string, defval bool) (bool, bool)
+	ParamString(key string, defval string) (string, bool)
+
+	// form
+	FormAll(key string) url.Values
+	FormInt(key string, defval int) (int, bool)
+	FormInt64(key string, defval int64) (int64, bool)
+	FormFloat32(key string, defval float32) (float32, bool)
+	FormFloat64(key string, defval float64) (float64, bool)
+	FormBool(key string, defval bool) (bool, bool)
+	FormString(key string, defval string) (string, bool)
+	FormStringSlice(key string, defval []string) ([]string, bool)
+	FormFile(key string) (*multipart.FileHeader, error)
+
+	// JSON body
+	BindJSON(obj any) error
+
+	// XML body
+	BindXML(obj any) error
+
+	// RAW body
+	GetRawData() ([]byte, error)
+
+	// Basic informations
+	Uri() string
+	Method() string
+	Host() string
+	ClientIP() string
+
+	// Header
+	Headers() map[string][]string
+	Header(key string) (string, bool)
+
+	// Cookie
+	Cookies() map[string]string
+	Cookie(key string) (string, bool)
+}
+
+// {{{ url query
+
+// QueryAll returns all queries in a request URL
+func (ctx *Context) QueryAll() url.Values {
+	if ctx.request != nil {
+		return map[string][]string(ctx.request.URL.Query())
+	}
+	return url.Values{}
+}
+
+// QueryInt gets an int value from the query request
+func (ctx *Context) QueryInt(key string, defval int) (int, bool) {
+	params := ctx.QueryAll()
+	if vals, ok := params[key]; ok {
+		if len(vals) > 0 {
+			return cast.ToInt(vals[0]), true
+		}
+	}
+	return defval, false
+}
+
+func (ctx *Context) QueryInt64(key string, defval int64) (int64, bool) {
+	params := ctx.QueryAll()
+	if vals, ok := params[key]; ok {
+		if len(vals) > 0 {
+			return cast.ToInt64(vals[0]), true
+		}
+	}
+	return defval, false
+}
+
+func (ctx *Context) QueryBool(key string, defval bool) (bool, bool) {
+	params := ctx.QueryAll()
+	if vals, ok := params[key]; ok {
+		if len(vals) > 0 {
+			return cast.ToBool(vals[0]), true
+		}
+	}
+	return defval, false
+}
+
+func (ctx *Context) QueryFloat32(key string, defval float32) (float32, bool) {
+	params := ctx.QueryAll()
+	if vals, ok := params[key]; ok {
+		if len(vals) > 0 {
+			return cast.ToFloat32(vals[0]), true
+		}
+	}
+	return defval, false
+}
+
+func (ctx *Context) QueryFloat64(key string, defval float64) (float64, bool) {
+	params := ctx.QueryAll()
+	if vals, ok := params[key]; ok {
+		if len(vals) > 0 {
+			return cast.ToFloat64(vals[0]), true
+		}
+	}
+	return defval, false
+}
+
+// QueryString gets a string value from the query request
+func (ctx *Context) QueryString(key string, defval string) (string, bool) {
+	params := ctx.QueryAll()
+	if vals, ok := params[key]; ok {
+		if len(vals) > 0 {
+			return cast.ToString(vals[0]), true
+		}
+	}
+	return defval, false
+}
+
+// QueryArray gets an array of string values from the query request
+func (ctx *Context) QueryStringSlice(key string, defval []string) ([]string, bool) {
+	params := ctx.QueryAll()
+	if vals, ok := params[key]; ok {
+		return cast.ToStringSlice(vals[0]), true
+	}
+	return defval, false
+}
+
+// }}}
+// {{{ url params
+
+func (ctx *Context) Param(key string) any {
+	if ctx.params != nil {
+		if val, ok := ctx.params[key]; ok {
+			return val
+		}
+	}
+	return nil
+}
+
+func (ctx *Context) ParamInt(key string, def int) (int, bool) {
+	if val := ctx.Param(key); val != nil {
+		return cast.ToInt(val), true
+	}
+	return def, false
+}
+
+func (ctx *Context) ParamInt64(key string, def int64) (int64, bool) {
+	if val := ctx.Param(key); val != nil {
+		return cast.ToInt64(val), true
+	}
+	return def, false
+}
+
+func (ctx *Context) ParamFloat64(key string, def float64) (float64, bool) {
+	if val := ctx.Param(key); val != nil {
+		return cast.ToFloat64(val), true
+	}
+	return def, false
+}
+
+func (ctx *Context) ParamFloat32(key string, def float32) (float32, bool) {
+	if val := ctx.Param(key); val != nil {
+		return cast.ToFloat32(val), true
+	}
+	return def, false
+}
+
+func (ctx *Context) ParamBool(key string, def bool) (bool, bool) {
+	if val := ctx.Param(key); val != nil {
+		return cast.ToBool(val), true
+	}
+	return def, false
+}
+
+func (ctx *Context) ParamString(key string, def string) (string, bool) {
+	if val := ctx.Param(key); val != nil {
+		return cast.ToString(val), true
+	}
+	return def, false
+}
+
+// }}}
+// {{{ Post form
+
+// FormAll gets everything from the submitted form
+func (ctx *Context) FormAll() url.Values {
+	if ctx.request != nil {
+		_ = ctx.request.ParseForm()
+		return ctx.request.PostForm
+	}
+	return url.Values{}
+}
+
+// FormInt gets an int value from the submitted form
+func (ctx *Context) FormInt(key string, defval int) (int, bool) {
+	params := ctx.FormAll()
+	if vals, ok := params[key]; ok {
+		if len(vals) > 0 {
+			return cast.ToInt(vals[0]), true
+		}
+	}
+	return defval, false
+}
+
+func (ctx *Context) FormInt64(key string, defval int64) (int64, bool) {
+	params := ctx.FormAll()
+	if vals, ok := params[key]; ok {
+		if len(vals) > 0 {
+			return cast.ToInt64(vals[0]), true
+		}
+	}
+	return defval, false
+}
+
+func (ctx *Context) FormBool(key string, defval bool) (bool, bool) {
+	params := ctx.FormAll()
+	if vals, ok := params[key]; ok {
+		if len(vals) > 0 {
+			return cast.ToBool(vals[0]), true
+		}
+	}
+	return defval, false
+}
+
+func (ctx *Context) FormFloat32(key string, defval float32) (float32, bool) {
+	params := ctx.FormAll()
+	if vals, ok := params[key]; ok {
+		if len(vals) > 0 {
+			return cast.ToFloat32(vals[0]), true
+		}
+	}
+	return defval, false
+}
+
+func (ctx *Context) FormFloat64(key string, defval float64) (float64, bool) {
+	params := ctx.FormAll()
+	if vals, ok := params[key]; ok {
+		if len(vals) > 0 {
+			return cast.ToFloat64(vals[0]), true
+		}
+	}
+	return defval, false
+}
+
+func (ctx *Context) FormString(key string, defval string) (string, bool) {
+	params := ctx.FormAll()
+	if vals, ok := params[key]; ok {
+		if len(vals) > 0 {
+			return cast.ToString(vals[0]), true
+		}
+	}
+	return defval, false
+}
+
+func (ctx *Context) FormStringSlice(key string, defval []string) ([]string, bool) {
+	params := ctx.FormAll()
+	if vals, ok := params[key]; ok {
+		return cast.ToStringSlice(vals[0]), true
+	}
+	return defval, false
+}
+
+// }}}
+// {{{ type binder
+
+var (
+	ErrNoRequest    = errors.New("missing request in the context")
+	ErrNotSingleObj = errors.New("body must have only a single value")
+)
+
+// JSON body
+func (ctx *Context) BindJSON(obj any) error {
+	if ctx.request == nil {
+		return ErrNoRequest
+	}
+	dec := json.NewDecoder(ctx.request.Body)
+	err := dec.Decode(obj)
+	if err != nil {
+		return err
+	}
+	err = dec.Decode(&struct{}{})
+	if err != io.EOF {
+		return ErrNotSingleObj
+	}
+
+	return nil
+}
+
+// XML body
+func (ctx *Context) BindXML(obj any) error {
+	if ctx.request == nil {
+		return ErrNoRequest
+	}
+	dec := xml.NewDecoder(ctx.request.Body)
+	err := dec.Decode(obj)
+	if err != nil {
+		return err
+	}
+	err = dec.Decode(&struct{}{})
+	if err != io.EOF {
+		return ErrNotSingleObj
+	}
+
+	return nil
+}
+
+// RAW body
+func (ctx *Context) GetRawData() ([]byte, error) {
+	if ctx.request == nil {
+		return []byte{}, ErrNoRequest
+	}
+	body, err := io.ReadAll(ctx.request.Body)
+	if err != nil {
+		return []byte{}, err
+	}
+	/* Restore the body (io.ReadCloser) to it's original state */
+	ctx.request.Body = io.NopCloser(bytes.NewBuffer(body))
+
+	return body, nil
+}
+
+// }}}
+// {{{ Basic informations
+
+func (ctx *Context) Uri() string {
+	return ctx.request.RequestURI
+}
+
+func (ctx *Context) Method() string {
+	return ctx.request.Method
+}
+
+func (ctx *Context) Host() string {
+	return ctx.request.Host
+}
+
+func (ctx *Context) ClientIP() string {
+	r := ctx.request
+	ipAddress := r.Header.Get("X-Real-Ip")
+	if ipAddress == "" {
+		ipAddress = r.Header.Get("X-Forwarded-For")
+	}
+	if ipAddress == "" {
+		ipAddress = r.RemoteAddr
+	}
+	return ipAddress
+}
+
+// }}}
+// {{{ Headers
+
+// Header
+func (ctx *Context) Headers() map[string][]string {
+	return ctx.request.Header
+}
+
+func (ctx *Context) Header(key string) (string, bool) {
+	vals := ctx.request.Header.Values(key)
+	if vals == nil || len(vals) <= 0 {
+		return "", false
+	}
+	return vals[0], true
+}
+
+// }}}
+// {{{ Cookies
+
+// Cookies gets cookie key-value pairs
+func (ctx *Context) Cookies() map[string]string {
+	cookies := ctx.request.Cookies()
+	ret := map[string]string{}
+	for _, c := range cookies {
+		ret[c.Name] = c.Value
+	}
+	return ret
+}
+
+func (ctx *Context) Cookie(key string) (string, bool) {
+	cookies := ctx.Cookies()
+	if val, ok := cookies[key]; ok {
+		return val, true
+	}
+	return "", false
+}
+
+// }}}

framework/response.go

@@ -0,0 +1,123 @@
+package framework
+
+import (
+	"encoding/json"
+	"encoding/xml"
+	"fmt"
+	"html/template"
+	"net/http"
+	"net/url"
+)
+
+type IResponse interface {
+	WriteJSON(status int, obj any) IResponse
+	WriteXML(status int, obj any) IResponse
+	WriteHTML(status int, filepath string, obj any) IResponse
+	WriteText(format string, values ...any) IResponse
+
+	Redirect(path string) IResponse
+	SetHeader(key string, val string) IResponse
+	SetCookie(
+		key string,
+		val string,
+		maxAge int,
+		path, domain string,
+		secure, httpOnly bool,
+	) IResponse
+	SetStatus(code int) IResponse
+
+	// set 200
+	SetOkStatus() IResponse
+}
+
+func (ctx *Context) WriteJSON(status int, obj any) IResponse {
+	// There is a timeout, some error message data must have already been
+	// written to the output. Stop writing anything into the responseWriter.
+	if ctx.HasTimeout() {
+		return nil
+	}
+	data, err := json.Marshal(obj)
+	if err != nil {
+		return ctx.SetStatus(http.StatusInternalServerError)
+	}
+	ctx.responseWriter.Header().Set("Content-type", "application/json")
+	ctx.responseWriter.WriteHeader(status)
+	_, _ = ctx.responseWriter.Write(data)
+	return ctx
+}
+
+func (ctx *Context) WriteXML(status int, obj any) IResponse {
+	// There is a timeout, some error message data must have already been
+	// written to the output. Stop writing anything into the responseWriter.
+	if ctx.HasTimeout() {
+		return nil
+	}
+	data, err := xml.Marshal(obj)
+	if err != nil {
+		return ctx.SetStatus(http.StatusInternalServerError)
+	}
+	ctx.responseWriter.Header().Set("Content-type", "application/json")
+	ctx.responseWriter.WriteHeader(status)
+	_, _ = ctx.responseWriter.Write(data)
+	return ctx
+}
+
+func (ctx *Context) WriteHTML(status int, filepath string, obj any) IResponse {
+	ctx.SetHeader("Content-Type", "application/html")
+	t, _ := template.New("output").ParseFiles(filepath)
+	t.Execute(ctx.responseWriter, obj)
+
+	return ctx
+}
+
+func (ctx *Context) WriteText(format string, values ...any) IResponse {
+	out := fmt.Sprintf(format, values...)
+	ctx.SetHeader("Content-Type", "application/text")
+	ctx.responseWriter.Write([]byte(out))
+	return ctx
+}
+
+func (ctx *Context) Redirect(path string) IResponse {
+	http.Redirect(ctx.responseWriter, ctx.request, path, http.StatusTemporaryRedirect)
+	return ctx
+}
+
+func (ctx *Context) SetHeader(key string, val string) IResponse {
+	ctx.responseWriter.Header().Add(key, val)
+	return ctx
+}
+
+func (ctx *Context) SetCookie(
+	key string,
+	val string,
+	maxAge int,
+	path, domain string,
+	secure, httpOnly bool,
+) IResponse {
+	if path == "" {
+		path = "/"
+	}
+
+	http.SetCookie(ctx.responseWriter, &http.Cookie{
+		Name:     key,
+		Value:    url.QueryEscape(val),
+		MaxAge:   maxAge,
+		Path:     path,
+		Domain:   domain,
+		SameSite: http.SameSiteDefaultMode,
+		Secure:   secure,
+		HttpOnly: httpOnly,
+	})
+	return ctx
+}
+
+func (ctx *Context) SetStatus(code int) IResponse {
+	ctx.responseWriter.WriteHeader(code)
+	return ctx
+}
+
+// set 200
+func (ctx *Context) SetOkStatus() IResponse {
+	ctx.responseWriter.WriteHeader(http.StatusOK)
+	return ctx
+}

framework/trie.go

@@ -0,0 +1,180 @@
+package framework
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+)
+
+type Trie struct {
+	root *node
+}
+
+func NewTrie() *Trie {
+	return &Trie{root: newNode("")}
+}
+
+func (t *Trie) FindRoute(uri string) *node {
+	uri = strings.ToUpper(uri)
+	uri = strings.TrimPrefix(uri, "/")
+	if uri == "" {
+		return t.root
+	}
+
+	found := t.root.findRoute(uri)
+	if found == nil {
+		return nil
+	}
+
+	return found
+}
+
+func (t *Trie) AddRouter(uri string, handlers []ControllerHandler) error {
+	uri = strings.ToUpper(uri)
+	uri = strings.TrimPrefix(uri, "/")
+	if uri == "" {
+		t.root.isLast = true
+		t.root.handlers = append(t.root.handlers, handlers...)
+		return nil
+	}
+
+	upperUri := strings.ToUpper(uri)
+	match := t.FindRoute(upperUri)
+	if match != nil {
+		// existing route
+		return fmt.Errorf("existing route for %q", uri)
+	}
+
+	// The route does not exist, add it to the tree
+	err := t.root.addRoute(upperUri, handlers)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+type node struct {
+	isLast   bool
+	segment  string
+	handlers []ControllerHandler
+	children []*node
+	parent   *node
+}
+
+func (n *node) ParseParamsFromEndNode(uri string) map[string]string {
+	ret := map[string]string{}
+	uri = strings.ToUpper(uri)
+	uri = strings.TrimPrefix(uri, "/")
+	if uri == "" {
+		// root
+		return ret
+	}
+	segments := strings.Split(uri, "/")
+	cnt := len(segments)
+	cur := n
+
+	for i := cnt - 1; i >= 0; i-- {
+		if isWildcard(cur.segment) {
+			// set params
+			ret[cur.segment[1:]] = segments[i]
+		}
+		cur = cur.parent
+	}
+	return ret
+}
+
+func newNode(segment string) *node {
+	return &node{segment: segment}
+}
+
+func isWildcard(s string) bool {
+	return strings.HasPrefix(s, ":")
+}
+
+// /user/name
+// /user/:id/name
+// /user/3/name
+
+// findRoute finds the handler for the uri if exists.
+//
+// we suppose that uri passed here doesn't begin with "/"
+func (n *node) findRoute(uri string) *node {
+	splitted := strings.SplitN(uri, "/", 2)
+	splittedLen := len(splitted)
+
+	if isWildcard(splitted[0]) {
+		// input is a wildcard, check if this endpoint has already children
+		// if so, return the first one which is not nil.
+		nbChildren := len(n.children)
+		if nbChildren > 0 && n.children[0].segment != splitted[0] {
+			// several nodes exist, return the first one that is not nil
+			return n.children[0]
+		}
+	}
+
+	// try to find the value in childre
+	for _, child := range n.children {
+		if isWildcard(child.segment) || child.segment == splitted[0] {
+			if splittedLen == 1 {
+				// This is the last value, do the check and return
+				if child.isLast {
+					// if isLast, that means we have already registered the endpoint
+					return child
+				} else {
+					// otherwise, take it as not registered
+					return nil
+				}
+			}
+			// More segments to check
+			return child.findRoute(splitted[1])
+		}
+	}
+
+	// nothing found in the children
+	return nil
+}
+
+func (n *node) addRoute(uri string, handlers []ControllerHandler) error {
+	splitted := strings.SplitN(uri, "/", 2)
+	splittedLen := len(splitted)
+	isLast := splittedLen == 1
+
+	// try to find the value in childre
+	for _, child := range n.children {
+		if isWildcard(child.segment) || child.segment == splitted[0] {
+			if isLast {
+				// This is the last value, do the check and return
+				if child.isLast {
+					// if isLast, that means we have already registered the endpoint
+					return errors.New("node exists")
+				} else {
+					// otherwise, set the child
+					child.isLast = true
+					child.handlers = append(child.handlers, handlers...)
+					return nil
+				}
+			}
+			// More segments to check
+			return child.addRoute(splitted[1], handlers)
+		}
+	}
+
+	// create a new node
+	new := newNode(splitted[0])
+	new.parent = n
+	if isLast {
+		// this is the end
+		new.handlers = append(new.handlers, handlers...)
+		new.isLast = true
+		n.children = append(n.children, new)
+		return nil
+	}
+	// continue
+	new.isLast = false
+	err := new.addRoute(splitted[1], handlers)
+	if err != nil {
+		return err
+	}
+	n.children = append(n.children, new)
+	return nil
+}

go.mod

@@ -0,0 +1,5 @@
+module git.vinchent.xyz/vinchent/go-web
+
+go 1.22.5
+
+require github.com/spf13/cast v1.7.0

go.sum

@@ -0,0 +1,12 @@
+github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
+github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
+github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
+github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
+github.com/spf13/cast v1.7.0 h1:ntdiHjuueXFgm5nzDRdOS4yfT43P5Fnud6DH50rz/7w=
+github.com/spf13/cast v1.7.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=

handlers.go

@@ -0,0 +1,85 @@
+package main
+
+import (
+	"context"
+	"log"
+	"net/http"
+	"time"
+
+	"git.vinchent.xyz/vinchent/go-web/framework"
+)
+
+// func FooControllerHandler(ctx *framework.Context) error {
+// 	return ctx.WriteJSON(http.StatusOK, map[string]any{
+// 		"code": 0,
+// 	})
+// }
+
+func FooControllerHandler(ctx *framework.Context) error {
+	durationCtx, cancel := context.WithTimeout(ctx.BaseContext(), time.Duration(1*time.Second))
+	defer cancel()
+
+	finish := make(chan struct{}, 1)
+	panicChan := make(chan interface{}, 1)
+
+	// some long task
+	go func() {
+		// Deal with the panic during the work
+		defer func() {
+			if p := recover(); p != nil {
+				panicChan <- p
+			}
+		}()
+		// do the business
+		time.Sleep(10 * time.Second)
+		ctx.WriteJSON(http.StatusOK, "ok")
+		finish <- struct{}{}
+	}()
+
+	select {
+	case <-panicChan:
+		// Protect ResponseWriter for concurrently writing from different
+		// goroutines if there are any
+		ctx.WriterMux().Lock()
+		defer ctx.WriterMux().Unlock()
+		log.Println("panicked")
+		ctx.WriteJSON(http.StatusInternalServerError, "panicked")
+	case <-finish:
+		log.Println("finished")
+	case <-durationCtx.Done():
+		ctx.WriterMux().Lock()
+		defer ctx.WriterMux().Unlock()
+		log.Println("Timeout")
+		ctx.WriteJSON(http.StatusInternalServerError, "time out")
+		ctx.SetHasTimeout()
+	}
+
+	return nil
+}
+
+func UserLoginController(ctx *framework.Context) error {
+	time.Sleep(10 * time.Second)
+	ctx.WriteJSON(http.StatusOK, "ok")
+	return nil
+}
+
+func SubjectDelController(ctx *framework.Context) error {
+	ctx.WriteJSON(http.StatusAccepted, "deleted")
+	return nil
+}
+
+func SubjectUpdateController(ctx *framework.Context) error {
+	ctx.WriteJSON(http.StatusAccepted, "updated")
+	return nil
+}
+
+func SubjectGetController(ctx *framework.Context) error {
+	ctx.WriteJSON(http.StatusAccepted, "got")
+	log.Println(ctx.ParamInt("ID", 0))
+	return nil
+}
+
+func SubjectListController(ctx *framework.Context) error {
+	ctx.WriteJSON(http.StatusAccepted, "list")
+	return nil
+}

main.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"git.vinchent.xyz/vinchent/go-web/framework"
+)
+
+func main() {
+	core := framework.NewCore()
+	registerRouter(core)
+	server := &http.Server{
+		Addr:    ":8080",
+		Handler: core,
+	}
+
+	go func() {
+		server.ListenAndServe()
+	}()
+
+	// create quit channel
+	quit := make(chan os.Signal, 1)
+
+	// set notifier
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
+
+	<-quit
+	fmt.Println("YOLO")
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	if err := server.Shutdown(ctx); err != nil {
+		log.Fatal("server shutdown: ", err)
+	}
+}

routes.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"git.vinchent.xyz/vinchent/go-web/framework"
+	"git.vinchent.xyz/vinchent/go-web/framework/middleware"
+)
+
+func registerRouter(core *framework.Core) {
+	core.Use(middleware.Test1(), middleware.Test2())
+	core.Get("/user/login", UserLoginController)
+
+	subjectApi := core.Group("/subject")
+	{
+		subjectApi.Use(middleware.Test3())
+		subjectApi.Delete("/:id", SubjectDelController)
+		subjectApi.Put("/:id", SubjectUpdateController)
+		subjectApi.Get("/:id", SubjectGetController)
+		subjectApi.Get("/:id/test", SubjectGetController)
+		subjectApi.Get("/list/all", SubjectListController)
+	}
+}