Milo: Add machine pool info for buildbot builder view.

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 (
         "crypto/sha1"
         "encoding/base64"
         "errors"
@@ skipping 146 matching lines @@
         builder   string
         available []string
 }
 
 func (e errBuilderNotFound) Error() string {
         avail := strings.Join(e.available, "\n")
         return fmt.Sprintf("Cannot find builder %q in master %q.\nAvailable builders: \n%s",
                 e.builder, e.master, avail)
 }
 
+func summarizeSlavePool(
+        baseURL string, slaves []string, slaveMap map[string]*buildbotSlave) *resp.MachinePool {
+
+        mp := &resp.MachinePool{
+                Total: len(slaves),
+                Bots:  make([]resp.Bot, 0, len(slaves)),
+        }
+        for _, slaveName := range slaves {
+                slave, ok := slaveMap[slaveName]
+                bot := resp.Bot{
+                        Name: resp.Link{
+                                Label: slaveName,
+                                URL:   fmt.Sprintf("%s/buildslaves/%s", baseURL, slaveName),
+                        },
+                }
+                switch {
+                case !ok:
+                        // This shouldn't happen
+                case !slave.Connected:
+                        bot.Status = resp.Disconnected
+                        mp.Disconnected++
+                case len(slave.RunningbuildsMap) > 0:
+                        bot.Status = resp.Busy
+                        mp.Busy++
+                default:
+                        bot.Status = resp.Idle
+                        mp.Idle++
+                }
+                mp.Bots = append(mp.Bots, bot)
+        }
+        return mp
+}
+
 // 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, limit int, cursor string) (
         *resp.Builder, error) {
 
         var thisCursor *datastore.Cursor
         if cursor != "" {
                 tmpCur, err := datastore.DecodeCursor(c, cursor)
                 if err != nil {
                         return nil, fmt.Errorf("bad cursor: %s", err)
                 }
                 thisCursor = &tmpCur
         }
 
         result := &resp.Builder{
                 Name: builderName,
         }
-        master, t, err := getMasterJSON(c, masterName)
+        master, internal, t, err := getMasterJSON(c, masterName)
         if err != nil {
                 return nil, err
         }
         if clock.Now(c).Sub(t) > 2*time.Minute {
                 warning := fmt.Sprintf(
                         "WARNING: Master data is stale (last updated %s)", t)
                 logging.Warningf(c, warning)
                 result.Warning = warning
         }
 
@@ skipping 21 matching lines @@
                 }
                 result.PendingBuilds[i].Blame = make([]*resp.Commit, len(pb.Source.Changes))
                 for j, cm := range pb.Source.Changes {
                         result.PendingBuilds[i].Blame[j] = &resp.Commit{
                                 AuthorEmail: cm.Who,
                                 CommitURL:   cm.Revlink,
                         }
                 }
         }
 
+        baseURL := "https://build.chromium.org/p/"
+        if internal {
+                baseURL = "https://uberchromegw.corp.google.com/i/"
+        }
+        result.MachinePool = summarizeSlavePool(baseURL+master.Name, p.Slaves, master.Slaves)
+
         // This is CPU bound anyways, so there's no need to do this in parallel.
         finishedBuilds, nextCursor, err := getBuilds(c, masterName, builderName, true, limit, thisCursor)
         if err != nil {
                 return nil, err
         }
         if prevCursor, ok := maybeSetGetCursor(c, thisCursor, nextCursor, limit); ok {
                 if prevCursor == nil {
                         // Magic string to signal display prev without cursor
                         result.PrevCursor = "EMPTY"
                 } else {
@@ skipping 14 matching lines @@
         }
         result.CurrentBuilds = currentBuilds
 
         for _, fb := range finishedBuilds {
                 if fb != nil {
                         result.FinishedBuilds = append(result.FinishedBuilds, fb)
                 }
         }
         return result, nil
 }