[milo] Refactor all html knowledge out of backends.

milo/buildsource/buildbot/grpc.go

 // Copyright 2016 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,
@@ skipping 10 matching lines @@
 
         "golang.org/x/net/context"
         "google.golang.org/grpc"
         "google.golang.org/grpc/codes"
 
         "github.com/golang/protobuf/ptypes/timestamp"
         "github.com/luci/gae/service/datastore"
         "github.com/luci/luci-go/common/iotools"
         "github.com/luci/luci-go/common/logging"
         milo "github.com/luci/luci-go/milo/api/proto"
+        "github.com/luci/luci-go/milo/common"
         "github.com/luci/luci-go/server/auth"
 )
 
 // Service is a service implementation that displays BuildBot builds.
 type Service struct{}
 
 var errNotFoundGRPC = grpc.Errorf(codes.NotFound, "Master Not Found")
 
 // GetBuildbotBuildJSON implements milo.BuildbotServer.
 func (s *Service) GetBuildbotBuildJSON(c context.Context, req *milo.BuildbotBuildRequest) (
         *milo.BuildbotBuildJSON, error) {
 
         if req.Master == "" {
                 return nil, grpc.Errorf(codes.InvalidArgument, "No master specified")
         }
         if req.Builder == "" {
                 return nil, grpc.Errorf(codes.InvalidArgument, "No builder specified")
         }
 
         cu := auth.CurrentUser(c)
         logging.Debugf(c, "%s is requesting %s/%s/%d",
                 cu.Identity, req.Master, req.Builder, req.BuildNum)
 
         b, err := getBuild(c, req.Master, req.Builder, int(req.BuildNum))
-        switch {
-        case err == errBuildNotFound:
-                return nil, grpc.Errorf(codes.NotFound, "Build not found")
-        case err == errNotAuth:
-                return nil, grpc.Errorf(codes.Unauthenticated, "Unauthenticated request")
-        case err != nil:
-                return nil, err
+        if err != nil {
+                switch common.ErrorTag.In(err) {
+                case common.CodeNotFound:
+                        return nil, grpc.Errorf(codes.NotFound, "Build not found")
+                case common.CodeUnauthorized:
+                        return nil, grpc.Errorf(codes.Unauthenticated, "Unauthenticated request")
+                default:
+                        return nil, err
+                }
         }
 
         updatePostProcessBuild(b)
         bs, err := json.Marshal(b)
         if err != nil {
                 return nil, err
         }
 
         // Marshal the build back into JSON format.
         return &milo.BuildbotBuildJSON{Data: bs}, nil
@@ skipping 12 matching lines @@
 
         limit := req.Limit
         if limit == 0 {
                 limit = 20
         }
 
         cu := auth.CurrentUser(c)
         logging.Debugf(c, "%s is requesting %s/%s (limit %d, cursor %s)",
                 cu.Identity, req.Master, req.Builder, limit, req.Cursor)
 
-        // Perform an ACL check by fetching the master.
-        _, err := getMasterEntry(c, req.Master)
-        switch {
-        case err == errMasterNotFound:
-                return nil, grpc.Errorf(codes.NotFound, "Master not found")
-        case err == errNotAuth:
-                return nil, grpc.Errorf(codes.Unauthenticated, "Unauthenticated request")
-        case err != nil:
-                return nil, err
+        if err := canAccessMaster(c, req.Master); err != nil {
+                switch common.ErrorTag.In(err) {
+                case common.CodeNotFound:
+                        return nil, grpc.Errorf(codes.NotFound, "Master not found")
+                case common.CodeUnauthorized:
+                        return nil, grpc.Errorf(codes.Unauthenticated, "Unauthenticated request")
+                default:
+                        return nil, err
+                }
         }
 
         q := datastore.NewQuery("buildbotBuild")
         q = q.Eq("master", req.Master).
                 Eq("builder", req.Builder).
                 Limit(limit).
                 Order("-number")
         if req.IncludeCurrent == false {
                 q = q.Eq("finished", true)
         }
@@ skipping 19 matching lines @@
                 bs, err := json.Marshal(b)
                 if err != nil {
                         return nil, err
                 }
                 results[i] = &milo.BuildbotBuildJSON{Data: bs}
         }
         buildsJSON := &milo.BuildbotBuildsJSON{
                 Builds: results,
         }
         if nextCursor != nil {
-                buildsJSON.Cursor = (*nextCursor).String()
+                buildsJSON.Cursor = nextCursor.String()
         }
         return buildsJSON, nil
 }
 
 // GetCompressedMasterJSON assembles a CompressedMasterJSON object from the
 // provided MasterRequest.
 func (s *Service) GetCompressedMasterJSON(c context.Context, req *milo.MasterRequest) (
         *milo.CompressedMasterJSON, error) {
 
         if req.Name == "" {
                 return nil, grpc.Errorf(codes.InvalidArgument, "No master specified")
         }
 
         cu := auth.CurrentUser(c)
         logging.Debugf(c, "%s is making a master request for %s", cu.Identity, req.Name)
 
         entry, err := getMasterEntry(c, req.Name)
-        switch {
-        case err == errMasterNotFound:
-                return nil, errNotFoundGRPC
-        case err == errNotAuth:
-                return nil, grpc.Errorf(codes.Unauthenticated, "Unauthenticated request")
-        case err != nil:
-                return nil, err
+        if err != nil {
+                switch common.ErrorTag.In(err) {
+                case common.CodeNotFound:
+                        return nil, errNotFoundGRPC
+                case common.CodeUnauthorized:
+                        return nil, grpc.Errorf(codes.Unauthenticated, "Unauthenticated request")
+                default:
+                        return nil, err
+                }
         }
+
         // Decompress it so we can inject current build information.
         master := &buildbotMaster{}
         if err = decodeMasterEntry(c, entry, master); err != nil {
                 return nil, err
         }
         for _, slave := range master.Slaves {
                 numBuilds := 0
                 for _, builds := range slave.RunningbuildsMap {
                         numBuilds += len(builds)
                 }
@@ skipping 56 matching lines @@
 
         return &milo.CompressedMasterJSON{
                 Internal: entry.Internal,
                 Modified: &timestamp.Timestamp{
                         Seconds: entry.Modified.Unix(),
                         Nanos:   int32(entry.Modified.Nanosecond()),
                 },
                 Data: gzbs.Bytes(),
         }, nil
 }