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

appengine/gaeauth/server/internal/authdbimpl/authdb.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 authdbimpl
 
 import (
         "fmt"
         "strings"
         "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/errors"
         "github.com/luci/luci-go/common/logging"
+        "github.com/luci/luci-go/common/retry"
         "github.com/luci/luci-go/server/auth/service"
         "github.com/luci/luci-go/server/auth/service/protocol"
 )
 
 // SnapshotInfo identifies some concrete AuthDB snapshot.
 //
 // Singleton entity. Serves as a pointer to a blob with corresponding AuthDB
 // proto message (stored in separate Snapshot entity).
 type SnapshotInfo struct {
         AuthServiceURL string `gae:",noindex"`
@@ skipping 38 matching lines @@
         report := durationReporter(c, latestSnapshotInfoDuration)
         logging.Debugf(c, "Fetching AuthDB snapshot info from the datastore")
         c = ds.WithoutTransaction(defaultNS(c))
         info := SnapshotInfo{}
         switch err := ds.Get(c, &info); {
         case err == ds.ErrNoSuchEntity:
                 report("SUCCESS")
                 return nil, nil
         case err != nil:
                 report("ERROR_TRANSIENT")
-                return nil, errors.WrapTransient(err)
+                return nil, retry.Tag.Apply(err)
         default:
                 report("SUCCESS")
                 return &info, nil
         }
 }
 
 // deleteSnapshotInfo removes SnapshotInfo entity from the datastore.
 //
 // Used to detach the service from auth_service.
 func deleteSnapshotInfo(c context.Context) error {
         c = ds.WithoutTransaction(c)
         return ds.Delete(c, ds.KeyForObj(c, &SnapshotInfo{}))
 }
 
 // GetAuthDBSnapshot fetches, inflates and deserializes AuthDB snapshot.
 func GetAuthDBSnapshot(c context.Context, id string) (*protocol.AuthDB, error) {
         report := durationReporter(c, getSnapshotDuration)
         logging.Debugf(c, "Fetching AuthDB snapshot from the datastore")
         defer logging.Debugf(c, "AuthDB snapshot fetched")
 
         c = ds.WithoutTransaction(defaultNS(c))
         snap := Snapshot{ID: id}
         switch err := ds.Get(c, &snap); {
         case err == ds.ErrNoSuchEntity:
                 report("ERROR_NO_SNAPSHOT")
                 return nil, err // not transient
         case err != nil:
                 report("ERROR_TRANSIENT")
-                return nil, errors.WrapTransient(err)
+                return nil, retry.Tag.Apply(err)
         }
 
         db, err := service.InflateAuthDB(snap.AuthDBDeflated)
         if err != nil {
                 report("ERROR_INFLATION")
                 return nil, err
         }
 
         report("SUCCESS")
         return db, nil
@@ skipping 49 matching lines @@
         // Configure PubSub subscription to receive future updates.
         if err := setupPubSub(c, baseURL, authServiceURL); err != nil {
                 logging.Errorf(c, "Failed to configure pubsub subscription - %s", err)
                 return err
         }
 
         // All is configured. Switch SnapshotInfo entity to point to new snapshot.
         // It makes syncAuthDB fetch changes from `authServiceURL`, thus promoting
         // `authServiceURL` to the status of main auth service.
         if err := ds.Put(ds.WithoutTransaction(c), info); err != nil {
-                return errors.WrapTransient(err)
+                return retry.Tag.Apply(err)
         }
 
         // Stop getting notifications from previously used auth service.
         if prevAuthServiceURL != "" && prevAuthServiceURL != authServiceURL {
                 return killPubSub(c, prevAuthServiceURL)
         }
 
         return nil
 }
 
@@ skipping 12 matching lines @@
         if err != nil {
                 return err
         }
         ent := Snapshot{
                 ID:             info.GetSnapshotID(),
                 AuthDBDeflated: blob,
                 CreatedAt:      snap.Created.UTC(),
                 FetchedAt:      clock.Now(c).UTC(),
         }
         logging.Infof(c, "Lag: %s", ent.FetchedAt.Sub(ent.CreatedAt))
-        return errors.WrapTransient(ds.Put(ds.WithoutTransaction(c), &ent))
+        return retry.Tag.Apply(ds.Put(ds.WithoutTransaction(c), &ent))
 }
 
 // syncAuthDB fetches latest AuthDB snapshot from the configured auth service,
 // puts it into the datastore and updates SnapshotInfo entity to point to it.
 //
 // Expects authenticating transport to be in the context. Called when receiving
 // PubSub notifications.
 //
 // Returns SnapshotInfo of the most recent snapshot.
 func syncAuthDB(c context.Context) (*SnapshotInfo, error) {
@@ skipping 61 matching lines @@
                 case latest.Rev >= info.Rev:
                         logging.Warningf(c, "Already have rev %d", info.Rev)
                         return nil
                 }
                 latest = info
                 return ds.Put(c, info)
         }, nil)
 
         if err != nil {
                 report("ERROR_COMMITTING")
-                return nil, errors.WrapTransient(err)
+                return nil, retry.Tag.Apply(err)
         }
 
         report("SUCCESS_UPDATED")
         return latest, nil
 }