gin/gin.go

179 lines
4.6 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"
"net/http"
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"
"github.com/julienschmidt/httprouter"
2014-06-17 23:42:34 +00:00
)
type (
HandlerFunc func(*Context)
// 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
2015-03-25 15:53:58 +00:00
HTMLRender render.Render
Default404Body []byte
Default405Body []byte
pool sync.Pool
allNoRoute []HandlerFunc
allNoMethod []HandlerFunc
noRoute []HandlerFunc
noMethod []HandlerFunc
router *httprouter.Router
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 {
2014-06-17 23:42:34 +00:00
engine := &Engine{}
2014-10-08 19:37:26 +00:00
engine.RouterGroup = &RouterGroup{
Handlers: nil,
absolutePath: "/",
engine: engine,
}
2014-06-17 23:42:34 +00:00
engine.router = httprouter.New()
2014-10-08 23:40:42 +00:00
engine.Default404Body = []byte("404 page not found")
engine.Default405Body = []byte("405 method not allowed")
2014-06-17 23:42:34 +00:00
engine.router.NotFound = engine.handle404
engine.router.MethodNotAllowed = engine.handle405
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) {
context = &Context{Engine: engine}
context.Writer = &context.writermem
context.Input = inputHolder{context: context}
2015-03-25 18:33:17 +00:00
return
}
2015-03-31 15:39:30 +00:00
func (engine *Engine) createContext(w http.ResponseWriter, req *http.Request, params httprouter.Params, handlers []HandlerFunc) *Context {
c := engine.pool.Get().(*Context)
c.reset()
c.writermem.reset(w)
c.Request = req
c.Params = params
c.handlers = handlers
return c
}
func (engine *Engine) reuseContext(c *Context) {
engine.pool.Put(c)
}
2014-07-15 15:41:56 +00:00
func (engine *Engine) LoadHTMLGlob(pattern string) {
2014-10-08 19:37:26 +00:00
if IsDebugging() {
r := &render.HTMLDebugRender{Glob: pattern}
engine.HTMLRender = r
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() {
r := &render.HTMLDebugRender{Files: files}
engine.HTMLRender = r
} 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) {
engine.HTMLRender = render.HTMLRender{
Template: templ,
2014-07-15 15:41:56 +00:00
}
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
}
2014-10-08 23:40:42 +00:00
func (engine *Engine) handle404(w http.ResponseWriter, req *http.Request) {
2015-03-25 15:53:58 +00:00
c := engine.createContext(w, req, nil, engine.allNoRoute)
2014-10-08 23:40:42 +00:00
// set 404 by default, useful for logging
c.Writer.WriteHeader(404)
c.Next()
if !c.Writer.Written() {
if c.Writer.Status() == 404 {
2015-03-31 15:51:10 +00:00
c.Data(-1, binding.MIMEPlain, engine.Default404Body)
2014-10-08 23:40:42 +00:00
} else {
c.Writer.WriteHeaderNow()
}
}
engine.reuseContext(c)
}
func (engine *Engine) handle405(w http.ResponseWriter, req *http.Request) {
2015-03-25 15:53:58 +00:00
c := engine.createContext(w, req, nil, engine.allNoMethod)
// set 405 by default, useful for logging
c.Writer.WriteHeader(405)
c.Next()
if !c.Writer.Written() {
if c.Writer.Status() == 405 {
2015-03-31 15:51:10 +00:00
c.Data(-1, binding.MIMEPlain, engine.Default405Body)
} else {
c.Writer.WriteHeaderNow()
}
}
engine.reuseContext(c)
}
2014-06-17 23:42:34 +00:00
// ServeHTTP makes the router implement the http.Handler interface.
2014-10-08 19:37:26 +00:00
func (engine *Engine) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
engine.router.ServeHTTP(writer, request)
2014-06-17 23:42:34 +00:00
}
2015-01-04 01:23:49 +00:00
func (engine *Engine) Run(addr string) error {
debugPrint("Listening and serving HTTP on %s\n", addr)
2015-03-23 03:41:29 +00:00
return http.ListenAndServe(addr, engine)
2014-06-17 23:42:34 +00:00
}
2015-01-04 01:23:49 +00:00
func (engine *Engine) RunTLS(addr string, cert string, key string) error {
debugPrint("Listening and serving HTTPS on %s\n", addr)
2015-03-23 03:41:29 +00:00
return http.ListenAndServeTLS(addr, cert, key, engine)
}