Update bulidbucket client

dm/appengine/distributor/jobsim/run.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 jobsim
 
 import (
         "encoding/json"
         "fmt"
         "math/rand"
         "net/http"
-        "strings"
         "time"
 
         "github.com/golang/protobuf/jsonpb"
         "google.golang.org/grpc/codes"
 
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/data/rand/cryptorand"
+        "github.com/luci/luci-go/common/lhttp"
         "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/dm/api/distributor/jobsim"
         dm "github.com/luci/luci-go/dm/api/service/v1"
         "github.com/luci/luci-go/grpc/grpcutil"
         "github.com/luci/luci-go/grpc/prpc"
         authlib "github.com/luci/luci-go/server/auth"
         "golang.org/x/net/context"
 )
 
 // state is the opaque state data that DM will pass between re-executions of the
@@ skipping 282 matching lines @@
         _, err = r.dmc.FinishAttempt(r.c, &dm.FinishAttemptReq{
                 Auth: r.auth,
                 Data: executionResult(false, 0, time.Time{}),
         })
         if err != nil {
                 logging.WithError(err).Warningf(r.c, "got error on FinishAttempt")
         }
         return
 }
 
-func isLocalHost(host string) bool {
-        switch {
-        case host == "localhost", strings.HasPrefix(host, "localhost:"):
-        case host == "127.0.0.1", strings.HasPrefix(host, "127.0.0.1:"):
-        case host == "[::1]", strings.HasPrefix(host, "[::1]:"):
-        case strings.HasPrefix(host, ":"):
-
-        default:
-                return false
-        }
-        return true
-}
-
 // runJob is analogous to a single Execution of a recipe. It will:
 //   * Activate itself with DM.
 //   * Inspect its previous State to determine where it left off on the previous
 //     execution.
 //   * Execute stages (incrementing the Stage counter in the state, and/or
 //     accumulating into Sum) until it hits a stop condition:
 //     * depending on incomplete Attempts
 //     * arriving at a final result
 //
 // If it hits some underlying error it will return that error, and expect to be
 // retried by DM.
 func runJob(c context.Context, host string, state *state, job *jobsim.Phrase, auth *dm.Execution_Auth, cfgName string) error {
         tr, err := authlib.GetRPCTransport(c, authlib.NoAuth)
         if err != nil {
                 return err
         }
         pcli := &prpc.Client{
                 C:       &http.Client{Transport: tr},
                 Host:    host,
                 Options: prpc.DefaultOptions(),
         }
-        pcli.Options.Insecure = isLocalHost(host)
+        pcli.Options.Insecure = lhttp.IsLocalHost(host)
         dmc := dm.NewDepsPRPCClient(pcli)
         r := runner{c, auth, dmc, state}
 
         ok, err := r.activateExecution()
         if !ok || err != nil {
                 return err
         }
 
         stop := false
         for ; r.state.Stage < len(job.Stages); r.state.Stage++ {
                 switch stg := job.Stages[r.state.Stage].StageType.(type) {
                 case *jobsim.Stage_Deps:
                         stop, err = r.doDeps(job.Seed, stg.Deps, cfgName)
                 case *jobsim.Stage_Stall:
                         r.doStall(stg.Stall)
                 case *jobsim.Stage_Failure:
                         stop, err = r.doFailure(job.Seed, stg.Failure.Chance)
                 default:
                         err = fmt.Errorf("don't know how to handle StageType: %T", stg)
                 }
                 if stop || err != nil {
                         return err
                 }
         }
         return r.doReturnStage(job.ReturnStage)
 }