Beego/error.go

// Copyright 2014 beego Author. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package beego

import (
	"fmt"
	"html/template"
	"net/http"
	"reflect"
	"runtime"
	"strconv"
	"strings"

	"github.com/astaxie/beego/context"
	"github.com/astaxie/beego/utils"
)

const (
	errorTypeHandler = iota
	errorTypeController
)

var tpl = `
<!DOCTYPE html>
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    <title>beego application error</title>
    <style>
        html, body, body * {padding: 0; margin: 0;}
        #header {background:#ffd; border-bottom:solid 2px #A31515; padding: 20px 10px;}
        #header h2{ }
        #footer {border-top:solid 1px #aaa; padding: 5px 10px; font-size: 12px; color:green;}
        #content {padding: 5px;}
        #content .stack b{ font-size: 13px; color: red;}
        #content .stack pre{padding-left: 10px;}
        table {}
        td.t {text-align: right; padding-right: 5px; color: #888;}
    </style>
    <script type="text/javascript">
    </script>
</head>
<body>
    <div id="header">
        <h2>{{.AppError}}</h2>
    </div>
    <div id="content">
        <table>
            <tr>
                <td class="t">Request Method: </td><td>{{.RequestMethod}}</td>
            </tr>
            <tr>
                <td class="t">Request URL: </td><td>{{.RequestURL}}</td>
            </tr>
            <tr>
                <td class="t">RemoteAddr: </td><td>{{.RemoteAddr }}</td>
            </tr>
        </table>
        <div class="stack">
            <b>Stack</b>
            <pre>{{.Stack}}</pre>
        </div>
    </div>
    <div id="footer">
        <p>beego {{ .BeegoVersion }} (beego framework)</p>
        <p>golang version: {{.GoVersion}}</p>
    </div>
</body>
</html>
`

// render default application error page with error and stack string.
func showErr(err interface{}, ctx *context.Context, stack string) {
	t, _ := template.New("beegoerrortemp").Parse(tpl)
	data := map[string]string{
		"AppError":      fmt.Sprintf("%s:%v", BConfig.AppName, err),
		"RequestMethod": ctx.Input.Method(),
		"RequestURL":    ctx.Input.URI(),
		"RemoteAddr":    ctx.Input.IP(),
		"Stack":         stack,
		"BeegoVersion":  VERSION,
		"GoVersion":     runtime.Version(),
	}
	ctx.ResponseWriter.WriteHeader(500)
	t.Execute(ctx.ResponseWriter, data)
}

var errtpl = `
<!DOCTYPE html>
<html lang="en">
	<head>
		<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
		<title>{{.Title}}</title>
		<style type="text/css">
			* {
				margin:0;
				padding:0;
			}

			body {
				background-color:#EFEFEF;
				font: .9em "Lucida Sans Unicode", "Lucida Grande", sans-serif;
			}

			#wrapper{
				width:600px;
				margin:40px auto 0;
				text-align:center;
				-moz-box-shadow: 5px 5px 10px rgba(0,0,0,0.3);
				-webkit-box-shadow: 5px 5px 10px rgba(0,0,0,0.3);
				box-shadow: 5px 5px 10px rgba(0,0,0,0.3);
			}

			#wrapper h1{
				color:#FFF;
				text-align:center;
				margin-bottom:20px;
			}

			#wrapper a{
				display:block;
				font-size:.9em;
				padding-top:20px;
				color:#FFF;
				text-decoration:none;
				text-align:center;
			}

			#container {
				width:600px;
				padding-bottom:15px;
				background-color:#FFFFFF;
			}

			.navtop{
				height:40px;
				background-color:#24B2EB;
				padding:13px;
			}

			.content {
				padding:10px 10px 25px;
				background: #FFFFFF;
				margin:;
				color:#333;
			}

			a.button{
				color:white;
				padding:15px 20px;
				text-shadow:1px 1px 0 #00A5FF;
				font-weight:bold;
				text-align:center;
				border:1px solid #24B2EB;
				margin:0px 200px;
				clear:both;
				background-color: #24B2EB;
				border-radius:100px;
				-moz-border-radius:100px;
				-webkit-border-radius:100px;
			}

			a.button:hover{
				text-decoration:none;
				background-color: #24B2EB;
			}

		</style>
	</head>
	<body>
		<div id="wrapper">
			<div id="container">
				<div class="navtop">
					<h1>{{.Title}}</h1>
				</div>
				<div id="content">
					{{.Content}}
					<a href="/" title="Home" class="button">Go Home</a><br />

					<br>Powered by beego {{.BeegoVersion}}
				</div>
			</div>
		</div>
	</body>
</html>
`

type errorInfo struct {
	controllerType reflect.Type
	handler        http.HandlerFunc
	method         string
	errorType      int
}

