Update APIs to use new Google cloud paths.

logdog/server/cmd/logdog_archivist/main.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 main
 
 import (
         "time"
 
         "github.com/luci/luci-go/common/auth"
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/config"
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/gcloud/gs"
         gcps "github.com/luci/luci-go/common/gcloud/pubsub"
         log "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/sync/parallel"
         "github.com/luci/luci-go/common/tsmon/distribution"
         "github.com/luci/luci-go/common/tsmon/field"
         "github.com/luci/luci-go/common/tsmon/metric"
         "github.com/luci/luci-go/common/tsmon/types"
         "github.com/luci/luci-go/logdog/api/config/svcconfig"
         "github.com/luci/luci-go/logdog/server/archivist"
         "github.com/luci/luci-go/logdog/server/service"
+
+        "cloud.google.com/go/pubsub"
         "golang.org/x/net/context"
-        "google.golang.org/cloud"
-        "google.golang.org/cloud/pubsub"
+        "google.golang.org/api/option"
 )
 
 var (
         errInvalidConfig = errors.New("invalid configuration")
 
         // tsTaskProcessingTime measures the amount of time spent processing a single
         // task.
         //
         // The "consumed" field is true if the underlying task was consumed and
         // false if it was not.
@@ skipping 46 matching lines @@
         psProject, psSubscriptionName := taskSub.Split()
 
         psAuth, err := a.Authenticator(c, func(o *auth.Options) {
                 o.Scopes = gcps.SubscriberScopes
         })
         if err != nil {
                 log.WithError(err).Errorf(c, "Failed to get Pub/Sub authenticator.")
                 return err
         }
 
-        // Pub/Sub: HTTP Client => Context
-        psHTTPClient, err := psAuth.Client()
-        if err != nil {
-                log.WithError(err).Errorf(c, "Failed to create authenticated Pub/Sub transport.")
-                return err
-        }
-        psContext := cloud.WithContext(c, psProject, psHTTPClient)
-
         // Pub/Sub: TokenSource => Client
-        psClient, err := pubsub.NewClient(c, psProject, cloud.WithTokenSource(psAuth.TokenSource()))
+        psClient, err := pubsub.NewClient(c, psProject, option.WithTokenSource(psAuth.TokenSource()))
         if err != nil {
                 log.WithError(err).Errorf(c, "Failed to create Pub/Sub client.")
                 return err
         }
         sub := psClient.Subscription(psSubscriptionName)
 
         // Initialize our Storage.
         st, err := a.IntermediateStorage(c)
         if err != nil {
                 log.WithError(err).Errorf(c, "Failed to get storage instance.")
@@ skipping 69 matching lines @@
                                                 } else {
                                                         log.Fields{
                                                                 "duration": duration,
                                                         }.Infof(c, "Task processing incomplete. Not deleting.")
                                                 }
 
                                                 // Add to our processing time metric.
                                                 tsTaskProcessingTime.Add(c, duration.Seconds()*1000, deleteTask)
                                         }()
 
-                                        task, err := makePubSubArchivistTask(psContext, psSubscriptionName, msg)
+                                        task, err := makePubSubArchivistTask(psSubscriptionName, msg)
                                         if err != nil {
                                                 log.WithError(err).Errorf(c, "Failed to unmarshal archive task from message.")
                                                 deleteTask = true
                                                 return nil
                                         }
 
                                         ar.ArchiveTask(c, task)
                                         deleteTask = task.consumed
 
                                         return nil
@@ skipping 71 matching lines @@
 
 // Entry point.
 func main() {
         a := application{
                 Service: service.Service{
                         Name: "archivist",
                 },
         }
         a.Run(context.Background(), a.runArchivist)
 }