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

appengine/gaesettings/gaesettings.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 gaesettings implements settings.Storage interface on top of GAE
 // datastore.
 //
 // See github.com/luci/luci-go/server/settings for more details.
 package gaesettings
 
 import (
         "encoding/json"
         "strconv"
         "time"
 
         "golang.org/x/net/context"
 
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/info"
         "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/settings"
 )
 
 // Storage knows how to store JSON blobs with settings in the datastore.
 //
 // It implements server/settings.EventualConsistentStorage interface.
 type Storage struct{}
 
 // settingsEntity is used to store all settings as JSON blob. Latest settings
 // are stored under key (gaesettings.Settings, latest). The historical log is
@@ skipping 41 matching lines @@
 // FetchAllSettings fetches all latest settings at once.
 func (s Storage) FetchAllSettings(c context.Context) (*settings.Bundle, error) {
         c = defaultContext(c)
         logging.Debugf(c, "Fetching app settings from the datastore")
 
         latest := latestSettings()
         switch err := ds.Get(c, &latest); {
         case err == ds.ErrNoSuchEntity:
                 break
         case err != nil:
-                return nil, errors.WrapTransient(err)
+                return nil, retry.Tag.Apply(err)
         }
 
         pairs := map[string]*json.RawMessage{}
         if latest.Value != "" {
                 if err := json.Unmarshal([]byte(latest.Value), &pairs); err != nil {
                         return nil, err
                 }
         }
         return &settings.Bundle{
                 Values: pairs,
@@ skipping 49 matching lines @@
                 // Don't store copy of "no settings at all", it's useless.
                 if latest.Version == 1 {
                         return ds.Put(c, &latest)
                 }
                 return ds.Put(c, &latest, &auditCopy)
         }, nil)
 
         if fatalFail != nil {
                 return fatalFail
         }
-        return errors.WrapTransient(err)
+        return retry.Tag.Apply(err)
 }
 
 // GetConsistencyTime returns "last modification time" + "expiration period".
 //
 // It indicates moment in time when last setting change is fully propagated to
 // all instances.
 //
 // Returns zero time if there are no settings stored.
 func (s Storage) GetConsistencyTime(c context.Context) (time.Time, error) {
         c = defaultContext(c)
         latest := latestSettings()
         switch err := ds.Get(c, &latest); err {
         case nil:
                 return latest.When.Add(s.expirationDuration(c)), nil
         case ds.ErrNoSuchEntity:
                 return time.Time{}, nil
         default:
-                return time.Time{}, errors.WrapTransient(err)
+                return time.Time{}, retry.Tag.Apply(err)
         }
 }