1
0
mirror of https://github.com/astaxie/beego.git synced 2024-11-26 05:01:28 +00:00
Beego/router.go

525 lines
12 KiB
Go
Raw Normal View History

2012-12-18 07:18:43 +00:00
package beego
import (
2013-04-11 06:35:43 +00:00
"fmt"
2012-12-18 07:18:43 +00:00
"net/http"
"net/url"
"reflect"
"regexp"
"runtime"
2013-05-28 05:58:42 +00:00
"strconv"
2012-12-18 07:18:43 +00:00
"strings"
)
var (
sc *Controller = &Controller{}
)
2012-12-18 07:18:43 +00:00
type controllerInfo struct {
pattern string
regex *regexp.Regexp
params map[int]string
controllerType reflect.Type
}
2013-04-07 16:28:32 +00:00
type userHandler struct {
pattern string
regex *regexp.Regexp
params map[int]string
h http.Handler
}
2012-12-18 07:18:43 +00:00
type ControllerRegistor struct {
2013-04-07 16:28:32 +00:00
routers []*controllerInfo
fixrouters []*controllerInfo
filters []http.HandlerFunc
userHandlers map[string]*userHandler
2012-12-18 07:18:43 +00:00
}
func NewControllerRegistor() *ControllerRegistor {
2013-04-07 16:28:32 +00:00
return &ControllerRegistor{routers: make([]*controllerInfo, 0), userHandlers: make(map[string]*userHandler)}
2012-12-18 07:18:43 +00:00
}
func (p *ControllerRegistor) Add(pattern string, c ControllerInterface) {
parts := strings.Split(pattern, "/")
j := 0
params := make(map[int]string)
for i, part := range parts {
if strings.HasPrefix(part, ":") {
2013-04-09 15:33:48 +00:00
expr := "(.+)"
2012-12-18 07:18:43 +00:00
//a user may choose to override the defult expression
// similar to expressjs: /user/:id([0-9]+)
2012-12-18 07:18:43 +00:00
if index := strings.Index(part, "("); index != -1 {
expr = part[index:]
part = part[:index]
2013-04-09 15:33:48 +00:00
//match /user/:id:int ([0-9]+)
2013-04-10 02:20:23 +00:00
//match /post/:username:string ([\w]+)
2013-04-09 15:33:48 +00:00
} else if lindex := strings.LastIndex(part, ":"); lindex != 0 {
switch part[lindex:] {
2013-04-09 15:51:19 +00:00
case ":int":
2013-04-09 15:33:48 +00:00
expr = "([0-9]+)"
2013-04-09 15:51:19 +00:00
part = part[:lindex]
2013-04-10 02:20:23 +00:00
case ":string":
2013-04-09 15:33:48 +00:00
expr = `([\w]+)`
2013-04-09 15:51:19 +00:00
part = part[:lindex]
2013-04-09 15:33:48 +00:00
}
2012-12-18 07:18:43 +00:00
}
params[j] = part
parts[i] = expr
j++
}
2013-04-09 15:33:48 +00:00
if strings.HasPrefix(part, "*") {
expr := "(.+)"
if part == "*.*" {
params[j] = ":path"
2013-04-09 15:51:19 +00:00
parts[i] = "([^.]+).([^.]+)"
2013-04-09 15:33:48 +00:00
j++
params[j] = ":ext"
j++
} else {
params[j] = ":splat"
parts[i] = expr
j++
}
}
2012-12-18 07:18:43 +00:00
}
if j == 0 {
//now create the Route
t := reflect.Indirect(reflect.ValueOf(c)).Type()
route := &controllerInfo{}
route.pattern = pattern
route.controllerType = t
p.fixrouters = append(p.fixrouters, route)
} else { // add regexp routers
//recreate the url pattern, with parameters replaced
//by regular expressions. then compile the regex
pattern = strings.Join(parts, "/")
regex, regexErr := regexp.Compile(pattern)
if regexErr != nil {
//TODO add error handling here to avoid panic
panic(regexErr)
return
}
//now create the Route
t := reflect.Indirect(reflect.ValueOf(c)).Type()
route := &controllerInfo{}
route.regex = regex
route.params = params
route.pattern = pattern
route.controllerType = t
p.routers = append(p.routers, route)
}
}
2013-04-07 16:28:32 +00:00
func (p *ControllerRegistor) AddHandler(pattern string, c http.Handler) {
parts := strings.Split(pattern, "/")
j := 0
params := make(map[int]string)
for i, part := range parts {
if strings.HasPrefix(part, ":") {
expr := "([^/]+)"
//a user may choose to override the defult expression
// similar to expressjs: /user/:id([0-9]+)
2013-04-07 16:28:32 +00:00
if index := strings.Index(part, "("); index != -1 {
expr = part[index:]
part = part[:index]
}
params[j] = part
parts[i] = expr
j++
}
}
if j == 0 {
//now create the Route
uh := &userHandler{}
uh.pattern = pattern
uh.h = c
p.userHandlers[pattern] = uh
} else { // add regexp routers
//recreate the url pattern, with parameters replaced
//by regular expressions. then compile the regex
pattern = strings.Join(parts, "/")
regex, regexErr := regexp.Compile(pattern)
if regexErr != nil {
//TODO add error handling here to avoid panic
panic(regexErr)
return
}
//now create the Route
uh := &userHandler{}
uh.regex = regex
uh.params = params
uh.pattern = pattern
uh.h = c
p.userHandlers[pattern] = uh
}
}
2012-12-18 07:18:43 +00:00
// Filter adds the middleware filter.
func (p *ControllerRegistor) Filter(filter http.HandlerFunc) {
p.filters = append(p.filters, filter)
}
// FilterParam adds the middleware filter if the REST URL parameter exists.
func (p *ControllerRegistor) FilterParam(param string, filter http.HandlerFunc) {
if !strings.HasPrefix(param, ":") {
param = ":" + param
}
p.Filter(func(w http.ResponseWriter, r *http.Request) {
p := r.URL.Query().Get(param)
if len(p) > 0 {
filter(w, r)
}
})
}
// FilterPrefixPath adds the middleware filter if the prefix path exists.
func (p *ControllerRegistor) FilterPrefixPath(path string, filter http.HandlerFunc) {
p.Filter(func(w http.ResponseWriter, r *http.Request) {
if strings.HasPrefix(r.URL.Path, path) {
filter(w, r)
}
})
}
func StructMap(vc reflect.Value, r *http.Request) error {
for k, t := range r.Form {
v := t[0]
2013-05-28 05:58:42 +00:00
names := strings.Split(k, ".")
var value reflect.Value = vc
for i, name := range names {
name = strings.Title(name)
if i == 0 {
if reflect.ValueOf(sc).Elem().FieldByName(name).IsValid() {
Trace("Controller's property should not be changed by mapper.")
break
2013-05-28 05:58:42 +00:00
}
}
if value.Kind() != reflect.Struct {
Trace(fmt.Sprintf("arg error, value kind is %v", value.Kind()))
break
}
if i != len(names)-1 {
value = value.FieldByName(name)
2013-05-28 05:58:42 +00:00
if !value.IsValid() {
Trace(fmt.Sprintf("(%v value is not valid %v)", name, value))
break
2013-05-28 05:58:42 +00:00
}
} else {
tv := value.FieldByName(name)
if !tv.IsValid() {
Trace(fmt.Sprintf("struct %v has no field named %v", value, name))
break
2013-05-28 05:58:42 +00:00
}
if !tv.CanSet() {
Trace("can not set " + k)
break
2013-05-28 05:58:42 +00:00
}
var l interface{}
switch k := tv.Kind(); k {
case reflect.String:
l = v
case reflect.Bool:
l = (v == "true")
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32:
x, err := strconv.Atoi(v)
if err != nil {
Trace("arg " + v + " as int: " + err.Error())
break
2013-05-28 05:58:42 +00:00
}
l = x
case reflect.Int64:
x, err := strconv.ParseInt(v, 10, 64)
if err != nil {
Trace("arg " + v + " as int: " + err.Error())
break
2013-05-28 05:58:42 +00:00
}
l = x
case reflect.Float32, reflect.Float64:
x, err := strconv.ParseFloat(v, 64)
if err != nil {
Trace("arg " + v + " as float64: " + err.Error())
break
2013-05-28 05:58:42 +00:00
}
l = x
case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
x, err := strconv.ParseUint(v, 10, 64)
if err != nil {
Trace("arg " + v + " as int: " + err.Error())
break
2013-05-28 05:58:42 +00:00
}
l = x
case reflect.Struct:
Trace("can not set an struct")
2013-05-28 05:58:42 +00:00
}
tv.Set(reflect.ValueOf(l))
}
}
}
return nil
}
2012-12-18 07:18:43 +00:00
// AutoRoute
func (p *ControllerRegistor) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
defer func() {
if err := recover(); err != nil {
2013-05-06 16:17:25 +00:00
errstr := fmt.Sprint(err)
if handler, ok := ErrorMaps[errstr]; ok {
handler(rw, r)
2012-12-18 07:18:43 +00:00
} else {
2013-05-06 16:17:25 +00:00
if !RecoverPanic {
// go back to panic
panic(err)
} else {
var stack string
Critical("Handler crashed with error", err)
for i := 1; ; i++ {
_, file, line, ok := runtime.Caller(i)
if !ok {
break
}
Critical(file, line)
if RunMode == "dev" {
stack = stack + fmt.Sprintln(file, line)
}
2012-12-18 07:18:43 +00:00
}
2013-04-11 06:35:43 +00:00
if RunMode == "dev" {
2013-05-06 16:17:25 +00:00
ShowErr(err, rw, r, stack)
2013-04-11 06:35:43 +00:00
}
}
2012-12-18 07:18:43 +00:00
}
}
}()
w := &responseWriter{writer: rw}
var runrouter *controllerInfo
var findrouter bool
params := make(map[string]string)
//static file server
for prefix, staticDir := range StaticDir {
if r.URL.Path == "/favicon.ico" {
file := staticDir + r.URL.Path
http.ServeFile(w, r, file)
w.started = true
return
}
2012-12-18 07:18:43 +00:00
if strings.HasPrefix(r.URL.Path, prefix) {
file := staticDir + r.URL.Path[len(prefix):]
http.ServeFile(w, r, file)
w.started = true
return
}
}
requestPath := r.URL.Path
2013-04-27 14:48:20 +00:00
r.ParseMultipartForm(MaxMemory)
2012-12-18 07:18:43 +00:00
2013-04-07 16:28:32 +00:00
//user defined Handler
for pattern, c := range p.userHandlers {
if c.regex == nil && pattern == requestPath {
c.h.ServeHTTP(rw, r)
return
} else if c.regex == nil {
continue
}
//check if Route pattern matches url
if !c.regex.MatchString(requestPath) {
continue
}
//get submatches (params)
matches := c.regex.FindStringSubmatch(requestPath)
//double check that the Route matches the URL pattern.
if len(matches[0]) != len(requestPath) {
continue
}
if len(c.params) > 0 {
//add url parameters to the query param map
values := r.URL.Query()
for i, match := range matches[1:] {
values.Add(c.params[i], match)
2013-05-08 05:00:35 +00:00
r.Form.Add(c.params[i], match)
2013-04-07 16:28:32 +00:00
params[c.params[i]] = match
}
//reassemble query params and add to RawQuery
r.URL.RawQuery = url.Values(values).Encode() + "&" + r.URL.RawQuery
//r.URL.RawQuery = url.Values(values).Encode()
}
c.h.ServeHTTP(rw, r)
return
}
2012-12-18 07:18:43 +00:00
//first find path from the fixrouters to Improve Performance
for _, route := range p.fixrouters {
n := len(requestPath)
//route like "/"
if n == 1 {
if requestPath == route.pattern {
runrouter = route
findrouter = true
break
} else {
continue
}
}
2012-12-18 07:18:43 +00:00
if (requestPath[n-1] != '/' && route.pattern == requestPath) ||
(requestPath[n-1] == '/' && len(route.pattern) >= n-1 && requestPath[0:n-1] == route.pattern) {
2012-12-18 07:18:43 +00:00
runrouter = route
findrouter = true
break
}
}
if !findrouter {
//find a matching Route
for _, route := range p.routers {
//check if Route pattern matches url
if !route.regex.MatchString(requestPath) {
continue
}
//get submatches (params)
matches := route.regex.FindStringSubmatch(requestPath)
//double check that the Route matches the URL pattern.
if len(matches[0]) != len(requestPath) {
continue
}
if len(route.params) > 0 {
//add url parameters to the query param map
values := r.URL.Query()
for i, match := range matches[1:] {
values.Add(route.params[i], match)
2013-05-08 05:00:35 +00:00
r.Form.Add(route.params[i], match)
2012-12-18 07:18:43 +00:00
params[route.params[i]] = match
}
//reassemble query params and add to RawQuery
r.URL.RawQuery = url.Values(values).Encode() + "&" + r.URL.RawQuery
//r.URL.RawQuery = url.Values(values).Encode()
}
runrouter = route
findrouter = true
break
}
}
if runrouter != nil {
//execute middleware filters
for _, filter := range p.filters {
filter(w, r)
if w.started {
return
}
}
//Invoke the request handler
vc := reflect.New(runrouter.controllerType)
2013-06-04 11:45:48 +00:00
StructMap(vc.Elem(), r)
2012-12-18 07:18:43 +00:00
//call the controller init function
init := vc.MethodByName("Init")
in := make([]reflect.Value, 2)
ct := &Context{ResponseWriter: w, Request: r, Params: params}
2013-05-28 05:58:42 +00:00
2012-12-18 07:18:43 +00:00
in[0] = reflect.ValueOf(ct)
in[1] = reflect.ValueOf(runrouter.controllerType.Name())
init.Call(in)
//call prepare function
in = make([]reflect.Value, 0)
method := vc.MethodByName("Prepare")
method.Call(in)
//if response has written,yes don't run next
if !w.started {
if r.Method == "GET" {
method = vc.MethodByName("Get")
method.Call(in)
} else if r.Method == "HEAD" {
method = vc.MethodByName("Head")
method.Call(in)
2013-04-27 14:47:32 +00:00
} else if r.Method == "DELETE" || (r.Method == "POST" && r.Form.Get("_method") == "delete") {
2012-12-18 07:18:43 +00:00
method = vc.MethodByName("Delete")
method.Call(in)
2013-04-27 14:47:32 +00:00
} else if r.Method == "PUT" || (r.Method == "POST" && r.Form.Get("_method") == "put") {
2012-12-18 07:18:43 +00:00
method = vc.MethodByName("Put")
method.Call(in)
2013-04-27 14:47:32 +00:00
} else if r.Method == "POST" {
method = vc.MethodByName("Post")
method.Call(in)
2012-12-18 07:18:43 +00:00
} else if r.Method == "PATCH" {
method = vc.MethodByName("Patch")
method.Call(in)
} else if r.Method == "OPTIONS" {
method = vc.MethodByName("Options")
method.Call(in)
}
if !w.started {
if AutoRender {
method = vc.MethodByName("Render")
method.Call(in)
}
if !w.started {
method = vc.MethodByName("Finish")
method.Call(in)
}
}
}
2013-05-08 05:56:48 +00:00
method = vc.MethodByName("Destructor")
method.Call(in)
2012-12-18 07:18:43 +00:00
}
//if no matches to url, throw a not found exception
2013-05-13 08:31:17 +00:00
if !findrouter {
2013-05-06 16:17:25 +00:00
if h, ok := ErrorMaps["404"]; ok {
h(w, r)
} else {
http.NotFound(w, r)
}
2012-12-18 07:18:43 +00:00
}
}
//responseWriter is a wrapper for the http.ResponseWriter
//started set to true if response was written to then don't execute other handler
type responseWriter struct {
writer http.ResponseWriter
started bool
status int
}
// Header returns the header map that will be sent by WriteHeader.
func (w *responseWriter) Header() http.Header {
return w.writer.Header()
}
// Write writes the data to the connection as part of an HTTP reply,
// and sets `started` to true
func (w *responseWriter) Write(p []byte) (int, error) {
w.started = true
return w.writer.Write(p)
}
// WriteHeader sends an HTTP response header with status code,
// and sets `started` to true
func (w *responseWriter) WriteHeader(code int) {
w.status = code
w.started = true
w.writer.WriteHeader(code)
}