Zero allocation router, first commit

gin.go

@@ -11,9 +11,32 @@ import (
 
 	"github.com/gin-gonic/gin/binding"
 	"github.com/gin-gonic/gin/render"
-	"github.com/julienschmidt/httprouter"
 )
 
+// Param is a single URL parameter, consisting of a key and a value.
+type Param struct {
+	Key   string
+	Value string
+}
+
+// Params is a Param-slice, as returned by the router.
+// The slice is ordered, the first URL parameter is also the first slice value.
+// It is therefore safe to read values by the index.
+type Params []Param
+
+// ByName returns the value of the first Param which key matches the given name.
+// If no matching Param is found, an empty string is returned.
+func (ps Params) ByName(name string) string {
+	for i := range ps {
+		if ps[i].Key == name {
+			return ps[i].Value
+		}
+	}
+	return ""
+}
+
+var default404Body = []byte("404 page not found")
+var default405Body = []byte("405 method not allowed")
 
 type (
 	HandlerFunc func(*Context)
@@ -21,32 +44,56 @@ type (
 	// Represents the web framework, it wraps the blazing fast httprouter multiplexer and a list of global middlewares.
 	Engine struct {
 		*RouterGroup
-		HTMLRender     render.Render
-		Default404Body []byte
-		Default405Body []byte
-		pool           sync.Pool
-		allNoRoute     []HandlerFunc
-		allNoMethod    []HandlerFunc
-		noRoute        []HandlerFunc
-		noMethod       []HandlerFunc
-		router         *httprouter.Router
+		HTMLRender  render.Render
+		pool        sync.Pool
+		allNoRoute  []HandlerFunc
+		allNoMethod []HandlerFunc
+		noRoute     []HandlerFunc
+		noMethod    []HandlerFunc
+		trees       map[string]*node
+
+		// Enables automatic redirection if the current route can't be matched but a
+		// handler for the path with (without) the trailing slash exists.
+		// For example if /foo/ is requested but a route only exists for /foo, the
+		// client is redirected to /foo with http status code 301 for GET requests
+		// and 307 for all other request methods.
+		RedirectTrailingSlash bool
+
+		// If enabled, the router tries to fix the current request path, if no
+		// handle is registered for it.
+		// First superfluous path elements like ../ or // are removed.
+		// Afterwards the router does a case-insensitive lookup of the cleaned path.
+		// If a handle can be found for this route, the router makes a redirection
+		// to the corrected path with status code 301 for GET requests and 307 for
+		// all other request methods.
+		// For example /FOO and /..//Foo could be redirected to /foo.
+		// RedirectTrailingSlash is independent of this option.
+		RedirectFixedPath bool
+
+		// If enabled, the router checks if another method is allowed for the
+		// current route, if the current request can not be routed.
+		// If this is the case, the request is answered with 'Method Not Allowed'
+		// and HTTP status code 405.
+		// If no other Method is allowed, the request is delegated to the NotFound
+		// handler.
+		HandleMethodNotAllowed bool
 	}
 )
 
 // Returns a new blank Engine instance without any middleware attached.
 // The most basic configuration
 func New() *Engine {
-	engine := &Engine{}
+	engine := &Engine{
+		RedirectTrailingSlash:  true,
+		RedirectFixedPath:      true,
+		HandleMethodNotAllowed: true,
+		trees: make(map[string]*node),
+	}
 	engine.RouterGroup = &RouterGroup{
 		Handlers:     nil,
 		absolutePath: "/",
 		engine:       engine,
 	}
-	engine.router = httprouter.New()
-	engine.Default404Body = []byte("404 page not found")
-	engine.Default405Body = []byte("405 method not allowed")
-	engine.router.NotFound = engine.handle404
-	engine.router.MethodNotAllowed = engine.handle405
 	engine.pool.New = func() interface{} {
 		return engine.allocateContext()
 	}
@@ -67,13 +114,11 @@ func (engine *Engine) allocateContext() (context *Context) {
 	return
 }
 
-func (engine *Engine) createContext(w http.ResponseWriter, req *http.Request, params httprouter.Params, handlers []HandlerFunc) *Context {
+func (engine *Engine) createContext(w http.ResponseWriter, req *http.Request) *Context {
 	c := engine.pool.Get().(*Context)
 	c.reset()
 	c.writermem.reset(w)
 	c.Request = req
-	c.Params = params
-	c.handlers = handlers
 	return c
 }
 
@@ -132,39 +177,66 @@ func (engine *Engine) rebuild405Handlers() {
 	engine.allNoMethod = engine.combineHandlers(engine.noMethod)
 }
 
-func (engine *Engine) handle404(w http.ResponseWriter, req *http.Request) {
-	c := engine.createContext(w, req, nil, engine.allNoRoute)
+func (engine *Engine) handle404(c *Context) {
 	// set 404 by default, useful for logging
+	c.handlers = engine.allNoRoute
 	c.Writer.WriteHeader(404)
 	c.Next()
 	if !c.Writer.Written() {
 		if c.Writer.Status() == 404 {
-			c.Data(-1, binding.MIMEPlain, engine.Default404Body)
+			c.Data(-1, binding.MIMEPlain, default404Body)
 		} else {
 			c.Writer.WriteHeaderNow()
 		}
 	}
-	engine.reuseContext(c)
 }
 
-func (engine *Engine) handle405(w http.ResponseWriter, req *http.Request) {
-	c := engine.createContext(w, req, nil, engine.allNoMethod)
+func (engine *Engine) handle405(c *Context) {
 	// set 405 by default, useful for logging
+	c.handlers = engine.allNoMethod
 	c.Writer.WriteHeader(405)
 	c.Next()
 	if !c.Writer.Written() {
 		if c.Writer.Status() == 405 {
-			c.Data(-1, binding.MIMEPlain, engine.Default405Body)
+			c.Data(-1, binding.MIMEPlain, default405Body)
 		} else {
 			c.Writer.WriteHeaderNow()
 		}
 	}
-	engine.reuseContext(c)
+}
+
+func (engine *Engine) handle(method, path string, handlers []HandlerFunc) {
+	if path[0] != '/' {
+		panic("path must begin with '/'")
+	}
+
+	//methodCode := codeForHTTPMethod(method)
+	root := engine.trees[method]
+	if root == nil {
+		root = new(node)
+		engine.trees[method] = root
+	}
+	root.addRoute(path, handlers)
 }
 
 // ServeHTTP makes the router implement the http.Handler interface.
-func (engine *Engine) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
-	engine.router.ServeHTTP(writer, request)
+func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+	c := engine.createContext(w, req)
+	//methodCode := codeForHTTPMethod(req.Method)
+	if root := engine.trees[req.Method]; root != nil {
+		path := req.URL.Path
+		if handlers, params, _ := root.getValue(path, c.Params); handlers != nil {
+			c.handlers = handlers
+			c.Params = params
+			c.Next()
+			engine.reuseContext(c)
+			return
+		}
+	}
+
+	// Handle 404
+	engine.handle404(c)
+	engine.reuseContext(c)
 }
 
 func (engine *Engine) Run(addr string) error {