gin/gin.go

298 lines
7.9 KiB
Go
Raw Normal View History

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
2015-03-31 15:51:10 +00:00
"github.com/gin-gonic/gin/binding"
2015-03-23 03:41:29 +00:00
"github.com/gin-gonic/gin/render"
2014-06-17 23:42:34 +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
// 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-03-31 19:39:06 +00:00
pool sync.Pool
2015-05-07 09:30:01 +00:00
allNoRoute HandlersChain
allNoMethod HandlersChain
noRoute HandlersChain
noMethod HandlersChain
2015-03-31 19:39:06 +00:00
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
2014-06-17 23:42:34 +00:00
}
)
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{
Handlers: nil,
BasePath: "/",
2015-04-07 10:22:38 +00:00
},
2015-03-31 19:39:06 +00:00
RedirectTrailingSlash: true,
RedirectFixedPath: true,
HandleMethodNotAllowed: true,
trees: make(map[string]*node),
}
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-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-03-31 15:39:30 +00:00
func (engine *Engine) allocateContext() (context *Context) {
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}
} 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-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
}
func (engine *Engine) NoMethod(handlers ...HandlerFunc) {
engine.noMethod = handlers
engine.rebuild405Handlers()
}
2014-07-17 22:29:44 +00:00
func (engine *Engine) Use(middlewares ...HandlerFunc) {
engine.RouterGroup.Use(middlewares...)
2014-10-08 19:37:26 +00:00
engine.rebuild404Handlers()
engine.rebuild405Handlers()
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)
}
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) {
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-03-31 19:39:06 +00:00
root := engine.trees[method]
if root == nil {
root = new(node)
engine.trees[method] = root
}
root.addRoute(path, handlers)
}
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-09 01:34:43 +00:00
func (engine *Engine) RunTLS(addr string, cert string, key 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
err = http.ListenAndServe(addr, engine)
return
2015-04-07 10:22:38 +00:00
}
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
}
2014-06-17 23:42:34 +00:00
// ServeHTTP makes the router implement 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.getcontext(w, req)
engine.handleHTTPRequest(c)
engine.putcontext(c)
}
2015-04-07 10:22:38 +00:00
2015-05-18 18:50:46 +00:00
func (engine *Engine) getcontext(w http.ResponseWriter, req *http.Request) *Context {
c := engine.pool.Get().(*Context)
c.writermem.reset(w)
c.Request = req
c.reset()
return c
}
2015-04-07 10:22:38 +00:00
2015-05-18 18:50:46 +00:00
func (engine *Engine) putcontext(c *Context) {
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
if root := engine.trees[httpMethod]; root != nil {
// Find route in tree
handlers, params, tsr := root.getValue(path, context.Params)
if handlers != nil {
context.handlers = handlers
context.Params = params
context.Next()
context.writermem.WriteHeaderNow()
2015-03-31 19:39:06 +00:00
return
2015-04-07 10:22:38 +00:00
} else if httpMethod != "CONNECT" && path != "/" {
if engine.serveAutoRedirect(context, root, tsr) {
return
}
2015-03-31 19:39:06 +00:00
}
}
2015-04-07 10:22:38 +00:00
if engine.HandleMethodNotAllowed {
for method, root := range engine.trees {
if method != httpMethod {
if handlers, _, _ := root.getValue(path, nil); handlers != nil {
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-04-07 10:22:38 +00:00
func (engine *Engine) serveAutoRedirect(c *Context, root *node, tsr bool) bool {
req := c.Request
path := req.URL.Path
code := 301 // Permanent redirect, request with GET method
if req.Method != "GET" {
code = 307
}
if tsr && engine.RedirectTrailingSlash {
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())
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
}
// Try to fix the request path
if engine.RedirectFixedPath {
fixedPath, found := root.findCaseInsensitivePath(
CleanPath(path),
engine.RedirectTrailingSlash,
)
if found {
req.URL.Path = string(fixedPath)
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
}
2015-04-07 10:22:38 +00:00
func serveError(c *Context, code int, defaultMessage []byte) {
c.writermem.status = code
c.Next()
if !c.Writer.Written() {
if c.Writer.Status() == code {
c.Data(-1, binding.MIMEPlain, defaultMessage)
} else {
c.Writer.WriteHeaderNow()
}
}
}