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

tokenserver/appengine/impl/certconfig/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/sha1"
         "crypto/x509/pkix"
         "encoding/hex"
         "fmt"
         "math/big"
         "sync"
         "time"
 
         "golang.org/x/net/context"
 
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/data/caching/lazyslot"
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/proto/google"
+        "github.com/luci/luci-go/common/retry"
 
         "github.com/luci/luci-go/tokenserver/api/admin/v1"
 
         "github.com/luci/luci-go/tokenserver/appengine/impl/utils"
         "github.com/luci/luci-go/tokenserver/appengine/impl/utils/shards"
 )
 
 // CRLShardCount is a number of shards to use for storing CRL in the datastore.
 //
 // Each shard can hold ~2 MB of data (taking into account zlib compression),
@@ skipping 232 matching lines @@
         }
 
         // Have something locally already? Quickly fetch CRLShardHeader to check
         // whether we need to pull a heavy CRLShardBody.
         hdr := CRLShardHeader{ID: shardEntityID(ch.cn, ch.shardCount, idx)}
         if prevState.sha1 != "" {
                 switch err := ds.Get(c, &hdr); {
                 case err == ds.ErrNoSuchEntity:
                         return lazyslot.Value{}, fmt.Errorf("shard header %q is missing", hdr.ID)
                 case err != nil:
-                        return lazyslot.Value{}, errors.WrapTransient(err)
+                        return lazyslot.Value{}, retry.Tag.Apply(err)
                 }
                 // The currently cached copy is still good enough?
                 if hdr.SHA1 == prevState.sha1 {
                         return lazyslot.Value{
                                 Value:      prevState,
                                 Expiration: clock.Now(c).Add(ch.cacheDuration),
                         }, nil
                 }
         }
 
         // Nothing is cached, or the datastore copy is fresher than what we have in
         // the cache. Need to fetch a new copy, unzip and deserialize it. This entity
         // is prepared by updateCRLShard.
         body := CRLShardBody{Parent: ds.KeyForObj(c, &hdr)}
         switch err := ds.Get(c, &body); {
         case err == ds.ErrNoSuchEntity:
                 return lazyslot.Value{}, fmt.Errorf("shard body %q is missing", hdr.ID)
         case err != nil:
-                return lazyslot.Value{}, errors.WrapTransient(err)
+                return lazyslot.Value{}, retry.Tag.Apply(err)
         }
 
         // Unzip and deserialize.
         blob, err := utils.ZlibDecompress(body.ZippedData)
         if err != nil {
                 return lazyslot.Value{}, err
         }
         shard, err := shards.ParseShard(blob)
         if err != nil {
                 return lazyslot.Value{}, err
         }
 
         return lazyslot.Value{
                 Value: shardCache{
                         shard: shard,
                         sha1:  body.SHA1,
                 },
                 Expiration: clock.Now(c).Add(ch.cacheDuration),
         }, nil
 }