// ErrorMaps holds map of http handlers for each error string.
// there is 10 kinds default error(40x and 50x)
var ErrorMaps = make(map[string]*errorInfo, 10)

// show 401 unauthorized error.
func unauthorized(rw http.ResponseWriter, r *http.Request) {
	t, _ := template.New("beegoerrortemp").Parse(errtpl)
	data := map[string]interface{}{
		"Title":        http.StatusText(401),
		"BeegoVersion": VERSION,
	}
	data["Content"] = template.HTML("<br>The page you have requested can't be authorized." +
		"<br>Perhaps you are here because:" +
		"<br><br><ul>" +
		"<br>The credentials you supplied are incorrect" +
		"<br>There are errors in the website address" +
		"</ul>")
	t.Execute(rw, data)
}

// show 402 Payment Required
func paymentRequired(rw http.ResponseWriter, r *http.Request) {
	t, _ := template.New("beegoerrortemp").Parse(errtpl)
	data := map[string]interface{}{
		"Title":        http.StatusText(402),
		"BeegoVersion": VERSION,
	}
	data["Content"] = template.HTML("<br>The page you have requested Payment Required." +
		"<br>Perhaps you are here because:" +
		"<br><br><ul>" +
		"<br>The credentials you supplied are incorrect" +
		"<br>There are errors in the website address" +
		"</ul>")
	t.Execute(rw, data)
}

// show 403 forbidden error.
func forbidden(rw http.ResponseWriter, r *http.Request) {
	t, _ := template.New("beegoerrortemp").Parse(errtpl)
	data := map[string]interface{}{
		"Title":        http.StatusText(403),
		"BeegoVersion": VERSION,
	}
	data["Content"] = template.HTML("<br>The page you have requested is forbidden." +
		"<br>Perhaps you are here because:" +
		"<br><br><ul>" +
		"<br>Your address may be blocked" +
		"<br>The site may be disabled" +
		"<br>You need to log in" +
		"</ul>")
	t.Execute(rw, data)
}

// show 404 notfound error.
func notFound(rw http.ResponseWriter, r *http.Request) {
	t, _ := template.New("beegoerrortemp").Parse(errtpl)
	data := map[string]interface{}{
		"Title":        http.StatusText(404),
		"BeegoVersion": VERSION,
	}
	data["Content"] = template.HTML("<br>The page you have requested has flown the coop." +
		"<br>Perhaps you are here because:" +
		"<br><br><ul>" +
		"<br>The page has moved" +
		"<br>The page no longer exists" +
		"<br>You were looking for your puppy and got lost" +
		"<br>You like 404 pages" +
		"</ul>")
	t.Execute(rw, data)
}

// show 405 Method Not Allowed
func methodNotAllowed(rw http.ResponseWriter, r *http.Request) {
	t, _ := template.New("beegoerrortemp").Parse(errtpl)
	data := map[string]interface{}{
		"Title":        http.StatusText(405),
		"BeegoVersion": VERSION,
	}
	data["Content"] = template.HTML("<br>The method you have requested Not Allowed." +
		"<br>Perhaps you are here because:" +
		"<br><br><ul>" +
		"<br>The method specified in the Request-Line is not allowed for the resource identified by the Request-URI" +
		"<br>The response MUST include an Allow header containing a list of valid methods for the requested resource." +
		"</ul>")
	t.Execute(rw, data)
}

// show 500 internal server error.
func internalServerError(rw http.ResponseWriter, r *http.Request) {
	t, _ := template.New("beegoerrortemp").Parse(errtpl)
	data := map[string]interface{}{
		"Title":        http.StatusText(500),
		"BeegoVersion": VERSION,
	}
	data["Content"] = template.HTML("<br>The page you have requested is down right now." +
		"<br><br><ul>" +
		"<br>Please try again later and report the error to the website administrator" +
		"<br></ul>")
	t.Execute(rw, data)
}

// show 501 Not Implemented.
func notImplemented(rw http.ResponseWriter, r *http.Request) {
	t, _ := template.New("beegoerrortemp").Parse(errtpl)
	data := map[string]interface{}{
		"Title":        http.StatusText(504),
		"BeegoVersion": VERSION,
	}
	data["Content"] = template.HTML("<br>The page you have requested is Not Implemented." +
		"<br><br><ul>" +
		"<br>Please try again later and report the error to the website administrator" +
		"<br></ul>")
	t.Execute(rw, data)
}

// show 502 Bad Gateway.
func badGateway(rw http.ResponseWriter, r *http.Request) {
	t, _ := template.New("beegoerrortemp").Parse(errtpl)
	data := map[string]interface{}{
		"Title":        http.StatusText(502),
		"BeegoVersion": VERSION,
	}
	data["Content"] = template.HTML("<br>The page you have requested is down right now." +
		"<br><br><ul>" +
		"<br>The server, while acting as a gateway or proxy, received an invalid response from the upstream server it accessed in attempting to fulfill the request." +
		"<br>Please try again later and report the error to the website administrator" +
		"<br></ul>")
	t.Execute(rw, data)
}

