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

server/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
 
 import (
         "fmt"
         "net/http"
 
         "golang.org/x/net/context"
 
         "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/server/auth/delegation"
         "github.com/luci/luci-go/server/auth/identity"
         "github.com/luci/luci-go/server/auth/signing"
         "github.com/luci/luci-go/server/router"
 )
 
 var (
         // ErrNotConfigured is returned by Authenticate if auth library wasn't
         // properly initialized (see SetConfig).
@@ skipping 85 matching lines @@
 }
 
 // GetMiddleware returns a middleware that uses this Authenticator for
 // authentication.
 //
 // It uses a.Authenticate internally and handles errors appropriately.
 func (a *Authenticator) GetMiddleware() router.Middleware {
         return func(c *router.Context, next router.Handler) {
                 ctx, err := a.Authenticate(c.Context, c.Request)
                 switch {
-                case errors.IsTransient(err):
+                case transient.Tag.In(err):
                         replyError(c.Context, c.Writer, 500, "Transient error during authentication", err)
                 case err != nil:
                         replyError(c.Context, c.Writer, 401, "Authentication error", err)
                 default:
                         c.Context = ctx
                         next(c)
                 }
         }
 }
 
@@ skipping 106 matching lines @@
                         return nil, err
                 }
                 delegatedIdentity, err := delegation.CheckToken(c, delegation.CheckTokenParams{
                         Token:                delegationTok,
                         PeerID:               s.peerIdent,
                         CertificatesProvider: s.db,
                         GroupsChecker:        s.db,
                         OwnServiceIdentity:   ownServiceIdentity,
                 })
                 if err != nil {
-                        if errors.IsTransient(err) {
+                        if transient.Tag.In(err) {
                                 report(err, "ERROR_TRANSIENT_IN_TOKEN_CHECK")
                         } else {
                                 report(err, "ERROR_BAD_DELEGATION_TOKEN")
                         }
                         return nil, err
                 }
 
                 // User profile information is not available when using delegation, so just
                 // wipe it.
                 s.user = &User{Identity: delegatedIdentity}
@@ skipping 59 matching lines @@
 func getOwnServiceIdentity(c context.Context, signer signing.Signer) (identity.Identity, error) {
         if signer == nil {
                 return "", ErrNotConfigured
         }
         serviceInfo, err := signer.ServiceInfo(c)
         if err != nil {
                 return "", err
         }
         return identity.MakeIdentity("service:" + serviceInfo.AppID)
 }