environ: add SetConfig

environs/ec2/storage.go

 package ec2
 
 import (
         "fmt"
         "io"
         "launchpad.net/goamz/s3"
         "launchpad.net/juju/go/environs"
         "sync"
+        "time"
 )
 
 // storage implements environs.Storage on
 // an ec2.bucket.
 type storage struct {
-        // bucketMutex protects the visibility of buckedUnlocked
-        // and madeBucket.
-        bucketMutex    sync.Mutex
-        bucketUnlocked *s3.Bucket
-        madeBucket     bool
-}
-
-func (s *storage) bucket() *s3.Bucket {
-        s.bucketMutex.Lock()
-        defer s.bucketMutex.Unlock()
-        return s.bucketUnlocked
-}
-
-func (s *storage) setBucket(bucket *s3.Bucket) {
-        s.bucketMutex.Lock()
-        defer s.bucketMutex.Unlock()
-        s.bucketUnlocked = bucket
-        s.madeBucket = false
+        // bucketMutex protects seralises calls to·
+        // bucket.PutBucket.
+        bucketMutex sync.Mutex
+        bucket      *s3.Bucket
 }
 
 func (s *storage) Put(file string, r io.Reader, length int64) error {
         if err := s.makeBucket(); err != nil {
                 return fmt.Errorf("ec2: cannot make S3 control bucket: %v", err)
         }
-        err := s.bucket().PutReader(file, r, length, "binary/octet-stream", s3.Private)
+        err := s.bucket.PutReader(file, r, length, "binary/octet-stream", s3.Private)
         if err != nil {
                 return fmt.Errorf("ec2: cannot write file %q to control bucket: %v", file, err)
         }
         return nil
 }
 
 // makeBucket makes the environent's control bucket, the
 // place where bootstrap information and deployed charms
 // are stored. To avoid two round trips on every PUT operation,
 // we do this only once for each environ.
 func (s *storage) makeBucket() error {
         // try to make the bucket - PutBucket will succeed if the
         // bucket already exists.
         s.bucketMutex.Lock()
         defer s.bucketMutex.Unlock()

[rog, 2012/05/25 08:07:22]

if there's no madeBucket, then there's no need for a mutex here. i'd prefer to
actually fix the logic to use madeBucket correctly (my original oops, obviously)
so that we don't incur two round-trips for every Put.

[niemeyer, 2012/05/25 19:08:02]

Indeed, no need for the method either.

-
-        // we already hold bucketMutex so calling through s.bucket()·
-        // will deadlock.·
-        err := s.bucketUnlocked.PutBucket(s3.Private)
-        if err == nil {
-                s.madeBucket = true
-        }
-        return err
+        return s.bucket.PutBucket(s3.Private)
 }
 
 func (s *storage) Get(file string) (r io.ReadCloser, err error) {
         for a := shortAttempt.start(); a.next(); {
-                r, err = s.bucket().GetReader(file)
+                r, err = s.bucket.GetReader(file)
                 if s3ErrorStatusCode(err) == 404 {
                         continue
                 }
                 return
         }
         return r, maybeNotFound(err)
 }
 
 func (s *storage) URL(name string) (string, error) {
-        return s.bucket().URL(name), nil
+        // 10 years should be good enough.
+        return s.bucket.SignedURL(name, time.Now().AddDate(1, 0, 0)), nil
 }
 
 // s3ErrorStatusCode returns the HTTP status of the S3 request error,
 // if it is an error from an S3 operation, or 0 if it was not.
 func s3ErrorStatusCode(err error) int {
         if err, _ := err.(*s3.Error); err != nil {
                 return err.StatusCode
         }
         return 0
 }
 
 func (s *storage) Remove(file string) error {
-        err := s.bucket().Del(file)
+        err := s.bucket.Del(file)
         // If we can't delete the object because the bucket doesn't
         // exist, then we don't care.
         if s3ErrorStatusCode(err) == 404 {
                 return nil
         }
         return err
 }
 
 func (s *storage) List(prefix string) ([]string, error) {
         // TODO cope with more than 1000 objects in the bucket.
-        resp, err := s.bucket().List(prefix, "", "", 0)
+        resp, err := s.bucket.List(prefix, "", "", 0)
         if err != nil {
                 return nil, maybeNotFound(err)
         }
         var names []string
         for _, key := range resp.Contents {
                 names = append(names, key.Key)
         }
         return names, nil
 }
 
-func (e *environ) Storage() environs.Storage {
-        return &e.storage
+func (s *storage) deleteAll() error {
+        names, err := s.List("")
+        if err != nil {
+                if _, ok := err.(*environs.NotFoundError); ok {
+                        return 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() {
+                        if err := s.Remove(name); err != nil {
+                                errc <- err
+                        }
+                        wg.Done()
+                }()
+        }
+        wg.Wait()
+        select {
+        case err := <-errc:
+                return fmt.Errorf("cannot delete all provider state: %v", err)
+        default:
+        }
+
+        return s.bucket.DelBucket()
 }
-
-func (e *environ) PublicStorage() environs.StorageReader {
-        // TODO use public storage bucket
-        return environs.EmptyStorage
-}