[milo] Add BuildSummary and common models.

milo/appengine/buildbucket/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 buildbucket
 
 import (
         "encoding/json"
         "fmt"
         "net/url"
@@ skipping 10 matching lines @@
         "github.com/luci/gae/service/info"
         "github.com/luci/luci-go/common/api/buildbucket/buildbucket/v1"
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/retry"
         "github.com/luci/luci-go/common/sync/parallel"
 
         "github.com/luci/luci-go/milo/api/resp"
         "github.com/luci/luci-go/milo/appengine/common"
+        "github.com/luci/luci-go/milo/appengine/common/model"
 )
 
 // search executes the search request with retries and exponential back-off.
 func search(c context.Context, client *buildbucket.Service, req *buildbucket.SearchCall) (
         *buildbucket.ApiSearchResponseMessage, error) {
 
         var res *buildbucket.ApiSearchResponseMessage
         err := retry.Retry(
                 c,
                 retry.TransientOnly(retry.Default),
@@ skipping 70 matching lines @@
         }
         if result.Revision == "" {
                 result.Revision = params.Properties.Revision
         }
 
         var err error
         result.Status, err = parseStatus(build)
         if err != nil {
                 // almost never happens
                 logging.WithError(err).Errorf(c, "could not convert status of build %d", build.Id)
-                result.Status = resp.InfraFailure
+                result.Status = model.InfraFailure
                 result.Text = append(result.Text, fmt.Sprintf("invalid build: %s", err))
         }
 
         result.PendingTime.Started = parseTimestamp(build.CreatedTs)
         switch build.Status {
         case "SCHEDULED":
                 result.PendingTime.Duration = clock.Since(c, result.PendingTime.Started)
 
         case "STARTED":
                 result.ExecutionTime.Started = parseTimestamp(build.StatusChangedTs)
@@ skipping 20 matching lines @@
                 // map milo links to itself
                 switch {
                 case err != nil:
                         logging.Errorf(c, "invalid URL in build %d: %s", build.Id, err)
                 case parsed.Host == info.DefaultVersionHostname(c):
                         parsed.Host = ""
                         parsed.Scheme = ""
                         u = parsed.String()
                 }
 
-                result.Link = &resp.Link{
-                        URL:   u,
-                        Label: strconv.FormatInt(build.Id, 10),
-                }
+                result.Link = resp.NewLink(strconv.FormatInt(build.Id, 10), u)
 
                 // compute the best link label
                 if taskID := tags["swarming_task_id"]; taskID != "" {
                         result.Link.Label = taskID
                 } else if resultDetails.Properties.BuildNumber != 0 {
                         result.Link.Label = strconv.Itoa(resultDetails.Properties.BuildNumber)
                 } else if parsed != nil {
                         // does the URL look like a buildbot build URL?
                         pattern := fmt.Sprintf(
                                 `/%s/builders/%s/builds/`,
@@ skipping 21 matching lines @@
         defer resFile.Close()
 
         res := &buildbucket.ApiSearchResponseMessage{}
         if err := json.NewDecoder(resFile).Decode(res); err != nil {
                 return err
         }
 
         for _, bb := range res.Builds {
                 mb := toMiloBuild(c, bb)
                 switch mb.Status {
-                case resp.NotRun:
+                case model.NotRun:
                         target.PendingBuilds = append(target.PendingBuilds, mb)
 
-                case resp.Running:
+                case model.Running:
                         target.CurrentBuilds = append(target.CurrentBuilds, mb)
 
-                case resp.Success, resp.Failure, resp.InfraFailure, resp.Warning:
+                case model.Success, model.Failure, model.InfraFailure, model.Warning:
                         if len(target.FinishedBuilds) < maxCompletedBuilds {
                                 target.FinishedBuilds = append(target.FinishedBuilds, mb)
                         }
 
                 default:
                         panic("impossible")
                 }
         }
         return nil
 }
@@ skipping 65 matching lines @@
         return time.Unix(microseconds/1e6, microseconds%1e6*1000).UTC()
 }
 
 type newBuildsFirst []*resp.BuildSummary
 
 func (a newBuildsFirst) Len() int      { return len(a) }
 func (a newBuildsFirst) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
 func (a newBuildsFirst) Less(i, j int) bool {
         return a[i].PendingTime.Started.After(a[j].PendingTime.Started)
 }