[milo] Add BuildSummary and common models.

milo/appengine/buildbot/build.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"
         "errors"
         "fmt"
         "io/ioutil"
         "math"
         "path/filepath"
         "regexp"
         "sort"
         "strings"
         "time"
 
         "golang.org/x/net/context"
 
         "github.com/luci/gae/service/datastore"
         "github.com/luci/luci-go/common/data/stringset"
         "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/milo/api/resp"
+        "github.com/luci/luci-go/milo/appengine/common/model"
 )
 
 var errBuildNotFound = errors.New("Build not found")
 
 // getBuild fetches a buildbot build from the datastore and checks ACLs.
 // The return code matches the master responses.
 func getBuild(c context.Context, master, builder string, buildNum int) (*buildbotBuild, error) {
         result := &buildbotBuild{
                 Master:      master,
                 Buildername: builder,
                 Number:      buildNum,
         }
 
         err := datastore.Get(c, result)
         err = checkAccess(c, err, result.Internal)
         if err == errMasterNotFound {
                 err = errBuildNotFound
         }
 
         return result, err
 }
 
-// result2Status translates a buildbot result integer into a resp.Status.
-func result2Status(s *int) (status resp.Status) {
+// result2Status translates a buildbot result integer into a model.Status.
+func result2Status(s *int) (status model.Status) {
         if s == nil {
-                return resp.Running
+                return model.Running
         }
         switch *s {
         case 0:
-                status = resp.Success
+                status = model.Success
         case 1:
-                status = resp.Warning
+                status = model.Warning
         case 2:
-                status = resp.Failure
+                status = model.Failure
         case 3:
-                status = resp.NotRun // Skipped
+                status = model.NotRun // Skipped
         case 4:
-                status = resp.Exception
+                status = model.Exception
         case 5:
-                status = resp.WaitingDependency // Retry
+                status = model.WaitingDependency // Retry
         default:
                 panic(fmt.Errorf("Unknown status %d", s))
         }
         return
 }
 
 // buildbotTimeToTime converts a buildbot time representation (pointer to float
 // of seconds since epoch) to a native time.Time object.
 func buildbotTimeToTime(t *float64) (result time.Time) {
         if t != nil {
@@ skipping 53 matching lines @@
         }
         logging.Warningf(c, "No OS info found.")
         return nil
 }
 
 // summary extracts the top level summary from a buildbot build as a
 // BuildComponent
 func summary(c context.Context, b *buildbotBuild) resp.BuildComponent {
         // TODO(hinoka): use b.toStatus()
         // Status
-        var status resp.Status
+        var status model.Status
         if b.Currentstep != nil {
-                status = resp.Running
+                status = model.Running
         } else {
                 status = result2Status(b.Results)
         }
 
         // Timing info
         started, ended, duration := parseTimes(nil, b.Times)
 
         // Link to bot and original build.
         host := "build.chromium.org/p"
         if b.Internal {
                 host = "uberchromegw.corp.google.com/i"
         }
-        bot := &resp.Link{
-                Label: b.Slave,
-                URL:   fmt.Sprintf("https://%s/%s/buildslaves/%s", host, b.Master, b.Slave),
-        }
-        source := &resp.Link{
-                Label: fmt.Sprintf("%s/%s/%d", b.Master, b.Buildername, b.Number),
-                URL: fmt.Sprintf(
-                        "https://%s/%s/builders/%s/builds/%d",
+        bot := resp.NewLink(
+                b.Slave,
+                fmt.Sprintf("https://%s/%s/buildslaves/%s", host, b.Master, b.Slave),
+        )
+        source := resp.NewLink(
+                fmt.Sprintf("%s/%s/%d", b.Master, b.Buildername, b.Number),
+                fmt.Sprintf("https://%s/%s/builders/%s/builds/%d",
                         host, b.Master, b.Buildername, b.Number),
-        }
+        )
 
         // The link to the builder page.
-        parent := &resp.Link{
-                Label: b.Buildername,
-                URL:   ".",
-        }
+        parent := resp.NewLink(b.Buildername, ".")
 
         // Do a best effort lookup for the bot information to fill in OS/Platform info.
         banner := getBanner(c, b)
 
         sum := resp.BuildComponent{
                 ParentLabel: parent,
                 Label:       fmt.Sprintf("#%d", b.Number),
                 Banner:      banner,
                 Status:      status,
                 Started:     started,
@@ skipping 24 matching lines @@
                 }
                 // Step text sometimes contains <br>, which we want to parse into new lines.
                 for _, t := range step.Text {
                         for _, line := range rLineBreak.Split(t, -1) {
                                 bc.Text = append(bc.Text, line)
                         }
                 }
 
                 // Figure out the status.
                 if !step.IsStarted {
-                        bc.Status = resp.NotRun
+                        bc.Status = model.NotRun
                 } else if !step.IsFinished {
-                        bc.Status = resp.Running
+                        bc.Status = model.Running
                 } else {
                         if len(step.Results) > 0 {
                                 status := int(step.Results[0].(float64))
                                 bc.Status = result2Status(&status)
                         } else {
-                                bc.Status = resp.Success
+                                bc.Status = model.Success
                         }
                 }
 
                 // Raise the interesting-ness if the step is not "Success".
-                if bc.Status != resp.Success {
+                if bc.Status != model.Success {
                         bc.Verbosity = resp.Interesting
                 }
 
                 remainingAliases := stringset.New(len(step.Aliases))
                 for linkAnchor := range step.Aliases {
                         remainingAliases.Add(linkAnchor)
                 }
 
                 getLinksWithAliases := func(logLink *resp.Link, isLog bool) resp.LinkSet {
                         // Generate alias links.
@@ skipping 10 matching lines @@
                         links := make(resp.LinkSet, 1, 1+len(aliases))
                         links[0] = logLink
 
                         for _, a := range aliases {
                                 a.Alias = true
                         }
                         return append(links, aliases...)
                 }
 
                 for _, l := range step.Logs {
-                        logLink := resp.Link{
-                                Label: l[0],
-                                URL:   l[1],
-                        }
+                        logLink := resp.NewLink(l[0], l[1])
 
-                        links := getLinksWithAliases(&logLink, true)
+                        links := getLinksWithAliases(logLink, true)
                         if logLink.Label == "stdio" {
                                 bc.MainLink = links
                         } else {
                                 bc.SubLink = append(bc.SubLink, links)
                         }
                 }
 
                 // Step links are stored as maps of name: url
                 // Because Go doesn't believe in nice things, we now create another array
                 // just so that we can iterate through this map in order.
                 names := make([]string, 0, len(step.Urls))
                 for name := range step.Urls {
                         names = append(names, name)
                 }
                 sort.Strings(names)
                 for _, name := range names {
-                        logLink := resp.Link{
-                                Label: name,
-                                URL:   step.Urls[name],
-                        }
+                        logLink := resp.NewLink(name, step.Urls[name])
 
-                        bc.SubLink = append(bc.SubLink, getLinksWithAliases(&logLink, false))
+                        bc.SubLink = append(bc.SubLink, getLinksWithAliases(logLink, false))
                 }
 
                 // Add any unused aliases directly.
                 if remainingAliases.Len() > 0 {
                         unusedAliases := remainingAliases.ToSlice()
                         sort.Strings(unusedAliases)
 
                         for _, label := range unusedAliases {
                                 var baseLink resp.LinkSet
                                 for _, alias := range step.Aliases[label] {
@@ skipping 88 matching lines @@
 
 // blame extracts the commit and blame information from a buildbot build and
 // returns it as a list of Commits.
 func blame(b *buildbotBuild) (result []*resp.Commit) {
         for _, c := range b.Sourcestamp.Changes {
                 files := c.GetFiles()
                 result = append(result, &resp.Commit{
                         AuthorEmail: c.Who,
                         Repo:        c.Repository,
                         CommitTime:  time.Unix(int64(c.When), 0).UTC(),
-                        Revision: &resp.Link{
-                                URL:   c.Revlink,
-                                Label: c.Revision,
-                        },
+                        Revision:    resp.NewLink(c.Revision, c.Revlink),
                         Description: c.Comments,
                         Title:       strings.Split(c.Comments, "\n")[0],
                         File:        files,
                 })
         }
         return
 }
 
 // sourcestamp extracts the source stamp from various parts of a buildbot build,
 // including the properties.
@@ skipping 28 matching lines @@
 
                 case "repository":
                         if v, ok := prop.Value.(string); ok {
                                 repository = v
                         }
                 }
         }
         if issue != -1 {
                 if rietveld != "" {
                         rietveld = strings.TrimRight(rietveld, "/")
-                        ss.Changelist = &resp.Link{
-                                Label: fmt.Sprintf("Issue %d", issue),
-                                URL:   fmt.Sprintf("%s/%d", rietveld, issue),
-                        }
+                        ss.Changelist = resp.NewLink(
+                                fmt.Sprintf("Issue %d", issue),
+                                fmt.Sprintf("%s/%d", rietveld, issue),
+                        )
                 } else {
                         logging.Warningf(c, "Found issue but not rietveld property.")
                 }
         }
         if got_revision != "" {
-                ss.Revision = &resp.Link{
-                        Label: got_revision,
-                }
+                ss.Revision = resp.NewLink(got_revision, "")
                 if repository != "" {
                         ss.Revision.URL = repository + "/+/" + got_revision
                 }
         }
         return ss
 }
 
 func getDebugBuild(c context.Context, builder string, buildNum int) (*buildbotBuild, error) {
         fname := fmt.Sprintf("%s.%d.json", builder, buildNum)
         // ../buildbot below assumes that
@@ skipping 172 matching lines @@
         var newAliases map[string][]*buildbotLinkAlias
         if l := remainingAliases.Len(); l > 0 {
                 newAliases = make(map[string][]*buildbotLinkAlias, l)
                 remainingAliases.Iter(func(v string) bool {
                         newAliases[v] = s.Aliases[v]
                         return true
                 })
         }
         s.Aliases = newAliases
 }