// show 503 service unavailable error.
func serviceUnavailable(rw http.ResponseWriter, r *http.Request) {
	t, _ := template.New("beegoerrortemp").Parse(errtpl)
	data := map[string]interface{}{
		"Title":        http.StatusText(503),
		"BeegoVersion": VERSION,
	}
	data["Content"] = template.HTML("<br>The page you have requested is unavailable." +
		"<br>Perhaps you are here because:" +
		"<br><br><ul>" +
		"<br><br>The page is overloaded" +
		"<br>Please try again later." +
		"</ul>")
	t.Execute(rw, data)
}

// show 504 Gateway Timeout.
func gatewayTimeout(rw http.ResponseWriter, r *http.Request) {
	t, _ := template.New("beegoerrortemp").Parse(errtpl)
	data := map[string]interface{}{
		"Title":        http.StatusText(504),
		"BeegoVersion": VERSION,
	}
	data["Content"] = template.HTML("<br>The page you have requested is unavailable." +
		"<br>Perhaps you are here because:" +
		"<br><br><ul>" +
		"<br><br>The server, while acting as a gateway or proxy, did not receive a timely response from the upstream server specified by the URI." +
		"<br>Please try again later." +
		"</ul>")
	t.Execute(rw, data)
}

// ErrorHandler registers http.HandlerFunc to each http err code string.
// usage:
// 	beego.ErrorHandler("404",NotFound)
//	beego.ErrorHandler("500",InternalServerError)
func ErrorHandler(code string, h http.HandlerFunc) *App {
	ErrorMaps[code] = &errorInfo{
		errorType: errorTypeHandler,
		handler:   h,
		method:    code,
	}
	return BeeApp
}

// ErrorController registers ControllerInterface to each http err code string.
// usage:
// 	beego.ErrorController(&controllers.ErrorController{})
func ErrorController(c ControllerInterface) *App {
	reflectVal := reflect.ValueOf(c)
	rt := reflectVal.Type()
	ct := reflect.Indirect(reflectVal).Type()
	for i := 0; i < rt.NumMethod(); i++ {
		methodName := rt.Method(i).Name
		if !utils.InSlice(methodName, exceptMethod) && strings.HasPrefix(methodName, "Error") {
			errName := strings.TrimPrefix(methodName, "Error")
			ErrorMaps[errName] = &errorInfo{
				errorType:      errorTypeController,
				controllerType: ct,
				method:         methodName,
			}
		}
	}
	return BeeApp
}

// show error string as simple text message.
// if error string is empty, show 503 or 500 error as default.
func exception(errCode string, ctx *context.Context) {
	atoi := func(code string) int {
		v, err := strconv.Atoi(code)
		if err == nil {
			return v
		}
		return 503
	}

	for _, ec := range []string{errCode, "503", "500"} {
		if h, ok := ErrorMaps[ec]; ok {
			executeError(h, ctx, atoi(ec))
			return
		}
	}
	//if 50x error has been removed from errorMap
	ctx.ResponseWriter.WriteHeader(atoi(errCode))
	ctx.WriteString(errCode)
}

func executeError(err *errorInfo, ctx *context.Context, code int) {
	if err.errorType == errorTypeHandler {
		err.handler(ctx.ResponseWriter, ctx.Request)
		return
	}
	if err.errorType == errorTypeController {
		ctx.Output.SetStatus(code)
		//Invoke the request handler
		vc := reflect.New(err.controllerType)
		execController, ok := vc.Interface().(ControllerInterface)
		if !ok {
			panic("controller is not ControllerInterface")
		}
		//call the controller init function
		execController.Init(ctx, err.controllerType.Name(), err.method, vc.Interface())

		//call prepare function
		execController.Prepare()

		execController.URLMapping()

		method := vc.MethodByName(err.method)
		method.Call([]reflect.Value{})

		//render template
		if BConfig.WebConfig.AutoRender {
			if err := execController.Render(); err != nil {
				panic(err)
			}
		}

		// finish all runrouter. release resource
		execController.Finish()
	}
}
update the documents & comments 2014-08-18 08:41:43 +00:00			`// Copyright 2014 beego Author. All Rights Reserved.`
beego: update licence& fix #669 2014-07-03 15:40:21 +00:00			`//`
update the documents & comments 2014-08-18 08:41:43 +00:00			`// Licensed under the Apache License, Version 2.0 (the "License");`
			`// you may not use this file except in compliance with the License.`
			`// You may obtain a copy of the License at`
