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

common/gcloud/gs/gs.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 gs
 
 import (
         "fmt"
         "io"
         "net/http"
         "time"
 
         "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"
 
         gs "cloud.google.com/go/storage"
         "golang.org/x/net/context"
         "google.golang.org/api/googleapi"
         "google.golang.org/api/option"
 )
 
 var (
         // ReadWriteScopes is the set of scopes needed for read/write Google Storage
         // access.
@@ skipping 99 matching lines @@
         if err != nil {
                 return fmt.Errorf("invalid source path: %s", err)
         }
 
         dstObj, err := c.handleForPath(dst)
         if err != nil {
                 return fmt.Errorf("invalid destination path: %s", err)
         }
 
         // First stage: CopyTo
-        err = retry.Retry(c, retry.TransientOnly(retry.Default), func() error {
+        err = retry.Retry(c, transient.Only(retry.Default), func() error {
                 if _, err := dstObj.CopierFrom(srcObj).Run(c); err != nil {
                         // The storage library doesn't return gs.ErrObjectNotExist when Delete
                         // returns a 404. Catch that explicitly.
                         if isNotFoundError(err) {
                                 return err
                         }
 
                         // Assume all unexpected errors are transient.
-                        return errors.WrapTransient(err)
+                        return transient.Tag.Apply(err)
                 }
                 return nil
         }, func(err error, d time.Duration) {
                 log.Fields{
                         log.ErrorKey: err,
                         "delay":      d,
                         "src":        src,
                         "dst":        dst,
                 }.Warningf(c, "Transient error copying GS file. Retrying...")
         })
@@ skipping 14 matching lines @@
 func (c *prodClient) Delete(p Path) error {
         dstObj, err := c.handleForPath(p)
         if err != nil {
                 return fmt.Errorf("invalid path: %s", err)
         }
 
         return c.deleteObject(dstObj)
 }
 
 func (c *prodClient) deleteObject(o *gs.ObjectHandle) error {
-        return retry.Retry(c, retry.TransientOnly(retry.Default), func() error {
+        return retry.Retry(c, transient.Only(retry.Default), func() error {
                 if err := o.Delete(c); err != nil {
                         // The storage library doesn't return gs.ErrObjectNotExist when Delete
                         // returns a 404. Catch that explicitly.
                         if isNotFoundError(err) {
                                 // If the file wasn't found, then the delete "succeeded".
                                 return nil
                         }
 
                         // Assume all unexpected errors are transient.
-                        return errors.WrapTransient(err)
+                        return transient.Tag.Apply(err)
                 }
                 return nil
         }, func(err error, d time.Duration) {
                 log.Fields{
                         log.ErrorKey: err,
                         "delay":      d,
                 }.Warningf(c, "Transient error deleting file. Retrying...")
         })
 }
 
@@ skipping 31 matching lines @@
         // The storage library doesn't return gs.ErrObjectNotExist when Delete
         // returns a 404. Catch that explicitly.
         if t, ok := err.(*googleapi.Error); ok {
                 switch t.Code {
                 case http.StatusNotFound:
                         return true
                 }
         }
         return false
 }