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

common/auth/localauth/server.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 localauth
 
 import (
         "crypto/subtle"
         "encoding/json"
         "fmt"
         "io"
         "mime"
         "net"
         "net/http"
         "regexp"
         "sort"
         "sync"
         "time"
 
         "golang.org/x/net/context"
         "golang.org/x/oauth2"
 
         "github.com/luci/luci-go/common/auth/localauth/rpcs"
         "github.com/luci/luci-go/common/data/rand/cryptorand"
         "github.com/luci/luci-go/common/data/stringset"
-        "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/common/runtime/paniccatcher"
         "github.com/luci/luci-go/lucictx"
 )
 
 // TokenGenerator produces access tokens.
 //
 // It is called to return an access token for given combination of scopes (given
 // as a sorted list of strings without duplicates).
 //
 // It is called for each request to the local auth server. It may be called
 // concurrently from multiple goroutines and must implement its own caching and
 // synchronization if necessary.
 //
 // It is expected that the returned token lives for at least given 'lifetime'
 // duration (which is typically on order of minutes), but it may live longer.
 // Clients may cache the returned token for the duration of its lifetime.
 //
-// May return transient errors (in errors.IsTransient returning true sense).
-// Such errors result in HTTP 500 responses. This is appropriate for non-fatal
-// errors. Clients may immediately retry requests on such errors.
+// May return transient errors (in transient.Tag.In(err) returning true
+// sense). Such errors result in HTTP 500 responses. This is appropriate for
+// non-fatal errors. Clients may immediately retry requests on such errors.
 //
 // Any non-transient error is considered fatal and results in an RPC-level
 // error response ({"error": ...}). Clients must treat such responses as fatal
 // and don't retry requests.
 //
 // If the error implements ErrorWithCode interface, the error code returned to
 // clients will be grabbed from the error object, otherwise the error code is
 // set to -1.
 type TokenGenerator func(ctx context.Context, scopes []string, lifetime time.Duration) (*oauth2.Token, error)
 
@@ skipping 270 matching lines @@
         // Route to the appropriate RPC handler.
         response, err := h.routeToImpl(method, request)
 
         // *protocolError are sent as HTTP errors.
         if pErr, _ := err.(*protocolError); pErr != nil {
                 http.Error(rw, pErr.Message, pErr.Status)
                 return
         }
 
         // Transient errors are returned as HTTP 500 responses.
-        if errors.IsTransient(err) {
+        if transient.Tag.In(err) {
                 http.Error(rw, fmt.Sprintf("Transient error - %s", err), http.StatusInternalServerError)
                 return
         }
 
         // Fatal errors are returned as specially structured JSON responses with
         // HTTP 200 code. Replace 'response' with it.
         if err != nil {
                 fatalError := rpcs.BaseResponse{
                         ErrorCode:    -1,
                         ErrorMessage: err.Error(),
@@ skipping 84 matching lines @@
         // Ask the token provider for the token. This may produce ErrorWithCode.
         tok, err := generator(h.ctx, sortedScopes, minTokenLifetime)
         if err != nil {
                 return nil, err
         }
         return &rpcs.GetOAuthTokenResponse{
                 AccessToken: tok.AccessToken,
                 Expiry:      tok.Expiry.Unix(),
         }, nil
 }