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 := make(map[string]string)
	data["AppError"] = AppName + ":" + fmt.Sprint(err)
	data["RequestMethod"] = ctx.Input.Method()
	data["RequestURL"] = ctx.Input.Uri()
	data["RemoteAddr"] = ctx.Input.IP()
	data["Stack"] = Stack
	data["BeegoVersion"] = VERSION
	data["GoVersion"] = runtime.Version()
	ctx.Output.SetStatus(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
}

// map of http handlers for each error string.
var ErrorMaps map[string]*errorInfo

func init() {
	ErrorMaps = make(map[string]*errorInfo)
}

// show 401 unauthorized error.
func unauthorized(rw http.ResponseWriter, r *http.Request) {
	t, _ := template.New("beegoerrortemp").Parse(errtpl)
	data := make(map[string]interface{})
	data["Title"] = "Unauthorized"
	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>")
	data["BeegoVersion"] = VERSION
	t.Execute(rw, data)
}

// show 402 Payment Required
func paymentRequired(rw http.ResponseWriter, r *http.Request) {
	t, _ := template.New("beegoerrortemp").Parse(errtpl)
	data := make(map[string]interface{})
	data["Title"] = "Payment Required"
	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>")
	data["BeegoVersion"] = VERSION
	t.Execute(rw, data)
}

// show 403 forbidden error.
func forbidden(rw http.ResponseWriter, r *http.Request) {
	t, _ := template.New("beegoerrortemp").Parse(errtpl)
	data := make(map[string]interface{})
	data["Title"] = "Forbidden"
	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>")
	data["BeegoVersion"] = VERSION
	t.Execute(rw, data)
}

// show 404 notfound error.
func notFound(rw http.ResponseWriter, r *http.Request) {
	t, _ := template.New("beegoerrortemp").Parse(errtpl)
	data := make(map[string]interface{})
	data["Title"] = "Page Not Found"
	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>")
	data["BeegoVersion"] = VERSION
	t.Execute(rw, data)
}

// show 405 Method Not Allowed
func methodNotAllowed(rw http.ResponseWriter, r *http.Request) {
	t, _ := template.New("beegoerrortemp").Parse(errtpl)
	data := make(map[string]interface{})
	data["Title"] = "Method Not Allowed"
	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>")
	data["BeegoVersion"] = VERSION
	t.Execute(rw, data)
}

// show 500 internal server error.
func internalServerError(rw http.ResponseWriter, r *http.Request) {
	t, _ := template.New("beegoerrortemp").Parse(errtpl)
	data := make(map[string]interface{})
	data["Title"] = "Internal Server Error"
	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>")
	data["BeegoVersion"] = VERSION
	t.Execute(rw, data)
}

// show 501 Not Implemented.
func notImplemented(rw http.ResponseWriter, r *http.Request) {
	t, _ := template.New("beegoerrortemp").Parse(errtpl)
	data := make(map[string]interface{})
	data["Title"] = "Not Implemented"
	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>")
	data["BeegoVersion"] = VERSION
	t.Execute(rw, data)
}

// show 502 Bad Gateway.
func badGateway(rw http.ResponseWriter, r *http.Request) {
	t, _ := template.New("beegoerrortemp").Parse(errtpl)
	data := make(map[string]interface{})
	data["Title"] = "Bad Gateway"
	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>")
	data["BeegoVersion"] = VERSION
	t.Execute(rw, data)
}

// show 503 service unavailable error.
func serviceUnavailable(rw http.ResponseWriter, r *http.Request) {
	t, _ := template.New("beegoerrortemp").Parse(errtpl)
	data := make(map[string]interface{})
	data["Title"] = "Service Unavailable"
	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>")
	data["BeegoVersion"] = VERSION
	t.Execute(rw, data)
}

