[milo] Add BuildSummary and common models.

milo/appengine/swarming/build.go

 // Copyright 2015 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 swarming
 
 import (
         "bytes"
         "fmt"
         "net/http"
         "net/url"
         "strings"
         "time"
 
         "golang.org/x/net/context"
 
         swarming "github.com/luci/luci-go/common/api/swarming/swarming/v1"
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/proto/google"
         miloProto "github.com/luci/luci-go/common/proto/milo"
         "github.com/luci/luci-go/common/sync/parallel"
         "github.com/luci/luci-go/logdog/client/annotee"
         "github.com/luci/luci-go/logdog/client/coordinator"
         "github.com/luci/luci-go/logdog/common/types"
         "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"
         "github.com/luci/luci-go/milo/appengine/logdog"
         "github.com/luci/luci-go/server/auth"
 )
 
 // errNotMiloJob is returned if a Swarming task is fetched that does not self-
 // identify as a Milo job.
 var errNotMiloJob = errors.New("Not a Milo Job or access denied")
 
 // SwarmingTimeLayout is time layout used by swarming.
 const SwarmingTimeLayout = "2006-01-02T15:04:05.999999999"
@@ skipping 219 matching lines @@
                 }
         }
         return result
 }
 
 // addBuilderLink adds a link to the buildbucket builder view.
 func addBuilderLink(c context.Context, build *resp.MiloBuild, tags map[string]string) {
         bucket := tags["buildbucket_bucket"]
         builder := tags["builder"]
         if bucket != "" && builder != "" {
-                build.Summary.ParentLabel = &resp.Link{
-                        Label: builder,
-                        URL:   fmt.Sprintf("/buildbucket/%s/%s", bucket, builder),
-                }
+                build.Summary.ParentLabel = resp.NewLink(
+                        builder, fmt.Sprintf("/buildbucket/%s/%s", bucket, builder))
         }
 }
 
 // addBanner adds an OS banner derived from "os" swarming tag, if present.
 func addBanner(build *resp.MiloBuild, tags map[string]string) {
         os := tags["os"]
         var ver string
         parts := strings.SplitN(os, "-", 2)
         if len(parts) == 2 {
                 os = parts[0]
@@ skipping 120 matching lines @@
         if strings.HasPrefix(patchset, "gerrit/") {
                 gerritPatchset := strings.TrimLeft(patchset, "gerrit/")
                 parts := strings.Split(gerritPatchset, "/")
                 if len(parts) != 3 {
                         // Not a well-formed gerrit patchset.
                         return
                 }
                 if build.SourceStamp == nil {
                         build.SourceStamp = &resp.SourceStamp{}
                 }
-                build.SourceStamp.Changelist = &resp.Link{
-                        Label: "Gerrit CL",
-                        URL:   fmt.Sprintf("https://%s/c/%s/%s", parts[0], parts[1], parts[2]),
-                }
+                build.SourceStamp.Changelist = resp.NewLink(
+                        "Gerrit CL", fmt.Sprintf("https://%s/c/%s/%s", parts[0], parts[1], parts[2]))
 
         }
 }
 
 func addRecipeLink(build *resp.MiloBuild, tags map[string]string) {
         name := tags["recipe_name"]
         repoURL := tags["recipe_repository"]
         revision := tags["recipe_revision"]
         if name != "" && repoURL != "" {
                 if revision == "" {
                         revision = "master"
                 }
                 // Link directly to the revision if it is a gerrit URL, otherwise just
                 // display it in the name.
                 if repoParse, err := url.Parse(repoURL); err == nil && strings.HasSuffix(
                         repoParse.Host, ".googlesource.com") {
                         repoURL += "/+/" + revision + "/"
                 } else {
                         if len(revision) > 8 {
                                 revision = revision[:8]
                         }
                         name += " @ " + revision
                 }
-                build.Summary.Recipe = &resp.Link{
-                        Label: name,
-                        URL:   repoURL,
-                }
+                build.Summary.Recipe = resp.NewLink(name, repoURL)
         }
 }
 
 func addTaskToBuild(c context.Context, server string, sr *swarming.SwarmingRpcsTaskResult, build *resp.MiloBuild) error {
         build.Summary.Label = sr.TaskId
         build.Summary.Type = resp.Recipe
-        build.Summary.Source = &resp.Link{
-                Label: "Task " + sr.TaskId,
-                URL:   taskPageURL(server, sr.TaskId),
-        }
+        build.Summary.Source = resp.NewLink("Task "+sr.TaskId, taskPageURL(server, sr.TaskId))
 
         // Extract more swarming specific information into the properties.
         if props := taskProperties(sr); len(props.Property) > 0 {
                 build.PropertyGroup = append(build.PropertyGroup, props)
         }
         tags := tagsToMap(sr.Tags)
 
         addBuildsetInfo(build, tags)
         addBanner(build, tags)
         addBuilderLink(c, build, tags)
         addRecipeLink(build, tags)
 
         // Add a link to the bot.
         if sr.BotId != "" {
-                build.Summary.Bot = &resp.Link{
-                        Label: sr.BotId,
-                        URL:   botPageURL(server, sr.BotId),
-                }
+                build.Summary.Bot = resp.NewLink(sr.BotId, botPageURL(server, sr.BotId))
         }
 
         return nil
 }
 
 // streamsFromAnnotatedLog takes in an annotated log and returns a fully
 // populated set of logdog streams
 func streamsFromAnnotatedLog(ctx context.Context, log string) (*logdog.Streams, error) {
         c := &memoryClient{}
         p := annotee.New(ctx, annotee.Options{
@@ skipping 51 matching lines @@
         }
 
         return &as, nil
 }
 
 // failedToStart is called in the case where logdog-only mode is on but the
 // stream doesn't exist and the swarming job is complete.  It modifies the build
 // to add information that would've otherwise been in the annotation stream.
 func failedToStart(c context.Context, build *resp.MiloBuild, res *swarming.SwarmingRpcsTaskResult, host string) error {
         var err error
-        build.Summary.Status = resp.InfraFailure
+        build.Summary.Status = model.InfraFailure
         build.Summary.Started, err = time.Parse(SwarmingTimeLayout, res.StartedTs)
         if err != nil {
                 return err
         }
         build.Summary.Finished, err = time.Parse(SwarmingTimeLayout, res.CompletedTs)
         if err != nil {
                 return err
         }
         build.Summary.Duration = build.Summary.Finished.Sub(build.Summary.Started)
-        infoComp := infoComponent(resp.InfraFailure,
+        infoComp := infoComponent(model.InfraFailure,
                 "LogDog stream not found", "Job likely failed to start.")
         infoComp.Started = build.Summary.Started
         infoComp.Finished = build.Summary.Finished
         infoComp.Duration = build.Summary.Duration
         infoComp.Verbosity = resp.Interesting
         build.Components = append(build.Components, infoComp)
         return addTaskToBuild(c, host, res, build)
 }
 
 func (bl *buildLoader) swarmingBuildImpl(c context.Context, svc swarmingService, linkBase, taskID string) (*resp.MiloBuild, error) {
@@ skipping 68 matching lines @@
                                 // The stream was not found.  This could be due to one of two things:
                                 // 1. The step just started and we're just waiting for the logs
                                 // to propogage to logdog.
                                 // 2. The bootsrap on the client failed, and never sent data to logdog.
                                 // This would be evident because the swarming result would be a failure.
                                 if fr.res.State == TaskCompleted {
                                         err = failedToStart(c, &build, fr.res, svc.getHost())
                                         return &build, err
                                 }
                                 logging.WithError(err).Errorf(c, "User cannot access stream.")
-                                build.Components = append(build.Components, infoComponent(resp.Running,
+                                build.Components = append(build.Components, infoComponent(model.Running,
                                         "Waiting...", "waiting for annotation stream"))
 
                         case coordinator.ErrNoAccess:
                                 logging.WithError(err).Errorf(c, "User cannot access stream.")
-                                build.Components = append(build.Components, infoComponent(resp.Failure,
+                                build.Components = append(build.Components, infoComponent(model.Failure,
                                         "No Access", "no access to annotation stream"))
 
                         default:
                                 logging.WithError(err).Errorf(c, "Failed to load LogDog annotation stream.")
-                                build.Components = append(build.Components, infoComponent(resp.InfraFailure,
+                                build.Components = append(build.Components, infoComponent(model.InfraFailure,
                                         "Error", "failed to load annotation stream"))
                         }
                 }
 
         case fr.log != "":
                 // Decode the data using annotee. The logdog stream returned here is assumed
                 // to be consistent, which is why the following block of code are not
                 // expected to ever err out.
                 var err error
                 lds, err = streamsFromAnnotatedLog(c, fr.log)
                 if err != nil {
-                        comp := infoComponent(resp.InfraFailure, "Milo annotation parser", err.Error())
-                        comp.SubLink = append(comp.SubLink, resp.LinkSet{&resp.Link{
-                                Label: "swarming task",
-                                URL:   taskPageURL(svc.getHost(), taskID),
-                        }})
+                        comp := infoComponent(model.InfraFailure, "Milo annotation parser", err.Error())
+                        comp.SubLink = append(comp.SubLink, resp.LinkSet{
+                                resp.NewLink("swarming task", taskPageURL(svc.getHost(), taskID)),
+                        })
                         build.Components = append(build.Components, comp)
                 }
 
                 if lds != nil && lds.MainStream != nil && lds.MainStream.Data != nil {
                         s = lds.MainStream.Data
                 }
                 ub = swarmingURLBuilder(linkBase)
 
         default:
                 s = &miloProto.Step{}
                 ub = swarmingURLBuilder(linkBase)
         }
 
         if s != nil {
                 if err := addTaskToMiloStep(c, svc.getHost(), fr.res, s); err != nil {
                         return nil, err
                 }
                 logdog.AddLogDogToBuild(c, ub, s, &build)
         }
 
         if err := addTaskToBuild(c, svc.getHost(), fr.res, &build); err != nil {
                 return nil, err
         }
 
         return &build, nil
 }
 
-func infoComponent(st resp.Status, label, text string) *resp.BuildComponent {
+func infoComponent(st model.Status, label, text string) *resp.BuildComponent {
         return &resp.BuildComponent{
                 Type:   resp.Summary,
                 Label:  label,
                 Text:   []string{text},
                 Status: st,
         }
 }
 
 // isAllowed checks if:
 // 1. allow_milo:1 is present.  If so, it's a public job.
@@ skipping 50 matching lines @@
 
         switch t := l.Value.(type) {
         case *miloProto.Link_LogdogStream:
                 ls := t.LogdogStream
 
                 if u.Path == "" {
                         u.Path = ls.Name
                 } else {
                         u.Path = strings.TrimSuffix(u.Path, "/") + "/" + ls.Name
                 }
-                link := resp.Link{
-                        Label: l.Label,
-                        URL:   u.String(),
-                }
+                link := resp.NewLink(l.Label, u.String())
                 if link.Label == "" {
                         link.Label = ls.Name
                 }
-                return &link
+                return link
 
         case *miloProto.Link_Url:
-                return &resp.Link{
-                        Label: l.Label,
-                        URL:   t.Url,
-                }
+                return resp.NewLink(l.Label, t.Url)
 
         default:
                 return nil
         }
 }
 
 func swarmingTags(v []string) map[string]string {
         res := make(map[string]string, len(v))
         for _, tag := range v {
                 var value string
                 parts := strings.SplitN(tag, ":", 2)
                 if len(parts) == 2 {
                         value = parts[1]
                 }
                 res[parts[0]] = value
         }
         return res
 }