Skip to content

Commit

Permalink
Zero allocation router, first commit
Browse files Browse the repository at this point in the history
  • Loading branch information
@manucorporat
manucorporat committed Mar 31, 2015
1 parent c0e8ced commit 2915fa0
Show file tree
Hide file tree
Showing 8 changed files with 909 additions and 172 deletions.
3 changes: 1 addition & 2 deletions context.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -13,7 +13,6 @@ import (

"github.com/gin-gonic/gin/binding"
"github.com/gin-gonic/gin/render"
"github.com/julienschmidt/httprouter"
)

const AbortIndex = math.MaxInt8 / 2
Expand All @@ -26,7 +25,7 @@ type Context struct {
Request *http.Request
Writer ResponseWriter

Params httprouter.Params
Params Params
Input inputHolder
handlers []HandlerFunc
index int8
Expand Down
132 changes: 0 additions & 132 deletions deprecated.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3,135 +3,3 @@
// license that can be found in the LICENSE file.

package gin

import (
"log"
"net"
"net/http"
"strings"

"github.com/gin-gonic/gin/binding"
)

const (
MIMEJSON = binding.MIMEJSON
MIMEHTML = binding.MIMEHTML
MIMEXML = binding.MIMEXML
MIMEXML2 = binding.MIMEXML2
MIMEPlain = binding.MIMEPlain
MIMEPOSTForm = binding.MIMEPOSTForm
MIMEMultipartPOSTForm = binding.MIMEMultipartPOSTForm
)

// DEPRECATED, use Bind() instead.
// Like ParseBody() but this method also writes a 400 error if the json is not valid.
func (c *Context) EnsureBody(item interface{}) bool {
return c.Bind(item)
}

// DEPRECATED use bindings directly
// Parses the body content as a JSON input. It decodes the json payload into the struct specified as a pointer.
func (c *Context) ParseBody(item interface{}) error {
return binding.JSON.Bind(c.Request, item)
}

// DEPRECATED use gin.Static() instead
// ServeFiles serves files from the given file system root.
// The path must end with "/*filepath", files are then served from the local
// path /defined/root/dir/*filepath.
// For example if root is "/etc" and *filepath is "passwd", the local file
// "/etc/passwd" would be served.
// Internally a http.FileServer is used, therefore http.NotFound is used instead
// of the Router's NotFound handler.
// To use the operating system's file system implementation,
// use http.Dir:
// router.ServeFiles("/src/*filepath", http.Dir("/var/www"))
func (engine *Engine) ServeFiles(path string, root http.FileSystem) {
engine.router.ServeFiles(path, root)
}

// DEPRECATED use gin.LoadHTMLGlob() or gin.LoadHTMLFiles() instead
func (engine *Engine) LoadHTMLTemplates(pattern string) {
engine.LoadHTMLGlob(pattern)
}

// DEPRECATED. Use NoRoute() instead
func (engine *Engine) NotFound404(handlers ...HandlerFunc) {
engine.NoRoute(handlers...)
}

// the ForwardedFor middleware unwraps the X-Forwarded-For headers, be careful to only use this
// middleware if you've got servers in front of this server. The list with (known) proxies and
// local ips are being filtered out of the forwarded for list, giving the last not local ip being
// the real client ip.
func ForwardedFor(proxies ...interface{}) HandlerFunc {
if len(proxies) == 0 {
// default to local ips
var reservedLocalIps = []string{"10.0.0.0/8", "127.0.0.1/32", "172.16.0.0/12", "192.168.0.0/16"}

proxies = make([]interface{}, len(reservedLocalIps))

for i, v := range reservedLocalIps {
proxies[i] = v
}
}

return func(c *Context) {
// the X-Forwarded-For header contains an array with left most the client ip, then
// comma separated, all proxies the request passed. The last proxy appears
// as the remote address of the request. Returning the client
// ip to comply with default RemoteAddr response.

// check if remoteaddr is local ip or in list of defined proxies
remoteIp := net.ParseIP(strings.Split(c.Request.RemoteAddr, ":")[0])

if !ipInMasks(remoteIp, proxies) {
return
}

if forwardedFor := c.Request.Header.Get("X-Forwarded-For"); forwardedFor != "" {
parts := strings.Split(forwardedFor, ",")

for i := len(parts) - 1; i >= 0; i-- {
part := parts[i]

ip := net.ParseIP(strings.TrimSpace(part))

if ipInMasks(ip, proxies) {
continue
}

// returning remote addr conform the original remote addr format
c.Request.RemoteAddr = ip.String() + ":0"

// remove forwarded for address
c.Request.Header.Set("X-Forwarded-For", "")
return
}
}
}
}

func ipInMasks(ip net.IP, masks []interface{}) bool {
for _, proxy := range masks {
var mask *net.IPNet
var err error

switch t := proxy.(type) {
case string:
if _, mask, err = net.ParseCIDR(t); err != nil {
log.Panic(err)
}
case net.IP:
mask = &net.IPNet{IP: t, Mask: net.CIDRMask(len(t)*8, len(t)*8)}
case net.IPNet:
mask = &t
}

if mask.Contains(ip) {
return true
}
}

return false
}
130 changes: 101 additions & 29 deletions gin.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -11,42 +11,89 @@ 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)

// 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()
}
Expand All @@ -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
}

Expand Down Expand Up @@ -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 {
Expand Down
Loading

0 comments on commit 2915fa0

Please sign in to comment.