beego: update licence& fix #669 2014-07-03 15:40:21 +00:00			`//`
update the documents & comments 2014-08-18 08:41:43 +00:00			`// http://www.apache.org/licenses/LICENSE-2.0`
beego: update licence& fix #669 2014-07-03 15:40:21 +00:00			`//`
update the documents & comments 2014-08-18 08:41:43 +00:00			`// Unless required by applicable law or agreed to in writing, software`
			`// distributed under the License is distributed on an "AS IS" BASIS,`
			`// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.`
			`// See the License for the specific language governing permissions and`
			`// limitations under the License.`

error support controller 2015-02-26 15:34:43 +00:00			`package beego`
change a log about new version 2013-09-09 16:00:11 +00:00
			`import (`
			`"fmt"`
			`"html/template"`
			`"net/http"`
error support controller 2015-02-26 15:34:43 +00:00			`"reflect"`
change a log about new version 2013-09-09 16:00:11 +00:00			`"runtime"`
update middleware & beego's error 2013-09-11 09:00:39 +00:00			`"strconv"`
error support controller 2015-02-26 15:34:43 +00:00			`"strings"`

			`"github.com/astaxie/beego/context"`
			`"github.com/astaxie/beego/utils"`
change a log about new version 2013-09-09 16:00:11 +00:00			`)`

error support controller 2015-02-26 15:34:43 +00:00			`const (`
			`errorTypeHandler = iota`
			`errorTypeController`
update info 2013-09-11 08:31:18 +00:00			`)`
error support controller 2015-02-26 15:34:43 +00:00
change a log about new version 2013-09-09 16:00:11 +00:00			var tpl = `
Restore SimpleServerError method 2013-12-06 05:44:54 +00:00			`<!DOCTYPE html>`
			`<html>`
change a log about new version 2013-09-09 16:00:11 +00:00			`<head>`
			`<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />`
			`<title>beego application error</title>`
			`<style>`
			`html, body, body * {padding: 0; margin: 0;}`
			`#header {background:#ffd; border-bottom:solid 2px #A31515; padding: 20px 10px;}`
			`#header h2{ }`
			`#footer {border-top:solid 1px #aaa; padding: 5px 10px; font-size: 12px; color:green;}`
			`#content {padding: 5px;}`
			`#content .stack b{ font-size: 13px; color: red;}`
			`#content .stack pre{padding-left: 10px;}`
			`table {}`
			`td.t {text-align: right; padding-right: 5px; color: #888;}`
Restore SimpleServerError method 2013-12-06 05:44:54 +00:00			`</style>`
change a log about new version 2013-09-09 16:00:11 +00:00			`<script type="text/javascript">`
			`</script>`
Restore SimpleServerError method 2013-12-06 05:44:54 +00:00			`</head>`
change a log about new version 2013-09-09 16:00:11 +00:00			`<body>`
			`<div id="header">`
			`<h2>{{.AppError}}</h2>`
			`</div>`
			`<div id="content">`
			`<table>`
			`<tr>`
			`<td class="t">Request Method: </td><td>{{.RequestMethod}}</td>`
			`</tr>`
			`<tr>`
			`<td class="t">Request URL: </td><td>{{.RequestURL}}</td>`
			`</tr>`
			`<tr>`
			`<td class="t">RemoteAddr: </td><td>{{.RemoteAddr }}</td>`
			`</tr>`
			`</table>`
			`<div class="stack">`
			`<b>Stack</b>`
			`<pre>{{.Stack}}</pre>`
			`</div>`
			`</div>`
			`<div id="footer">`
			`<p>beego {{ .BeegoVersion }} (beego framework)</p>`
			`<p>golang version: {{.GoVersion}}</p>`
			`</div>`
			`</body>`
Restore SimpleServerError method 2013-12-06 05:44:54 +00:00			`</html>`
change a log about new version 2013-09-09 16:00:11 +00:00			`

add comments for middleware packages, fix typo error 2014-01-17 08:03:01 +00:00			`// render default application error page with error and stack string.`
simplify docs.go and error.go, use http.StatusText instead of string codes 2015-12-21 09:16:58 +00:00			`func showErr(err interface{}, ctx *context.Context, stack string) {`
change a log about new version 2013-09-09 16:00:11 +00:00			`t, _ := template.New("beegoerrortemp").Parse(tpl)`
simplify docs.go and error.go, use http.StatusText instead of string codes 2015-12-21 09:16:58 +00:00			`data := map[string]string{`
			`"AppError": fmt.Sprintf("%s:%v", BConfig.AppName, err),`
			`"RequestMethod": ctx.Input.Method(),`
			`"RequestURL": ctx.Input.URI(),`
			`"RemoteAddr": ctx.Input.IP(),`
			`"Stack": stack,`
			`"BeegoVersion": VERSION,`
			`"GoVersion": runtime.Version(),`
			`}`
