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

tokenserver/appengine/impl/delegation/rpc_mint_delegation_token.go

 // Copyright 2016 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 delegation
 
 import (
         "fmt"
         "strings"
         "time"
 
         "github.com/golang/protobuf/jsonpb"
         "golang.org/x/net/context"
         "google.golang.org/grpc"
         "google.golang.org/grpc/codes"
 
         "github.com/luci/gae/service/info"
         "github.com/luci/luci-go/common/clock"
-        "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/logging"
+        "github.com/luci/luci-go/common/retry"
         "github.com/luci/luci-go/server/auth"
         "github.com/luci/luci-go/server/auth/authdb"
         "github.com/luci/luci-go/server/auth/delegation/messages"
         "github.com/luci/luci-go/server/auth/identity"
         "github.com/luci/luci-go/server/auth/signing"
 
         admin "github.com/luci/luci-go/tokenserver/api/admin/v1"
         "github.com/luci/luci-go/tokenserver/api/minter/v1"
         "github.com/luci/luci-go/tokenserver/appengine/impl/utils"
         "github.com/luci/luci-go/tokenserver/appengine/impl/utils/identityset"
@@ skipping 87 matching lines @@
         if req.ValidityDuration < 0 {
                 err = fmt.Errorf("invalid 'validity_duration' (%d)", req.ValidityDuration)
                 logging.WithError(err).Errorf(c, "Bad request")
                 return nil, grpc.Errorf(codes.InvalidArgument, "bad request - %s", err)
         }
 
         // Validate and normalize the request. This may do relatively expensive calls
         // to resolve "https://<service-url>" entries to "service:<id>" entries.
         query, err := buildRulesQuery(c, req, callerID)
         if err != nil {
-                if errors.IsTransient(err) {
+                if retry.Tag.In(err) {
                         logging.WithError(err).Errorf(c, "buildRulesQuery failed")
                         return nil, grpc.Errorf(codes.Internal, "failure when resolving target service ID - %s", err)
                 }
                 logging.WithError(err).Errorf(c, "Bad request")
                 return nil, grpc.Errorf(codes.InvalidArgument, "bad request - %s", err)
         }
 
         // Consult the config to find the rule that allows this operation (if any).
         rule, err := rules.FindMatchingRule(c, query)
         if err != nil {
-                if errors.IsTransient(err) {
+                if retry.Tag.In(err) {
                         logging.WithError(err).Errorf(c, "FindMatchingRule failed")
                         return nil, grpc.Errorf(codes.Internal, "failure when checking rules - %s", err)
                 }
                 logging.WithError(err).Errorf(c, "Didn't pass rules check")
                 return nil, grpc.Errorf(codes.PermissionDenied, "forbidden - %s", err)
         }
         logging.Infof(c, "Found the matching rule %q in the config rev %s", rule.Name, rules.ConfigRevision())
 
         // Make sure the requested token lifetime is allowed by the rule.
         if req.ValidityDuration > rule.MaxValidityDuration {
@@ skipping 192 matching lines @@
         for _, url := range urls {
                 go func(url string) {
                         id, err := fetchLUCIServiceIdentity(c, url)
                         ch <- Result{url, id, err}
                 }(url)
         }
 
         for i := 0; i < len(urls); i++ {
                 result := <-ch
                 if result.Err != nil {
-                        if errors.IsTransient(result.Err) {
+                        if retry.Tag.In(result.Err) {
                                 return result.Err
                         }
                         return fmt.Errorf("could not resolve %q to service ID - %s", result.URL, result.Err)
                 }
                 out.AddIdentity(result.ID)
         }
 
         return nil
 }