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)
-
-func NewStorage(env *maasEnviron) environs.Storage {
+var _ storage.Storage = (*maasStorage)(nil)
+
+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 142 matching lines @@
 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 := environs.DefaultList(stor, "")
+        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
 }