fix #1143 2015-05-05 13:36:31 +00:00			`ctx.ResponseWriter.WriteHeader(500)`
error support controller 2015-02-26 15:34:43 +00:00			`t.Execute(ctx.ResponseWriter, data)`
change a log about new version 2013-09-09 16:00:11 +00:00			`}`

			var errtpl = `
			`<!DOCTYPE html>`
			`<html lang="en">`
			`<head>`
			`<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">`
			`<title>{{.Title}}</title>`
			`<style type="text/css">`
			`* {`
			`margin:0;`
			`padding:0;`
			`}`

			`body {`
			`background-color:#EFEFEF;`
			`font: .9em "Lucida Sans Unicode", "Lucida Grande", sans-serif;`
			`}`

			`#wrapper{`
			`width:600px;`
			`margin:40px auto 0;`
			`text-align:center;`
			`-moz-box-shadow: 5px 5px 10px rgba(0,0,0,0.3);`
			`-webkit-box-shadow: 5px 5px 10px rgba(0,0,0,0.3);`
			`box-shadow: 5px 5px 10px rgba(0,0,0,0.3);`
			`}`

			`#wrapper h1{`
			`color:#FFF;`
			`text-align:center;`
			`margin-bottom:20px;`
			`}`

			`#wrapper a{`
			`display:block;`
			`font-size:.9em;`
			`padding-top:20px;`
			`color:#FFF;`
			`text-decoration:none;`
			`text-align:center;`
			`}`

			`#container {`
			`width:600px;`
			`padding-bottom:15px;`
			`background-color:#FFFFFF;`
			`}`

			`.navtop{`
			`height:40px;`
			`background-color:#24B2EB;`
			`padding:13px;`
			`}`

			`.content {`
			`padding:10px 10px 25px;`
			`background: #FFFFFF;`
			`margin:;`
			`color:#333;`
			`}`

			`a.button{`
			`color:white;`
			`padding:15px 20px;`
			`text-shadow:1px 1px 0 #00A5FF;`
			`font-weight:bold;`
			`text-align:center;`
			`border:1px solid #24B2EB;`
			`margin:0px 200px;`
			`clear:both;`
			`background-color: #24B2EB;`
			`border-radius:100px;`
			`-moz-border-radius:100px;`
			`-webkit-border-radius:100px;`
			`}`

			`a.button:hover{`
			`text-decoration:none;`
			`background-color: #24B2EB;`
			`}`

			`</style>`
			`</head>`
			`<body>`
			`<div id="wrapper">`
			`<div id="container">`
			`<div class="navtop">`
			`<h1>{{.Title}}</h1>`
			`</div>`
			`<div id="content">`
			`{{.Content}}`
			`<a href="/" title="Home" class="button">Go Home</a><br />`

Update error.go Fix the spelling mistake of error page. 2014-02-10 04:55:53 +00:00			`<br>Powered by beego {{.BeegoVersion}}`
change a log about new version 2013-09-09 16:00:11 +00:00			`</div>`
			`</div>`
			`</div>`
			`</body>`
			`</html>`
			`

error support controller 2015-02-26 15:34:43 +00:00			`type errorInfo struct {`
			`controllerType reflect.Type`
			`handler http.HandlerFunc`
			`method string`
			`errorType int`
			`}`

golint all the files 2016-01-17 16:18:21 +00:00			`// ErrorMaps holds map of http handlers for each error string.`
add comment 2015-09-18 02:32:21 +00:00			`// there is 10 kinds default error(40x and 50x)`
fix the error refactor 2015-09-17 15:05:45 +00:00			`var ErrorMaps = make(map[string]*errorInfo, 10)`
change a log about new version 2013-09-09 16:00:11 +00:00
add more error functions 2015-02-26 15:49:24 +00:00			`// show 401 unauthorized error.`
			`func unauthorized(rw http.ResponseWriter, r *http.Request) {`
change a log about new version 2013-09-09 16:00:11 +00:00			`t, _ := template.New("beegoerrortemp").Parse(errtpl)`
simplify docs.go and error.go, use http.StatusText instead of string codes 2015-12-21 09:16:58 +00:00			`data := map[string]interface{}{`
			`"Title": http.StatusText(401),`
			`"BeegoVersion": VERSION,`
			`}`
add more error functions 2015-02-26 15:49:24 +00:00			`data["Content"] = template.HTML("<br>The page you have requested can't be authorized." +`
change a log about new version 2013-09-09 16:00:11 +00:00			`"<br>Perhaps you are here because:" +`
added back a <br> 2014-01-02 14:54:15 +00:00			`"<br><br><ul>" +`
add more error functions 2015-02-26 15:49:24 +00:00			`"<br>The credentials you supplied are incorrect" +`
			`"<br>There are errors in the website address" +`
change a log about new version 2013-09-09 16:00:11 +00:00			`"</ul>")`
			`t.Execute(rw, data)`
			`}`

add more error functions 2015-02-26 15:49:24 +00:00			`// show 402 Payment Required`
			`func paymentRequired(rw http.ResponseWriter, r *http.Request) {`