// show 504 Gateway Timeout.
func gatewayTimeout(rw http.ResponseWriter, r *http.Request) {
	t, _ := template.New("beegoerrortemp").Parse(errtpl)
	data := make(map[string]interface{})
	data["Title"] = "Gateway Timeout"
	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>")
	data["BeegoVersion"] = VERSION
	t.Execute(rw, data)
}

// register default error http handlers, 404,401,403,500 and 503.
func registerDefaultErrorHandler() {
	if _, ok := ErrorMaps["401"]; !ok {
		Errorhandler("401", unauthorized)
	}

	if _, ok := ErrorMaps["402"]; !ok {
		Errorhandler("402", paymentRequired)
	}

	if _, ok := ErrorMaps["403"]; !ok {
		Errorhandler("403", forbidden)
	}

	if _, ok := ErrorMaps["404"]; !ok {
		Errorhandler("404", notFound)
	}

	if _, ok := ErrorMaps["405"]; !ok {
		Errorhandler("405", methodNotAllowed)
	}

	if _, ok := ErrorMaps["500"]; !ok {
		Errorhandler("500", internalServerError)
	}
	if _, ok := ErrorMaps["501"]; !ok {
		Errorhandler("501", notImplemented)
	}
	if _, ok := ErrorMaps["502"]; !ok {
		Errorhandler("502", badGateway)
	}

	if _, ok := ErrorMaps["503"]; !ok {
		Errorhandler("503", serviceUnavailable)
	}

	if _, ok := ErrorMaps["504"]; !ok {
		Errorhandler("504", gatewayTimeout)
	}
}

// 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 {
	errinfo := &errorInfo{}
	errinfo.errorType = errorTypeHandler
	errinfo.handler = h
	errinfo.method = code
	ErrorMaps[code] = errinfo
	return BeeApp
}

// ErrorController registers ControllerInterface to each http err code string.
// usage:
// 	beego.ErrorHandler(&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++ {
		if !utils.InSlice(rt.Method(i).Name, exceptMethod) && strings.HasPrefix(rt.Method(i).Name, "Error") {
			errinfo := &errorInfo{}
			errinfo.errorType = errorTypeController
			errinfo.controllerType = ct
			errinfo.method = rt.Method(i).Name
			errname := strings.TrimPrefix(rt.Method(i).Name, "Error")
			ErrorMaps[errname] = errinfo
		}
	}
	return BeeApp
}

// show error string as simple text message.
// if error string is empty, show 500 error as default.
func exception(errcode string, ctx *context.Context) {
	code, err := strconv.Atoi(errcode)
	if err != nil {
		code = 503
	}
	ctx.ResponseWriter.WriteHeader(code)
	if h, ok := ErrorMaps[errcode]; ok {
		executeError(h, ctx)
		return
	} else if h, ok := ErrorMaps["503"]; ok {
		executeError(h, ctx)
		return
	} else {
		ctx.WriteString(errcode)
	}
}

