fix bug

astaxie
Showing 1 changed file with 284 additions and 283 deletions
router.go
--- a/router.go
View file @8a99591
+++ b/router.go
View file @8a99591
 package beego
 import (
 	"net/http"
 	"net/url"
 	"reflect"
 	"regexp"
 	"runtime"
 	"strings"
 )
 type controllerInfo struct {
 	pattern        string
 	regex          *regexp.Regexp
 	params         map[int]string
 	controllerType reflect.Type
 }
 type ControllerRegistor struct {
 	routers    []*controllerInfo
 	fixrouters []*controllerInfo
 	filters    []http.HandlerFunc
 }
 func NewControllerRegistor() *ControllerRegistor {
 	return &ControllerRegistor{routers: make([]*controllerInfo, 0)}
 }
 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, ":") {
 			expr := "([^/]+)"
 			//a user may choose to override the defult expression
 			// similar to expressjs: ‘/user/:id([0-9]+)’ 
 			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
 		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.controllerType = t
+		route.pattern = pattern
+		route.controllerType = t
-		p.routers = append(p.routers, route)
-	}
+		p.routers = append(p.routers, route)
+	}
-}
+}
-// Filter adds the middleware filter.
-func (p *ControllerRegistor) Filter(filter http.HandlerFunc) {
+// Filter adds the middleware filter.
-	p.filters = append(p.filters, 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) {
+// FilterParam adds the middleware filter if the REST URL parameter exists.
-	if !strings.HasPrefix(param, ":") {
+func (p *ControllerRegistor) FilterParam(param string, filter http.HandlerFunc) {
-		param = ":" + param
+	if !strings.HasPrefix(param, ":") {
-	}
+		param = ":" + param
+	}
-	p.Filter(func(w http.ResponseWriter, r *http.Request) {
-		p := r.URL.Query().Get(param)
+	p.Filter(func(w http.ResponseWriter, r *http.Request) {
-		if len(p) > 0 {
+		p := r.URL.Query().Get(param)
-			filter(w, r)
+		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) {
+// FilterPrefixPath adds the middleware filter if the prefix path exists.
-	p.Filter(func(w http.ResponseWriter, r *http.Request) {
+func (p *ControllerRegistor) FilterPrefixPath(path string, filter http.HandlerFunc) {
-		if strings.HasPrefix(r.URL.Path, path) {
+	p.Filter(func(w http.ResponseWriter, r *http.Request) {
-			filter(w, r)
+		if strings.HasPrefix(r.URL.Path, path) {
-		}
+			filter(w, r)
-	})
+		}
-}
+	})
+}
-// AutoRoute
-func (p *ControllerRegistor) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+// AutoRoute
-	defer func() {
+func (p *ControllerRegistor) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
-		if err := recover(); err != nil {
+	defer func() {
-			if !RecoverPanic {
+		if err := recover(); err != nil {
-				// go back to panic
+			if !RecoverPanic {
-				panic(err)
+				// go back to panic
-			} else {
+				panic(err)
-				Critical("Handler crashed with error", err)
+			} else {
-				for i := 1; ; i += 1 {
+				Critical("Handler crashed with error", err)
-					_, file, line, ok := runtime.Caller(i)
+				for i := 1; ; i += 1 {
-					if !ok {
+					_, file, line, ok := runtime.Caller(i)
-						break
+					if !ok {
-					}
+						break
-					Critical(file, line)
+					}
-				}
+					Critical(file, line)
-			}
+				}
-		}
+			}
-	}()
+		}
-	w := &responseWriter{writer: rw}
+	}()
+	w := &responseWriter{writer: rw}
-	var runrouter *controllerInfo
-	var findrouter bool
+	var runrouter *controllerInfo
+	var findrouter bool
-	params := make(map[string]string)
+	params := make(map[string]string)
-	//static file server
-	for prefix, staticDir := range StaticDir {
+	//static file server
-		if strings.HasPrefix(r.URL.Path, prefix) {
+	for prefix, staticDir := range StaticDir {
-			file := staticDir + r.URL.Path[len(prefix):]
+		if strings.HasPrefix(r.URL.Path, prefix) {
-			http.ServeFile(w, r, file)
+			file := staticDir + r.URL.Path[len(prefix):]
-			w.started = true
+			http.ServeFile(w, r, file)
-			return
+			w.started = true
-		}
+			return
-	}
+		}
+	}
-	requestPath := r.URL.Path
+	requestPath := r.URL.Path
-	//first find path from the fixrouters to Improve Performance
-	for _, route := range p.fixrouters {
+	//first find path from the fixrouters to Improve Performance
-		n := len(requestPath)
+	for _, route := range p.fixrouters {
-		if (requestPath[n-1] != '/' && route.pattern == requestPath) ||
+		n := len(requestPath)
-			(len(route.pattern) >= n && requestPath[0:n] == route.pattern) {
+		if (requestPath[n-1] != '/' && route.pattern == requestPath) ||
-			runrouter = route
+			(len(route.pattern) >= n && requestPath[0:n-1] == route.pattern) {
-			findrouter = true
+			runrouter = route
-			break
+			findrouter = true
-		}
+			break
-	}
+		}
+	}
-	if !findrouter {
-		//find a matching Route
+	if !findrouter {
-		for _, route := range p.routers {
+		//find a matching Route
+		for _, route := range p.routers {
-			//check if Route pattern matches url
-			if !route.regex.MatchString(requestPath) {
+			//check if Route pattern matches url
-				continue
+			if !route.regex.MatchString(requestPath) {
-			}
+				continue
+			}
-			//get submatches (params)
-			matches := route.regex.FindStringSubmatch(requestPath)
+			//get submatches (params)
+			matches := route.regex.FindStringSubmatch(requestPath)
-			//double check that the Route matches the URL pattern.
-			if len(matches[0]) != len(requestPath) {
+			//double check that the Route matches the URL pattern.
-				continue
+			if len(matches[0]) != len(requestPath) {
-			}
+				continue
+			}
-			if len(route.params) > 0 {
-				//add url parameters to the query param map
+			if len(route.params) > 0 {
-				values := r.URL.Query()
+				//add url parameters to the query param map
-				for i, match := range matches[1:] {
+				values := r.URL.Query()
-					values.Add(route.params[i], match)
+				for i, match := range matches[1:] {
-					params[route.params[i]] = match
+					values.Add(route.params[i], match)
-				}
+					params[route.params[i]] = match
-				//reassemble query params and add to RawQuery
+				}
-				r.URL.RawQuery = url.Values(values).Encode() + "&" + r.URL.RawQuery
+				//reassemble query params and add to RawQuery
-				//r.URL.RawQuery = url.Values(values).Encode()
+				r.URL.RawQuery = url.Values(values).Encode() + "&" + r.URL.RawQuery
-			}
+				//r.URL.RawQuery = url.Values(values).Encode()
-			runrouter = route
+			}
-			findrouter = true
+			runrouter = route
-			break
+			findrouter = true
-		}
+			break
-	}
+		}
+	}
-	if runrouter != nil {
-		//execute middleware filters
+	if runrouter != nil {
-		for _, filter := range p.filters {
+		//execute middleware filters
-			filter(w, r)
+		for _, filter := range p.filters {
-			if w.started {
+			filter(w, r)
-				return
+			if w.started {
-			}
+				return
-		}
+			}
+		}
-		//Invoke the request handler
-		vc := reflect.New(runrouter.controllerType)
+		//Invoke the request handler
+		vc := reflect.New(runrouter.controllerType)
-		//call the controller init function
-		init := vc.MethodByName("Init")
+		//call the controller init function
-		in := make([]reflect.Value, 2)
+		init := vc.MethodByName("Init")
-		ct := &Context{ResponseWriter: w, Request: r, Params: params}
+		in := make([]reflect.Value, 2)
-		in[0] = reflect.ValueOf(ct)
+		ct := &Context{ResponseWriter: w, Request: r, Params: params}
-		in[1] = reflect.ValueOf(runrouter.controllerType.Name())
+		in[0] = reflect.ValueOf(ct)
-		init.Call(in)
+		in[1] = reflect.ValueOf(runrouter.controllerType.Name())
-		//call prepare function
+		init.Call(in)
-		in = make([]reflect.Value, 0)
+		//call prepare function
-		method := vc.MethodByName("Prepare")
+		in = make([]reflect.Value, 0)
-		method.Call(in)
+		method := vc.MethodByName("Prepare")
+		method.Call(in)
-		//if response has written,yes don't run next
-		if !w.started {
+		//if response has written,yes don't run next
-			if r.Method == "GET" {
+		if !w.started {
-				method = vc.MethodByName("Get")
+			if r.Method == "GET" {
-				method.Call(in)
+				method = vc.MethodByName("Get")
-			} else if r.Method == "POST" {
+				method.Call(in)
-				method = vc.MethodByName("Post")
+			} else if r.Method == "POST" {
-				method.Call(in)
+				method = vc.MethodByName("Post")
-			} else if r.Method == "HEAD" {
+				method.Call(in)
-				method = vc.MethodByName("Head")
+			} else if r.Method == "HEAD" {
-				method.Call(in)
+				method = vc.MethodByName("Head")
-			} else if r.Method == "DELETE" {
+				method.Call(in)
-				method = vc.MethodByName("Delete")
+			} else if r.Method == "DELETE" {
-				method.Call(in)
+				method = vc.MethodByName("Delete")
-			} else if r.Method == "PUT" {
+				method.Call(in)
-				method = vc.MethodByName("Put")
+			} else if r.Method == "PUT" {
-				method.Call(in)
+				method = vc.MethodByName("Put")
-			} else if r.Method == "PATCH" {
+				method.Call(in)
-				method = vc.MethodByName("Patch")
+			} else if r.Method == "PATCH" {
-				method.Call(in)
+				method = vc.MethodByName("Patch")
-			} else if r.Method == "OPTIONS" {
+				method.Call(in)
-				method = vc.MethodByName("Options")
+			} else if r.Method == "OPTIONS" {
-				method.Call(in)
+				method = vc.MethodByName("Options")
-			}
+				method.Call(in)
-			if !w.started {
+			}
-				if AutoRender {
+			if !w.started {
-					method = vc.MethodByName("Render")
+				if AutoRender {
-					method.Call(in)
+					method = vc.MethodByName("Render")
-				}
+					method.Call(in)
-				if !w.started {
+				}
-					method = vc.MethodByName("Finish")
+				if !w.started {
-					method.Call(in)
+					method = vc.MethodByName("Finish")
-				}
+					method.Call(in)
-			}
+				}
-		}
+			}
-	}
+		}
+	}
-	//if no matches to url, throw a not found exception
-	if w.started == false {
+	//if no matches to url, throw a not found exception
-		http.NotFound(w, r)
+	if w.started == false {
-	}
+		http.NotFound(w, r)
-}
+	}
+}
-//responseWriter is a wrapper for the http.ResponseWriter
-//started set to true if response was written to then don't execute other handler
+//responseWriter is a wrapper for the http.ResponseWriter
-type responseWriter struct {
+//started set to true if response was written to then don't execute other handler
-	writer  http.ResponseWriter
+type responseWriter struct {
-	started bool
+	writer  http.ResponseWriter
-	status  int
+	started bool
-}
+	status  int
+}
-// Header returns the header map that will be sent by WriteHeader.
-func (w *responseWriter) Header() http.Header {
+// Header returns the header map that will be sent by WriteHeader.
-	return w.writer.Header()
+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
+// Write writes the data to the connection as part of an HTTP reply,
-func (w *responseWriter) Write(p []byte) (int, error) {
+// and sets `started` to true
-	w.started = true
+func (w *responseWriter) Write(p []byte) (int, error) {
-	return w.writer.Write(p)
+	w.started = true
-}
+	return w.writer.Write(p)
+}
-// WriteHeader sends an HTTP response header with status code,
-// and sets `started` to true
+// WriteHeader sends an HTTP response header with status code,
-func (w *responseWriter) WriteHeader(code int) {
+// and sets `started` to true
-	w.status = code
+func (w *responseWriter) WriteHeader(code int) {
-	w.started = true
+	w.status = code
-	w.writer.WriteHeader(code)
+	w.started = true
-}
+	w.writer.WriteHeader(code)
+}