Reduce unnecessary s3 timeouts

provider/maas/storage.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package maas
 
 import (
         "bytes"
         "encoding/base64"
         "fmt"
         "io"
         "io/ioutil"
         "net/url"
         "sort"
         "sync"
 
         "launchpad.net/gomaasapi"
 
-        "launchpad.net/juju-core/environs"
+        "launchpad.net/juju-core/environs/storage"
         "launchpad.net/juju-core/errors"
         "launchpad.net/juju-core/utils"
 )
 
 type maasStorage struct {
         // Mutex protects the "*Unlocked" fields.
         sync.Mutex
 
         // The Environ that this Storage is for.
         environUnlocked *maasEnviron
 
         // Reference to the URL on the API where files are stored.
         maasClientUnlocked gomaasapi.MAASObject
 }
 
-var _ environs.Storage = (*maasStorage)(nil)
+var _ storage.Storage = (*maasStorage)(nil)
 
-func NewStorage(env *maasEnviron) environs.Storage {
+func NewStorage(env *maasEnviron) storage.Storage {
         storage := new(maasStorage)
         storage.environUnlocked = env
         storage.maasClientUnlocked = env.getMAASClient().GetSubObject("files")
         return storage
 }
 
 // getSnapshot returns a consistent copy of a maasStorage.  Use this if you
 // need a consistent view of the object's entire state, without having to
 // lock the object the whole time.
 //
@@ skipping 107 matching lines @@
 
         partialURL, err := url.Parse(uri)
         if err != nil {
                 return "", err
         }
         fullURL := fileObj.URL().ResolveReference(partialURL)
         return fullURL.String(), nil
 }
 
 // ConsistencyStrategy is specified in the StorageReader interface.
-func (stor *maasStorage) ConsistencyStrategy() utils.AttemptStrategy {
+func (stor *maasStorage) DefaultConsistencyStrategy() utils.AttemptStrategy {
         // This storage backend has immediate consistency, so there's no
         // need to wait.  One attempt should do.
         return utils.AttemptStrategy{}
 }
 
+// ShouldRetry is specified in the StorageReader interface.
+func (stor *maasStorage) ShouldRetry(err error) bool {
+        return false
+}
+
 // Put is specified in the StorageWriter interface.
 func (stor *maasStorage) Put(name string, r io.Reader, length int64) error {
         data, err := ioutil.ReadAll(io.LimitReader(r, length))
         if err != nil {
                 return err
         }
         params := url.Values{"filename": {name}}
         files := map[string][]byte{"file": data}
         snapshot := stor.getSnapshot()
         _, err = snapshot.maasClientUnlocked.CallPostFiles("add", params, files)
         return err
 }
 
 // Remove is specified in the StorageWriter interface.
 func (stor *maasStorage) Remove(name string) error {
         // The only thing that can go wrong here, really, is that the file
         // does not exist.  But deletion is idempotent: deleting a file that
         // is no longer there anyway is success, not failure.
         stor.getSnapshot().maasClientUnlocked.GetSubObject(name).Delete()
         return nil
 }
 
 // RemoveAll is specified in the StorageWriter interface.
 func (stor *maasStorage) RemoveAll() error {
-        names, err := stor.List("")
+        names, err := storage.ListWithDefaultRetry(stor, "")
         if err != nil {
                 return err
         }
         // Remove all the objects in parallel so that we incur less round-trips.
         // If we're in danger of having hundreds of objects,
         // we'll want to change this to limit the number
         // of concurrent operations.
         var wg sync.WaitGroup
         wg.Add(len(names))
         errc := make(chan error, len(names))
         for _, name := range names {
                 name := name
                 go func() {
                         defer wg.Done()
                         if err := stor.Remove(name); err != nil {
                                 errc <- err
                         }
                 }()
         }
         wg.Wait()
         select {
         case err := <-errc:
                 return fmt.Errorf("cannot delete all provider state: %v", err)
         default:
         }
         return nil
 }