[milo] Refactor all html knowledge out of backends.

milo/buildsource/rawpresentation/build.go

 // Copyright 2016 The LUCI Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 package rawpresentation
 
 import (
-        "errors"
-        "fmt"
+        "strings"
         "time"
 
+        "github.com/golang/protobuf/proto"
+        "golang.org/x/net/context"
+
+        "github.com/luci/luci-go/common/errors"
         log "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/logdog/api/logpb"
         "github.com/luci/luci-go/logdog/client/coordinator"
         "github.com/luci/luci-go/logdog/common/types"
         "github.com/luci/luci-go/logdog/common/viewer"
         "github.com/luci/luci-go/luci_config/common/cfgtypes"
         "github.com/luci/luci-go/milo/api/resp"
         "github.com/luci/luci-go/milo/buildsource/rawpresentation/internal"
-
-        "github.com/golang/protobuf/proto"
-        "golang.org/x/net/context"
+        "github.com/luci/luci-go/milo/common"
 )
 
 const (
         // intermediateCacheLifetime is the amount of time to cache intermediate (non-
         // terminal) annotation streams. Terminal annotation streams are cached
         // indefinitely.
         intermediateCacheLifetime = 10 * time.Second
 
         // 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
 
         // 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)
+                return errors.Annotate(err, "Invalid project name: %s", as.Project).Tag(common.CodeParameterError).Err()
         }
 
         if err := as.Path.Validate(); err != nil {
-                return fmt.Errorf("Invalid log stream path %q: %s", as.Path, err)
+                return errors.Annotate(err, "Invalid log stream path %q", as.Path).Tag(common.CodeParameterError).Err()
         }
 
         return nil
 }
 
 var errNotMilo = errors.New("Requested stream is not a Milo annotation protobuf")
 var errNotDatagram = errors.New("Requested stream is not a datagram stream")
 var errNoEntries = errors.New("Log stream has no annotation entries")
 
 // Fetch loads the annotation stream from LogDog.
@@ skipping 146 matching lines @@
                 if link.Label == "" {
                         link.Label = "unnamed"
                 }
                 return link
 
         default:
                 // Don't know how to render.
                 return nil
         }
 }
+
+// BuildID implements buildsource.ID.
+type BuildID struct {
+        Host    string
+        Project cfgtypes.ProjectName
+        Path    types.StreamPath
+}
+
+// GetLog implements buildsource.ID.
+func (b *BuildID) GetLog(context.Context, string) (string, bool, error) { panic("not implemented") }
+
+// Get implements buildsource.ID.
+func (b *BuildID) Get(c context.Context) (*resp.MiloBuild, error) {
+        as := AnnotationStream{
+                Project: b.Project,
+                Path:    b.Path,
+        }
+        if err := as.Normalize(); err != nil {
+                return nil, err
+        }
+
+        // Setup our LogDog client.
+        var err error
+        if as.Client, err = NewClient(c, b.Host); err != nil {
+                return nil, errors.Annotate(err, "generating LogDog Client").Err()
+        }
+
+        // Load the Milo annotation protobuf from the annotation stream.
+        switch _, err := as.Fetch(c); errors.Unwrap(err) {
+        case nil, errNoEntries:
+
+        case coordinator.ErrNoSuchStream:
+                return nil, common.CodeNotFound.Tag().Apply(err)
+
+        case coordinator.ErrNoAccess:
+                return nil, common.CodeNoAccess.Tag().Apply(err)
+
+        case errNotMilo, errNotDatagram:
+                // The user requested a LogDog url that isn't a Milo annotation.
+                return nil, common.CodeParameterError.Tag().Apply(err)
+
+        default:
+                return nil, errors.Annotate(err, "failed to load stream").Err()
+        }
+
+        return as.toMiloBuild(c), nil
+}
+
+// NewBuildID generates a new un-validated BuildID.
+func NewBuildID(host, project, path string) *BuildID {
+        return &BuildID{
+                strings.TrimSpace(host),
+                cfgtypes.ProjectName(project),
+                types.StreamPath(strings.Trim(path, "/")),
+        }
+}