2014-08-29 17:49:50 +00:00
|
|
|
// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
|
|
|
|
// Use of this source code is governed by a MIT style
|
|
|
|
// license that can be found in the LICENSE file.
|
|
|
|
|
2014-06-17 23:42:34 +00:00
|
|
|
package gin
|
|
|
|
|
|
|
|
import (
|
|
|
|
"html/template"
|
2015-05-18 22:45:08 +00:00
|
|
|
"net"
|
2014-06-17 23:42:34 +00:00
|
|
|
"net/http"
|
2015-05-18 22:45:08 +00:00
|
|
|
"os"
|
2014-07-06 19:09:23 +00:00
|
|
|
"sync"
|
2015-03-23 03:41:29 +00:00
|
|
|
|
|
|
|
"github.com/gin-gonic/gin/render"
|
2014-06-17 23:42:34 +00:00
|
|
|
)
|
|
|
|
|
2015-06-07 11:51:13 +00:00
|
|
|
const Version = "v1.0rc2"
|
2015-05-22 14:55:16 +00:00
|
|
|
|
2015-03-31 19:39:06 +00:00
|
|
|
var default404Body = []byte("404 page not found")
|
|
|
|
var default405Body = []byte("405 method not allowed")
|
2014-06-17 23:42:34 +00:00
|
|
|
|
|
|
|
type (
|
2015-05-07 09:30:01 +00:00
|
|
|
HandlerFunc func(*Context)
|
|
|
|
HandlersChain []HandlerFunc
|
2014-06-17 23:42:34 +00:00
|
|
|
|
2014-07-03 18:30:01 +00:00
|
|
|
// Represents the web framework, it wraps the blazing fast httprouter multiplexer and a list of global middlewares.
|
2014-06-17 23:42:34 +00:00
|
|
|
Engine struct {
|
2015-04-07 10:22:38 +00:00
|
|
|
RouterGroup
|
2015-05-18 13:45:24 +00:00
|
|
|
HTMLRender render.HTMLRender
|
2015-05-07 09:30:01 +00:00
|
|
|
allNoRoute HandlersChain
|
|
|
|
allNoMethod HandlersChain
|
|
|
|
noRoute HandlersChain
|
|
|
|
noMethod HandlersChain
|
2015-05-29 19:03:28 +00:00
|
|
|
pool sync.Pool
|
|
|
|
trees methodTrees
|
2015-03-31 19:39:06 +00:00
|
|
|
|
|
|
|
// 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
|
2015-06-07 11:51:13 +00:00
|
|
|
ForwardedByClientIP bool
|
2014-06-17 23:42:34 +00:00
|
|
|
}
|
2015-06-07 02:20:39 +00:00
|
|
|
|
2015-06-18 15:17:22 +00:00
|
|
|
RoutesInfo []RouteInfo
|
|
|
|
RouteInfo struct {
|
2015-06-07 11:49:36 +00:00
|
|
|
Method string
|
|
|
|
Path string
|
|
|
|
Handler string
|
2015-06-07 02:20:39 +00:00
|
|
|
}
|
2014-06-17 23:42:34 +00:00
|
|
|
)
|
|
|
|
|
2015-06-07 11:49:36 +00:00
|
|
|
func (c HandlersChain) Last() HandlerFunc {
|
|
|
|
length := len(c)
|
|
|
|
if length > 0 {
|
|
|
|
return c[length-1]
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2014-07-06 19:09:23 +00:00
|
|
|
// Returns a new blank Engine instance without any middleware attached.
|
|
|
|
// The most basic configuration
|
|
|
|
func New() *Engine {
|
2015-05-09 01:34:43 +00:00
|
|
|
debugPrintWARNING()
|
2015-03-31 19:39:06 +00:00
|
|
|
engine := &Engine{
|
2015-04-07 10:22:38 +00:00
|
|
|
RouterGroup: RouterGroup{
|
2015-05-16 16:08:19 +00:00
|
|
|
Handlers: nil,
|
|
|
|
BasePath: "/",
|
2015-06-10 23:02:38 +00:00
|
|
|
root: true,
|
2015-04-07 10:22:38 +00:00
|
|
|
},
|
2015-03-31 19:39:06 +00:00
|
|
|
RedirectTrailingSlash: true,
|
2015-05-30 12:45:13 +00:00
|
|
|
RedirectFixedPath: false,
|
|
|
|
HandleMethodNotAllowed: false,
|
2015-06-07 11:51:13 +00:00
|
|
|
ForwardedByClientIP: true,
|
|
|
|
trees: make(methodTrees, 0, 9),
|
2015-03-31 19:39:06 +00:00
|
|
|
}
|
2015-04-07 10:22:38 +00:00
|
|
|
engine.RouterGroup.engine = engine
|
2014-10-08 19:37:26 +00:00
|
|
|
engine.pool.New = func() interface{} {
|
2015-03-25 18:33:17 +00:00
|
|
|
return engine.allocateContext()
|
2014-07-02 18:17:57 +00:00
|
|
|
}
|
2014-06-17 23:42:34 +00:00
|
|
|
return engine
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns a Engine instance with the Logger and Recovery already attached.
|
|
|
|
func Default() *Engine {
|
|
|
|
engine := New()
|
|
|
|
engine.Use(Recovery(), Logger())
|
|
|
|
return engine
|
|
|
|
}
|
|
|
|
|
2015-06-07 11:51:13 +00:00
|
|
|
func (engine *Engine) allocateContext() *Context {
|
2015-05-22 00:24:13 +00:00
|
|
|
return &Context{engine: engine}
|
2015-03-25 18:33:17 +00:00
|
|
|
}
|
|
|
|
|
2014-07-15 15:41:56 +00:00
|
|
|
func (engine *Engine) LoadHTMLGlob(pattern string) {
|
2014-10-08 19:37:26 +00:00
|
|
|
if IsDebugging() {
|
2015-05-18 13:45:24 +00:00
|
|
|
engine.HTMLRender = render.HTMLDebug{Glob: pattern}
|
2014-08-20 23:04:35 +00:00
|
|
|
} else {
|
|
|
|
templ := template.Must(template.ParseGlob(pattern))
|
|
|
|
engine.SetHTMLTemplate(templ)
|
|
|
|
}
|
2014-07-15 15:41:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (engine *Engine) LoadHTMLFiles(files ...string) {
|
2014-10-08 19:37:26 +00:00
|
|
|
if IsDebugging() {
|
2015-05-18 13:45:24 +00:00
|
|
|
engine.HTMLRender = render.HTMLDebug{Files: files}
|
2014-08-20 16:14:10 +00:00
|
|
|
} else {
|
2014-08-20 23:04:35 +00:00
|
|
|
templ := template.Must(template.ParseFiles(files...))
|
|
|
|
engine.SetHTMLTemplate(templ)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (engine *Engine) SetHTMLTemplate(templ *template.Template) {
|
2015-06-12 16:09:44 +00:00
|
|
|
if len(engine.trees) > 0 {
|
|
|
|
debugPrint(`[WARNING] Since SetHTMLTemplate() is NOT thread-safe. It should only be called
|
|
|
|
at initialization. ie. before any route is registered or the router is listening in a socket:
|
|
|
|
|
|
|
|
router := gin.Default()
|
|
|
|
router.SetHTMLTemplate(template) // << good place
|
|
|
|
`)
|
|
|
|
}
|
2015-05-18 13:45:24 +00:00
|
|
|
engine.HTMLRender = render.HTMLProduction{Template: templ}
|
2014-06-17 23:42:34 +00:00
|
|
|
}
|
|
|
|
|
2014-07-17 21:42:23 +00:00
|
|
|
// Adds handlers for NoRoute. It return a 404 code by default.
|
|
|
|
func (engine *Engine) NoRoute(handlers ...HandlerFunc) {
|
2014-07-17 22:29:44 +00:00
|
|
|
engine.noRoute = handlers
|
2014-10-08 19:37:26 +00:00
|
|
|
engine.rebuild404Handlers()
|
2014-07-17 22:29:44 +00:00
|
|
|
}
|
|
|
|
|
2015-05-29 19:03:41 +00:00
|
|
|
// Sets the handlers called when... TODO
|
2015-03-08 23:37:27 +00:00
|
|
|
func (engine *Engine) NoMethod(handlers ...HandlerFunc) {
|
|
|
|
engine.noMethod = handlers
|
|
|
|
engine.rebuild405Handlers()
|
|
|
|
}
|
|
|
|
|
2015-05-29 19:03:41 +00:00
|
|
|
// Attachs a global middleware to the router. ie. the middlewares attached though Use() will be
|
|
|
|
// included in the handlers chain for every single request. Even 404, 405, static files...
|
|
|
|
// For example, this is the right place for a logger or error management middleware.
|
2015-06-10 23:02:38 +00:00
|
|
|
func (engine *Engine) Use(middlewares ...HandlerFunc) routesInterface {
|
2014-07-17 22:29:44 +00:00
|
|
|
engine.RouterGroup.Use(middlewares...)
|
2014-10-08 19:37:26 +00:00
|
|
|
engine.rebuild404Handlers()
|
2015-03-08 23:37:27 +00:00
|
|
|
engine.rebuild405Handlers()
|
2015-06-10 23:02:38 +00:00
|
|
|
return engine
|
2014-10-08 19:37:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (engine *Engine) rebuild404Handlers() {
|
2015-03-25 15:53:58 +00:00
|
|
|
engine.allNoRoute = engine.combineHandlers(engine.noRoute)
|
2015-03-08 23:37:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (engine *Engine) rebuild405Handlers() {
|
2015-03-25 15:53:58 +00:00
|
|
|
engine.allNoMethod = engine.combineHandlers(engine.noMethod)
|
2014-06-17 23:42:34 +00:00
|
|
|
}
|
|
|
|
|
2015-05-19 21:22:35 +00:00
|
|
|
func (engine *Engine) addRoute(method, path string, handlers HandlersChain) {
|
2015-05-20 09:32:39 +00:00
|
|
|
debugPrintRoute(method, path, handlers)
|
|
|
|
|
2015-03-31 19:39:06 +00:00
|
|
|
if path[0] != '/' {
|
|
|
|
panic("path must begin with '/'")
|
|
|
|
}
|
2015-04-09 10:15:02 +00:00
|
|
|
if method == "" {
|
|
|
|
panic("HTTP method can not be empty")
|
|
|
|
}
|
|
|
|
if len(handlers) == 0 {
|
|
|
|
panic("there must be at least one handler")
|
|
|
|
}
|
|
|
|
|
2015-06-03 23:54:36 +00:00
|
|
|
root := engine.trees.get(method)
|
2015-03-31 19:39:06 +00:00
|
|
|
if root == nil {
|
|
|
|
root = new(node)
|
2015-05-29 19:03:28 +00:00
|
|
|
engine.trees = append(engine.trees, methodTree{
|
|
|
|
method: method,
|
|
|
|
root: root,
|
|
|
|
})
|
2015-03-31 19:39:06 +00:00
|
|
|
}
|
|
|
|
root.addRoute(path, handlers)
|
2015-03-08 23:37:27 +00:00
|
|
|
}
|
|
|
|
|
2015-06-18 15:17:22 +00:00
|
|
|
func (engine *Engine) Routes() (routes RoutesInfo) {
|
2015-06-07 02:20:39 +00:00
|
|
|
for _, tree := range engine.trees {
|
2015-06-07 11:49:36 +00:00
|
|
|
routes = iterate("", tree.method, routes, tree.root)
|
2015-06-07 02:20:39 +00:00
|
|
|
}
|
|
|
|
return routes
|
|
|
|
}
|
|
|
|
|
2015-06-18 15:17:22 +00:00
|
|
|
func iterate(path, method string, routes RoutesInfo, root *node) RoutesInfo {
|
2015-06-07 02:20:39 +00:00
|
|
|
path += root.path
|
2015-06-07 11:49:36 +00:00
|
|
|
if len(root.handlers) > 0 {
|
|
|
|
routes = append(routes, RouteInfo{
|
|
|
|
Method: method,
|
|
|
|
Path: path,
|
|
|
|
Handler: nameOfFunction(root.handlers.Last()),
|
|
|
|
})
|
2015-06-07 02:20:39 +00:00
|
|
|
}
|
|
|
|
for _, node := range root.children {
|
2015-06-07 11:49:36 +00:00
|
|
|
routes = iterate(path, method, routes, node)
|
2015-06-07 02:20:39 +00:00
|
|
|
}
|
|
|
|
return routes
|
|
|
|
}
|
|
|
|
|
2015-05-29 19:03:41 +00:00
|
|
|
// The router is attached to a http.Server and starts listening and serving HTTP requests.
|
|
|
|
// It is a shortcut for http.ListenAndServe(addr, router)
|
|
|
|
// Note: this method will block the calling goroutine undefinitelly unless an error happens.
|
2015-05-09 01:34:43 +00:00
|
|
|
func (engine *Engine) Run(addr string) (err error) {
|
2015-04-07 10:22:38 +00:00
|
|
|
debugPrint("Listening and serving HTTP on %s\n", addr)
|
2015-05-18 22:45:08 +00:00
|
|
|
defer func() { debugPrintError(err) }()
|
2015-05-09 01:34:43 +00:00
|
|
|
|
|
|
|
err = http.ListenAndServe(addr, engine)
|
|
|
|
return
|
2015-04-07 10:22:38 +00:00
|
|
|
}
|
|
|
|
|
2015-05-29 19:03:41 +00:00
|
|
|
// The router is attached to a http.Server and starts listening and serving HTTPS requests.
|
|
|
|
// It is a shortcut for http.ListenAndServeTLS(addr, certFile, keyFile, router)
|
|
|
|
// Note: this method will block the calling goroutine undefinitelly unless an error happens.
|
2015-05-28 01:02:53 +00:00
|
|
|
func (engine *Engine) RunTLS(addr string, certFile string, keyFile string) (err error) {
|
2015-04-07 10:22:38 +00:00
|
|
|
debugPrint("Listening and serving HTTPS on %s\n", addr)
|
2015-05-18 22:45:08 +00:00
|
|
|
defer func() { debugPrintError(err) }()
|
2015-05-09 01:34:43 +00:00
|
|
|
|
2015-05-28 01:02:53 +00:00
|
|
|
err = http.ListenAndServeTLS(addr, certFile, keyFile, engine)
|
2015-05-09 01:34:43 +00:00
|
|
|
return
|
2015-04-07 10:22:38 +00:00
|
|
|
}
|
|
|
|
|
2015-05-29 19:03:41 +00:00
|
|
|
// The router is attached to a http.Server and starts listening and serving HTTP requests
|
|
|
|
// through the specified unix socket (ie. a file)
|
|
|
|
// Note: this method will block the calling goroutine undefinitelly unless an error happens.
|
2015-05-18 22:45:08 +00:00
|
|
|
func (engine *Engine) RunUnix(file string) (err error) {
|
|
|
|
debugPrint("Listening and serving HTTP on unix:/%s", file)
|
|
|
|
defer func() { debugPrintError(err) }()
|
|
|
|
|
|
|
|
os.Remove(file)
|
2015-05-18 22:48:19 +00:00
|
|
|
listener, err := net.Listen("unix", file)
|
2015-05-18 22:45:08 +00:00
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
defer listener.Close()
|
|
|
|
err = http.Serve(listener, engine)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2015-05-29 19:03:41 +00:00
|
|
|
// Conforms to the http.Handler interface.
|
2015-03-31 19:39:06 +00:00
|
|
|
func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
|
2015-05-18 18:50:46 +00:00
|
|
|
c := engine.pool.Get().(*Context)
|
|
|
|
c.writermem.reset(w)
|
|
|
|
c.Request = req
|
|
|
|
c.reset()
|
2015-04-07 10:22:38 +00:00
|
|
|
|
2015-05-28 01:22:34 +00:00
|
|
|
engine.handleHTTPRequest(c)
|
|
|
|
|
2015-05-18 18:50:46 +00:00
|
|
|
engine.pool.Put(c)
|
2015-04-07 10:22:38 +00:00
|
|
|
}
|
|
|
|
|
2015-05-18 18:50:46 +00:00
|
|
|
func (engine *Engine) handleHTTPRequest(context *Context) {
|
2015-04-07 10:22:38 +00:00
|
|
|
httpMethod := context.Request.Method
|
|
|
|
path := context.Request.URL.Path
|
|
|
|
|
|
|
|
// Find root of the tree for the given HTTP method
|
2015-05-29 19:03:28 +00:00
|
|
|
t := engine.trees
|
|
|
|
for i, tl := 0, len(t); i < tl; i++ {
|
|
|
|
if t[i].method == httpMethod {
|
2015-05-30 13:55:19 +00:00
|
|
|
root := t[i].root
|
2015-05-29 19:03:28 +00:00
|
|
|
// Find route in tree
|
2015-05-30 13:55:19 +00:00
|
|
|
handlers, params, tsr := root.getValue(path, context.Params)
|
2015-05-29 19:03:28 +00:00
|
|
|
if handlers != nil {
|
|
|
|
context.handlers = handlers
|
|
|
|
context.Params = params
|
|
|
|
context.Next()
|
|
|
|
context.writermem.WriteHeaderNow()
|
2015-04-07 10:22:38 +00:00
|
|
|
return
|
2015-05-29 19:03:28 +00:00
|
|
|
|
|
|
|
} else if httpMethod != "CONNECT" && path != "/" {
|
2015-05-30 13:55:19 +00:00
|
|
|
if tsr && engine.RedirectFixedPath {
|
|
|
|
redirectTrailingSlash(context)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if engine.RedirectFixedPath && redirectFixedPath(context, root, engine.RedirectFixedPath) {
|
2015-05-29 19:03:28 +00:00
|
|
|
return
|
|
|
|
}
|
2015-04-07 10:22:38 +00:00
|
|
|
}
|
2015-06-03 23:54:36 +00:00
|
|
|
break
|
2015-03-31 19:39:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-29 19:03:28 +00:00
|
|
|
// TODO: unit test
|
2015-04-07 10:22:38 +00:00
|
|
|
if engine.HandleMethodNotAllowed {
|
2015-05-29 19:03:28 +00:00
|
|
|
for _, tree := range engine.trees {
|
|
|
|
if tree.method != httpMethod {
|
|
|
|
if handlers, _, _ := tree.root.getValue(path, nil); handlers != nil {
|
2015-04-07 10:22:38 +00:00
|
|
|
context.handlers = engine.allNoMethod
|
|
|
|
serveError(context, 405, default405Body)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-04-08 12:24:49 +00:00
|
|
|
context.handlers = engine.allNoRoute
|
2015-04-07 10:22:38 +00:00
|
|
|
serveError(context, 404, default404Body)
|
2014-06-17 23:42:34 +00:00
|
|
|
}
|
|
|
|
|
2015-05-30 13:55:19 +00:00
|
|
|
var mimePlain = []string{MIMEPlain}
|
|
|
|
|
|
|
|
func serveError(c *Context, code int, defaultMessage []byte) {
|
|
|
|
c.writermem.status = code
|
|
|
|
c.Next()
|
|
|
|
if !c.writermem.Written() {
|
|
|
|
if c.writermem.Status() == code {
|
|
|
|
c.writermem.Header()["Content-Type"] = mimePlain
|
|
|
|
c.Writer.Write(defaultMessage)
|
|
|
|
} else {
|
|
|
|
c.writermem.WriteHeaderNow()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func redirectTrailingSlash(c *Context) {
|
2015-04-07 10:22:38 +00:00
|
|
|
req := c.Request
|
|
|
|
path := req.URL.Path
|
|
|
|
code := 301 // Permanent redirect, request with GET method
|
|
|
|
if req.Method != "GET" {
|
|
|
|
code = 307
|
|
|
|
}
|
|
|
|
|
2015-05-30 13:55:19 +00:00
|
|
|
if len(path) > 1 && path[len(path)-1] == '/' {
|
|
|
|
req.URL.Path = path[:len(path)-1]
|
|
|
|
} else {
|
|
|
|
req.URL.Path = path + "/"
|
|
|
|
}
|
|
|
|
debugPrint("redirecting request %d: %s --> %s", code, path, req.URL.String())
|
|
|
|
http.Redirect(c.Writer, req, req.URL.String(), code)
|
|
|
|
c.writermem.WriteHeaderNow()
|
|
|
|
}
|
|
|
|
|
|
|
|
func redirectFixedPath(c *Context, root *node, trailingSlash bool) bool {
|
|
|
|
req := c.Request
|
|
|
|
path := req.URL.Path
|
|
|
|
|
|
|
|
fixedPath, found := root.findCaseInsensitivePath(
|
|
|
|
cleanPath(path),
|
|
|
|
trailingSlash,
|
|
|
|
)
|
|
|
|
if found {
|
|
|
|
code := 301 // Permanent redirect, request with GET method
|
|
|
|
if req.Method != "GET" {
|
|
|
|
code = 307
|
2015-04-07 10:22:38 +00:00
|
|
|
}
|
2015-05-30 13:55:19 +00:00
|
|
|
req.URL.Path = string(fixedPath)
|
2015-05-05 13:06:38 +00:00
|
|
|
debugPrint("redirecting request %d: %s --> %s", code, path, req.URL.String())
|
2015-04-07 10:22:38 +00:00
|
|
|
http.Redirect(c.Writer, req, req.URL.String(), code)
|
2015-05-05 14:37:33 +00:00
|
|
|
c.writermem.WriteHeaderNow()
|
2015-04-07 10:22:38 +00:00
|
|
|
return true
|
|
|
|
}
|
|
|
|
return false
|
2014-06-17 23:42:34 +00:00
|
|
|
}
|