155 lines
3.4 KiB
Go
155 lines
3.4 KiB
Go
package mux
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"strings"
|
|
"sync/atomic"
|
|
)
|
|
|
|
// Mux is a wrapper around the go's standard http.ServeMux.
|
|
// It's a lean wrapper with methods to make routing easier
|
|
type Mux struct {
|
|
mux *http.ServeMux
|
|
middlewares []func(http.Handler) http.Handler
|
|
routes *RouteList
|
|
IsShuttingDown atomic.Bool
|
|
}
|
|
|
|
func New() *Mux {
|
|
m := &Mux{
|
|
mux: http.NewServeMux(),
|
|
routes: new(RouteList),
|
|
}
|
|
return m
|
|
}
|
|
|
|
// HttpServeMux DO NOT USE it for routing, exposed only for edge cases.
|
|
func (m *Mux) HttpServeMux() *http.ServeMux {
|
|
return m.mux
|
|
}
|
|
|
|
// Use will register middleware(s) with router stack
|
|
func (m *Mux) Use(h ...func(http.Handler) http.Handler) {
|
|
if m == nil {
|
|
panic("mux: func Use was called on nil")
|
|
}
|
|
m.middlewares = append(m.middlewares, h...)
|
|
}
|
|
|
|
// GET method route
|
|
func (m *Mux) GET(pattern string, h http.HandlerFunc) {
|
|
m.handle(http.MethodGet, pattern, h)
|
|
}
|
|
|
|
// HEAD method route
|
|
func (m *Mux) HEAD(pattern string, h http.HandlerFunc) {
|
|
m.handle(http.MethodHead, pattern, h)
|
|
}
|
|
|
|
// POST method route
|
|
func (m *Mux) POST(pattern string, h http.HandlerFunc) {
|
|
m.handle(http.MethodPost, pattern, h)
|
|
}
|
|
|
|
// PUT method route
|
|
func (m *Mux) PUT(pattern string, h http.HandlerFunc) {
|
|
m.handle(http.MethodPut, pattern, h)
|
|
}
|
|
|
|
// PATCH method route
|
|
func (m *Mux) PATCH(pattern string, h http.HandlerFunc) {
|
|
m.handle(http.MethodPatch, pattern, h)
|
|
}
|
|
|
|
// DELETE method route
|
|
func (m *Mux) DELETE(pattern string, h http.HandlerFunc) {
|
|
m.handle(http.MethodDelete, pattern, h)
|
|
}
|
|
|
|
// CONNECT method route
|
|
func (m *Mux) CONNECT(pattern string, h http.HandlerFunc) {
|
|
m.handle(http.MethodConnect, pattern, h)
|
|
}
|
|
|
|
// OPTIONS method route
|
|
func (m *Mux) OPTIONS(pattern string, h http.HandlerFunc) {
|
|
m.handle(http.MethodOptions, pattern, h)
|
|
}
|
|
|
|
// TRACE method route
|
|
func (m *Mux) TRACE(pattern string, h http.HandlerFunc) {
|
|
m.handle(http.MethodTrace, pattern, h)
|
|
}
|
|
|
|
// handle registers the handler for the given pattern.
|
|
// If the given pattern conflicts, with one that is already registered, HandleFunc
|
|
// panics.
|
|
func (m *Mux) handle(method, pattern string, h http.HandlerFunc) {
|
|
if m == nil {
|
|
panic("mux: func Handle() was called on nil")
|
|
}
|
|
|
|
if strings.TrimSpace(pattern) == "" {
|
|
panic("mux: pattern cannot be empty")
|
|
}
|
|
|
|
if !strings.HasPrefix(pattern, "/") {
|
|
pattern = "/" + pattern
|
|
}
|
|
|
|
path := fmt.Sprintf("%s %s", method, pattern)
|
|
m.mux.Handle(path, stack(m.middlewares, h))
|
|
m.routes.Add(path)
|
|
}
|
|
|
|
// With adds inline middlewares for an endpoint handler.
|
|
func (m *Mux) With(middleware ...func(http.Handler) http.Handler) *Mux {
|
|
mws := make([]func(http.Handler) http.Handler, len(m.middlewares))
|
|
copy(mws, m.middlewares)
|
|
mws = append(mws, middleware...)
|
|
|
|
im := &Mux{
|
|
mux: m.mux,
|
|
middlewares: mws,
|
|
routes: m.routes,
|
|
}
|
|
|
|
return im
|
|
}
|
|
|
|
// Group adds a new inline-Router along the current routing
|
|
// path, with a fresh middleware stack for the inline-Router.
|
|
func (m *Mux) Group(fn func(grp *Mux)) {
|
|
if m == nil {
|
|
panic("mux: Group() called on nil")
|
|
}
|
|
|
|
if fn == nil {
|
|
panic("mux: Group() requires callback")
|
|
}
|
|
|
|
im := m.With()
|
|
fn(im)
|
|
}
|
|
|
|
func (m *Mux) ServeHTTP(w http.ResponseWriter, req *http.Request) {
|
|
if m == nil {
|
|
panic("mux: method ServeHTTP called on nil")
|
|
}
|
|
|
|
m.mux.ServeHTTP(w, req)
|
|
}
|
|
|
|
func (m *Mux) PrintRoutes(w io.Writer) {
|
|
for _, route := range m.routes.All() {
|
|
w.Write([]byte(route))
|
|
w.Write([]byte("\n"))
|
|
}
|
|
}
|
|
|
|
func (m *Mux) RouteList() []string {
|
|
return m.routes.All()
|
|
}
|