change a log about new version 2013-09-09 16:00:11 +00:00			`t, _ := template.New("beegoerrortemp").Parse(errtpl)`
simplify docs.go and error.go, use http.StatusText instead of string codes 2015-12-21 09:16:58 +00:00			`data := map[string]interface{}{`
			`"Title": http.StatusText(402),`
			`"BeegoVersion": VERSION,`
			`}`
add more error functions 2015-02-26 15:49:24 +00:00			`data["Content"] = template.HTML("<br>The page you have requested Payment Required." +`
change a log about new version 2013-09-09 16:00:11 +00:00			`"<br>Perhaps you are here because:" +`
			`"<br><br><ul>" +`
Improved the language on the error pages 2014-01-02 14:53:09 +00:00			`"<br>The credentials you supplied are incorrect" +`
			`"<br>There are errors in the website address" +`
change a log about new version 2013-09-09 16:00:11 +00:00			`"</ul>")`
			`t.Execute(rw, data)`
			`}`

add comments for middleware packages, fix typo error 2014-01-17 08:03:01 +00:00			`// show 403 forbidden error.`
add more error functions 2015-02-26 15:49:24 +00:00			`func forbidden(rw http.ResponseWriter, r *http.Request) {`
change a log about new version 2013-09-09 16:00:11 +00:00			`t, _ := template.New("beegoerrortemp").Parse(errtpl)`
simplify docs.go and error.go, use http.StatusText instead of string codes 2015-12-21 09:16:58 +00:00			`data := map[string]interface{}{`
			`"Title": http.StatusText(403),`
			`"BeegoVersion": VERSION,`
			`}`
Improved the language on the error pages 2014-01-02 14:53:09 +00:00			`data["Content"] = template.HTML("<br>The page you have requested is forbidden." +`
change a log about new version 2013-09-09 16:00:11 +00:00			`"<br>Perhaps you are here because:" +`
			`"<br><br><ul>" +`
			`"<br>Your address may be blocked" +`
			`"<br>The site may be disabled" +`
			`"<br>You need to log in" +`
			`"</ul>")`
			`t.Execute(rw, data)`
			`}`

add more error functions 2015-02-26 15:49:24 +00:00			`// show 404 notfound error.`
			`func notFound(rw http.ResponseWriter, r *http.Request) {`
change a log about new version 2013-09-09 16:00:11 +00:00			`t, _ := template.New("beegoerrortemp").Parse(errtpl)`
simplify docs.go and error.go, use http.StatusText instead of string codes 2015-12-21 09:16:58 +00:00			`data := map[string]interface{}{`
			`"Title": http.StatusText(404),`
			`"BeegoVersion": VERSION,`
			`}`
add more error functions 2015-02-26 15:49:24 +00:00			`data["Content"] = template.HTML("<br>The page you have requested has flown the coop." +`
change a log about new version 2013-09-09 16:00:11 +00:00			`"<br>Perhaps you are here because:" +`
			`"<br><br><ul>" +`
add more error functions 2015-02-26 15:49:24 +00:00			`"<br>The page has moved" +`
			`"<br>The page no longer exists" +`
			`"<br>You were looking for your puppy and got lost" +`
			`"<br>You like 404 pages" +`
			`"</ul>")`
			`t.Execute(rw, data)`
			`}`

			`// show 405 Method Not Allowed`
			`func methodNotAllowed(rw http.ResponseWriter, r *http.Request) {`
			`t, _ := template.New("beegoerrortemp").Parse(errtpl)`
simplify docs.go and error.go, use http.StatusText instead of string codes 2015-12-21 09:16:58 +00:00			`data := map[string]interface{}{`
			`"Title": http.StatusText(405),`
			`"BeegoVersion": VERSION,`
			`}`
add more error functions 2015-02-26 15:49:24 +00:00			`data["Content"] = template.HTML("<br>The method you have requested Not Allowed." +`
			`"<br>Perhaps you are here because:" +`
			`"<br><br><ul>" +`
			`"<br>The method specified in the Request-Line is not allowed for the resource identified by the Request-URI" +`
			`"<br>The response MUST include an Allow header containing a list of valid methods for the requested resource." +`
change a log about new version 2013-09-09 16:00:11 +00:00			`"</ul>")`
			`t.Execute(rw, data)`
			`}`

add comments for middleware packages, fix typo error 2014-01-17 08:03:01 +00:00			`// show 500 internal server error.`
add more error functions 2015-02-26 15:49:24 +00:00			`func internalServerError(rw http.ResponseWriter, r *http.Request) {`
change a log about new version 2013-09-09 16:00:11 +00:00			`t, _ := template.New("beegoerrortemp").Parse(errtpl)`
simplify docs.go and error.go, use http.StatusText instead of string codes 2015-12-21 09:16:58 +00:00			`data := map[string]interface{}{`
			`"Title": http.StatusText(500),`
			`"BeegoVersion": VERSION,`
			`}`
