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

grpc/prpc/client.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 prpc
 
 import (
         "bytes"
         "fmt"
         "io"
         "io/ioutil"
         "net/http"
         "net/url"
         "strconv"
         "strings"
         "time"
 
         "github.com/golang/protobuf/proto"
         "golang.org/x/net/context"
         "golang.org/x/net/context/ctxhttp"
         "google.golang.org/grpc"
         "google.golang.org/grpc/codes"
         "google.golang.org/grpc/metadata"
 
         "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/common/retry/transient"
         "github.com/luci/luci-go/grpc/grpcutil"
 )
 
 const (
         // HeaderGRPCCode is a name of the HTTP header that specifies the
         // gRPC code in the response.
         // A pRPC server must always specify it.
         HeaderGRPCCode = "X-Prpc-Grpc-Code"
 
         // HeaderTimeout is HTTP header used to set pRPC request timeout.
@@ skipping 107 matching lines @@
                 "host":    c.Host,
                 "service": serviceName,
                 "method":  methodName,
         })
 
         // Send the request in a retry loop.
         var buf bytes.Buffer
         var contentType string
         err = retry.Retry(
                 ctx,
-                retry.TransientOnly(options.Retry),
+                transient.Only(options.Retry),
                 func() error {
                         ctx := ctx
                         logging.Debugf(ctx, "RPC %s/%s.%s", c.Host, serviceName, methodName)
 
                         // If there is a deadline on our Context, set the timeout header on the
                         // request.
                         now := clock.Now(ctx)
                         var requestDeadline time.Time
                         if options.PerRPCTimeout > 0 {
                                 requestDeadline = now.Add(options.PerRPCTimeout)
@@ skipping 29 matching lines @@
                         req.Body = ioutil.NopCloser(bytes.NewReader(in))
                         res, err := ctxhttp.Do(ctx, c.getHTTPClient(), req)
                         if res != nil && res.Body != nil {
                                 defer res.Body.Close()
                         }
                         if c.testPostHTTP != nil {
                                 err = c.testPostHTTP(ctx, err)
                         }
                         if err != nil {
                                 // Treat all errors here as transient.
-                                return errors.WrapTransient(fmt.Errorf("failed to send request: %s", err))
+                                return errors.Annotate(err).Reason("failed to send request").
+                                        Tag(transient.Tag).Err()
                         }
 
                         if options.resHeaderMetadata != nil {
                                 *options.resHeaderMetadata = metadataFromHeaders(res.Header)
                         }
                         contentType = res.Header.Get("Content-Type")
 
                         // Read the response body.
                         buf.Reset()
                         var body io.Reader = res.Body
@@ skipping 42 matching lines @@
                                 }
                                 if len(body) > bodySize {
                                         body = body[:bodySize] + "..."
                                 }
                                 err := fmt.Errorf("HTTP %d: no gRPC code. Body: %q", res.StatusCode, body)
 
                                 // Some HTTP codes are returned directly by hosting platforms (e.g.,
                                 // AppEngine), and should be automatically retried even if a gRPC code
                                 // header is not supplied.
                                 if res.StatusCode >= http.StatusInternalServerError {
-                                        err = errors.WrapTransient(err)
+                                        err = transient.Tag.Apply(err)
                                 }
                                 return err
                         }
 
                         codeInt, err := strconv.Atoi(codeHeader)
                         if err != nil {
                                 // Not a valid pRPC response.
                                 return fmt.Errorf("invalid grpc code %q: %s", codeHeader, err)
                         }
 
                         code := codes.Code(codeInt)
                         if code != codes.OK {
                                 desc := strings.TrimSuffix(buf.String(), "\n")
                                 err := grpcutil.Errf(code, "%s", desc)
                                 if grpcutil.IsTransientCode(code) {
-                                        err = errors.WrapTransient(err)
+                                        err = transient.Tag.Apply(err)
                                 }
                                 return err
                         }
                         return nil
                 },
                 func(err error, sleepTime time.Duration) {
                         logging.Fields{
                                 logging.ErrorKey: err,
                                 "sleepTime":      sleepTime,
                         }.Warningf(ctx, "RPC failed transiently. Will retry in %s", sleepTime)
@@ skipping 66 matching lines @@
         if len(h) == 0 {
                 return nil
         }
 
         md := make(metadata.MD, len(h))
         for k, v := range h {
                 md[strings.ToLower(k)] = v
         }
         return md
 }