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

tokenserver/client/tokenclient.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 client
 
 import (
         "crypto/x509"
         "fmt"
 
         "github.com/golang/protobuf/proto"
         "golang.org/x/net/context"
         "google.golang.org/grpc"
         "google.golang.org/grpc/codes"
 
         "github.com/luci/luci-go/common/clock"
-        "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/proto/google"
+        "github.com/luci/luci-go/common/retry/transient"
         "github.com/luci/luci-go/grpc/grpcutil"
 
         "github.com/luci/luci-go/tokenserver/api/minter/v1"
 )
 
 // Client can make signed requests to the token server.
 type Client struct {
         // Client is interface to use for raw RPC calls to the token server.
         //
         // Use minter.NewTokenMinterClient (or NewTokenMinterPRPCClient) to
@@ skipping 20 matching lines @@
 //
 // Use typecast to distinguish recognized and unrecognized errors.
 type RPCError struct {
         error
 
         GrpcCode       codes.Code       // grpc-level status code
         ErrorCode      minter.ErrorCode // protocol-level status code
         ServiceVersion string           // version of the backend, if known
 }
 
-// IsTransient is needed to implement errors.Transient.
-func (e RPCError) IsTransient() bool {
-        return e.error != nil && grpcutil.IsTransientCode(e.GrpcCode)
-}
-
-var _ errors.Transient = RPCError{}
-
 // MintMachineToken signs the request using the signer and sends it.
 //
 // It will update in-place the following fields of the request:
 //   * Certificate will be set to ASN1 cert corresponding to the signer key.
 //   * SignatureAlgorithm will be set to the algorithm used to sign the request.
 //   * IssuedAt will be set to the current time.
 //
 // The rest of the fields must be already populated by the caller and will be
 // sent to the server as is.
 //
@@ skipping 33 matching lines @@
         }
 
         // Make an RPC call (with retries done by pRPC client).
         resp, err := c.Client.MintMachineToken(ctx, &minter.MintMachineTokenRequest{
                 SerializedTokenRequest: tokenRequest,
                 Signature:              signature,
         }, opts...)
 
         // Fatal pRPC-level error or transient error in case retries didn't help.
         if err != nil {
-                return nil, RPCError{
+                code := grpc.Code(err)
+                err = RPCError{
                         error:    err,
-                        GrpcCode: grpc.Code(err),
+                        GrpcCode: code,
                 }
+                if grpcutil.IsTransientCode(code) {
+                        err = transient.Tag.Apply(err)
+                }
+                return nil, err
         }
 
         // The response still may indicate a fatal error.
         if resp.ErrorCode != minter.ErrorCode_SUCCESS {
                 details := resp.ErrorMessage
                 if details == "" {
                         details = "no detailed error message"
                 }
                 return nil, RPCError{
                         error:          fmt.Errorf("token server error %s - %s", resp.ErrorCode, details),
                         GrpcCode:       codes.OK,
                         ErrorCode:      resp.ErrorCode,
                         ServiceVersion: resp.ServiceVersion,
                 }
         }
 
         // Must not happen. But better return an error than nil-panic if it does.
         if resp.TokenResponse == nil {
                 return nil, fmt.Errorf("token server didn't return a token")
         }
 
         return resp.TokenResponse, nil
 }