You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

381 lines
9.9KB

  1. // Copyright 2014 The Macaron Authors
  2. //
  3. // Licensed under the Apache License, Version 2.0 (the "License"): you may
  4. // not use this file except in compliance with the License. You may obtain
  5. // a copy of the License at
  6. //
  7. // http://www.apache.org/licenses/LICENSE-2.0
  8. //
  9. // Unless required by applicable law or agreed to in writing, software
  10. // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  11. // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  12. // License for the specific language governing permissions and limitations
  13. // under the License.
  14. package macaron
  15. import (
  16. "net/http"
  17. "strings"
  18. "sync"
  19. )
  20. var (
  21. // Known HTTP methods.
  22. _HTTP_METHODS = map[string]bool{
  23. "GET": true,
  24. "POST": true,
  25. "PUT": true,
  26. "DELETE": true,
  27. "PATCH": true,
  28. "OPTIONS": true,
  29. "HEAD": true,
  30. }
  31. )
  32. // routeMap represents a thread-safe map for route tree.
  33. type routeMap struct {
  34. lock sync.RWMutex
  35. routes map[string]map[string]*Leaf
  36. }
  37. // NewRouteMap initializes and returns a new routeMap.
  38. func NewRouteMap() *routeMap {
  39. rm := &routeMap{
  40. routes: make(map[string]map[string]*Leaf),
  41. }
  42. for m := range _HTTP_METHODS {
  43. rm.routes[m] = make(map[string]*Leaf)
  44. }
  45. return rm
  46. }
  47. // getLeaf returns Leaf object if a route has been registered.
  48. func (rm *routeMap) getLeaf(method, pattern string) *Leaf {
  49. rm.lock.RLock()
  50. defer rm.lock.RUnlock()
  51. return rm.routes[method][pattern]
  52. }
  53. // add adds new route to route tree map.
  54. func (rm *routeMap) add(method, pattern string, leaf *Leaf) {
  55. rm.lock.Lock()
  56. defer rm.lock.Unlock()
  57. rm.routes[method][pattern] = leaf
  58. }
  59. type group struct {
  60. pattern string
  61. handlers []Handler
  62. }
  63. // Router represents a Macaron router layer.
  64. type Router struct {
  65. m *Macaron
  66. autoHead bool
  67. routers map[string]*Tree
  68. *routeMap
  69. namedRoutes map[string]*Leaf
  70. groups []group
  71. notFound http.HandlerFunc
  72. internalServerError func(*Context, error)
  73. // handlerWrapper is used to wrap arbitrary function from Handler to inject.FastInvoker.
  74. handlerWrapper func(Handler) Handler
  75. }
  76. func NewRouter() *Router {
  77. return &Router{
  78. routers: make(map[string]*Tree),
  79. routeMap: NewRouteMap(),
  80. namedRoutes: make(map[string]*Leaf),
  81. }
  82. }
  83. // SetAutoHead sets the value who determines whether add HEAD method automatically
  84. // when GET method is added.
  85. func (r *Router) SetAutoHead(v bool) {
  86. r.autoHead = v
  87. }
  88. type Params map[string]string
  89. // Handle is a function that can be registered to a route to handle HTTP requests.
  90. // Like http.HandlerFunc, but has a third parameter for the values of wildcards (variables).
  91. type Handle func(http.ResponseWriter, *http.Request, Params)
  92. // Route represents a wrapper of leaf route and upper level router.
  93. type Route struct {
  94. router *Router
  95. leaf *Leaf
  96. }
  97. // Name sets name of route.
  98. func (r *Route) Name(name string) {
  99. if len(name) == 0 {
  100. panic("route name cannot be empty")
  101. } else if r.router.namedRoutes[name] != nil {
  102. panic("route with given name already exists: " + name)
  103. }
  104. r.router.namedRoutes[name] = r.leaf
  105. }
  106. // handle adds new route to the router tree.
  107. func (r *Router) handle(method, pattern string, handle Handle) *Route {
  108. method = strings.ToUpper(method)
  109. var leaf *Leaf
  110. // Prevent duplicate routes.
  111. if leaf = r.getLeaf(method, pattern); leaf != nil {
  112. return &Route{r, leaf}
  113. }
  114. // Validate HTTP methods.
  115. if !_HTTP_METHODS[method] && method != "*" {
  116. panic("unknown HTTP method: " + method)
  117. }
  118. // Generate methods need register.
  119. methods := make(map[string]bool)
  120. if method == "*" {
  121. for m := range _HTTP_METHODS {
  122. methods[m] = true
  123. }
  124. } else {
  125. methods[method] = true
  126. }
  127. // Add to router tree.
  128. for m := range methods {
  129. if t, ok := r.routers[m]; ok {
  130. leaf = t.Add(pattern, handle)
  131. } else {
  132. t := NewTree()
  133. leaf = t.Add(pattern, handle)
  134. r.routers[m] = t
  135. }
  136. r.add(m, pattern, leaf)
  137. }
  138. return &Route{r, leaf}
  139. }
  140. // Handle registers a new request handle with the given pattern, method and handlers.
  141. func (r *Router) Handle(method string, pattern string, handlers []Handler) *Route {
  142. if len(r.groups) > 0 {
  143. groupPattern := ""
  144. h := make([]Handler, 0)
  145. for _, g := range r.groups {
  146. groupPattern += g.pattern
  147. h = append(h, g.handlers...)
  148. }
  149. pattern = groupPattern + pattern
  150. h = append(h, handlers...)
  151. handlers = h
  152. }
  153. handlers = validateAndWrapHandlers(handlers, r.handlerWrapper)
  154. return r.handle(method, pattern, func(resp http.ResponseWriter, req *http.Request, params Params) {
  155. c := r.m.createContext(resp, req)
  156. c.params = params
  157. c.handlers = make([]Handler, 0, len(r.m.handlers)+len(handlers))
  158. c.handlers = append(c.handlers, r.m.handlers...)
  159. c.handlers = append(c.handlers, handlers...)
  160. c.run()
  161. })
  162. }
  163. func (r *Router) Group(pattern string, fn func(), h ...Handler) {
  164. r.groups = append(r.groups, group{pattern, h})
  165. fn()
  166. r.groups = r.groups[:len(r.groups)-1]
  167. }
  168. // Get is a shortcut for r.Handle("GET", pattern, handlers)
  169. func (r *Router) Get(pattern string, h ...Handler) (leaf *Route) {
  170. leaf = r.Handle("GET", pattern, h)
  171. if r.autoHead {
  172. r.Head(pattern, h...)
  173. }
  174. return leaf
  175. }
  176. // Patch is a shortcut for r.Handle("PATCH", pattern, handlers)
  177. func (r *Router) Patch(pattern string, h ...Handler) *Route {
  178. return r.Handle("PATCH", pattern, h)
  179. }
  180. // Post is a shortcut for r.Handle("POST", pattern, handlers)
  181. func (r *Router) Post(pattern string, h ...Handler) *Route {
  182. return r.Handle("POST", pattern, h)
  183. }
  184. // Put is a shortcut for r.Handle("PUT", pattern, handlers)
  185. func (r *Router) Put(pattern string, h ...Handler) *Route {
  186. return r.Handle("PUT", pattern, h)
  187. }
  188. // Delete is a shortcut for r.Handle("DELETE", pattern, handlers)
  189. func (r *Router) Delete(pattern string, h ...Handler) *Route {
  190. return r.Handle("DELETE", pattern, h)
  191. }
  192. // Options is a shortcut for r.Handle("OPTIONS", pattern, handlers)
  193. func (r *Router) Options(pattern string, h ...Handler) *Route {
  194. return r.Handle("OPTIONS", pattern, h)
  195. }
  196. // Head is a shortcut for r.Handle("HEAD", pattern, handlers)
  197. func (r *Router) Head(pattern string, h ...Handler) *Route {
  198. return r.Handle("HEAD", pattern, h)
  199. }
  200. // Any is a shortcut for r.Handle("*", pattern, handlers)
  201. func (r *Router) Any(pattern string, h ...Handler) *Route {
  202. return r.Handle("*", pattern, h)
  203. }
  204. // Route is a shortcut for same handlers but different HTTP methods.
  205. //
  206. // Example:
  207. // m.Route("/", "GET,POST", h)
  208. func (r *Router) Route(pattern, methods string, h ...Handler) (route *Route) {
  209. for _, m := range strings.Split(methods, ",") {
  210. route = r.Handle(strings.TrimSpace(m), pattern, h)
  211. }
  212. return route
  213. }
  214. // Combo returns a combo router.
  215. func (r *Router) Combo(pattern string, h ...Handler) *ComboRouter {
  216. return &ComboRouter{r, pattern, h, map[string]bool{}, nil}
  217. }
  218. // NotFound configurates http.HandlerFunc which is called when no matching route is
  219. // found. If it is not set, http.NotFound is used.
  220. // Be sure to set 404 response code in your handler.
  221. func (r *Router) NotFound(handlers ...Handler) {
  222. handlers = validateAndWrapHandlers(handlers)
  223. r.notFound = func(rw http.ResponseWriter, req *http.Request) {
  224. c := r.m.createContext(rw, req)
  225. c.handlers = make([]Handler, 0, len(r.m.handlers)+len(handlers))
  226. c.handlers = append(c.handlers, r.m.handlers...)
  227. c.handlers = append(c.handlers, handlers...)
  228. c.run()
  229. }
  230. }
  231. // InternalServerError configurates handler which is called when route handler returns
  232. // error. If it is not set, default handler is used.
  233. // Be sure to set 500 response code in your handler.
  234. func (r *Router) InternalServerError(handlers ...Handler) {
  235. handlers = validateAndWrapHandlers(handlers)
  236. r.internalServerError = func(c *Context, err error) {
  237. c.index = 0
  238. c.handlers = handlers
  239. c.Map(err)
  240. c.run()
  241. }
  242. }
  243. // SetHandlerWrapper sets handlerWrapper for the router.
  244. func (r *Router) SetHandlerWrapper(f func(Handler) Handler) {
  245. r.handlerWrapper = f
  246. }
  247. func (r *Router) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
  248. if t, ok := r.routers[req.Method]; ok {
  249. // Fast match for static routes
  250. leaf := r.getLeaf(req.Method, req.URL.Path)
  251. if leaf != nil {
  252. leaf.handle(rw, req, nil)
  253. return
  254. }
  255. h, p, ok := t.Match(req.URL.EscapedPath())
  256. if ok {
  257. if splat, ok := p["*0"]; ok {
  258. p["*"] = splat // Easy name.
  259. }
  260. h(rw, req, p)
  261. return
  262. }
  263. }
  264. r.notFound(rw, req)
  265. }
  266. // URLFor builds path part of URL by given pair values.
  267. func (r *Router) URLFor(name string, pairs ...string) string {
  268. leaf, ok := r.namedRoutes[name]
  269. if !ok {
  270. panic("route with given name does not exists: " + name)
  271. }
  272. return leaf.URLPath(pairs...)
  273. }
  274. // ComboRouter represents a combo router.
  275. type ComboRouter struct {
  276. router *Router
  277. pattern string
  278. handlers []Handler
  279. methods map[string]bool // Registered methods.
  280. lastRoute *Route
  281. }
  282. func (cr *ComboRouter) checkMethod(name string) {
  283. if cr.methods[name] {
  284. panic("method '" + name + "' has already been registered")
  285. }
  286. cr.methods[name] = true
  287. }
  288. func (cr *ComboRouter) route(fn func(string, ...Handler) *Route, method string, h ...Handler) *ComboRouter {
  289. cr.checkMethod(method)
  290. cr.lastRoute = fn(cr.pattern, append(cr.handlers, h...)...)
  291. return cr
  292. }
  293. func (cr *ComboRouter) Get(h ...Handler) *ComboRouter {
  294. if cr.router.autoHead {
  295. cr.Head(h...)
  296. }
  297. return cr.route(cr.router.Get, "GET", h...)
  298. }
  299. func (cr *ComboRouter) Patch(h ...Handler) *ComboRouter {
  300. return cr.route(cr.router.Patch, "PATCH", h...)
  301. }
  302. func (cr *ComboRouter) Post(h ...Handler) *ComboRouter {
  303. return cr.route(cr.router.Post, "POST", h...)
  304. }
  305. func (cr *ComboRouter) Put(h ...Handler) *ComboRouter {
  306. return cr.route(cr.router.Put, "PUT", h...)
  307. }
  308. func (cr *ComboRouter) Delete(h ...Handler) *ComboRouter {
  309. return cr.route(cr.router.Delete, "DELETE", h...)
  310. }
  311. func (cr *ComboRouter) Options(h ...Handler) *ComboRouter {
  312. return cr.route(cr.router.Options, "OPTIONS", h...)
  313. }
  314. func (cr *ComboRouter) Head(h ...Handler) *ComboRouter {
  315. return cr.route(cr.router.Head, "HEAD", h...)
  316. }
  317. // Name sets name of ComboRouter route.
  318. func (cr *ComboRouter) Name(name string) {
  319. if cr.lastRoute == nil {
  320. panic("no corresponding route to be named")
  321. }
  322. cr.lastRoute.Name(name)
  323. }