Update APIs to use new Google cloud paths.

logdog/appengine/coordinator/service.go

 // Copyright 2015 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 coordinator
 
 import (
         "net/http"
         "sync"
         "sync/atomic"
 
         "github.com/luci/luci-go/appengine/gaemiddleware"
         luciConfig "github.com/luci/luci-go/common/config"
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/gcloud/gs"
         "github.com/luci/luci-go/common/gcloud/pubsub"
         log "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/logdog/api/config/svcconfig"
         "github.com/luci/luci-go/logdog/appengine/coordinator/config"
         "github.com/luci/luci-go/logdog/common/storage"
         "github.com/luci/luci-go/logdog/common/storage/bigtable"
         "github.com/luci/luci-go/server/auth"
         "github.com/luci/luci-go/server/router"
+
+        gcps "cloud.google.com/go/pubsub"
         "golang.org/x/net/context"
-        "google.golang.org/cloud"
-        gcps "google.golang.org/cloud/pubsub"
+        "google.golang.org/api/option"
         "google.golang.org/grpc/metadata"
 )
 
 // Services is a set of support services used by Coordinator.
 //
 // Each Services instance is valid for a singel request, but can be re-used
 // throughout that request. This is advised, as the Services instance may
 // optionally cache values.
 //
 // Services methods are goroutine-safe.
@@ skipping 157 matching lines @@
 
         // Explicitly clear gRPC metadata from the Context. It is forwarded to
         // delegate calls by default, and standard request metadata can break BigTable
         // calls.
         c = metadata.NewContext(c, nil)
 
         st, err := bigtable.New(c, bigtable.Options{
                 Project:  bt.Project,
                 Instance: bt.Instance,
                 LogTable: bt.LogTableName,
-                ClientOptions: []cloud.ClientOption{
-                        cloud.WithBaseHTTP(&http.Client{Transport: transport}),
+                ClientOptions: []option.ClientOption{
+                        option.WithHTTPClient(&http.Client{Transport: transport}),
                 },
         })
         if err != nil {
                 log.WithError(err).Errorf(c, "Failed to create BigTable instance.")
                 return nil, err
         }
         return st, nil
 }
 
 func (s *prodServicesInst) GSClient(c context.Context) (gs.Client, error) {
@@ skipping 23 matching lines @@
         }
         project, topic := fullTopic.Split()
 
         // Create an authenticated Pub/Sub client.
         transport, err := auth.GetRPCTransport(c, auth.AsSelf, auth.WithScopes(pubsub.PublisherScopes...))
         if err != nil {
                 log.WithError(err).Errorf(c, "Failed to create Pub/Sub authenticator.")
                 return nil, errors.New("failed to create Pub/Sub authenticator")
         }
         client := &http.Client{Transport: transport}
-        psClient, err := gcps.NewClient(c, project, cloud.WithBaseHTTP(client))
+        psClient, err := gcps.NewClient(c, project, option.WithHTTPClient(client))
         if err != nil {
                 log.WithError(err).Errorf(c, "Failed to create Pub/Sub client.")
                 return nil, errors.New("failed to create Pub/Sub client")
         }
 
         return &pubsubArchivalPublisher{
                 topic:            psClient.Topic(topic),
                 publishIndexFunc: s.nextArchiveIndex,
         }, nil
 }
 
 func (s *prodServicesInst) nextArchiveIndex() uint64 {
         // We use a 32-bit value for this because it avoids atomic memory bounary
         // issues. Furthermore, we constrain it to be positive, using a negative
         // value as a sentinel that the archival index has wrapped.
         //
         // This is reasonable, as it is very unlikely that a single request will issue
         // more than MaxInt32 archival tasks.
         v := atomic.AddInt32(&s.archivalIndex, 1) - 1
         if v < 0 {
                 panic("archival index has wrapped")
         }
         return uint64(v)
 }