[errors] de-specialize Transient in favor of Tags.

common/auth/auth.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 auth implements a wrapper around golang.org/x/oauth2.
 //
 // Its main improvement is the on-disk cache for OAuth tokens, which is
 // especially important for 3-legged interactive OAuth flows: its usage
 // eliminates annoying login prompts each time a program is used (because the
 // refresh token can now be reused). The cache also allows to reduce unnecessary
@@ skipping 23 matching lines @@
         "golang.org/x/net/context"
         "golang.org/x/oauth2"
         "google.golang.org/grpc/credentials"
 
         "github.com/luci/luci-go/common/auth/internal"
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/gcloud/iam"
         "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/retry"
+        "github.com/luci/luci-go/common/retry/transient"
         "github.com/luci/luci-go/lucictx"
 )
 
 var (
         // ErrLoginRequired is returned by Transport() in case long term credentials
         // are not cached and the user must go through interactive login.
         ErrLoginRequired = errors.New("interactive login is required")
 
         // ErrInsufficientAccess is returned by Login() or Transport() if access_token
         // can't be minted for given OAuth scopes. For example if GCE instance wasn't
@@ skipping 1134 matching lines @@
                         Retries:  50,
                         MaxTotal: 5 * time.Second,
                 },
                 Multiplier: 2,
         }
 }
 
 // mintTokenWithRetries calls provider's MintToken() retrying on transient
 // errors a bunch of times. Called only for non-interactive providers.
 func (t *tokenWithProvider) mintTokenWithRetries(ctx context.Context, base *oauth2.Token) (tok *oauth2.Token, err error) {
-        err = retry.Retry(ctx, retry.TransientOnly(retryParams), func() error {
+        err = retry.Retry(ctx, transient.Only(retryParams), func() error {
                 tok, err = t.provider.MintToken(ctx, base)
                 return err
         }, nil)
         return
 }
 
 // refreshTokenWithRetries calls providers' RefreshToken(...) retrying on
 // transient errors a bunch of times.
 func (t *tokenWithProvider) refreshTokenWithRetries(ctx context.Context, prev, base *oauth2.Token) (tok *oauth2.Token, err error) {
-        err = retry.Retry(ctx, retry.TransientOnly(retryParams), func() error {
+        err = retry.Retry(ctx, transient.Only(retryParams), func() error {
                 tok, err = t.provider.RefreshToken(ctx, prev, base)
                 return err
         }, nil)
         return
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Utility functions.
 
 // makeBaseTokenProvider creates TokenProvider implementation based on options.
@@ skipping 43 matching lines @@
 func makeIAMTokenProvider(ctx context.Context, opts *Options) (internal.TokenProvider, error) {
         if opts.testingIAMTokenProvider != nil {
                 return opts.testingIAMTokenProvider, nil
         }
         return internal.NewIAMTokenProvider(
                 ctx,
                 opts.ActAsServiceAccount,
                 opts.Scopes,
                 opts.Transport)
 }