Milo: Display pending builds

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"
-        "os"
         "sort"
         "strings"
         "time"
 
         ds "github.com/luci/gae/service/datastore"
 
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/milo/api/resp"
         "golang.org/x/net/context"
@@ skipping 105 matching lines @@
         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
         }
 
         s, _ := json.Marshal(master)
         logging.Debugf(c, "Master: %s", s)
 
-        _, ok := master.Builders[builderName]
+        p, 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)
                 avail := strings.Join(keys, "\n")
                 return nil, fmt.Errorf(
                         "Cannot find builder %s in master %s.\nAvailable builders: \n%s",
                         builderName, masterName, avail)
         }
+        // Extract pending builds out of the master json.
+        result.PendingBuilds = make([]*resp.BuildSummary, len(p.PendingBuildStates))
+        logging.Debugf(c, "Number of pending builds: %d", len(p.PendingBuildStates))
+        for i, pb := range p.PendingBuildStates {
+                start := time.Unix(int64(pb.SubmittedAt), 0)
+                result.PendingBuilds[i] = &resp.BuildSummary{
+                        PendingTime: resp.Interval{
+                                Started:  start,
+                                Duration: time.Now().Sub(start),
+                        },
+                }
+                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,
+                        }
+                }
+        }
 
         recentBuilds, err := getBuilds(c, masterName, builderName, true)
         if err != nil {
-                return nil, err // Or maybe not?
+                return nil, err
         }
-        currentBuilds := getCurrentBuilds(c, master, builderName)
-        fmt.Fprintf(os.Stderr, "Number of current builds: %d\n", len(currentBuilds))
-        result.CurrentBuilds = currentBuilds
+        currentBuilds, err := getBuilds(c, masterName, builderName, false)
+        if err != nil {
+                return nil, err
+        }
+        logging.Debugf(c, "Number of current builds: %d", len(currentBuilds))
+        // TODO(hinoka): This works, but there's a lot of junk data from
+        // masters with unclean shutdown.  Need to implement a cleanup
+        // procedure of some sort. Once that is done, set:
+        // 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
 }