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

tokenserver/appengine/impl/certconfig/rpc_fetch_crl.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 certconfig
 
 import (
         "crypto/x509"
         "fmt"
         "io/ioutil"
         "net/http"
         "time"
 
         "golang.org/x/net/context"
         "google.golang.org/grpc"
         "google.golang.org/grpc/codes"
 
         ds "github.com/luci/gae/service/datastore"
         "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/tokenserver/api/admin/v1"
 )
 
 // List of OAuth scopes to use for token sent to CRL endpoint.
 var crlFetchScopes = []string{
         "https://www.googleapis.com/auth/userinfo.email",
 }
 
@@ skipping 29 matching lines @@
 
         // Fetch latest CRL blob.
         logging.Infof(c, "Fetching CRL for %q from %s", ca.CN, cfg.CrlUrl)
         knownETag := crl.LastFetchETag
         if req.Force {
                 knownETag = ""
         }
         fetchCtx, _ := clock.WithTimeout(c, time.Minute)
         crlDer, newEtag, err := fetchCRL(fetchCtx, cfg, knownETag)
         switch {
-        case errors.IsTransient(err):
+        case retry.Tag.In(err):
                 return nil, grpc.Errorf(codes.Internal, "transient error when fetching CRL - %s", err)
         case err != nil:
                 return nil, grpc.Errorf(codes.Unknown, "can't fetch CRL - %s", err)
         }
 
         // No changes?
         if knownETag != "" && knownETag == newEtag {
                 logging.Infof(c, "No changes to CRL (etag is %s), skipping", knownETag)
         } else {
                 logging.Infof(c, "Fetched CRL size is %d bytes, etag is %s", len(crlDer), newEtag)
                 crl, err = validateAndStoreCRL(c, crlDer, newEtag, ca, crl)
                 switch {
-                case errors.IsTransient(err):
+                case retry.Tag.In(err):
                         return nil, grpc.Errorf(codes.Internal, "transient error when storing CRL - %s", err)
                 case err != nil:
                         return nil, grpc.Errorf(codes.Unknown, "bad CRL - %s", err)
                 }
         }
 
         return &admin.FetchCRLResponse{CrlStatus: crl.GetStatusProto()}, nil
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 18 matching lines @@
         req, err := http.NewRequest("GET", cfg.CrlUrl, nil)
         if err != nil {
                 return nil, "", err
         }
         if knownETag != "" {
                 req.Header.Set("If-None-Match", knownETag)
         }
         cl := http.Client{Transport: transport}
         resp, err := cl.Do(req)
         if err != nil {
-                return nil, "", errors.WrapTransient(err)
+                return nil, "", retry.Tag.Apply(err)
         }
         defer resp.Body.Close()
 
         // Nothing new?
         if resp.StatusCode == http.StatusNotModified {
                 if knownETag == "" {
                         return nil, "", errors.New("unexpected 304 status, no etag header was sent")
                 }
                 return nil, knownETag, nil
         }
 
         // Read the body in its entirety.
         blob, err = ioutil.ReadAll(resp.Body)
         if err != nil {
-                return nil, "", errors.WrapTransient(err)
+                return nil, "", retry.Tag.Apply(err)
         }
 
         // Transient error?
         if resp.StatusCode >= http.StatusInternalServerError {
                 logging.Warningf(c, "GET %s - HTTP %d; %q", cfg.CrlUrl, resp.StatusCode, string(blob))
-                return nil, "", errors.WrapTransient(fmt.Errorf("server replied with HTTP %d", resp.StatusCode))
+                return nil, "", errors.Reason("server replied with HTTP %(code)d").
+                        D("code", resp.StatusCode).Tag(retry.Tag).Err()
         }
 
         // Something we don't support or expect?
         if resp.StatusCode != http.StatusOK {
                 logging.Errorf(c, "GET %s - HTTP %d; %q", cfg.CrlUrl, resp.StatusCode, string(blob))
                 return nil, "", fmt.Errorf("unexpected status HTTP %d", resp.StatusCode)
         }
 
         // Good enough.
         return blob, resp.Header.Get("ETag"), nil
@@ skipping 51 matching lines @@
                         return err
                 }
                 if !curCA.Ready {
                         logging.Infof(c, "CA %q is ready now", curCA.CN)
                         curCA.Ready = true
                         toPut = append(toPut, &curCA)
                 }
                 return ds.Put(c, toPut)
         }, nil)
         if err != nil {
-                return nil, errors.WrapTransient(err)
+                return nil, retry.Tag.Apply(err)
         }
 
         logging.Infof(c, "CRL for %q is updated, entity version is %d", ca.CN, updated.EntityVersion)
         return updated, nil
 }