milo: Enable Swarming LogDog log loading.

milo/appengine/logdog/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 logdog
 
 import (
         "fmt"
         "net/http"
         "time"
@@ skipping 26 matching lines @@
         // defaultLogDogHost is the default LogDog host, if one isn't specified via
         // query string.
         defaultLogDogHost = "luci-logdog.appspot.com"
 )
 
 // AnnotationStream represents a LogDog annotation protobuf stream.
 type AnnotationStream struct {
         Project cfgtypes.ProjectName
         Path    types.StreamPath
 
-        // logDogClient is the HTTP client to use for LogDog communication.
+        // Client is the HTTP client to use for LogDog communication.
         Client *coordinator.Client
 
         // cs is the unmarshalled annotation stream Step and associated data.
         cs internal.CachedStep
 }
 
 // Normalize validates and normalizes the stream's parameters.
 func (as *AnnotationStream) Normalize() error {
         if err := as.Project.Validate(); err != nil {
                 return fmt.Errorf("Invalid project name: %s", as.Project)
         }
 
         if err := as.Path.Validate(); err != nil {
                 return fmt.Errorf("Invalid log stream path %q: %s", as.Path, err)
         }
 
         return nil
 }
 
-// Load loads the annotation stream from LogDog.
+// Fetch loads the annotation stream from LogDog.
 //
-// If the stream does not exist, or is invalid, Load will return a Milo error.
+// If the stream does not exist, or is invalid, Fetch will return a Milo error.
 // Otherwise, it will return the Step that was loaded.
 //
-// Load caches the step, so multiple calls to Load will return the same Step
+// Fetch caches the step, so multiple calls to Fetch will return the same Step
 // value.
-func (as *AnnotationStream) Load(c context.Context) (*miloProto.Step, error) {
+func (as *AnnotationStream) Fetch(c context.Context) (*miloProto.Step, error) {
         // Cached?
         if as.cs.Step != nil {
                 return as.cs.Step, nil
         }
 
         // Load from memcache, if possible. If an error occurs, we will proceed as if
         // no CachedStep was available.
         mcKey := as.memcacheKey()
         mcItem, err := mc.GetKey(c, mcKey)
         switch err {
@@ skipping 120 matching lines @@
                 // No substep had an ended time :(
                 latestEndedTime = google.TimeFromProto(step.Started)
         }
 
         // Build our CachedStep.
         as.cs = internal.CachedStep{
                 Step:     &step,
                 Finished: (state.State.TerminalIndex >= 0 && le.StreamIndex == uint64(state.State.TerminalIndex)),
         }
 
-        // Annotee is apparently not putting an ended time on some annotation protos.
-        // This hack will ensure that a finished build will always have an ended time.
-        if as.cs.Finished && as.cs.Step.Ended == nil {
-                as.cs.Step.Ended = google.NewTimestamp(latestEndedTime)
-        }
-
         // Marshal and cache the step. If this is the final protobuf in the stream,
         // cache it indefinitely; otherwise, cache it for intermediateCacheLifetime.
         //
         // If this fails, it is non-fatal.
         mcData, err := proto.Marshal(&as.cs)
         if err == nil {
                 mcItem = mc.NewItem(c, mcKey)
                 if !as.cs.Finished {
                         mcItem.SetExpiration(intermediateCacheLifetime)
                 }
@@ skipping 22 matching lines @@
                         Prefix:     string(prefix),
                         Path:       string(name),
                         IsDatagram: true,
                         Data:       as.cs.Step,
                         Closed:     as.cs.Finished,
                 },
         }
 
         var (
                 build resp.MiloBuild
-                ub    = logDogURLBuilder{
-                        host:    as.Client.Host,
-                        project: as.Project,
-                        prefix:  prefix,
+                ub    = ViewerURLBuilder{
+                        Host:    as.Client.Host,
+                        Project: as.Project,
+                        Prefix:  prefix,
                 }
         )
         AddLogDogToBuild(c, &ub, streams.MainStream.Data, &build)
         return &build
 }
 
-type logDogURLBuilder struct {
-        host    string
-        prefix  types.StreamName
-        project cfgtypes.ProjectName
+// ViewerURLBuilder is a URL builder that constructs LogDog viewer URLs.
+type ViewerURLBuilder struct {
+        Host    string
+        Prefix  types.StreamName
+        Project cfgtypes.ProjectName
 }
 
-func (b *logDogURLBuilder) BuildLink(l *miloProto.Link) *resp.Link {
+// BuildLink implements URLBuilder.
+func (b *ViewerURLBuilder) BuildLink(l *miloProto.Link) *resp.Link {
         switch t := l.Value.(type) {
         case *miloProto.Link_LogdogStream:
                 ls := t.LogdogStream
 
                 server := ls.Server
                 if server == "" {
-                        server = b.host
+                        server = b.Host
                 }
 
                 prefix := types.StreamName(ls.Prefix)
                 if prefix == "" {
-                        prefix = b.prefix
+                        prefix = b.Prefix
                 }
 
-                u := viewer.GetURL(server, b.project, prefix.Join(types.StreamName(ls.Name)))
+                u := viewer.GetURL(server, b.Project, prefix.Join(types.StreamName(ls.Name)))
                 link := resp.Link{
                         Label: l.Label,
                         URL:   u,
                 }
                 if link.Label == "" {
                         link.Label = ls.Name
                 }
                 return &link
 
         case *miloProto.Link_Url:
                 link := resp.Link{
                         Label: l.Label,
                         URL:   t.Url,
                 }
                 if link.Label == "" {
                         link.Label = "unnamed"
                 }
                 return &link
 
         default:
                 // Don't know how to render.
                 return nil
         }
 }