func notFoundHandler(registry kit.Registry, r kit.Request) (kit.Response, bool) {
httpRequest := r.GetHttpRequest()
apiPrefix := "/" + registry.Config().UString("api.prefix", "api")
isApiRequest := strings.HasPrefix(httpRequest.URL.Path, apiPrefix)
// Try to render the page on the server, if enabled.
if !isApiRequest {
renderEnabled := registry.Config().UBool("serverRenderer.enabled", false)
noRender := strings.Contains(httpRequest.URL.String(), "no-server-render")
if renderEnabled && !noRender {
return serverRenderer(registry, r), false
}
}
// For non-api requests, render the default template.
if !isApiRequest {
tpl, err := getIndexTpl(registry)
if err != nil {
return kit.NewErrorResponse(err), false
}
return &kit.AppResponse{
RawData: tpl,
}, false
}
// For api requests, render the api not found error.
return &kit.AppResponse{
Error: &apperror.Err{
Code: "not_found",
Message: "This api route does not exist",
},
}, false
}
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 AuthenticationMiddleware(registry kit.Registry, r kit.Request) (kit.Response, bool) {
// Handle authentication.
httpRequest := r.GetHttpRequest()
userService := registry.UserService()
if userService == nil {
return nil, false
}
authHeader := httpRequest.Header.Get("Authentication")
if authHeader == "" {
return nil, false
}
// Check for basic auth.
if strings.HasPrefix(authHeader, "Basic ") {
str := authHeader[6:]
data, err := base64.StdEncoding.DecodeString(str)
if err != nil {
return kit.NewErrorResponse("invalid_basic_auth"), false
} else {
parts := strings.Split(string(data), ":")
if len(parts) == 2 {
userIdentifier := parts[0]
pw := parts[1]
user, err := userService.AuthenticateUser(userIdentifier, "password", map[string]interface{}{"password": pw})
if err != nil {
return kit.NewErrorResponse(err), false
}
r.SetUser(user)
return nil, false
}
}
}
// Check for auth token.
if authHeader != "" {
token := authHeader
user, session, err := userService.VerifySession(token)
if err == nil {
r.SetUser(user)
r.SetSession(session)
return nil, false
} else {
return kit.NewErrorResponse(err), false
}
}
return nil, false
}
func UnserializeRequestMiddleware(registry kit.Registry, request kit.Request) (kit.Response, bool) {
// Try to parse json in body. Ignore error since body might not contain json.
contentType := request.GetHttpRequest().Header.Get("Content-Type")
if strings.Contains(contentType, "json") {
// Only read the HTTP body automatically for json content type requests,
// since some handlers might need to read it themselfes (see the files package resource).
if err := request.ReadHttpBody(); err != nil {
return kit.NewErrorResponse(err, "http_body_read_error"), false
} else {
if request.GetRawData() != nil {
if err := request.ParseJsonData(); err != nil {
return kit.NewErrorResponse(err, "invalid_json_body", true), false
}
if request.GetData() != nil {
// Successfully parsed json body.
// Now try to unserialize.
// Determine serializer.
serializer := registry.DefaultSerializer()
// Check if a custom serializer was specified.
if name := request.GetContext().String("request-serializer"); name != "" {
serializer = registry.Serializer(name)
}
if serializer == nil {
return kit.NewErrorResponse("unknown_serializer", fmt.Sprintf("The specified request serializer does not exist")), false
} else {
if err := request.Unserialize(serializer); err != nil {
return kit.NewErrorResponse(err, "request_unserialize_error", true), false
}
}
}
}
}
}
return nil, false
}
func serverRenderer(registry kit.Registry, r kit.Request) kit.Response {
url := r.GetHttpRequest().URL
// Build the url to query.
if url.Scheme == "" {
url.Scheme = "http"
}
if url.Host == "" {
url.Host = registry.Config().UString("host", "localhost") + ":" + registry.Config().UString("port", "8000")
}
q := url.Query()
q.Set("no-server-render", "1")
url.RawQuery = q.Encode()
strUrl := url.String()
cacheKey := "serverrenderer_" + strUrl
cacheName := registry.Config().UString("serverRenderer.cache")
var cache kit.Cache
// If a cache is specified, try to retrieve it.
if cacheName != "" {
cache = registry.Cache(cacheName)
if cache == nil {
registry.Logger().Errorf("serverRenderer.cache is set to %v, but the cache is not registered with app", cacheName)
}
}
// If a cache was found, try to retrieve cached response.
if cache != nil {
item, err := cache.Get(cacheKey)
if err != nil {
registry.Logger().Errorf("serverRenderer: cache retrieval error: %v", err)
} else if item != nil {
// Cache item found, return response with cache item.
status, _ := strconv.ParseInt(item.GetTags()[0], 10, 64)
data, _ := item.ToString()
return &kit.AppResponse{
HttpStatus: int(status),
RawData: []byte(data),
}
}
}
// Either no cache or url not yet cached, so render it.
// First, ensure that the tmp directory exists.
tmpDir := path.Join(registry.Config().TmpDir(), "phantom")
if ok, _ := utils.FileExists(tmpDir); !ok {
if err := os.MkdirAll(tmpDir, 0777); err != nil {
return &kit.AppResponse{
Error: &apperror.Err{
Code: "create_tmp_dir_failed",
Message: fmt.Sprintf("Could not create the tmp directory at %v: %v", tmpDir, err),
},
}
}
}
// Build a unique file name.
filePath := path.Join(tmpDir, utils.UUIdv4()+".html")
// Execute phantom js.
// Find path of phantom script.
_, filename, _, _ := runtime.Caller(1)
scriptPath := path.Join(path.Dir(path.Dir(filename)), "phantom", "render.js")
start := time.Now()
phantomPath := registry.Config().UString("serverRenderer.phantomJsPath", "phantomjs")
args := []string{
"--web-security=false",
"--local-to-remote-url-access=true",
scriptPath,
"10",
strUrl,
filePath,
}
result, err := exec.Command(phantomPath, args...).CombinedOutput()
if err != nil {
registry.Logger().Errorf("Phantomjs execution error: %v", string(result))
return &kit.AppResponse{
Error: apperror.Wrap(err, "phantom_execution_failed"),
}
}
// Get time taken as milliseconds.
timeTaken := int(time.Now().Sub(start) / time.Millisecond)
registry.Logger().WithFields(log.Fields{
"action": "phantomjs_render",
"milliseconds": timeTaken,
}).Debugf("Rendered url %v with phantomjs", url)
content, err2 := utils.ReadFile(filePath)
if err2 != nil {
return kit.NewErrorResponse(err2)
}
// Find http status code.
status := 200
res := regexp.MustCompile("http_status_code\\=(\\d+)").FindStringSubmatch(string(content))
if res != nil {
s, _ := strconv.ParseInt(res[1], 10, 64)
status = int(s)
}
// Save to cache.
if cache != nil {
lifetime := registry.Config().UInt("serverRenderer.cacheLiftetime", 3600)
err := cache.Set(&caches.StrItem{
Key: cacheKey,
Value: string(content),
Tags: []string{strconv.FormatInt(int64(status), 10)},
ExpiresAt: time.Now().Add(time.Duration(lifetime) * time.Second),
})
if err != nil {
registry.Logger().Errorf("serverRenderer: Cache persist error: %v", err)
}
}
return &kit.AppResponse{
HttpStatus: status,
RawData: content,
}
}