Improved the language on the error pages 2014-01-02 14:53:09 +00:00			`data["Content"] = template.HTML("<br>The page you have requested is down right now." +`
change a log about new version 2013-09-09 16:00:11 +00:00			`"<br><br><ul>" +`
Improved the language on the error pages 2014-01-02 14:53:09 +00:00			`"<br>Please try again later and report the error to the website administrator" +`
			`"<br></ul>")`
change a log about new version 2013-09-09 16:00:11 +00:00			`t.Execute(rw, data)`
			`}`

add more error functions 2015-02-26 15:49:24 +00:00			`// show 501 Not Implemented.`
			`func notImplemented(rw http.ResponseWriter, r *http.Request) {`
			`t, _ := template.New("beegoerrortemp").Parse(errtpl)`
simplify docs.go and error.go, use http.StatusText instead of string codes 2015-12-21 09:16:58 +00:00			`data := map[string]interface{}{`
			`"Title": http.StatusText(504),`
			`"BeegoVersion": VERSION,`
			`}`
add more error functions 2015-02-26 15:49:24 +00:00			`data["Content"] = template.HTML("<br>The page you have requested is Not Implemented." +`
			`"<br><br><ul>" +`
			`"<br>Please try again later and report the error to the website administrator" +`
			`"<br></ul>")`
			`t.Execute(rw, data)`
			`}`

			`// show 502 Bad Gateway.`
			`func badGateway(rw http.ResponseWriter, r *http.Request) {`
			`t, _ := template.New("beegoerrortemp").Parse(errtpl)`
simplify docs.go and error.go, use http.StatusText instead of string codes 2015-12-21 09:16:58 +00:00			`data := map[string]interface{}{`
			`"Title": http.StatusText(502),`
			`"BeegoVersion": VERSION,`
			`}`
add more error functions 2015-02-26 15:49:24 +00:00			`data["Content"] = template.HTML("<br>The page you have requested is down right now." +`
			`"<br><br><ul>" +`
			`"<br>The server, while acting as a gateway or proxy, received an invalid response from the upstream server it accessed in attempting to fulfill the request." +`
			`"<br>Please try again later and report the error to the website administrator" +`
			`"<br></ul>")`
			`t.Execute(rw, data)`
			`}`

			`// show 503 service unavailable error.`
			`func serviceUnavailable(rw http.ResponseWriter, r *http.Request) {`
			`t, _ := template.New("beegoerrortemp").Parse(errtpl)`
simplify docs.go and error.go, use http.StatusText instead of string codes 2015-12-21 09:16:58 +00:00			`data := map[string]interface{}{`
			`"Title": http.StatusText(503),`
			`"BeegoVersion": VERSION,`
			`}`
add more error functions 2015-02-26 15:49:24 +00:00			`data["Content"] = template.HTML("<br>The page you have requested is unavailable." +`
			`"<br>Perhaps you are here because:" +`
			`"<br><br><ul>" +`
			`"<br><br>The page is overloaded" +`
			`"<br>Please try again later." +`
			`"</ul>")`
			`t.Execute(rw, data)`
			`}`

			`// show 504 Gateway Timeout.`
			`func gatewayTimeout(rw http.ResponseWriter, r *http.Request) {`
			`t, _ := template.New("beegoerrortemp").Parse(errtpl)`
simplify docs.go and error.go, use http.StatusText instead of string codes 2015-12-21 09:16:58 +00:00			`data := map[string]interface{}{`
			`"Title": http.StatusText(504),`
			`"BeegoVersion": VERSION,`
			`}`
add more error functions 2015-02-26 15:49:24 +00:00			`data["Content"] = template.HTML("<br>The page you have requested is unavailable." +`
			`"<br>Perhaps you are here because:" +`
			`"<br><br><ul>" +`
			`"<br><br>The server, while acting as a gateway or proxy, did not receive a timely response from the upstream server specified by the URI." +`
			`"<br>Please try again later." +`
			`"</ul>")`
			`t.Execute(rw, data)`
Restore SimpleServerError method 2013-12-06 05:44:54 +00:00			`}`

error support controller 2015-02-26 15:34:43 +00:00			`// ErrorHandler registers http.HandlerFunc to each http err code string.`
			`// usage:`
			`// beego.ErrorHandler("404",NotFound)`
			`// beego.ErrorHandler("500",InternalServerError)`
make golint happy 2015-09-08 13:41:38 +00:00			`func ErrorHandler(code string, h http.HandlerFunc) *App {`
simplify docs.go and error.go, use http.StatusText instead of string codes 2015-12-21 09:16:58 +00:00			`ErrorMaps[code] = &errorInfo{`
			`errorType: errorTypeHandler,`
			`handler: h,`
			`method: code,`
			`}`
