func ServerErrorMiddleware(registry kit.Registry, r kit.Request, response kit.Response) (kit.Response, bool) {
err := response.GetError()
if err == nil {
return nil, false
}
status := 500
// If the error is an apperror, and it contains a status,
// set it as the http status of the response.
if apperr, ok := err.(apperror.Error); ok {
if apperr.GetStatus() != 0 {
status = apperr.GetStatus()
}
}
response.SetHttpStatus(status)
if response.GetRawData() != nil || response.GetRawDataReader() != nil {
return nil, false
}
httpRequest := r.GetHttpRequest()
apiPrefix := "/" + registry.Config().UString("api.prefix", "api")
isApiRequest := strings.HasPrefix(httpRequest.URL.Path, apiPrefix)
if isApiRequest {
return nil, false
}
data := map[string]interface{}{"errors": []error{response.GetError()}}
tpl := defaultErrorTpl()
tplPath := registry.Config().UString("frontend.errorTemplate")
if tplPath != "" {
t, err := template.ParseFiles(tplPath)
if err != nil {
registry.Logger().Fatalf("Could not parse error template at '%v': %v", tplPath, err)
} else {
tpl = t
}
}
var buffer *bytes.Buffer
if err := tpl.Execute(buffer, data); err != nil {
registry.Logger().Fatalf("Could not render error template: %v\n", err)
response.SetRawData([]byte("Server error"))
} else {
response.SetRawData(buffer.Bytes())
}
return nil, false
}
func processRequest(registry kit.Registry, request kit.Request, handler kit.RequestHandler) (kit.Response, bool) {
var response kit.Response
// Run before middlewares.
for _, middleware := range registry.HttpFrontend().BeforeMiddlewares() {
var skip bool
response, skip = middleware(registry, request)
if skip {
return nil, true
} else if response != nil {
break
}
}
// Only run the handler if no middleware provided a response.
if response == nil {
skip := false
response, skip = handler(registry, request)
if skip {
return nil, true
}
}
if response.GetHttpStatus() == 0 {
// Note: error handler middleware will set proper http status for error responses.
response.SetHttpStatus(200)
}
// Run after request middlewares.
// Note: error responses are converted with the serverErrrorMiddleware middleware.
// Note: serializing the response into the proper format is done with the SerializeResponseMiddleware.
for _, middleware := range registry.HttpFrontend().AfterMiddlewares() {
resp, skip := middleware(registry, request, response)
if skip {
return nil, true
} else if resp != nil {
response = resp
}
}
return response, false
}