func executeError(err *errorInfo, ctx *context.Context) {
	if err.errorType == errorTypeHandler {
		err.handler(ctx.ResponseWriter, ctx.Request)
		return
	}
	if err.errorType == errorTypeController {
		//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()

		in := make([]reflect.Value, 0)
		method := vc.MethodByName(err.method)
		method.Call(in)

		//render template
		if ctx.Output.Status == 0 {
			if 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.`
error support controller 2015-02-26 15:34:43 +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)`
			`data := make(map[string]string)`
			`data["AppError"] = AppName + ":" + fmt.Sprint(err)`
error support controller 2015-02-26 15:34:43 +00:00			`data["RequestMethod"] = ctx.Input.Method()`
			`data["RequestURL"] = ctx.Input.Uri()`
			`data["RemoteAddr"] = ctx.Input.IP()`
change a log about new version 2013-09-09 16:00:11 +00:00			`data["Stack"] = Stack`
			`data["BeegoVersion"] = VERSION`
			`data["GoVersion"] = runtime.Version()`
error support controller 2015-02-26 15:34:43 +00:00			`ctx.Output.SetStatus(500)`
			`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`
			`}`

add comments for middleware packages, fix typo error 2014-01-17 08:03:01 +00:00			`// map of http handlers for each error string.`
error support controller 2015-02-26 15:34:43 +00:00			`var ErrorMaps map[string]*errorInfo`
change a log about new version 2013-09-09 16:00:11 +00:00
			`func init() {`
error support controller 2015-02-26 15:34:43 +00:00			`ErrorMaps = make(map[string]*errorInfo)`
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)`
			`data := make(map[string]interface{})`
add more error functions 2015-02-26 15:49:24 +00:00			`data["Title"] = "Unauthorized"`
			`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>")`
			`data["BeegoVersion"] = VERSION`
			`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)`
			`data := make(map[string]interface{})`
add more error functions 2015-02-26 15:49:24 +00:00			`data["Title"] = "Payment Required"`
			`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>")`
			`data["BeegoVersion"] = VERSION`
			`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)`
			`data := make(map[string]interface{})`
			`data["Title"] = "Forbidden"`
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>")`
			`data["BeegoVersion"] = VERSION`
			`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)`
			`data := make(map[string]interface{})`
add more error functions 2015-02-26 15:49:24 +00:00			`data["Title"] = "Page Not Found"`
			`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>")`
			`data["BeegoVersion"] = VERSION`
			`t.Execute(rw, data)`
			`}`

			`// show 405 Method Not Allowed`
			`func methodNotAllowed(rw http.ResponseWriter, r *http.Request) {`
			`t, _ := template.New("beegoerrortemp").Parse(errtpl)`
			`data := make(map[string]interface{})`
			`data["Title"] = "Method Not Allowed"`
			`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>")`
			`data["BeegoVersion"] = VERSION`
			`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)`
			`data := make(map[string]interface{})`
			`data["Title"] = "Internal Server Error"`
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			`data["BeegoVersion"] = VERSION`
			`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)`
			`data := make(map[string]interface{})`
			`data["Title"] = "Not Implemented"`
			`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>")`
			`data["BeegoVersion"] = VERSION`
			`t.Execute(rw, data)`
			`}`

			`// show 502 Bad Gateway.`
			`func badGateway(rw http.ResponseWriter, r *http.Request) {`
			`t, _ := template.New("beegoerrortemp").Parse(errtpl)`
			`data := make(map[string]interface{})`
			`data["Title"] = "Bad Gateway"`
			`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>")`
			`data["BeegoVersion"] = VERSION`
			`t.Execute(rw, data)`
			`}`

			`// show 503 service unavailable error.`
			`func serviceUnavailable(rw http.ResponseWriter, r *http.Request) {`
			`t, _ := template.New("beegoerrortemp").Parse(errtpl)`
			`data := make(map[string]interface{})`
			`data["Title"] = "Service Unavailable"`
			`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>")`
			`data["BeegoVersion"] = VERSION`
			`t.Execute(rw, data)`
			`}`

			`// show 504 Gateway Timeout.`
			`func gatewayTimeout(rw http.ResponseWriter, r *http.Request) {`
			`t, _ := template.New("beegoerrortemp").Parse(errtpl)`
			`data := make(map[string]interface{})`
			`data["Title"] = "Gateway Timeout"`
			`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>")`
			`data["BeegoVersion"] = VERSION`
			`t.Execute(rw, data)`
Restore SimpleServerError method 2013-12-06 05:44:54 +00:00			`}`

add comments for middleware packages, fix typo error 2014-01-17 08:03:01 +00:00			`// register default error http handlers, 404,401,403,500 and 503.`
error support controller 2015-02-26 15:34:43 +00:00			`func registerDefaultErrorHandler() {`
add more error functions 2015-02-26 15:49:24 +00:00			`if _, ok := ErrorMaps["401"]; !ok {`
			`Errorhandler("401", unauthorized)`
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			`if _, ok := ErrorMaps["402"]; !ok {`
			`Errorhandler("402", paymentRequired)`
change a log about new version 2013-09-09 16:00:11 +00:00			`}`

			`if _, ok := ErrorMaps["403"]; !ok {`
add more error functions 2015-02-26 15:49:24 +00:00			`Errorhandler("403", forbidden)`
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			`if _, ok := ErrorMaps["404"]; !ok {`
			`Errorhandler("404", notFound)`
			`}`

			`if _, ok := ErrorMaps["405"]; !ok {`
			`Errorhandler("405", methodNotAllowed)`
change a log about new version 2013-09-09 16:00:11 +00:00			`}`

			`if _, ok := ErrorMaps["500"]; !ok {`
add more error functions 2015-02-26 15:49:24 +00:00			`Errorhandler("500", internalServerError)`
			`}`
			`if _, ok := ErrorMaps["501"]; !ok {`
			`Errorhandler("501", notImplemented)`
			`}`
			`if _, ok := ErrorMaps["502"]; !ok {`
			`Errorhandler("502", badGateway)`
			`}`

			`if _, ok := ErrorMaps["503"]; !ok {`
			`Errorhandler("503", serviceUnavailable)`
			`}`

			`if _, ok := ErrorMaps["504"]; !ok {`
			`Errorhandler("504", gatewayTimeout)`
change a log about new version 2013-09-09 16:00:11 +00:00			`}`
			`}`
update middleware & beego's error 2013-09-11 09:00:39 +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)`
			`func Errorhandler(code string, h http.HandlerFunc) *App {`
			`errinfo := &errorInfo{}`
			`errinfo.errorType = errorTypeHandler`
			`errinfo.handler = h`
			`errinfo.method = code`
			`ErrorMaps[code] = errinfo`
			`return BeeApp`
			`}`

			`// ErrorController registers ControllerInterface to each http err code string.`
			`// usage:`
			`// beego.ErrorHandler(&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++ {`
			`if !utils.InSlice(rt.Method(i).Name, exceptMethod) && strings.HasPrefix(rt.Method(i).Name, "Error") {`
			`errinfo := &errorInfo{}`
			`errinfo.errorType = errorTypeController`
			`errinfo.controllerType = ct`
			`errinfo.method = rt.Method(i).Name`
			`errname := strings.TrimPrefix(rt.Method(i).Name, "Error")`
			`ErrorMaps[errname] = errinfo`
			`}`
			`}`
			`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.`
			`// if error string is empty, show 500 error as default.`
error support controller 2015-02-26 15:34:43 +00:00			`func exception(errcode string, ctx *context.Context) {`
			`code, err := strconv.Atoi(errcode)`
			`if err != nil {`
			`code = 503`
			`}`
			`ctx.ResponseWriter.WriteHeader(code)`
update middleware & beego's error 2013-09-11 09:00:39 +00:00			`if h, ok := ErrorMaps[errcode]; ok {`
error support controller 2015-02-26 15:34:43 +00:00			`executeError(h, ctx)`
			`return`
			`} else if h, ok := ErrorMaps["503"]; ok {`
			`executeError(h, ctx)`
update middleware & beego's error 2013-09-11 09:00:39 +00:00			`return`
error support controller 2015-02-26 15:34:43 +00:00			`} else {`
			`ctx.WriteString(errcode)`
update middleware & beego's error 2013-09-11 09:00:39 +00:00			`}`
error support controller 2015-02-26 15:34:43 +00:00			`}`

			`func executeError(err errorInfo, ctx context.Context) {`
			`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 {`
			`//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()`

			`in := make([]reflect.Value, 0)`
			`method := vc.MethodByName(err.method)`
			`method.Call(in)`

			`//render template`
			`if ctx.Output.Status == 0 {`
			`if AutoRender {`
			`if err := execController.Render(); err != nil {`
			`panic(err)`
			`}`
			`}`
			`}`

			`// 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			`}`