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

common/lhttp/client.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 lhttp
 
 import (
         "bytes"
         "encoding/json"
         "fmt"
         "io"
         "io/ioutil"
         "net/http"
         "strings"
 
         "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"
+        "github.com/luci/luci-go/common/retry/transient"
 )
 
 const (
         jsonContentType        = "application/json"
         jsonContentTypeForPOST = "application/json; charset=utf-8"
 )
 
 // Handler is called once or multiple times for each HTTP request that is tried.
 type Handler func(*http.Response) error
 
@@ skipping 19 matching lines @@
 // example if a TCP connection is terminated while receiving the content.
 //
 // If rFn is nil, NewRequest will use a default exponential backoff strategy
 // only for transient errors.
 //
 // If errorHandler is nil, the default error handler will drain and close the
 // response body.
 func NewRequest(ctx context.Context, c *http.Client, rFn retry.Factory, rgen RequestGen,
         handler Handler, errorHandler ErrorHandler) func() (int, error) {
         if rFn == nil {
-                rFn = retry.TransientOnly(retry.Default)
+                rFn = transient.Only(retry.Default)
         }
         if errorHandler == nil {
                 errorHandler = func(resp *http.Response, err error) error {
                         if resp != nil {
                                 // Drain and close the resp.Body.
                                 io.Copy(ioutil.Discard, resp.Body)
                                 resp.Body.Close()
                         }
                         return err
                 }
         }
 
         return func() (int, error) {
                 status, attempts := 0, 0
                 err := retry.Retry(ctx, rFn, func() error {
                         attempts++
                         req, err := rgen()
                         if err != nil {
                                 return err
                         }
 
                         resp, err := c.Do(req)
                         if err != nil {
                                 // Retry every error. This is sad when you specify an invalid hostname but
                                 // it's better than failing when DNS resolution is flaky.
-                                return errorHandler(nil, errors.WrapTransient(err))
+                                return errorHandler(nil, transient.Tag.Apply(err))
                         }
                         status = resp.StatusCode
 
                         switch {
                         case status == 408, status == 429, status >= 500:
                                 // The HTTP status code means the request should be retried.
-                                err = errors.WrapTransient(
-                                        fmt.Errorf("http request failed: %s (HTTP %d)", http.StatusText(status), status))
+                                err = errors.Reason("http request failed: %(text)s (HTTP %(code)d)").
+                                        D("text", http.StatusText(status)).D("code", status).Tag(transient.Tag).Err()
                         case status == 404 && strings.HasPrefix(req.URL.Path, "/_ah/api/"):
                                 // Endpoints occasionally return 404 on valid requests!
                                 logging.Infof(ctx, "lhttp.Do() got a Cloud Endpoints 404: %#v", resp.Header)
-                                err = errors.WrapTransient(
-                                        fmt.Errorf("http request failed (endpoints): %s (HTTP %d)", http.StatusText(status), status))
+                                err = errors.Reason("http request failed (endpoints): %(text)s (HTTP %(code)d)").
+                                        D("text", http.StatusText(status)).D("code", status).Tag(transient.Tag).Err()
                         case status >= 400:
                                 // Any other failure code is a hard failure.
                                 err = fmt.Errorf("http request failed: %s (HTTP %d)", http.StatusText(status), status)
                         default:
                                 // The handler may still return a retry.Error to indicate that the request
                                 // should be retried even on successful status code.
                                 return handler(resp)
                         }
 
                         return errorHandler(resp, err)
@@ skipping 40 matching lines @@
                         // Non-retriable.
                         return fmt.Errorf("unexpected Content-Type, expected \"%s\", got \"%s\"", jsonContentType, ct)
                 }
                 if out == nil {
                         // The client doesn't care about the response. Still ensure the response
                         // is valid json.
                         out = &map[string]interface{}{}
                 }
                 if err := json.NewDecoder(resp.Body).Decode(out); err != nil {
                         // Retriable.
-                        return errors.WrapTransient(fmt.Errorf("bad response %s: %s", url, err))
+                        return errors.Annotate(err).Reason("bad response %(url)s").
+                                D("url", url).Tag(transient.Tag).Err()
                 }
                 return nil
         }, nil), nil
 }
 
 // GetJSON is a shorthand. It returns the HTTP status code and error if any.
 func GetJSON(ctx context.Context, rFn retry.Factory, c *http.Client, url string, out interface{}) (int, error) {
         req, err := NewRequestJSON(ctx, c, rFn, url, "GET", nil, nil, out)
         if err != nil {
                 return 0, err
         }
         return req()
 }
 
 // PostJSON is a shorthand. It returns the HTTP status code and error if any.
 func PostJSON(ctx context.Context, rFn retry.Factory, c *http.Client, url string, headers map[string]string, in, out interface{}) (int, error) {
         req, err := NewRequestJSON(ctx, c, rFn, url, "POST", headers, in, out)
         if err != nil {
                 return 0, err
         }
         return req()
 }