Milo: Move instance configuration to luci-config

milo/appengine/buildbucket/builder.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 buildbucket
 
 import (
         "encoding/json"
         "fmt"
         "net/url"
         "os"
         "path"
         "path/filepath"
         "strconv"
         "strings"
         "time"
 
         "golang.org/x/net/context"
         "google.golang.org/api/googleapi"
 
         "github.com/luci/luci-go/common/api/buildbucket/buildbucket/v1"
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/errors"
-        log "github.com/luci/luci-go/common/logging"
+        "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/retry"
         "github.com/luci/luci-go/common/sync/parallel"
         "github.com/luci/luci-go/milo/api/resp"
+        "github.com/luci/luci-go/milo/appengine/common"
 )
 
 // search executes the search request with retries and exponential back-off.
 func search(c context.Context, client *buildbucket.Service, req *buildbucket.SearchCall) (
         *buildbucket.ApiSearchResponseMessage, error) {
 
         var res *buildbucket.ApiSearchResponseMessage
         err := retry.Retry(
                 c,
                 retry.TransientOnly(retry.Default),
                 func() error {
                         var err error
                         res, err = req.Do()
                         if apiErr, ok := err.(*googleapi.Error); ok && apiErr.Code >= 500 {
                                 err = errors.WrapTransient(apiErr)
                         }
                         return err
                 },
                 func(err error, wait time.Duration) {
-                        log.WithError(err).Warningf(c, "buildbucket search request failed transiently, will retry in %s", wait)
+                        logging.WithError(err).Warningf(c, "buildbucket search request failed transiently, will retry in %s", wait)
                 })
         return res, err
 }
 
 // fetchBuilds fetches builds given a criteria.
 // The returned builds are sorted by build creation descending.
 // count defines maximum number of builds to fetch; if <0, defaults to 100.
 func fetchBuilds(c context.Context, client *buildbucket.Service, bucket, builder,
         status string, count int) ([]*buildbucket.ApiBuildMessage, error) {
 
@@ skipping 19 matching lines @@
                         return fetched, fmt.Errorf(res.Error.Message)
                 }
 
                 fetched = append(fetched, res.Builds...)
 
                 if len(res.Builds) == 0 || res.NextCursor == "" {
                         break
                 }
                 req.StartCursor(res.NextCursor)
         }
-        log.Debugf(c, "Fetched %d %s builds in %s", len(fetched), status, clock.Since(c, start))
+        logging.Debugf(c, "Fetched %d %s builds in %s", len(fetched), status, clock.Since(c, start))
         return fetched, nil
 }
 
 // toMiloBuild converts a buildbucket build to a milo build.
 // In case of an error, returns a build with a description of the error
 // and logs the error.
 func toMiloBuild(c context.Context, build *buildbucket.ApiBuildMessage) *resp.BuildSummary {
         // Parsing of parameters and result details is best effort.
         var params buildParameters
         if err := json.NewDecoder(strings.NewReader(build.ParametersJson)).Decode(&params); err != nil {
-                log.Errorf(c, "Could not parse parameters of build %d: %s", build.Id, err)
+                logging.Errorf(c, "Could not parse parameters of build %d: %s", build.Id, err)
         }
         var resultDetails resultDetails
         if err := json.NewDecoder(strings.NewReader(build.ResultDetailsJson)).Decode(&resultDetails); err != nil {
-                log.Errorf(c, "Could not parse result details of build %d: %s", build.Id, err)
+                logging.Errorf(c, "Could not parse result details of build %d: %s", build.Id, err)
         }
 
         result := &resp.BuildSummary{
                 Text:     []string{fmt.Sprintf("buildbucket id %d", build.Id)},
                 Revision: resultDetails.Properties.GotRevision,
         }
         if result.Revision == "" {
                 result.Revision = params.Properties.Revision
         }
 
         var err error
         result.Status, err = parseStatus(build)
         if err != nil {
                 // almost never happens
-                log.WithError(err).Errorf(c, "could not convert status of build %d", build.Id)
+                logging.WithError(err).Errorf(c, "could not convert status of build %d", build.Id)
                 result.Status = resp.InfraFailure
                 result.Text = append(result.Text, fmt.Sprintf("invalid build: %s", err))
         }
 
         result.PendingTime.Started = parseTimestamp(build.CreatedTs)
         switch build.Status {
         case "SCHEDULED":
                 result.PendingTime.Duration = clock.Since(c, result.PendingTime.Started)
 
         case "STARTED":
@@ skipping 14 matching lines @@
 
         tags := ParseTags(build.Tags)
 
         if build.Url != "" {
                 u := build.Url
                 parsed, err := url.Parse(u)
 
                 // map milo links to itself
                 switch {
                 case err != nil:
-                        log.Errorf(c, "invalid URL in build %d: %s", build.Id, err)
+                        logging.Errorf(c, "invalid URL in build %d: %s", build.Id, err)
                 case parsed.Host == "luci-milo.appspot.com":
                         parsed.Host = ""
                         parsed.Scheme = ""
                         u = parsed.String()
                 }
 
                 result.Link = &resp.Link{
                         URL:   u,
                         Label: strconv.FormatInt(build.Id, 10),
                 }
@@ skipping 50 matching lines @@
                         }
 
                 default:
                         panic("impossible")
                 }
         }
         return nil
 }
 
 type builderQuery struct {
-        Server  string
         Bucket  string
         Builder string
         Limit   int
 }
 
 // builderImpl is the implementation for getting a milo builder page from buildbucket.
 // if maxCompletedBuilds < 0, 25 is used.
 func builderImpl(c context.Context, q builderQuery) (*resp.Builder, error) {
+        settings, err := common.GetSettings(c)
+        if err != nil {
+                logging.WithError(err).Errorf(c, "failed to get settings")
+                return nil, err
+        }
+        if settings.Buildbucket == nil || settings.Buildbucket.Host == "" {
+                logging.WithError(err).Errorf(c, "missing buildbucket settings")
+                return nil, errors.New("missing buildbucket settings")
+        }
+        host := settings.Buildbucket.Host
+
         if q.Limit < 0 {
                 q.Limit = 20
         }
 
         result := &resp.Builder{
                 Name: q.Builder,
         }
-        if q.Server == "debug" {
+        if host == "debug" {
                 return result, getDebugBuilds(c, q.Bucket, q.Builder, q.Limit, result)
         }
-        client, err := newBuildbucketClient(c, q.Server)
+        client, err := newBuildbucketClient(c, host)
         if err != nil {
                 return nil, err
         }
 
         fetch := func(target *[]*resp.BuildSummary, status string, count int) error {
                 builds, err := fetchBuilds(c, client, q.Bucket, q.Builder, status, count)
                 if err != nil {
-                        log.Errorf(c, "Could not fetch builds with status %s: %s", status, err)
+                        logging.Errorf(c, "Could not fetch builds with status %s: %s", status, err)
                         return err
                 }
                 *target = make([]*resp.BuildSummary, len(builds))
                 for i, bb := range builds {
                         (*target)[i] = toMiloBuild(c, bb)
                 }
                 return nil
         }
         // fetch pending, current and finished builds concurrently.
         // Why not a single request? Because we need different build number
@@ skipping 19 matching lines @@
         return time.Unix(microseconds/1e6, microseconds%1e6*1000).UTC()
 }
 
 type newBuildsFirst []*resp.BuildSummary
 
 func (a newBuildsFirst) Len() int      { return len(a) }
 func (a newBuildsFirst) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
 func (a newBuildsFirst) Less(i, j int) bool {
         return a[i].PendingTime.Started.After(a[j].PendingTime.Started)
 }