Milo: Add themed page for errors

milo/appengine/settings/themes.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package settings
 
 import (
         "fmt"
         "io"
         "net/http"
@@ skipping 65 matching lines @@
 // passed to all templates.
 func GetTemplateBundles() []NamedBundle {
         result := []NamedBundle{}
         for name, t := range Themes {
                 if t.IsTemplate {
                         templateBundle := &templates.Bundle{
                                 Loader:          templates.FileSystemLoader(path.Join("templates", name)),
                                 DefaultTemplate: name,
                                 DebugMode:       info.IsDevAppServer,
                                 DefaultArgs: func(c context.Context) (templates.Args, error) {
-                                        loginURL, err := auth.LoginURL(c, "/")
+                                        r := getRequest(c)
+                                        path := r.URL.Path
+                                        loginURL, err := auth.LoginURL(c, path)
                                         if err != nil {
                                                 return nil, err
                                         }
-                                        logoutURL, err := auth.LogoutURL(c, "/")
+                                        logoutURL, err := auth.LogoutURL(c, path)
                                         if err != nil {
                                                 return nil, err
                                         }
                                         if err != nil {
                                                 return nil, err
                                         }
                                         return templates.Args{
                                                 "AppVersion":  strings.Split(info.VersionID(c), ".")[0],
                                                 "IsAnonymous": auth.CurrentIdentity(c) == "anonymous:anonymous",
                                                 "User":        auth.CurrentUser(c),
                                                 "LoginURL":    loginURL,
                                                 "LogoutURL":   logoutURL,
                                                 "CurrentTime": clock.Now(c),
                                                 "Analytics":   analytics.Snippet(c),
+                                                "RequestID":   info.RequestID(c),
                                         }, nil
                                 },
                                 FuncMap: funcMap,
                         }
                         result = append(result, NamedBundle{name, templateBundle, &t})
                 }
         }
         return result
 }
 
@@ skipping 50 matching lines @@
 // Wrap adapts a ThemedHandler into a router.Handler. Of note, the
 // Render functions' interface into rendering is purely through a single
 // templates.Args value which gets rendered here, while the http.ResponseWriter
 // is stripped out.
 func Wrap(h ThemedHandler) router.Handler {
         return func(c *router.Context) {
                 // Figure out if we need to do the things.
                 theme := GetTheme(c.Context, c.Request)
                 template := h.GetTemplateName(theme)
 
+                // Inject the request into the context.
+                c.Context = WithRequest(c.Context, c.Request)
+
                 // Do the things.
                 args, err := h.Render(c.Context, c.Request, c.Params)
 
                 // Throw errors.
                 // TODO(hinoka): Add themes and templates for errors so they look better.
                 if err != nil {
-                        if merr, ok := err.(*miloerror.Error); ok {
-                                http.Error(c.Writer, merr.Message, merr.Code)
-                        } else {
-                                http.Error(c.Writer, err.Error(), http.StatusInternalServerError)
+                        msg := err.Error()
+                        code := http.StatusInternalServerError
+                        if merr, ok := err.(miloerror.Error); ok {
+                                msg = merr.Message
+                                code = merr.Code
                         }
+                        c.Writer.WriteHeader(code)
+                        name := "pages/error.html"
+                        themedMustRender(c.Context, c.Writer, theme.Name, name, templates.Args{
+                                "Code":    code,
+                                "Message": msg,
+                        })
                         return
                 }
 
                 // Render the stuff.
                 name := fmt.Sprintf("pages/%s", template)
                 themedMustRender(c.Context, c.Writer, theme.Name, name, *args)
         }
 }
+
+// The context key
+var requestKey = "http.request"
+
+func WithRequest(c context.Context, r *http.Request) context.Context {
+        return context.WithValue(c, &requestKey, r)
+}
+
+func getRequest(c context.Context) *http.Request {
+        if req, ok := c.Value(&requestKey).(*http.Request); ok {
+                return req
+        }
+        panic("No http.request found in context")
+}