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

common/auth/internal/luci_ctx.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 internal
 
 import (
         "bytes"
         "crypto/sha1"
         "encoding/hex"
         "encoding/json"
         "fmt"
         "io/ioutil"
         "net/http"
         "strings"
         "time"
 
         "golang.org/x/net/context"
         "golang.org/x/net/context/ctxhttp"
         "golang.org/x/oauth2"
 
         "github.com/luci/luci-go/common/auth/localauth/rpcs"
-        "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/logging"
+        "github.com/luci/luci-go/common/retry/transient"
         "github.com/luci/luci-go/lucictx"
 )
 
 type luciContextTokenProvider struct {
         localAuth *lucictx.LocalAuth
         scopes    []string
         transport http.RoundTripper
         cacheKey  CacheKey // used only for in-memory cache
 }
 
@@ skipping 77 matching lines @@
         url := fmt.Sprintf("http://127.0.0.1:%d/rpc/LuciLocalAuthService.GetOAuthToken", p.localAuth.RPCPort)
         logging.Debugf(ctx, "POST %s", url)
         httpReq, err := http.NewRequest("POST", url, bytes.NewReader(body))
         if err != nil {
                 return nil, err
         }
         httpReq.Header.Set("Content-Type", "application/json")
 
         httpResp, err := ctxhttp.Do(ctx, &http.Client{Transport: p.transport}, httpReq)
         if err != nil {
-                return nil, errors.WrapTransient(err)
+                return nil, transient.Tag.Apply(err)
         }
         defer httpResp.Body.Close()
         respBody, err := ioutil.ReadAll(httpResp.Body)
         if err != nil {
-                return nil, errors.WrapTransient(err)
+                return nil, transient.Tag.Apply(err)
         }
 
         if httpResp.StatusCode != 200 {
                 err := fmt.Errorf("local auth - HTTP %d: %s", httpResp.StatusCode, strings.TrimSpace(string(respBody)))
                 if httpResp.StatusCode >= 500 {
-                        return nil, errors.WrapTransient(err)
+                        return nil, transient.Tag.Apply(err)
                 }
                 return nil, err
         }
 
         response := rpcs.GetOAuthTokenResponse{}
         if err := json.Unmarshal(respBody, &response); err != nil {
                 return nil, err
         }
         if response.ErrorMessage != "" || response.ErrorCode != 0 {
                 msg := response.ErrorMessage
                 if msg == "" {
                         msg = "unknown error"
                 }
                 return nil, fmt.Errorf("local auth - RPC code %d: %s", response.ErrorCode, msg)
         }
 
         return &oauth2.Token{
                 AccessToken: response.AccessToken,
                 Expiry:      time.Unix(response.Expiry, 0).UTC(),
                 TokenType:   "Bearer",
         }, nil
 }
 
 func (p *luciContextTokenProvider) RefreshToken(ctx context.Context, prev, base *oauth2.Token) (*oauth2.Token, error) {
         // Minting and refreshing is the same thing: a call to local auth server.
         return p.MintToken(ctx, base)
 }