[milo] Refactor all html knowledge out of backends.

milo/common/error.go

 // Copyright 2015 The LUCI Authors.
 //
 // 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 common
 
 import (
-        "github.com/luci/luci-go/server/router"
-        "github.com/luci/luci-go/server/templates"
+        "net/http"
+
+        "github.com/luci/luci-go/common/errors"
 )
 
-// ErrorPage writes an error page into c.Writer with an http code "code"
-// and custom message.
-func ErrorPage(c *router.Context, code int, message string) {
-        c.Writer.WriteHeader(code)
-        templates.MustRender(c.Context, c.Writer, "pages/error.html", templates.Args{
-                "Code":    code,
-                "Message": message,
-        })
+// ErrorCode represents milo's internal error code system. The subsystems in
+// milo can attach an ErrorCode to an error (using ErrorTag), and then the html
+// and grpc frontends know how to render the error in a way that will help the
+// user.
+type ErrorCode int
+
+const (
+        // CodeUnknown means an error happened, but we weren't able to classify it.
+        CodeUnknown ErrorCode = iota
+
+        // CodeUnauthorized occurs when a user isn't logged in, but needs to be to
+        // proceed further.
+        CodeUnauthorized
+
+        // CodeNoAccess occurs when the currently logged-in user is not permitted to
+        // see the resource.
+        CodeNoAccess
+
+        // CodeNotFound occurs when we weren't able to find the build that the
+        // user asked for.
+        CodeNotFound
+
+        // CodeParameterError occurs when one or more of the user-provided parameters
+        // was malformed.
+        CodeParameterError
+)
+
+var httpCode = map[ErrorCode]int{
+        CodeUnauthorized:   http.StatusUnauthorized,
+        CodeNoAccess:       http.StatusForbidden,
+        CodeNotFound:       http.StatusNotFound,
+        CodeParameterError: http.StatusBadRequest,
 }
+
+// HTTPStatus returns an HTTP Status code corresponding to this ErrorCode.
+func (c ErrorCode) HTTPStatus() int {
+        if ret, ok := httpCode[c]; ok {
+                return ret
+        }
+        return http.StatusInternalServerError
+}
+
+// Tag returns an errors.TagValue for this code.
+func (c ErrorCode) Tag() errors.TagValue {
+        return ErrorTag.With(c)
+}
+
+// GenerateErrorTagValue implements errors.TagValueGenerator so that ErrorCodes
+// can be used like:
+//   errors.Annotate(err).Tag(CodeNotFound)
+//   errors.New("terrible thing", CodeNotFound)
+func (c ErrorCode) GenerateErrorTagValue() errors.TagValue {
+        return ErrorTag.With(c)
+}
+
+type errorTag struct{ Key errors.TagKey }
+
+func (t *errorTag) In(err error) ErrorCode {
+        v, ok := errors.TagValueIn(t.Key, err)
+        if ok {
+                return v.(ErrorCode)
+        }
+        return CodeUnknown
+}
+
+func (t *errorTag) With(value ErrorCode) errors.TagValue {
+        return errors.TagValue{Key: t.Key, Value: value}
+}
+
+// ErrorTag should be used to tag errors in the milo ecosystem to categorize
+// them so they can be rendered properly in the frontend.
+var ErrorTag = errorTag{errors.NewTagKey("holds a milo ErrorCode")}