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

server/auth/actor.go

 // Copyright 2017 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
 
 import (
         "encoding/gob"
         "fmt"
         "net/http"
         "sort"
         "strings"
         "time"
 
         "golang.org/x/net/context"
         "golang.org/x/oauth2"
         "google.golang.org/api/googleapi"
 
         "github.com/luci/luci-go/common/clock"
-        "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/gcloud/googleoauth"
         "github.com/luci/luci-go/common/gcloud/iam"
         "github.com/luci/luci-go/common/logging"
+        "github.com/luci/luci-go/common/retry/transient"
 )
 
 // MintAccessTokenParams is passed to MintAccessTokenForServiceAccount.
 type MintAccessTokenParams struct {
         // ServiceAccount is an email of a service account to mint a token for.
         ServiceAccount string
 
         // Scopes is a list of OAuth scopes the token should have.
         Scopes []string
 
@@ skipping 120 matching lines @@
                                 Scopes: sortedScopes,
                                 Client: &http.Client{Transport: cfg.AnonymousTransport(ctx)},
                         })
 
                         // Both iam.Signer and googleoauth.GetAccessToken return googleapi.Error
                         // on HTTP-level responses. Recognize fatal HTTP errors. Everything else
                         // (stuff like connection timeouts, deadlines, etc) are transient errors.
                         if err != nil {
                                 if apiErr, ok := err.(*googleapi.Error); ok && apiErr.Code < 500 {
                                         return nil, err, fmt.Sprintf("ERROR_MINTING_HTTP_%d", apiErr.Code)
-                                } else {
-                                        return nil, errors.WrapTransient(err), "ERROR_TRANSIENT_IN_MINTING"
                                 }
+                                return nil, transient.Tag.Apply(err), "ERROR_TRANSIENT_IN_MINTING"
                         }
 
                         // Log details about the new token.
                         now := clock.Now(ctx).UTC()
                         logging.Fields{
                                 "fingerprint": tokenFingerprint(tok.AccessToken),
                                 "validity":    tok.Expiry.Sub(now),
                         }.Debugf(ctx, "Minted new actor OAuth token")
 
                         return &cachedToken{
                                 Token:   makeCachedOAuth2Token(tok),
                                 Created: now,
                                 Expiry:  tok.Expiry,
                         }, nil, "SUCCESS_CACHE_MISS"
                 },
         })
 
         if err != nil {
                 report(err, label)
                 return nil, err
         }
 
         t := cached.Token.(cachedOAuth2Token) // let it panic on type mismatch
         report(nil, label)
         return t.toToken(), nil
 }