gin/routergroup.go

260 lines
9.1 KiB
Go
Raw Normal View History

// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
2014-10-08 19:37:26 +00:00
// Use of this source code is governed by a MIT style
// license that can be found in the LICENSE file.
package gin
import (
"net/http"
"path"
2015-06-04 02:50:40 +00:00
"regexp"
2015-05-21 14:59:58 +00:00
"strings"
2014-10-08 19:37:26 +00:00
)
var (
2022-02-14 06:39:57 +00:00
// regEnLetter matches english letters for http method name
regEnLetter = regexp.MustCompile("^[A-Z]+$")
// anyMethods for RouterGroup Any method
anyMethods = []string{
http.MethodGet, http.MethodPost, http.MethodPut, http.MethodPatch,
http.MethodHead, http.MethodOptions, http.MethodDelete, http.MethodConnect,
http.MethodTrace,
}
)
// IRouter defines all router handle interface includes single and group router.
2017-07-05 07:47:36 +00:00
type IRouter interface {
IRoutes
Group(string, ...HandlerFunc) *RouterGroup
}
// IRoutes defines all router handle interface.
2017-07-05 07:47:36 +00:00
type IRoutes interface {
Use(...HandlerFunc) IRoutes
Handle(string, string, ...HandlerFunc) IRoutes
Any(string, ...HandlerFunc) IRoutes
GET(string, ...HandlerFunc) IRoutes
POST(string, ...HandlerFunc) IRoutes
DELETE(string, ...HandlerFunc) IRoutes
PATCH(string, ...HandlerFunc) IRoutes
PUT(string, ...HandlerFunc) IRoutes
OPTIONS(string, ...HandlerFunc) IRoutes
HEAD(string, ...HandlerFunc) IRoutes
Match([]string, string, ...HandlerFunc) IRoutes
2017-07-05 07:47:36 +00:00
StaticFile(string, string) IRoutes
StaticFileFS(string, string, http.FileSystem) IRoutes
2017-07-05 07:47:36 +00:00
Static(string, string) IRoutes
StaticFS(string, http.FileSystem) IRoutes
}
// RouterGroup is used internally to configure router, a RouterGroup is associated with
// a prefix and an array of handlers (middleware).
2017-07-05 07:47:36 +00:00
type RouterGroup struct {
Handlers HandlersChain
basePath string
engine *Engine
root bool
}
2014-10-08 19:37:26 +00:00
var _ IRouter = (*RouterGroup)(nil)
2015-06-26 14:01:35 +00:00
2018-12-31 01:02:53 +00:00
// Use adds middleware to the group, see example code in GitHub.
func (group *RouterGroup) Use(middleware ...HandlerFunc) IRoutes {
group.Handlers = append(group.Handlers, middleware...)
2015-06-10 23:02:38 +00:00
return group.returnObj()
2014-10-08 19:37:26 +00:00
}
2018-11-05 06:17:04 +00:00
// Group creates a new router group. You should add all the routes that have common middlewares or the same path prefix.
// For example, all the routes that use a common middleware for authorization could be grouped.
2014-10-08 19:37:26 +00:00
func (group *RouterGroup) Group(relativePath string, handlers ...HandlerFunc) *RouterGroup {
return &RouterGroup{
Handlers: group.combineHandlers(handlers),
basePath: group.calculateAbsolutePath(relativePath),
engine: group.engine,
2014-10-08 19:37:26 +00:00
}
}
// BasePath returns the base path of router group.
// For example, if v := router.Group("/rest/n/v1/api"), v.BasePath() is "/rest/n/v1/api".
func (group *RouterGroup) BasePath() string {
return group.basePath
}
func (group *RouterGroup) handle(httpMethod, relativePath string, handlers HandlersChain) IRoutes {
absolutePath := group.calculateAbsolutePath(relativePath)
handlers = group.combineHandlers(handlers)
group.engine.addRoute(httpMethod, absolutePath, handlers)
return group.returnObj()
}
// Handle registers a new request handle and middleware with the given path and method.
// The last handler should be the real handler, the other ones should be middleware that can and should be shared among different routes.
2018-12-31 01:02:53 +00:00
// See the example code in GitHub.
2014-10-08 19:37:26 +00:00
//
// 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(httpMethod, relativePath string, handlers ...HandlerFunc) IRoutes {
if matched := regEnLetter.MatchString(httpMethod); !matched {
2015-06-04 02:50:40 +00:00
panic("http method " + httpMethod + " is not valid")
}
2015-06-10 23:02:38 +00:00
return group.handle(httpMethod, relativePath, handlers)
2014-10-08 19:37:26 +00:00
}
// POST is a shortcut for router.Handle("POST", path, handlers).
func (group *RouterGroup) POST(relativePath string, handlers ...HandlerFunc) IRoutes {
return group.handle(http.MethodPost, relativePath, handlers)
2014-10-08 19:37:26 +00:00
}
// GET is a shortcut for router.Handle("GET", path, handlers).
func (group *RouterGroup) GET(relativePath string, handlers ...HandlerFunc) IRoutes {
return group.handle(http.MethodGet, relativePath, handlers)
2014-10-08 19:37:26 +00:00
}
// DELETE is a shortcut for router.Handle("DELETE", path, handlers).
func (group *RouterGroup) DELETE(relativePath string, handlers ...HandlerFunc) IRoutes {
return group.handle(http.MethodDelete, relativePath, handlers)
2014-10-08 19:37:26 +00:00
}
// PATCH is a shortcut for router.Handle("PATCH", path, handlers).
func (group *RouterGroup) PATCH(relativePath string, handlers ...HandlerFunc) IRoutes {
return group.handle(http.MethodPatch, relativePath, handlers)
2014-10-08 19:37:26 +00:00
}
// PUT is a shortcut for router.Handle("PUT", path, handlers).
func (group *RouterGroup) PUT(relativePath string, handlers ...HandlerFunc) IRoutes {
return group.handle(http.MethodPut, relativePath, handlers)
2014-10-08 19:37:26 +00:00
}
// OPTIONS is a shortcut for router.Handle("OPTIONS", path, handlers).
func (group *RouterGroup) OPTIONS(relativePath string, handlers ...HandlerFunc) IRoutes {
return group.handle(http.MethodOptions, relativePath, handlers)
2014-10-08 19:37:26 +00:00
}
// HEAD is a shortcut for router.Handle("HEAD", path, handlers).
func (group *RouterGroup) HEAD(relativePath string, handlers ...HandlerFunc) IRoutes {
return group.handle(http.MethodHead, relativePath, handlers)
2014-10-08 19:37:26 +00:00
}
// Any registers a route that matches all the HTTP methods.
2017-08-16 03:55:50 +00:00
// GET, POST, PUT, PATCH, HEAD, OPTIONS, DELETE, CONNECT, TRACE.
func (group *RouterGroup) Any(relativePath string, handlers ...HandlerFunc) IRoutes {
for _, method := range anyMethods {
group.handle(method, relativePath, handlers)
}
2015-06-10 23:02:38 +00:00
return group.returnObj()
2015-05-19 21:00:55 +00:00
}
// Match registers a route that matches the specified methods that you declared.
func (group *RouterGroup) Match(methods []string, relativePath string, handlers ...HandlerFunc) IRoutes {
for _, method := range methods {
group.handle(method, relativePath, handlers)
}
return group.returnObj()
}
2018-05-31 03:41:45 +00:00
// StaticFile registers a single route in order to serve a single file of the local filesystem.
// router.StaticFile("favicon.ico", "./resources/favicon.ico")
func (group *RouterGroup) StaticFile(relativePath, filepath string) IRoutes {
return group.staticFileHandler(relativePath, func(c *Context) {
c.File(filepath)
})
}
// StaticFileFS works just like `StaticFile` but a custom `http.FileSystem` can be used instead..
// router.StaticFileFS("favicon.ico", "./resources/favicon.ico", Dir{".", false})
// Gin by default uses: gin.Dir()
func (group *RouterGroup) StaticFileFS(relativePath, filepath string, fs http.FileSystem) IRoutes {
return group.staticFileHandler(relativePath, func(c *Context) {
c.FileFromFS(filepath, fs)
})
}
func (group *RouterGroup) staticFileHandler(relativePath string, handler HandlerFunc) IRoutes {
2015-05-21 14:59:58 +00:00
if strings.Contains(relativePath, ":") || strings.Contains(relativePath, "*") {
panic("URL parameters can not be used when serving a static file")
}
group.GET(relativePath, handler)
group.HEAD(relativePath, handler)
2015-06-10 23:02:38 +00:00
return group.returnObj()
2015-05-21 14:59:58 +00:00
}
2014-10-08 19:37:26 +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(relativePath, root string) IRoutes {
2015-06-10 15:10:34 +00:00
return group.StaticFS(relativePath, Dir(root, false))
2015-05-20 08:50:59 +00:00
}
// StaticFS works just like `Static()` but a custom `http.FileSystem` can be used instead.
// Gin by default uses: gin.Dir()
func (group *RouterGroup) StaticFS(relativePath string, fs http.FileSystem) IRoutes {
if strings.Contains(relativePath, ":") || strings.Contains(relativePath, "*") {
panic("URL parameters can not be used when serving a static folder")
}
handler := group.createStaticHandler(relativePath, fs)
2015-05-31 13:55:10 +00:00
urlPattern := path.Join(relativePath, "/*filepath")
2014-10-08 23:40:42 +00:00
// Register GET and HEAD handlers
2015-05-31 13:55:10 +00:00
group.GET(urlPattern, handler)
group.HEAD(urlPattern, handler)
2015-06-10 23:02:38 +00:00
return group.returnObj()
2014-10-08 19:49:08 +00:00
}
func (group *RouterGroup) createStaticHandler(relativePath string, fs http.FileSystem) HandlerFunc {
absolutePath := group.calculateAbsolutePath(relativePath)
2015-05-20 08:50:59 +00:00
fileServer := http.StripPrefix(absolutePath, http.FileServer(fs))
return func(c *Context) {
2020-05-25 12:13:09 +00:00
if _, noListing := fs.(*onlyFilesFS); noListing {
2018-12-05 05:36:49 +00:00
c.Writer.WriteHeader(http.StatusNotFound)
}
2018-12-05 05:36:49 +00:00
file := c.Param("filepath")
// Check if file exists and/or if we have permission to access it
f, err := fs.Open(file)
if err != nil {
c.Writer.WriteHeader(http.StatusNotFound)
c.handlers = group.engine.noRoute
// Reset index
c.index = -1
return
}
f.Close()
fileServer.ServeHTTP(c.Writer, c.Request)
}
2014-10-08 19:37:26 +00:00
}
2015-05-07 09:30:01 +00:00
func (group *RouterGroup) combineHandlers(handlers HandlersChain) HandlersChain {
2014-10-08 19:37:26 +00:00
finalSize := len(group.Handlers) + len(handlers)
2021-07-11 06:38:45 +00:00
assert1(finalSize < int(abortIndex), "too many handlers")
2015-05-07 09:30:01 +00:00
mergedHandlers := make(HandlersChain, finalSize)
2015-04-09 10:15:02 +00:00
copy(mergedHandlers, group.Handlers)
copy(mergedHandlers[len(group.Handlers):], handlers)
return mergedHandlers
2014-10-08 19:37:26 +00:00
}
func (group *RouterGroup) calculateAbsolutePath(relativePath string) string {
return joinPaths(group.basePath, relativePath)
2014-10-08 19:37:26 +00:00
}
2015-06-10 23:02:38 +00:00
func (group *RouterGroup) returnObj() IRoutes {
2015-06-10 23:02:38 +00:00
if group.root {
return group.engine
}
return group
2015-06-10 23:02:38 +00:00
}