Use native Pub/Sub library primitives.

client/cmd/logdog_butler/main.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package main
 
 import (
         "errors"
         "flag"
         "fmt"
@@ skipping 11 matching lines @@
         "github.com/luci/luci-go/common/auth"
         "github.com/luci/luci-go/common/clock/clockflag"
         "github.com/luci/luci-go/common/flag/multiflag"
         "github.com/luci/luci-go/common/gcloud/pubsub"
         "github.com/luci/luci-go/common/logdog/types"
         log "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/logging/gologger"
         "github.com/luci/luci-go/common/paniccatcher"
         "github.com/maruel/subcommands"
         "golang.org/x/net/context"
+        "golang.org/x/oauth2"
 )
 
 const (
         // flagErrorReturnCode is returned when there is an error with the Butler's
         // command-line configuration.
         configErrorReturnCode = 2
 
         // runtimeErrorReturnCode is returned when the execution fails due to a Butler
         // error. This is intended to help differentiate Butler errors from
         // passthrough bootstrapped subprocess errors.
@@ skipping 68 matching lines @@
                 "cpuprofile", "", "If specified, enables CPU profiling and profiles to the specified path.")
         fs.IntVar(&a.butler.OutputWorkers, "output-workers", butler.DefaultOutputWorkers,
                 "The maximum number of parallel output dispatches.")
         fs.Var(&a.maxBufferAge, "output-max-buffer-age",
                 "Send buffered messages if they've been held for longer than this period.")
         fs.BoolVar(&a.noBufferLogs, "output-no-buffer", false,
                 "If true, dispatch logs immediately. Setting this flag simplifies output at the expense "+
                         "of wire-format efficiency.")
 }
 
+func (a *application) authenticator(ctx context.Context) (*auth.Authenticator, error) {
+        opts, err := a.authFlags.Options()
+        if err != nil {
+                return nil, err
+        }
+        opts.Context = ctx
+        return auth.NewAuthenticator(auth.SilentLogin, opts), nil
+}
+
 func (a *application) authenticatedClient(ctx context.Context) (*http.Client, error) {
         if a.client == nil {
-                opts, err := a.authFlags.Options()
+                authenticator, err := a.authenticator(ctx)
                 if err != nil {
                         return nil, err
                 }
-                opts.Context = ctx
 
-                client, err := auth.NewAuthenticator(auth.SilentLogin, opts).Client()
+                client, err := authenticator.Client()
                 if err != nil {
                         return nil, err
                 }
                 a.client = client
         }
         return a.client, nil
 }
 
+func (a *application) authenticatedTokenSource(ctx context.Context) (oauth2.TokenSource, error) {

[Vadim Sh., 2016/03/29 19:02:37]

nit: just tokenSource(). It can't be "unauthenticated".

[dnj, 2016/03/29 19:27:20]

Done.

+        authenticator, err := a.authenticator(ctx)
+        if err != nil {
+                return nil, err
+        }
+        return authenticator.TokenSource(), nil
+}
+
 func (a *application) configOutput() (output.Output, error) {
         factory := a.outputConfig.getFactory()
         if factory == nil {
                 return nil, errors.New("main: No output is configured")
         }
 
         output, err := factory.configOutput(a)
         if err != nil {
                 return nil, err
         }
@@ skipping 191 matching lines @@
 
         paniccatcher.Do(func() {
                 rc = mainImpl(ctx, os.Args[1:])
         }, func(p *paniccatcher.Panic) {
                 log.Fields{
                         "panic.error": p.Reason,
                 }.Errorf(ctx, "Panic caught in main:\n%s", p.Stack)
                 rc = runtimeErrorReturnCode
         })
 }