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

appengine/datastorecache/cache.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 datastorecache
 
 import (
         "math"
         "time"
 
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/data/rand/mathrand"
         "github.com/luci/luci-go/common/errors"
         log "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/server/router"
 
         "github.com/luci/gae/impl/prod/constraints"
         "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/info"
 
         "golang.org/x/net/context"
 )
 
 const (
@@ skipping 263 matching lines @@
         // We'll try a few times, sleeping a short time in between if we fail to get
         // the lock. We don't want to wait too long and stall our parent application,
         // though.
         var (
                 attempts     = 0
                 acquiredLock = false
                 refreshValue Value
                 delta        time.Duration
         )
         err := retry.Retry(clock.Tag(c, "datastoreCacheLockRetry"),
-                retry.TransientOnly(bci.refreshRetryFactory), func() error {
+                transient.Only(bci.refreshRetryFactory), func() error {
 
                         // This is a retry. If the entry was missing before, check to see if some
                         // other process has since added it to the datastore.
                         // We only check this on the 2+ retry because we already checked this
                         // condition above in the initial datastore Get.
                         //
                         // If this fails, we'll continue to try and perform the Refresh.
                         if entryWasMissing && attempts > 0 {
                                 switch err := datastore.Get(c, &e); err {
                                 case nil:
@@ skipping 19 matching lines @@
                                 refreshValue, delta, err = doRefresh(c, bci.h, &e, userNS)
                                 return
                         })
                         switch err {
                         case nil:
                                 // Successfully loaded.
                                 return nil
 
                         case ErrFailedToLock:
                                 // Retry after delay.
-                                return errors.WrapTransient(err)
+                                return transient.Tag.Apply(err)
 
                         default:
                                 log.WithError(err).Warningf(c, "Unexpected failure obtaining initial load lock.")
                                 return err
                         }
                 }, func(err error, d time.Duration) {
                         log.WithError(err).Debugf(c, "Failed to acquire initial refresh lock. Retrying...")
                 })
         if err != nil {
                 // If we actually acquired the lock, then this refresh was a failure, and
@@ skipping 105 matching lines @@
 // delta is a factor representing the amount of time that it takes to
 // recalculate the value. Higher delta values allow for earlier recomputation
 // for values that take longer to calculate.
 //
 // beta can be set to >1 to favor earlier recomputations; however, in practice
 // beta=1 works well.
 func xFetch(now, expiry time.Time, delta time.Duration, beta float64, rf randFunc) bool {
         offset := time.Duration(float64(delta) * beta * math.Log(rf()))
         return !now.Add(-offset).Before(expiry)
 }