[milo] Add BuildSummary and common models.

milo/appengine/logdog/logDogBuild.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 logdog
 
 import (
         "fmt"
         "time"
 
         "golang.org/x/net/context"
 
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/proto/google"
         miloProto "github.com/luci/luci-go/common/proto/milo"
         "github.com/luci/luci-go/milo/api/resp"
+        "github.com/luci/luci-go/milo/appengine/common/model"
 )
 
 // URLBuilder constructs URLs for various link types.
 type URLBuilder interface {
         // LinkURL returns the URL associated with the supplied Link.
         //
         // If no URL could be built for that Link, nil will be returned.
         BuildLink(l *miloProto.Link) *resp.Link
 }
 
 // HACK(hinoka): This should be a part of recipes, but just hardcoding a list
 // of unimportant things for now.
 var builtIn = map[string]struct{}{
         "recipe bootstrap": {},
         "setup_build":      {},
         "recipe result":    {},
 }
 
 // miloBuildStep converts a logdog/milo step to a BuildComponent struct.
 // buildCompletedTime must be zero if build did not complete yet.
 func miloBuildStep(ub URLBuilder, anno *miloProto.Step, isMain bool, buildCompletedTime,
         now time.Time) []*resp.BuildComponent {
 
         comp := &resp.BuildComponent{Label: anno.Name}
         switch anno.Status {
         case miloProto.Status_RUNNING:
-                comp.Status = resp.Running
+                comp.Status = model.Running
 
         case miloProto.Status_SUCCESS:
-                comp.Status = resp.Success
+                comp.Status = model.Success
 
         case miloProto.Status_FAILURE:
                 if fd := anno.GetFailureDetails(); fd != nil {
                         switch fd.Type {
                         case miloProto.FailureDetails_EXCEPTION, miloProto.FailureDetails_INFRA:
-                                comp.Status = resp.InfraFailure
+                                comp.Status = model.InfraFailure
 
                         case miloProto.FailureDetails_EXPIRED:
-                                comp.Status = resp.Expired
+                                comp.Status = model.Expired
 
                         case miloProto.FailureDetails_DM_DEPENDENCY_FAILED:
-                                comp.Status = resp.DependencyFailure
+                                comp.Status = model.DependencyFailure
 
                         default:
-                                comp.Status = resp.Failure
+                                comp.Status = model.Failure
                         }
 
                         if fd.Text != "" {
                                 comp.Text = append(comp.Text, fd.Text)
                         }
                 } else {
-                        comp.Status = resp.Failure
+                        comp.Status = model.Failure
                 }
 
         case miloProto.Status_PENDING:
-                comp.Status = resp.NotRun
+                comp.Status = model.NotRun
 
                 // Missing the case of waiting on unfinished dependency...
         default:
-                comp.Status = resp.NotRun
+                comp.Status = model.NotRun
         }
 
         if !(buildCompletedTime.IsZero() || comp.Status.Terminal()) {
                 // The build has completed, but this step has not. Mark it as an
                 // infrastructure failure.
-                comp.Status = resp.InfraFailure
+                comp.Status = model.InfraFailure
         }
 
         // Hide the unimportant steps, highlight the interesting ones.
         switch comp.Status {
-        case resp.NotRun, resp.Running:
+        case model.NotRun, model.Running:
                 if isMain {
                         comp.Verbosity = resp.Hidden
                 }
 
-        case resp.Success:
+        case model.Success:
                 if _, ok := builtIn[anno.Name]; ok || isMain {
                         comp.Verbosity = resp.Hidden
                 }
-        case resp.InfraFailure, resp.Failure:
+        case model.InfraFailure, model.Failure:
                 comp.Verbosity = resp.Interesting
         }
 
         // Main link is a link to the stdout.
         var stdoutLink *miloProto.Link
         if anno.StdoutStream != nil {
                 stdoutLink = &miloProto.Link{
                         Label: "stdout",
                         Value: &miloProto.Link_LogdogStream{
                                 LogdogStream: anno.StdoutStream,
@@ skipping 36 matching lines @@
         comp.LevelsDeep = 0
 
         // Timestamps
         comp.Started = google.TimeFromProto(anno.Started)
         comp.Finished = google.TimeFromProto(anno.Ended)
 
         var till time.Time
         switch {
         case !comp.Finished.IsZero():
                 till = comp.Finished
-        case comp.Status == resp.Running:
+        case comp.Status == model.Running:
                 till = now
         case !buildCompletedTime.IsZero():
                 till = buildCompletedTime
         }
         if !comp.Started.IsZero() && till.After(comp.Started) {
                 comp.Duration = till.Sub(comp.Started)
         }
 
         // This should be the exact same thing.
         comp.Text = append(comp.Text, anno.Text...)
@@ skipping 32 matching lines @@
         build.Summary = *(miloBuildStep(ub, mainAnno, true, buildCompletedTime, now)[0])
         for _, substepContainer := range mainAnno.Substep {
                 anno := substepContainer.GetStep()
                 if anno == nil {
                         // TODO: We ignore non-embedded substeps for now.
                         continue
                 }
 
                 bss := miloBuildStep(ub, anno, false, buildCompletedTime, now)
                 for _, bs := range bss {
-                        if bs.Status != resp.Success {
+                        if bs.Status != model.Success {
                                 build.Summary.Text = append(
                                         build.Summary.Text, fmt.Sprintf("%s %s", bs.Status, bs.Label))
                         }
                         build.Components = append(build.Components, bs)
                         propGroup := &resp.PropertyGroup{GroupName: bs.Label}
                         for _, prop := range anno.Property {
                                 propGroup.Property = append(propGroup.Property, &resp.Property{
                                         Key:   prop.Name,
                                         Value: prop.Value,
                                 })
                         }
                         build.PropertyGroup = append(build.PropertyGroup, propGroup)
                 }
         }
 
         // Take care of properties
         propGroup := &resp.PropertyGroup{GroupName: "Main"}
         for _, prop := range mainAnno.Property {
                 propGroup.Property = append(propGroup.Property, &resp.Property{
                         Key:   prop.Name,
                         Value: prop.Value,
                 })
         }
         build.PropertyGroup = append(build.PropertyGroup, propGroup)
 
         return
 }