error support controller 2015-02-26 15:34:43 +00:00			`return BeeApp`
			`}`

			`// ErrorController registers ControllerInterface to each http err code string.`
			`// usage:`
make golint happy 2015-09-08 13:41:38 +00:00			`// beego.ErrorController(&controllers.ErrorController{})`
error support controller 2015-02-26 15:34:43 +00:00			`func ErrorController(c ControllerInterface) *App {`
			`reflectVal := reflect.ValueOf(c)`
			`rt := reflectVal.Type()`
			`ct := reflect.Indirect(reflectVal).Type()`
			`for i := 0; i < rt.NumMethod(); i++ {`
method name refactor 2015-09-18 09:59:28 +00:00			`methodName := rt.Method(i).Name`
			`if !utils.InSlice(methodName, exceptMethod) && strings.HasPrefix(methodName, "Error") {`
			`errName := strings.TrimPrefix(methodName, "Error")`
simplify docs.go and error.go, use http.StatusText instead of string codes 2015-12-21 09:16:58 +00:00			`ErrorMaps[errName] = &errorInfo{`
			`errorType: errorTypeController,`
			`controllerType: ct,`
			`method: methodName,`
			`}`
error support controller 2015-02-26 15:34:43 +00:00			`}`
			`}`
			`return BeeApp`
			`}`

add comments for middleware packages, fix typo error 2014-01-17 08:03:01 +00:00			`// show error string as simple text message.`
error map refactor 2015-09-17 02:33:12 +00:00			`// if error string is empty, show 503 or 500 error as default.`
			`func exception(errCode string, ctx *context.Context) {`
default atoi func to handle exception 2015-09-18 09:03:00 +00:00			`atoi := func(code string) int {`
			`v, err := strconv.Atoi(code)`
			`if err == nil {`
			`return v`
default exception handler 2015-09-18 02:31:10 +00:00			`}`
default atoi func to handle exception 2015-09-18 09:03:00 +00:00			`return 503`
			`}`

			`for _, ec := range []string{errCode, "503", "500"} {`
error map refactor 2015-09-17 02:33:12 +00:00			`if h, ok := ErrorMaps[ec]; ok {`
default atoi func to handle exception 2015-09-18 09:03:00 +00:00			`executeError(h, ctx, atoi(ec))`
error map refactor 2015-09-17 02:33:12 +00:00			`return`
			`}`
update middleware & beego's error 2013-09-11 09:00:39 +00:00			`}`
error map refactor 2015-09-17 02:33:12 +00:00			`//if 50x error has been removed from errorMap`
default atoi func to handle exception 2015-09-18 09:03:00 +00:00			`ctx.ResponseWriter.WriteHeader(atoi(errCode))`
error map refactor 2015-09-17 02:33:12 +00:00			`ctx.WriteString(errCode)`
error support controller 2015-02-26 15:34:43 +00:00			`}`

fix #1073 2015-03-30 12:35:57 +00:00			`func executeError(err errorInfo, ctx context.Context, code int) {`
error support controller 2015-02-26 15:34:43 +00:00			`if err.errorType == errorTypeHandler {`
			`err.handler(ctx.ResponseWriter, ctx.Request)`
			`return`
code simplify for package middleware 2015-02-23 03:50:13 +00:00			`}`
error support controller 2015-02-26 15:34:43 +00:00			`if err.errorType == errorTypeController {`
fix #1073 2015-03-30 12:35:57 +00:00			`ctx.Output.SetStatus(code)`
error support controller 2015-02-26 15:34:43 +00:00			`//Invoke the request handler`
			`vc := reflect.New(err.controllerType)`
			`execController, ok := vc.Interface().(ControllerInterface)`
			`if !ok {`
			`panic("controller is not ControllerInterface")`
			`}`
			`//call the controller init function`
			`execController.Init(ctx, err.controllerType.Name(), err.method, vc.Interface())`

			`//call prepare function`
			`execController.Prepare()`

			`execController.URLMapping()`

			`method := vc.MethodByName(err.method)`
simplify docs.go and error.go, use http.StatusText instead of string codes 2015-12-21 09:16:58 +00:00			`method.Call([]reflect.Value{})`
error support controller 2015-02-26 15:34:43 +00:00
			`//render template`
refact beego config 2015-12-09 15:35:04 +00:00			`if BConfig.WebConfig.AutoRender {`
fix #1073 2015-03-30 12:35:57 +00:00			`if err := execController.Render(); err != nil {`
			`panic(err)`
error support controller 2015-02-26 15:34:43 +00:00			`}`
			`}`

			`// finish all runrouter. release resource`
			`execController.Finish()`
code simplify for package middleware 2015-02-23 03:50:13 +00:00			`}`
update middleware & beego's error 2013-09-11 09:00:39 +00:00			`}`