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

common/auth/internal/disk_cache.go

 // Copyright 2017 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 internal
 
 import (
         "encoding/json"
         "io/ioutil"
         "os"
         "path/filepath"
         "time"
 
         "golang.org/x/net/context"
         "golang.org/x/oauth2"
 
         "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"
 )
 
 const (
         // GCAccessTokenMaxAge defines when to remove unused access tokens from the
         // disk cache.
         //
         // We define "an access token" as an instance of oauth2.Token with
         // RefreshToken set to "".
         //
         // If an access token expired older than GCAccessTokenMaxAge ago, it will be
@@ skipping 160 matching lines @@
         }
 
         // Note that TempFile creates the file in 0600 mode already, so we don't need
         // to chmod it.
         //
         // On Windows Rename may fail with sharing violation error if some other
         // process has opened the file. We treat it as transient error, to trigger
         // a retry in updateCacheFile.
         if err = os.Rename(tmp.Name(), c.absPath()); err != nil {
                 cleanup()
-                return errors.WrapTransient(err)
+                return transient.Tag.Apply(err)
         }
         return nil
 }
 
 // updateCacheFile reads the token cache file, calls the callback, writes the file
 // back if the callback returns 'true'.
 //
 // It retries a bunch of times when encountering sharing violation errors on
 // Windows.
 //
 // TODO(vadimsh): Change this to use file locking - updateCacheFile is a global
 // critical section.
 func (c *DiskTokenCache) updateCacheFile(cb func(*cacheFile, time.Time) bool) error {
         retryParams := func() retry.Iterator {
                 return &retry.ExponentialBackoff{
                         Limited: retry.Limited{
                                 Delay:    10 * time.Millisecond,
                                 Retries:  200,
                                 MaxTotal: 4 * time.Second,
                         },
                         Multiplier: 1.5,
                 }
         }
-        return retry.Retry(c.Context, retry.TransientOnly(retryParams), func() error {
+        return retry.Retry(c.Context, transient.Only(retryParams), func() error {
                 cache, err := c.readCacheFile()
                 if err != nil {
                         return err
                 }
                 now := clock.Now(c.Context).UTC()
                 if cb(cache, now) {
                         return c.writeCacheFile(cache, now)
                 }
                 return nil
         }, func(err error, d time.Duration) {
@@ skipping 43 matching lines @@
         return c.updateCacheFile(func(cache *cacheFile, now time.Time) bool {
                 for i, entry := range cache.Cache {
                         if EqualCacheKeys(&entry.Key, key) {
                                 cache.Cache = append(cache.Cache[:i], cache.Cache[i+1:]...)
                                 return true
                         }
                 }
                 return false // not there, this is fine, skip writing the file
         })
 }