milo: fix step duration

appengine/cmd/milo/logdog/logDogBuild.go

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package logdog
 
 import (
         "fmt"
         "strings"
         "time"
 
         "github.com/luci/luci-go/appengine/cmd/milo/resp"
+        "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/logdog/types"
         "github.com/luci/luci-go/common/logging"
         miloProto "github.com/luci/luci-go/common/proto/milo"
         "golang.org/x/net/context"
 )
 
 // Given a logdog/milo step, translate it to a BuildComponent struct.
-func miloBuildStep(
-        c context.Context, url string, anno *miloProto.Step, name string) *resp.BuildComponent {
-        comp := &resp.BuildComponent{}
+func miloBuildStep(c context.Context, url string, anno *miloProto.Step, name string) *resp.BuildComponent {
         asc := anno.GetStepComponent()
-        comp.Label = asc.Name
+        comp := &resp.BuildComponent{Label: asc.Name}
         switch asc.Status {
         case miloProto.Status_RUNNING:
                 comp.Status = resp.Running
 
         case miloProto.Status_SUCCESS:
                 comp.Status = resp.Success
 
         case miloProto.Status_FAILURE:
                 if anno.GetFailureDetails() != nil {
                         switch anno.GetFailureDetails().Type {
@@ skipping 43 matching lines @@
                 URL:   strings.Join([]string{url, name, "stdout"}, "/"),
         }
 
         // This should always be a step.
         comp.Type = resp.Step
 
         // This should always be 0
         comp.LevelsDeep = 0
 
         // Timestamps
-        comp.Started = asc.Started.Time().Format(time.RFC3339)
+        started := asc.Started.Time()
+        ended := asc.Ended.Time()
+        comp.Started = started.Format(time.RFC3339)
+        comp.Finished = ended.Format(time.RFC3339)

[estaab, 2016/06/16 00:48:53]

if you add

if asc.Status == miloProto.Status_RUNNING {
  ended = clock.Now()
}

and simplify the block on 91 it might be easier to read

[nodir, 2016/06/16 17:14:55]

Done.

+        if !started.IsZero() && (!ended.IsZero() || asc.Status == miloProto.Status_RUNNING) {
+                till := ended
+                if till.IsZero() {
+                        till = clock.Now(c)
+                }
+                comp.Duration = uint64((till.Sub(started)) / time.Second)
+        }
 
         // This should be the exact same thing.
         comp.Text = asc.Text
 
         return comp
 }
 
 // AddLogDogToBuild takes a set of logdog streams and populate a milo build.
-func AddLogDogToBuild(
-        c context.Context, url string, s *Streams,
-        build *resp.MiloBuild) {
+func AddLogDogToBuild(c context.Context, url string, s *Streams, build *resp.MiloBuild) {
         if s.MainStream == nil {
-                panic("Missing main stream")
+                panic("missing main stream")
         }
         // Now Fetch the main annotation of the build.
         mainAnno := s.MainStream.Data
 
         // Now fill in each of the step components.
         // TODO(hinoka): This is totes cachable.
         for _, name := range mainAnno.SubstepLogdogNameBase {
                 fullname := strings.Join([]string{name, "annotations"}, "/")
                 anno, ok := s.Streams[fullname]
                 if !ok {
@@ skipping 18 matching lines @@
         for _, prop := range mainAnno.GetStepComponent().Property {
                 propGroup.Property = append(propGroup.Property, &resp.Property{
                         Key:   prop.Name,
                         Value: prop.Value,
                 })
         }
         build.PropertyGroup = append(build.PropertyGroup, propGroup)
 
         return
 }