[milo] Refactor all html knowledge out of backends.

milo/buildsource/buildbot/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 buildbot
 
 import (
         "encoding/json"
-        "errors"
         "fmt"
         "io/ioutil"
         "math"
         "path/filepath"
         "regexp"
         "sort"
         "strconv"
         "strings"
         "time"
 
         "golang.org/x/net/context"
 
         "github.com/luci/gae/service/datastore"
         "github.com/luci/luci-go/common/data/stringset"
+        "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/milo/api/resp"
+        "github.com/luci/luci-go/milo/common"
         "github.com/luci/luci-go/milo/common/model"
 )
 
-var errBuildNotFound = errors.New("Build not found")
-
 // getBuild fetches a buildbot build from the datastore and checks ACLs.
 // The return code matches the master responses.
 func getBuild(c context.Context, master, builder string, buildNum int) (*buildbotBuild, error) {
         if err := canAccessMaster(c, master); err != nil {
                 return nil, err
         }
 
         result := &buildbotBuild{
                 Master:      master,
                 Buildername: builder,
                 Number:      buildNum,
         }
 
         err := datastore.Get(c, result)
         if err == datastore.ErrNoSuchEntity {
-                err = errBuildNotFound
+                err = errors.New("build not found", common.CodeNotFound)
         }
 
         return result, err
 }
 
 // result2Status translates a buildbot result integer into a model.Status.
 func result2Status(s *int) (status model.Status) {
         if s == nil {
                 return model.Running
         }
@@ skipping 598 matching lines @@
         var newAliases map[string][]*buildbotLinkAlias
         if l := remainingAliases.Len(); l > 0 {
                 newAliases = make(map[string][]*buildbotLinkAlias, l)
                 remainingAliases.Iter(func(v string) bool {
                         newAliases[v] = s.Aliases[v]
                         return true
                 })
         }
         s.Aliases = newAliases
 }
+
+// BuildID is buildbots's notion of a Build. See buildsource.ID.

[Ryan Tseng, 2017/07/13 22:00:46]

Make a note of why there is an error in here. (Because we validate on
generation, but return the error only when Get() is called)

It does seem a little awkward though, I have a very slight preference towards
making Number an string just so we don't have to carry the error around.

[iannucci, 2017/07/14 19:00:22]

Done.

+type BuildID struct {
+        Master      string
+        BuilderName string
+        BuildNumber int
+
+        err error
+}
+
+// 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(ctx context.Context) (*resp.MiloBuild, error) {
+        if b.err != nil {
+                return nil, b.err
+        }
+        if b.Master == "" {
+                return nil, errors.New("Master name is required", common.CodeParameterError)
+        }
+        if b.BuilderName == "" {
+                return nil, errors.New("BuilderName name is required", common.CodeParameterError)
+        }
+        if b.BuildNumber <= 0 {
+                return nil, errors.New("BuildNumber must be > 0", common.CodeParameterError)
+        }
+
+        return Build(ctx, b.Master, b.BuilderName, b.BuildNumber)
+}
+
+// NewBuildID generates a new BuildID.
+func NewBuildID(master, builder, build string) *BuildID {
+        num, err := strconv.ParseInt(build, 10, 0)
+        if err != nil {
+                return &BuildID{err: errors.
+                        Annotate(err, "BuildNumber is not a number").
+                        Tag(common.CodeParameterError).
+                        Err()}
+        }
+        return &BuildID{master, builder, int(num), nil}
+}