8 files changed, 147 insertions, 65 deletions

diff --git a/vendor/github.com/hashicorp/terraform/helper/resource/id.go b/vendor/github.com/hashicorp/terraform/helper/resource/id.go
index 629582b..1cde67c 100644
--- a/vendor/github.com/hashicorp/terraform/helper/resource/id.go
+++ b/vendor/github.com/hashicorp/terraform/helper/resource/id.go
@@ -1,21 +1,17 @@
 package resource
 
 import (
-        "crypto/rand"
         "fmt"
-        "math/big"
+        "strings"
         "sync"
+        "time"
 )
 
 const UniqueIdPrefix = `terraform-`
 
-// idCounter is a randomly seeded monotonic counter for generating ordered
-// unique ids.  It uses a big.Int so we can easily increment a long numeric
-// string.  The max possible hex value here with 12 random bytes is
-// "01000000000000000000000000", so there's no chance of rollover during
-// operation.
+// idCounter is a monotonic counter for generating ordered unique ids.
 var idMutex sync.Mutex
-var idCounter = big.NewInt(0).SetBytes(randomBytes(12))
+var idCounter uint32
 
 // Helper for a resource to generate a unique identifier w/ default prefix
 func UniqueId() string {
@@ -25,15 +21,20 @@ func UniqueId() string {
 // Helper for a resource to generate a unique identifier w/ given prefix
 //
 // After the prefix, the ID consists of an incrementing 26 digit value (to match
-// previous timestamp output).
+// previous timestamp output).  After the prefix, the ID consists of a timestamp
+// and an incrementing 8 hex digit value The timestamp means that multiple IDs
+// created with the same prefix will sort in the order of their creation, even
+// across multiple terraform executions, as long as the clock is not turned back
+// between calls, and as long as any given terraform execution generates fewer
+// than 4 billion IDs.
 func PrefixedUniqueId(prefix string) string {
+        // Be precise to 4 digits of fractional seconds, but remove the dot before the
+        // fractional seconds.
+        timestamp := strings.Replace(
+                time.Now().UTC().Format("20060102150405.0000"), ".", "", 1)
+
         idMutex.Lock()
         defer idMutex.Unlock()
-        return fmt.Sprintf("%s%026x", prefix, idCounter.Add(idCounter, big.NewInt(1)))
-}
-
-func randomBytes(n int) []byte {
-        b := make([]byte, n)
-        rand.Read(b)
-        return b
+        idCounter++
+        return fmt.Sprintf("%s%s%08x", prefix, timestamp, idCounter)
 }
diff --git a/vendor/github.com/hashicorp/terraform/helper/resource/testing.go b/vendor/github.com/hashicorp/terraform/helper/resource/testing.go
index ebdbde2..d7de1a0 100644
--- a/vendor/github.com/hashicorp/terraform/helper/resource/testing.go
+++ b/vendor/github.com/hashicorp/terraform/helper/resource/testing.go
@@ -383,11 +383,11 @@ func Test(t TestT, c TestCase) {
                 c.PreCheck()
         }
 
-        ctxProviders, err := testProviderFactories(c)
+        providerResolver, err := testProviderResolver(c)
         if err != nil {
                 t.Fatal(err)
         }
-        opts := terraform.ContextOpts{Providers: ctxProviders}
+        opts := terraform.ContextOpts{ProviderResolver: providerResolver}
 
         // A single state variable to track the lifecycle, starting with no state
         var state *terraform.State
@@ -400,15 +400,22 @@ func Test(t TestT, c TestCase) {
                 var err error
                 log.Printf("[WARN] Test: Executing step %d", i)
 
-                // Determine the test mode to execute
-                if step.Config != "" {
-                        state, err = testStepConfig(opts, state, step)
-                } else if step.ImportState {
-                        state, err = testStepImportState(opts, state, step)
-                } else {
+                if step.Config == "" && !step.ImportState {
                         err = fmt.Errorf(
                                 "unknown test mode for step. Please see TestStep docs\n\n%#v",
                                 step)
+                } else {
+                        if step.ImportState {
+                                if step.Config == "" {
+                                        step.Config = testProviderConfig(c)
+                                }
+
+                                // Can optionally set step.Config in addition to
+                                // step.ImportState, to provide config for the import.
+                                state, err = testStepImportState(opts, state, step)
+                        } else {
+                                state, err = testStepConfig(opts, state, step)
+                        }
                 }
 
                 // If there was an error, exit
@@ -496,16 +503,29 @@ func Test(t TestT, c TestCase) {
         }
 }
 
-// testProviderFactories is a helper to build the ResourceProviderFactory map
+// testProviderConfig takes the list of Providers in a TestCase and returns a
+// config with only empty provider blocks. This is useful for Import, where no
+// config is provided, but the providers must be defined.
+func testProviderConfig(c TestCase) string {
+        var lines []string
+        for p := range c.Providers {
+                lines = append(lines, fmt.Sprintf("provider %q {}\n", p))
+        }
+
+        return strings.Join(lines, "")
+}
+
+// testProviderResolver is a helper to build a ResourceProviderResolver
 // with pre instantiated ResourceProviders, so that we can reset them for the
 // test, while only calling the factory function once.
 // Any errors are stored so that they can be returned by the factory in
 // terraform to match non-test behavior.
-func testProviderFactories(c TestCase) (map[string]terraform.ResourceProviderFactory, error) {
-        ctxProviders := c.ProviderFactories // make(map[string]terraform.ResourceProviderFactory)
+func testProviderResolver(c TestCase) (terraform.ResourceProviderResolver, error) {
+        ctxProviders := c.ProviderFactories
         if ctxProviders == nil {
                 ctxProviders = make(map[string]terraform.ResourceProviderFactory)
         }
+
         // add any fixed providers
         for k, p := range c.Providers {
                 ctxProviders[k] = terraform.ResourceProviderFactoryFixed(p)
@@ -527,7 +547,7 @@ func testProviderFactories(c TestCase) (map[string]terraform.ResourceProviderFac
                 }
         }
 
-        return ctxProviders, nil
+        return terraform.ResourceProviderResolverFixed(ctxProviders), nil
 }
 
 // UnitTest is a helper to force the acceptance testing harness to run in the
diff --git a/vendor/github.com/hashicorp/terraform/helper/schema/provider.go b/vendor/github.com/hashicorp/terraform/helper/schema/provider.go
index d52d2f5..fb28b41 100644
--- a/vendor/github.com/hashicorp/terraform/helper/schema/provider.go
+++ b/vendor/github.com/hashicorp/terraform/helper/schema/provider.go
@@ -8,6 +8,7 @@ import (
         "sync"
 
         "github.com/hashicorp/go-multierror"
+        "github.com/hashicorp/terraform/config"
         "github.com/hashicorp/terraform/terraform"
 )
 
@@ -89,6 +90,13 @@ func (p *Provider) InternalValidate() error {
                 validationErrors = multierror.Append(validationErrors, err)
         }
 
+        // Provider-specific checks
+        for k, _ := range sm {
+                if isReservedProviderFieldName(k) {
+                        return fmt.Errorf("%s is a reserved field name for a provider", k)
+                }
+        }
+
         for k, r := range p.ResourcesMap {
                 if err := r.InternalValidate(nil, true); err != nil {
                         validationErrors = multierror.Append(validationErrors, fmt.Errorf("resource %s: %s", k, err))
@@ -104,6 +112,15 @@ func (p *Provider) InternalValidate() error {
         return validationErrors
 }
 
+func isReservedProviderFieldName(name string) bool {
+        for _, reservedName := range config.ReservedProviderFields {
+                if name == reservedName {
+                        return true
+                }
+        }
+        return false
+}
+
 // Meta returns the metadata associated with this provider that was
 // returned by the Configure call. It will be nil until Configure is called.
 func (p *Provider) Meta() interface{} {
diff --git a/vendor/github.com/hashicorp/terraform/helper/schema/provisioner.go b/vendor/github.com/hashicorp/terraform/helper/schema/provisioner.go
index 856c675..476192e 100644
--- a/vendor/github.com/hashicorp/terraform/helper/schema/provisioner.go
+++ b/vendor/github.com/hashicorp/terraform/helper/schema/provisioner.go
@@ -43,7 +43,7 @@ type Provisioner struct {
 
         // ValidateFunc is a function for extended validation. This is optional
         // and should be used when individual field validation is not enough.
-        ValidateFunc func(*ResourceData) ([]string, []error)
+        ValidateFunc func(*terraform.ResourceConfig) ([]string, []error)
 
         stopCtx       context.Context
         stopCtxCancel context.CancelFunc
@@ -121,32 +121,6 @@ func (p *Provisioner) Stop() error {
         return nil
 }
 
-func (p *Provisioner) Validate(config *terraform.ResourceConfig) ([]string, []error) {
-        if err := p.InternalValidate(); err != nil {
-                return nil, []error{fmt.Errorf(
-                        "Internal validation of the provisioner failed! This is always a bug\n"+
-                                "with the provisioner itself, and not a user issue. Please report\n"+
-                                "this bug:\n\n%s", err)}
-        }
-        w := []string{}
-        e := []error{}
-        if p.Schema != nil {
-                w2, e2 := schemaMap(p.Schema).Validate(config)
-                w = append(w, w2...)
-                e = append(e, e2...)
-        }
-        if p.ValidateFunc != nil {
-                data := &ResourceData{
-                        schema: p.Schema,
-                        config: config,
-                }
-                w2, e2 := p.ValidateFunc(data)
-                w = append(w, w2...)
-                e = append(e, e2...)
-        }
-        return w, e
-}
-
 // Apply implementation of terraform.ResourceProvisioner interface.
 func (p *Provisioner) Apply(
         o terraform.UIOutput,
@@ -204,3 +178,27 @@ func (p *Provisioner) Apply(
         ctx = context.WithValue(ctx, ProvRawStateKey, s)
         return p.ApplyFunc(ctx)
 }
+
+// Validate implements the terraform.ResourceProvisioner interface.
+func (p *Provisioner) Validate(c *terraform.ResourceConfig) (ws []string, es []error) {
+        if err := p.InternalValidate(); err != nil {
+                return nil, []error{fmt.Errorf(
+                        "Internal validation of the provisioner failed! This is always a bug\n"+
+                                "with the provisioner itself, and not a user issue. Please report\n"+
+                                "this bug:\n\n%s", err)}
+        }
+
+        if p.Schema != nil {
+                w, e := schemaMap(p.Schema).Validate(c)
+                ws = append(ws, w...)
+                es = append(es, e...)
+        }
+
+        if p.ValidateFunc != nil {
+                w, e := p.ValidateFunc(c)
+                ws = append(ws, w...)
+                es = append(es, e...)
+        }
+
+        return ws, es
+}
diff --git a/vendor/github.com/hashicorp/terraform/helper/schema/resource.go b/vendor/github.com/hashicorp/terraform/helper/schema/resource.go
index c810558..ddba109 100644
--- a/vendor/github.com/hashicorp/terraform/helper/schema/resource.go
+++ b/vendor/github.com/hashicorp/terraform/helper/schema/resource.go
@@ -6,6 +6,7 @@ import (
         "log"
         "strconv"
 
+        "github.com/hashicorp/terraform/config"
         "github.com/hashicorp/terraform/terraform"
 )
 
@@ -142,6 +143,12 @@ func (r *Resource) Apply(
                 if err := rt.DiffDecode(d); err != nil {
                         log.Printf("[ERR] Error decoding ResourceTimeout: %s", err)
                 }
+        } else if s != nil {
+                if _, ok := s.Meta[TimeoutKey]; ok {
+                        if err := rt.StateDecode(s); err != nil {
+                                log.Printf("[ERR] Error decoding ResourceTimeout: %s", err)
+                        }
+                }
         } else {
                 log.Printf("[DEBUG] No meta timeoutkey found in Apply()")
         }
@@ -388,9 +395,25 @@ func (r *Resource) InternalValidate(topSchemaMap schemaMap, writable bool) error
                 }
         }
 
+        // Resource-specific checks
+        for k, _ := range tsm {
+                if isReservedResourceFieldName(k) {
+                        return fmt.Errorf("%s is a reserved field name for a resource", k)
+                }
+        }
+
         return schemaMap(r.Schema).InternalValidate(tsm)
 }
 
+func isReservedResourceFieldName(name string) bool {
+        for _, reservedName := range config.ReservedResourceFields {
+                if name == reservedName {
+                        return true
+                }
+        }
+        return false
+}
+
 // Data returns a ResourceData struct for this Resource. Each return value
 // is a separate copy and can be safely modified differently.
 //
diff --git a/vendor/github.com/hashicorp/terraform/helper/schema/schema.go b/vendor/github.com/hashicorp/terraform/helper/schema/schema.go
index 632672a..acb5618 100644
--- a/vendor/github.com/hashicorp/terraform/helper/schema/schema.go
+++ b/vendor/github.com/hashicorp/terraform/helper/schema/schema.go
@@ -15,6 +15,7 @@ import (
         "fmt"
         "os"
         "reflect"
+        "regexp"
         "sort"
         "strconv"
         "strings"
@@ -661,7 +662,13 @@ func (m schemaMap) InternalValidate(topSchemaMap schemaMap) error {
                 if v.ValidateFunc != nil {
                         switch v.Type {
                         case TypeList, TypeSet:
-                                return fmt.Errorf("ValidateFunc is not yet supported on lists or sets.")
+                                return fmt.Errorf("%s: ValidateFunc is not yet supported on lists or sets.", k)
+                        }
+                }
+
+                if v.Deprecated == "" && v.Removed == "" {
+                        if !isValidFieldName(k) {
+                                return fmt.Errorf("%s: Field name may only contain lowercase alphanumeric characters & underscores.", k)
                         }
                 }
         }
@@ -669,6 +676,11 @@ func (m schemaMap) InternalValidate(topSchemaMap schemaMap) error {
         return nil
 }
 
+func isValidFieldName(name string) bool {
+        re := regexp.MustCompile("^[a-z0-9_]+$")
+        return re.MatchString(name)
+}
+
 func (m schemaMap) diff(
         k string,
         schema *Schema,
diff --git a/vendor/github.com/hashicorp/terraform/helper/shadow/closer.go b/vendor/github.com/hashicorp/terraform/helper/shadow/closer.go
index 7edd5e7..edc1e2a 100644
--- a/vendor/github.com/hashicorp/terraform/helper/shadow/closer.go
+++ b/vendor/github.com/hashicorp/terraform/helper/shadow/closer.go
@@ -39,6 +39,8 @@ func (w *closeWalker) Struct(reflect.Value) error {
         return nil
 }
 
+var closerType = reflect.TypeOf((*io.Closer)(nil)).Elem()
+
 func (w *closeWalker) StructField(f reflect.StructField, v reflect.Value) error {
         // Not sure why this would be but lets avoid some panics
         if !v.IsValid() {
@@ -56,17 +58,18 @@ func (w *closeWalker) StructField(f reflect.StructField, v reflect.Value) error
                 return nil
         }
 
-        // We're looking for an io.Closer
-        raw := v.Interface()
-        if raw == nil {
-                return nil
+        var closer io.Closer
+        if v.Type().Implements(closerType) {
+                closer = v.Interface().(io.Closer)
+        } else if v.CanAddr() {
+                // The Close method may require a pointer receiver, but we only have a value.
+                v := v.Addr()
+                if v.Type().Implements(closerType) {
+                        closer = v.Interface().(io.Closer)
+                }
         }
 
-        closer, ok := raw.(io.Closer)
-        if !ok && v.CanAddr() {
-                closer, ok = v.Addr().Interface().(io.Closer)
-        }
-        if !ok {
+        if closer == nil {
                 return reflectwalk.SkipEntry
         }
 
diff --git a/vendor/github.com/hashicorp/terraform/helper/shadow/value.go b/vendor/github.com/hashicorp/terraform/helper/shadow/value.go
index 2413335..178b7e7 100644
--- a/vendor/github.com/hashicorp/terraform/helper/shadow/value.go
+++ b/vendor/github.com/hashicorp/terraform/helper/shadow/value.go
@@ -26,6 +26,14 @@ type Value struct {
         valueSet bool
 }
 
+func (v *Value) Lock() {
+        v.lock.Lock()
+}
+
+func (v *Value) Unlock() {
+        v.lock.Unlock()
+}
+
 // Close closes the value. This can never fail. For a definition of
 // "close" see the struct docs.
 func (w *Value) Close() error {