Milo: Internal buildbot masters support

milo/appengine/buildbot/builder.go

 // Copyright 2016 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 buildbot
 
 import (
         "encoding/json"
         "fmt"
+        "net/http"
         "os"
         "sort"
         "strings"
         "time"
 
         "github.com/luci/gae/service/datastore"
 
         "github.com/luci/luci-go/common/clock"
-        log "github.com/luci/luci-go/common/logging"
+        "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/milo/api/resp"
+        "github.com/luci/luci-go/milo/appengine/settings"
+        "github.com/luci/luci-go/milo/common/miloerror"
         "golang.org/x/net/context"
 )
 
 // builderRef is used for keying specific builds in a master json.
 type builderRef struct {
         builder  string
         buildNum int
 }
 
 // buildMap contains all of the current build within a master json.  We use this
@@ skipping 25 matching lines @@
                         Started:  started,
                         Finished: finished,
                         Duration: duration,
                 },
                 Text:     b.Text,
                 Blame:    blame(b),
                 Revision: b.Sourcestamp.Revision,
         }
 }
 
-// getBuilds fetches all of the recent builds from the datastore.
+// getBuilds fetches all of the recent builds from the datastore.  Note that
+// getBuilds() does not perform ACL checks.
 func getBuilds(c context.Context, masterName, builderName string, finished bool) ([]*resp.BuildSummary, error) {
         // TODO(hinoka): Builder specific structs.
         result := []*resp.BuildSummary{}
         ds := datastore.Get(c)
         q := datastore.NewQuery("buildbotBuild")
         q = q.Eq("finished", finished)
         q = q.Eq("master", masterName)
         q = q.Eq("builder", builderName)
         q = q.Limit(25) // TODO(hinoka): This should be adjustable
         q = q.Order("-number")
         buildbots := []*buildbotBuild{}
         err := ds.GetAll(q, &buildbots)
         if err != nil {
                 return nil, err
         }
         for _, b := range buildbots {
                 result = append(result, getBuildSummary(b))
         }
         return result, nil
 }
 
 // getCurrentBuild extracts a build from a map of current builds, and translates
 // it into the milo version of the build.
 func getCurrentBuild(c context.Context, bMap buildMap, builder string, buildNum int) *resp.BuildSummary {
         b, ok := bMap[builderRef{builder, buildNum}]
         if !ok {
-                log.Warningf(c, "Could not find %s/%d in builder map:\n %s", builder, buildNum, bMap)
+                logging.Warningf(c, "Could not find %s/%d in builder map:\n %s", builder, buildNum, bMap)
                 return nil
         }
         return getBuildSummary(b)
 }
 
 // getCurrentBuilds extracts the list of all the current builds from a master json
 // from the slaves' runningBuilds portion.
 func getCurrentBuilds(c context.Context, master *buildbotMaster, builderName string) []*resp.BuildSummary {
         b := master.Builders[builderName]
         results := []*resp.BuildSummary{}
         bMap := createRunningBuildMap(master)
         for _, bn := range b.Currentbuilds {
                 cb := getCurrentBuild(c, bMap, builderName, bn)
                 if cb != nil {
                         results = append(results, cb)
                 }
         }
         return results
 }
 
+var errMasterNotFound = miloerror.Error{
+        Message: "Master not found",
+        Code:    http.StatusNotFound,
+}
+
 // builderImpl is the implementation for getting a milo builder page from buildbot.
 // This gets:
 // * Current Builds from querying the master json from the datastore.
 // * Recent Builds from a cron job that backfills the recent builds.
 func builderImpl(c context.Context, masterName, builderName string) (*resp.Builder, error) {
         result := &resp.Builder{}
         master, internal, t, err := getMasterJSON(c, masterName)
         if internal {
-                // TODO(hinoka): Implement ACL support and remove this.
-                return nil, fmt.Errorf("Internal masters are not yet supported.")
+                allowed, err := settings.IsAllowedInternal(c)
+                if err != nil {
+                        return nil, err
+                }
+                if !allowed {
+                        return nil, errMasterNotFound
+                }
         }
         if err != nil {
                 return nil, fmt.Errorf("Cannot find master %s\n%s", masterName, err.Error())
         }
         if clock.Now(c).Sub(t) > 2*time.Minute {
                 warning := fmt.Sprintf(
                         "WARNING: Master data is stale (last updated %s)", t)
-                log.Warningf(c, warning)
+                logging.Warningf(c, warning)
                 result.Warning = warning
         }
 
         s, _ := json.Marshal(master)
-        log.Debugf(c, "Master: %s", s)
+        logging.Debugf(c, "Master: %s", s)
 
         _, ok := master.Builders[builderName]
         if !ok {
                 // This long block is just to return a good error message when an invalid
                 // buildbot builder is specified.
                 keys := make([]string, 0, len(master.Builders))
                 for k := range master.Builders {
                         keys = append(keys, k)
                 }
                 sort.Strings(keys)
@@ skipping 12 matching lines @@
         result.CurrentBuilds = currentBuilds
         for _, fb := range recentBuilds {
                 // Yes recent builds is synonymous with finished builds.
                 // TODO(hinoka): Implement limits.
                 if fb != nil {
                         result.FinishedBuilds = append(result.FinishedBuilds, fb)
                 }
         }
         return result, nil
 }