beego.Context.Abort return immediately

* add common 4XX/5XX HTTP exceptions

context/context.go

@@ -2,6 +2,8 @@ package context
 
 import (
 	"net/http"
+
+	"github.com/astaxie/beego/middleware"
 )
 
 type Context struct {
@@ -19,6 +21,13 @@ func (ctx *Context) Redirect(status int, localurl string) {
 func (ctx *Context) Abort(status int, body string) {
 	ctx.Output.SetStatus(status)
 	ctx.Output.Body([]byte(body))
+
+    if e, ok := middleware.HTTPExceptionMaps[status]; ok {
+        if len(body) >= 1 {
+            e.Description = body
+        }
+        panic(e)
+    }
 }
 
 func (ctx *Context) WriteString(content string) {

middleware/exceptions.go

@@ -0,0 +1,32 @@
+package middleware
+
+import "fmt"
+
+type HTTPException struct {
+	StatusCode  int // http status code 4xx, 5xx
+	Description string
+}
+
+func (e *HTTPException) Error() string {
+	// return `status description`, e.g. `400 Bad Request`
+	return fmt.Sprintf("%d %s", e.StatusCode, e.Description)
+}
+
+var HTTPExceptionMaps map[int]HTTPException
+
+func init() {
+	HTTPExceptionMaps = make(map[int]HTTPException)
+
+	// Normal 4XX HTTP Status
+	HTTPExceptionMaps[400] = HTTPException{400, "Bad Request"}
+	HTTPExceptionMaps[401] = HTTPException{401, "Unauthorized"}
+	HTTPExceptionMaps[403] = HTTPException{403, "Forbidden"}
+	HTTPExceptionMaps[404] = HTTPException{404, "Not Found"}
+	HTTPExceptionMaps[405] = HTTPException{405, "Method Not Allowed"}
+
+	// Normal 5XX HTTP Status
+	HTTPExceptionMaps[500] = HTTPException{500, "Internal Server Error"}
+	HTTPExceptionMaps[502] = HTTPException{502, "Bad Gateway"}
+	HTTPExceptionMaps[503] = HTTPException{503, "Service Unavailable"}
+	HTTPExceptionMaps[504] = HTTPException{504, "Gateway Timeout"}
+}

router.go

@@ -407,29 +407,33 @@ func (p *ControllerRegistor) UrlFor(endpoint string, values ...string) string {
 func (p *ControllerRegistor) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
 	defer func() {
 		if err := recover(); err != nil {
-			errstr := fmt.Sprint(err)
-			if handler, ok := middleware.ErrorMaps[errstr]; ok && ErrorsShow {
-				handler(rw, r)
+			if _, ok := err.(middleware.HTTPException); ok {
+				// catch intented errors, only for HTTP 4XX and 5XX
 			} else {
-				if !RecoverPanic {
-					// go back to panic
-					panic(err)
+				errstr := fmt.Sprint(err)
+				if handler, ok := middleware.ErrorMaps[errstr]; ok && ErrorsShow {
+					handler(rw, r)
 				} else {
-					var stack string
-					Critical("Handler crashed with error", err)
-					for i := 1; ; i++ {
-						_, file, line, ok := runtime.Caller(i)
-						if !ok {
-							break
+					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)
+							}
 						}
-						Critical(file, line)
 						if RunMode == "dev" {
-							stack = stack + fmt.Sprintln(file, line)
+							middleware.ShowErr(err, rw, r, stack)
 						}
 					}
-					if RunMode == "dev" {
-						middleware.ShowErr(err, rw, r, stack)
-					}
 				}
 			}
 		}