gin/gin.go

233 lines
7.0 KiB
Go
Raw Normal View History

2014-06-17 23:42:34 +00:00
package gin
import (
2014-07-15 15:41:56 +00:00
"github.com/gin-gonic/gin/render"
2014-06-17 23:42:34 +00:00
"github.com/julienschmidt/httprouter"
"html/template"
"math"
"net/http"
"path"
2014-07-06 19:09:23 +00:00
"sync"
2014-06-17 23:42:34 +00:00
)
const (
2014-07-08 12:10:27 +00:00
AbortIndex = math.MaxInt8 / 2
MIMEJSON = "application/json"
MIMEHTML = "text/html"
MIMEXML = "application/xml"
MIMEXML2 = "text/xml"
MIMEPlain = "text/plain"
MIMEPOSTForm = "application/x-www-form-urlencoded"
2014-06-17 23:42:34 +00:00
)
type (
HandlerFunc func(*Context)
// Used internally to configure router, a RouterGroup is associated with a prefix
// and an array of handlers (middlewares)
RouterGroup struct {
Handlers []HandlerFunc
prefix string
parent *RouterGroup
engine *Engine
}
// 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 {
*RouterGroup
2014-07-17 22:29:44 +00:00
HTMLRender render.Render
cache sync.Pool
finalNoRoute []HandlerFunc
noRoute []HandlerFunc
router *httprouter.Router
2014-06-17 23:42:34 +00:00
}
)
func (engine *Engine) handle404(w http.ResponseWriter, req *http.Request) {
2014-07-17 22:29:44 +00:00
c := engine.createContext(w, req, nil, engine.finalNoRoute)
c.Writer.setStatus(404)
c.Next()
if !c.Writer.Written() {
c.Data(404, MIMEPlain, []byte("404 page not found"))
}
engine.cache.Put(c)
}
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 {
2014-06-17 23:42:34 +00:00
engine := &Engine{}
engine.RouterGroup = &RouterGroup{nil, "/", nil, engine}
2014-06-17 23:42:34 +00:00
engine.router = httprouter.New()
engine.router.NotFound = engine.handle404
2014-07-06 19:09:23 +00:00
engine.cache.New = func() interface{} {
c := &Context{Engine: engine}
c.Writer = &c.writermem
return c
}
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
}
2014-07-15 15:41:56 +00:00
func (engine *Engine) LoadHTMLGlob(pattern string) {
templ := template.Must(template.ParseGlob(pattern))
2014-07-16 12:53:57 +00:00
engine.SetHTMLTemplate(templ)
2014-07-15 15:41:56 +00:00
}
func (engine *Engine) LoadHTMLFiles(files ...string) {
templ := template.Must(template.ParseFiles(files...))
2014-07-16 12:53:57 +00:00
engine.SetHTMLTemplate(templ)
2014-07-15 15:41:56 +00:00
}
2014-07-16 12:53:57 +00:00
func (engine *Engine) SetHTMLTemplate(templ *template.Template) {
2014-07-15 15:41:56 +00:00
engine.HTMLRender = render.HTMLRender{
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
engine.finalNoRoute = engine.combineHandlers(engine.noRoute)
}
func (engine *Engine) Use(middlewares ...HandlerFunc) {
engine.RouterGroup.Use(middlewares...)
engine.finalNoRoute = engine.combineHandlers(engine.noRoute)
2014-06-17 23:42:34 +00:00
}
// ServeHTTP makes the router implement the http.Handler interface.
func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
engine.router.ServeHTTP(w, req)
}
func (engine *Engine) Run(addr string) {
2014-07-02 21:10:30 +00:00
if err := http.ListenAndServe(addr, engine); err != nil {
panic(err)
}
2014-06-17 23:42:34 +00:00
}
func (engine *Engine) RunTLS(addr string, cert string, key string) {
if err := http.ListenAndServeTLS(addr, cert, key, engine); err != nil {
panic(err)
}
}
2014-06-17 23:42:34 +00:00
/************************************/
/********** ROUTES GROUPING *********/
/************************************/
// Adds middlewares to the group, see example code in github.
func (group *RouterGroup) Use(middlewares ...HandlerFunc) {
group.Handlers = append(group.Handlers, middlewares...)
}
// Creates a new router group. You should add all the routes that have common middlwares or the same path prefix.
2014-06-17 23:42:34 +00:00
// For example, all the routes that use a common middlware for authorization could be grouped.
func (group *RouterGroup) Group(component string, handlers ...HandlerFunc) *RouterGroup {
2014-07-17 00:02:09 +00:00
prefix := group.pathFor(component)
2014-06-17 23:42:34 +00:00
return &RouterGroup{
2014-06-30 01:59:00 +00:00
Handlers: group.combineHandlers(handlers),
2014-06-17 23:42:34 +00:00
parent: group,
prefix: prefix,
engine: group.engine,
}
}
2014-07-17 00:02:09 +00:00
func (group *RouterGroup) pathFor(p string) string {
joined := path.Join(group.prefix, p)
// Append a '/' if the last component had one, but only if it's not there already
2014-07-17 23:34:29 +00:00
if len(p) > 0 && p[len(p)-1] == '/' && joined[len(joined)-1] != '/' {
2014-07-17 00:02:09 +00:00
return joined + "/"
}
return joined
}
2014-06-17 23:42:34 +00:00
// Handle registers a new request handle and middlewares with the given path and method.
// The last handler should be the real handler, the other ones should be middlewares that can and should be shared among different routes.
// See the example code in github.
//
// For GET, POST, PUT, PATCH and DELETE requests the respective shortcut
// functions can be used.
//
// This function is intended for bulk loading and to allow the usage of less
// frequently used, non-standardized or custom methods (e.g. for internal
// communication with a proxy).
func (group *RouterGroup) Handle(method, p string, handlers []HandlerFunc) {
2014-07-17 00:02:09 +00:00
p = group.pathFor(p)
2014-06-30 01:59:00 +00:00
handlers = group.combineHandlers(handlers)
2014-06-17 23:42:34 +00:00
group.engine.router.Handle(method, p, func(w http.ResponseWriter, req *http.Request, params httprouter.Params) {
c := group.engine.createContext(w, req, params, handlers)
c.Next()
2014-07-06 19:09:23 +00:00
group.engine.cache.Put(c)
2014-06-17 23:42:34 +00:00
})
}
// POST is a shortcut for router.Handle("POST", path, handle)
func (group *RouterGroup) POST(path string, handlers ...HandlerFunc) {
group.Handle("POST", path, handlers)
}
// GET is a shortcut for router.Handle("GET", path, handle)
func (group *RouterGroup) GET(path string, handlers ...HandlerFunc) {
group.Handle("GET", path, handlers)
}
// DELETE is a shortcut for router.Handle("DELETE", path, handle)
func (group *RouterGroup) DELETE(path string, handlers ...HandlerFunc) {
group.Handle("DELETE", path, handlers)
}
// PATCH is a shortcut for router.Handle("PATCH", path, handle)
func (group *RouterGroup) PATCH(path string, handlers ...HandlerFunc) {
group.Handle("PATCH", path, handlers)
}
// PUT is a shortcut for router.Handle("PUT", path, handle)
func (group *RouterGroup) PUT(path string, handlers ...HandlerFunc) {
group.Handle("PUT", path, handlers)
}
2014-07-03 14:14:33 +00:00
// OPTIONS is a shortcut for router.Handle("OPTIONS", path, handle)
func (group *RouterGroup) OPTIONS(path string, handlers ...HandlerFunc) {
group.Handle("OPTIONS", path, handlers)
2014-06-17 23:42:34 +00:00
}
2014-07-03 14:57:45 +00:00
// HEAD is a shortcut for router.Handle("HEAD", path, handle)
func (group *RouterGroup) HEAD(path string, handlers ...HandlerFunc) {
group.Handle("HEAD", path, handlers)
}
2014-07-07 23:09:48 +00:00
// Static serves files from the given file system root.
// 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 :
// router.Static("/static", "/var/www")
func (group *RouterGroup) Static(p, root string) {
2014-07-17 00:02:09 +00:00
prefix := group.pathFor(p)
2014-07-07 23:09:48 +00:00
p = path.Join(p, "/*filepath")
2014-07-17 00:02:09 +00:00
fileServer := http.StripPrefix(prefix, http.FileServer(http.Dir(root)))
2014-07-07 23:09:48 +00:00
group.GET(p, func(c *Context) {
fileServer.ServeHTTP(c.Writer, c.Request)
2014-07-07 23:09:48 +00:00
})
group.HEAD(p, func(c *Context) {
fileServer.ServeHTTP(c.Writer, c.Request)
})
2014-07-07 23:09:48 +00:00
}
2014-06-30 01:59:00 +00:00
func (group *RouterGroup) combineHandlers(handlers []HandlerFunc) []HandlerFunc {
s := len(group.Handlers) + len(handlers)
h := make([]HandlerFunc, 0, s)
h = append(h, group.Handlers...)
h = append(h, handlers...)
return h
2014-06-17 23:42:34 +00:00
}