Transfer of provider code

23 files changed, 553 insertions, 386 deletions

diff --git a/vendor/github.com/hashicorp/terraform/config/config.go b/vendor/github.com/hashicorp/terraform/config/config.go
index 9a764ac..a157824 100644
--- a/vendor/github.com/hashicorp/terraform/config/config.go
+++ b/vendor/github.com/hashicorp/terraform/config/config.go
@@ -545,7 +545,7 @@ func (c *Config) Validate() error {
 
                 // Verify provisioners
                 for _, p := range r.Provisioners {
-                        // This validation checks that there are now splat variables
+                        // This validation checks that there are no splat variables
                         // referencing ourself. This currently is not allowed.
 
                         for _, v := range p.ConnInfo.Variables {
@@ -705,17 +705,6 @@ func (c *Config) Validate() error {
                 }
         }
 
-        // Check that all variables are in the proper context
-        for source, rc := range c.rawConfigs() {
-                walker := &interpolationWalker{
-                        ContextF: c.validateVarContextFn(source, &errs),
-                }
-                if err := reflectwalk.Walk(rc.Raw, walker); err != nil {
-                        errs = append(errs, fmt.Errorf(
-                                "%s: error reading config: %s", source, err))
-                }
-        }
-
         // Validate the self variable
         for source, rc := range c.rawConfigs() {
                 // Ignore provisioners. This is a pretty brittle way to do this,
@@ -787,57 +776,6 @@ func (c *Config) rawConfigs() map[string]*RawConfig {
         return result
 }
 
-func (c *Config) validateVarContextFn(
-        source string, errs *[]error) interpolationWalkerContextFunc {
-        return func(loc reflectwalk.Location, node ast.Node) {
-                // If we're in a slice element, then its fine, since you can do
-                // anything in there.
-                if loc == reflectwalk.SliceElem {
-                        return
-                }
-
-                // Otherwise, let's check if there is a splat resource variable
-                // at the top level in here. We do this by doing a transform that
-                // replaces everything with a noop node unless its a variable
-                // access or concat. This should turn the AST into a flat tree
-                // of Concat(Noop, ...). If there are any variables left that are
-                // multi-access, then its still broken.
-                node = node.Accept(func(n ast.Node) ast.Node {
-                        // If it is a concat or variable access, we allow it.
-                        switch n.(type) {
-                        case *ast.Output:
-                                return n
-                        case *ast.VariableAccess:
-                                return n
-                        }
-
-                        // Otherwise, noop
-                        return &noopNode{}
-                })
-
-                vars, err := DetectVariables(node)
-                if err != nil {
-                        // Ignore it since this will be caught during parse. This
-                        // actually probably should never happen by the time this
-                        // is called, but its okay.
-                        return
-                }
-
-                for _, v := range vars {
-                        rv, ok := v.(*ResourceVariable)
-                        if !ok {
-                                return
-                        }
-
-                        if rv.Multi && rv.Index == -1 {
-                                *errs = append(*errs, fmt.Errorf(
-                                        "%s: use of the splat ('*') operator must be wrapped in a list declaration",
-                                        source))
-                        }
-                }
-        }
-}
-
 func (c *Config) validateDependsOn(
         n string,
         v []string,
diff --git a/vendor/github.com/hashicorp/terraform/config/interpolate_funcs.go b/vendor/github.com/hashicorp/terraform/config/interpolate_funcs.go
index f1f97b0..7b7b3f2 100644
--- a/vendor/github.com/hashicorp/terraform/config/interpolate_funcs.go
+++ b/vendor/github.com/hashicorp/terraform/config/interpolate_funcs.go
@@ -24,6 +24,7 @@ import (
         "github.com/hashicorp/hil"
         "github.com/hashicorp/hil/ast"
         "github.com/mitchellh/go-homedir"
+        "golang.org/x/crypto/bcrypt"
 )
 
 // stringSliceToVariableValue converts a string slice into the value
@@ -59,6 +60,7 @@ func Funcs() map[string]ast.Function {
                 "base64encode": interpolationFuncBase64Encode(),
                 "base64sha256": interpolationFuncBase64Sha256(),
                 "base64sha512": interpolationFuncBase64Sha512(),
+                "bcrypt":       interpolationFuncBcrypt(),
                 "ceil":         interpolationFuncCeil(),
                 "chomp":        interpolationFuncChomp(),
                 "cidrhost":     interpolationFuncCidrHost(),
@@ -89,6 +91,7 @@ func Funcs() map[string]ast.Function {
                 "merge":        interpolationFuncMerge(),
                 "min":          interpolationFuncMin(),
                 "pathexpand":   interpolationFuncPathExpand(),
+                "pow":          interpolationFuncPow(),
                 "uuid":         interpolationFuncUUID(),
                 "replace":      interpolationFuncReplace(),
                 "sha1":         interpolationFuncSha1(),
@@ -394,6 +397,17 @@ func interpolationFuncConcat() ast.Function {
         }
 }
 
+// interpolationFuncPow returns base x exponential of y.
+func interpolationFuncPow() ast.Function {
+        return ast.Function{
+                ArgTypes:   []ast.Type{ast.TypeFloat, ast.TypeFloat},
+                ReturnType: ast.TypeFloat,
+                Callback: func(args []interface{}) (interface{}, error) {
+                        return math.Pow(args[0].(float64), args[1].(float64)), nil
+                },
+        }
+}
+
 // interpolationFuncFile implements the "file" function that allows
 // loading contents from a file.
 func interpolationFuncFile() ast.Function {
@@ -1310,6 +1324,40 @@ func interpolationFuncBase64Sha512() ast.Function {
         }
 }
 
+func interpolationFuncBcrypt() ast.Function {
+        return ast.Function{
+                ArgTypes:     []ast.Type{ast.TypeString},
+                Variadic:     true,
+                VariadicType: ast.TypeString,
+                ReturnType:   ast.TypeString,
+                Callback: func(args []interface{}) (interface{}, error) {
+                        defaultCost := 10
+
+                        if len(args) > 1 {
+                                costStr := args[1].(string)
+                                cost, err := strconv.Atoi(costStr)
+                                if err != nil {
+                                        return "", err
+                                }
+
+                                defaultCost = cost
+                        }
+
+                        if len(args) > 2 {
+                                return "", fmt.Errorf("bcrypt() takes no more than two arguments")
+                        }
+
+                        input := args[0].(string)
+                        out, err := bcrypt.GenerateFromPassword([]byte(input), defaultCost)
+                        if err != nil {
+                                return "", fmt.Errorf("error occured generating password %s", err.Error())
+                        }
+
+                        return string(out), nil
+                },
+        }
+}
+
 func interpolationFuncUUID() ast.Function {
         return ast.Function{
                 ArgTypes:   []ast.Type{},
diff --git a/vendor/github.com/hashicorp/terraform/dag/set.go b/vendor/github.com/hashicorp/terraform/dag/set.go
index 3929c9d..92b4215 100644
--- a/vendor/github.com/hashicorp/terraform/dag/set.go
+++ b/vendor/github.com/hashicorp/terraform/dag/set.go
@@ -81,6 +81,20 @@ func (s *Set) Difference(other *Set) *Set {
         return result
 }
 
+// Filter returns a set that contains the elements from the receiver
+// where the given callback returns true.
+func (s *Set) Filter(cb func(interface{}) bool) *Set {
+        result := new(Set)
+
+        for _, v := range s.m {
+                if cb(v) {
+                        result.Add(v)
+                }
+        }
+
+        return result
+}
+
 // Len is the number of items in the set.
 func (s *Set) Len() int {
         if s == nil {
diff --git a/vendor/github.com/hashicorp/terraform/helper/acctest/acctest.go b/vendor/github.com/hashicorp/terraform/helper/acctest/acctest.go
deleted file mode 100644
index 9d31031..0000000
--- a/vendor/github.com/hashicorp/terraform/helper/acctest/acctest.go
+++ /dev/null
@@ -1,2 +0,0 @@
-// Package acctest contains for Terraform Acceptance Tests
-package acctest
diff --git a/vendor/github.com/hashicorp/terraform/helper/acctest/random.go b/vendor/github.com/hashicorp/terraform/helper/acctest/random.go
deleted file mode 100644
index 3ddc078..0000000
--- a/vendor/github.com/hashicorp/terraform/helper/acctest/random.go
+++ /dev/null
@@ -1,93 +0,0 @@
-package acctest
-
-import (
-        "bufio"
-        "bytes"
-        crand "crypto/rand"
-        "crypto/rsa"
-        "crypto/x509"
-        "encoding/pem"
-        "fmt"
-        "math/rand"
-        "strings"
-        "time"
-
-        "golang.org/x/crypto/ssh"
-)
-
-// Helpers for generating random tidbits for use in identifiers to prevent
-// collisions in acceptance tests.
-
-// RandInt generates a random integer
-func RandInt() int {
-        reseed()
-        return rand.New(rand.NewSource(time.Now().UnixNano())).Int()
-}
-
-// RandomWithPrefix is used to generate a unique name with a prefix, for
-// randomizing names in acceptance tests
-func RandomWithPrefix(name string) string {
-        reseed()
-        return fmt.Sprintf("%s-%d", name, rand.New(rand.NewSource(time.Now().UnixNano())).Int())
-}
-
-func RandIntRange(min int, max int) int {
-        reseed()
-        source := rand.New(rand.NewSource(time.Now().UnixNano()))
-        rangeMax := max - min
-
-        return int(source.Int31n(int32(rangeMax)))
-}
-
-// RandString generates a random alphanumeric string of the length specified
-func RandString(strlen int) string {
-        return RandStringFromCharSet(strlen, CharSetAlphaNum)
-}
-
-// RandStringFromCharSet generates a random string by selecting characters from
-// the charset provided
-func RandStringFromCharSet(strlen int, charSet string) string {
-        reseed()
-        result := make([]byte, strlen)
-        for i := 0; i < strlen; i++ {
-                result[i] = charSet[rand.Intn(len(charSet))]
-        }
-        return string(result)
-}
-
-// RandSSHKeyPair generates a public and private SSH key pair. The public key is
-// returned in OpenSSH format, and the private key is PEM encoded.
-func RandSSHKeyPair(comment string) (string, string, error) {
-        privateKey, err := rsa.GenerateKey(crand.Reader, 1024)
-        if err != nil {
-                return "", "", err
-        }
-
-        var privateKeyBuffer bytes.Buffer
-        privateKeyPEM := &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(privateKey)}
-        if err := pem.Encode(bufio.NewWriter(&privateKeyBuffer), privateKeyPEM); err != nil {
-                return "", "", err
-        }
-
-        publicKey, err := ssh.NewPublicKey(&privateKey.PublicKey)
-        if err != nil {
-                return "", "", err
-        }
-        keyMaterial := strings.TrimSpace(string(ssh.MarshalAuthorizedKey(publicKey)))
-        return fmt.Sprintf("%s %s", keyMaterial, comment), privateKeyBuffer.String(), nil
-}
-
-// Seeds random with current timestamp
-func reseed() {
-        rand.Seed(time.Now().UTC().UnixNano())
-}
-
-const (
-        // CharSetAlphaNum is the alphanumeric character set for use with
-        // RandStringFromCharSet
-        CharSetAlphaNum = "abcdefghijklmnopqrstuvwxyz012346789"
-
-        // CharSetAlpha is the alphabetical character set for use with
-        // RandStringFromCharSet
-        CharSetAlpha = "abcdefghijklmnopqrstuvwxyz"
-)
diff --git a/vendor/github.com/hashicorp/terraform/helper/acctest/remotetests.go b/vendor/github.com/hashicorp/terraform/helper/acctest/remotetests.go
deleted file mode 100644
index 87c60b8..0000000
--- a/vendor/github.com/hashicorp/terraform/helper/acctest/remotetests.go
+++ /dev/null
@@ -1,27 +0,0 @@
-package acctest
-
-import (
-        "net/http"
-        "os"
-        "testing"
-)
-
-// SkipRemoteTestsEnvVar is an environment variable that can be set by a user
-// running the tests in an environment with limited network connectivity. By
-// default, tests requiring internet connectivity make an effort to skip if no
-// internet is available, but in some cases the smoke test will pass even
-// though the test should still be skipped.
-const SkipRemoteTestsEnvVar = "TF_SKIP_REMOTE_TESTS"
-
-// RemoteTestPrecheck is meant to be run by any unit test that requires
-// outbound internet connectivity. The test will be skipped if it's
-// unavailable.
-func RemoteTestPrecheck(t *testing.T) {
-        if os.Getenv(SkipRemoteTestsEnvVar) != "" {
-                t.Skipf("skipping test, %s was set", SkipRemoteTestsEnvVar)
-        }
-
-        if _, err := http.Get("http://google.com"); err != nil {
-                t.Skipf("skipping, internet seems to not be available: %s", err)
-        }
-}
diff --git a/vendor/github.com/hashicorp/terraform/helper/resource/testing.go b/vendor/github.com/hashicorp/terraform/helper/resource/testing.go
index 04367c5..ebdbde2 100644
--- a/vendor/github.com/hashicorp/terraform/helper/resource/testing.go
+++ b/vendor/github.com/hashicorp/terraform/helper/resource/testing.go
@@ -1,6 +1,7 @@
 package resource
 
 import (
+        "flag"
         "fmt"
         "io"
         "io/ioutil"
@@ -20,6 +21,153 @@ import (
         "github.com/hashicorp/terraform/terraform"
 )
 
+// flagSweep is a flag available when running tests on the command line. It
+// contains a comma seperated list of regions to for the sweeper functions to
+// run in.  This flag bypasses the normal Test path and instead runs functions designed to
+// clean up any leaked resources a testing environment could have created. It is
+// a best effort attempt, and relies on Provider authors to implement "Sweeper"
+// methods for resources.
+
+// Adding Sweeper methods with AddTestSweepers will
+// construct a list of sweeper funcs to be called here. We iterate through
+// regions provided by the sweep flag, and for each region we iterate through the
+// tests, and exit on any errors. At time of writing, sweepers are ran
+// sequentially, however they can list dependencies to be ran first. We track
+// the sweepers that have been ran, so as to not run a sweeper twice for a given
+// region.
+//
+// WARNING:
+// Sweepers are designed to be destructive. You should not use the -sweep flag
+// in any environment that is not strictly a test environment. Resources will be
+// destroyed.
+
+var flagSweep = flag.String("sweep", "", "List of Regions to run available Sweepers")
+var flagSweepRun = flag.String("sweep-run", "", "Comma seperated list of Sweeper Tests to run")
+var sweeperFuncs map[string]*Sweeper
+
+// map of sweepers that have ran, and the success/fail status based on any error
+// raised
+var sweeperRunList map[string]bool
+
+// type SweeperFunc is a signature for a function that acts as a sweeper. It
+// accepts a string for the region that the sweeper is to be ran in. This
+// function must be able to construct a valid client for that region.
+type SweeperFunc func(r string) error
+
+type Sweeper struct {
+        // Name for sweeper. Must be unique to be ran by the Sweeper Runner
+        Name string
+
+        // Dependencies list the const names of other Sweeper functions that must be ran
+        // prior to running this Sweeper. This is an ordered list that will be invoked
+        // recursively at the helper/resource level
+        Dependencies []string
+
+        // Sweeper function that when invoked sweeps the Provider of specific
+        // resources
+        F SweeperFunc
+}
+
+func init() {
+        sweeperFuncs = make(map[string]*Sweeper)
+}
+
+// AddTestSweepers function adds a given name and Sweeper configuration
+// pair to the internal sweeperFuncs map. Invoke this function to register a
+// resource sweeper to be available for running when the -sweep flag is used
+// with `go test`. Sweeper names must be unique to help ensure a given sweeper
+// is only ran once per run.
+func AddTestSweepers(name string, s *Sweeper) {
+        if _, ok := sweeperFuncs[name]; ok {
+                log.Fatalf("[ERR] Error adding (%s) to sweeperFuncs: function already exists in map", name)
+        }
+
+        sweeperFuncs[name] = s
+}
+
+func TestMain(m *testing.M) {
+        flag.Parse()
+        if *flagSweep != "" {
+                // parse flagSweep contents for regions to run
+                regions := strings.Split(*flagSweep, ",")
+
+                // get filtered list of sweepers to run based on sweep-run flag
+                sweepers := filterSweepers(*flagSweepRun, sweeperFuncs)
+                for _, region := range regions {
+                        region = strings.TrimSpace(region)
+                        // reset sweeperRunList for each region
+                        sweeperRunList = map[string]bool{}
+
+                        log.Printf("[DEBUG] Running Sweepers for region (%s):\n", region)
+                        for _, sweeper := range sweepers {
+                                if err := runSweeperWithRegion(region, sweeper); err != nil {
+                                        log.Fatalf("[ERR] error running (%s): %s", sweeper.Name, err)
+                                }
+                        }
+
+                        log.Printf("Sweeper Tests ran:\n")
+                        for s, _ := range sweeperRunList {
+                                fmt.Printf("\t- %s\n", s)
+                        }
+                }
+        } else {
+                os.Exit(m.Run())
+        }
+}
+
+// filterSweepers takes a comma seperated string listing the names of sweepers
+// to be ran, and returns a filtered set from the list of all of sweepers to
+// run based on the names given.
+func filterSweepers(f string, source map[string]*Sweeper) map[string]*Sweeper {
+        filterSlice := strings.Split(strings.ToLower(f), ",")
+        if len(filterSlice) == 1 && filterSlice[0] == "" {
+                // if the filter slice is a single element of "" then no sweeper list was
+                // given, so just return the full list
+                return source
+        }
+
+        sweepers := make(map[string]*Sweeper)
+        for name, sweeper := range source {
+                for _, s := range filterSlice {
+                        if strings.Contains(strings.ToLower(name), s) {
+                                sweepers[name] = sweeper
+                        }
+                }
+        }
+        return sweepers
+}
+
+// runSweeperWithRegion recieves a sweeper and a region, and recursively calls
+// itself with that region for every dependency found for that sweeper. If there
+// are no dependencies, invoke the contained sweeper fun with the region, and
+// add the success/fail status to the sweeperRunList.
+func runSweeperWithRegion(region string, s *Sweeper) error {
+        for _, dep := range s.Dependencies {
+                if depSweeper, ok := sweeperFuncs[dep]; ok {
+                        log.Printf("[DEBUG] Sweeper (%s) has dependency (%s), running..", s.Name, dep)
+                        if err := runSweeperWithRegion(region, depSweeper); err != nil {
+                                return err
+                        }
+                } else {
+                        log.Printf("[DEBUG] Sweeper (%s) has dependency (%s), but that sweeper was not found", s.Name, dep)
+                }
+        }
+
+        if _, ok := sweeperRunList[s.Name]; ok {
+                log.Printf("[DEBUG] Sweeper (%s) already ran in region (%s)", s.Name, region)
+                return nil
+        }
+
+        runE := s.F(region)
+        if runE == nil {
+                sweeperRunList[s.Name] = true
+        } else {
+                sweeperRunList[s.Name] = false
+        }
+
+        return runE
+}
+
 const TestEnvVar = "TF_ACC"
 
 // TestProvider can be implemented by any ResourceProvider to provide custom
diff --git a/vendor/github.com/hashicorp/terraform/helper/schema/provisioner.go b/vendor/github.com/hashicorp/terraform/helper/schema/provisioner.go
index c1564a2..856c675 100644
--- a/vendor/github.com/hashicorp/terraform/helper/schema/provisioner.go
+++ b/vendor/github.com/hashicorp/terraform/helper/schema/provisioner.go
@@ -41,6 +41,10 @@ type Provisioner struct {
         // information.
         ApplyFunc func(ctx context.Context) error
 
+        // 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)
+
         stopCtx       context.Context
         stopCtxCancel context.CancelFunc
         stopOnce      sync.Once
@@ -117,8 +121,30 @@ func (p *Provisioner) Stop() error {
         return nil
 }
 
-func (p *Provisioner) Validate(c *terraform.ResourceConfig) ([]string, []error) {
-        return schemaMap(p.Schema).Validate(c)
+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.
diff --git a/vendor/github.com/hashicorp/terraform/helper/schema/schema.go b/vendor/github.com/hashicorp/terraform/helper/schema/schema.go
index 32d1721..632672a 100644
--- a/vendor/github.com/hashicorp/terraform/helper/schema/schema.go
+++ b/vendor/github.com/hashicorp/terraform/helper/schema/schema.go
@@ -1373,8 +1373,8 @@ func (m schemaMap) validateObject(
         k string,
         schema map[string]*Schema,
         c *terraform.ResourceConfig) ([]string, []error) {
-        raw, _ := c.GetRaw(k)
-        if _, ok := raw.(map[string]interface{}); !ok {
+        raw, _ := c.Get(k)
+        if _, ok := raw.(map[string]interface{}); !ok && !c.IsComputed(k) {
                 return nil, []error{fmt.Errorf(
                         "%s: expected object, got %s",
                         k, reflect.ValueOf(raw).Kind())}
diff --git a/vendor/github.com/hashicorp/terraform/helper/structure/expand_json.go b/vendor/github.com/hashicorp/terraform/helper/structure/expand_json.go
deleted file mode 100644
index b3eb90f..0000000
--- a/vendor/github.com/hashicorp/terraform/helper/structure/expand_json.go
+++ /dev/null
@@ -1,11 +0,0 @@
-package structure
-
-import "encoding/json"
-
-func ExpandJsonFromString(jsonString string) (map[string]interface{}, error) {
-        var result map[string]interface{}
-
-        err := json.Unmarshal([]byte(jsonString), &result)
-
-        return result, err
-}
diff --git a/vendor/github.com/hashicorp/terraform/helper/structure/flatten_json.go b/vendor/github.com/hashicorp/terraform/helper/structure/flatten_json.go
deleted file mode 100644
index 578ad2e..0000000
--- a/vendor/github.com/hashicorp/terraform/helper/structure/flatten_json.go
+++ /dev/null
@@ -1,16 +0,0 @@
-package structure
-
-import "encoding/json"
-
-func FlattenJsonToString(input map[string]interface{}) (string, error) {
-        if len(input) == 0 {
-                return "", nil
-        }
-
-        result, err := json.Marshal(input)
-        if err != nil {
-                return "", err
-        }
-
-        return string(result), nil
-}
diff --git a/vendor/github.com/hashicorp/terraform/helper/structure/normalize_json.go b/vendor/github.com/hashicorp/terraform/helper/structure/normalize_json.go
deleted file mode 100644
index 3256b47..0000000
--- a/vendor/github.com/hashicorp/terraform/helper/structure/normalize_json.go
+++ /dev/null
@@ -1,24 +0,0 @@
-package structure
-
-import "encoding/json"
-
-// Takes a value containing JSON string and passes it through
-// the JSON parser to normalize it, returns either a parsing
-// error or normalized JSON string.
-func NormalizeJsonString(jsonString interface{}) (string, error) {
-        var j interface{}
-
-        if jsonString == nil || jsonString.(string) == "" {
-                return "", nil
-        }
-
-        s := jsonString.(string)
-
-        err := json.Unmarshal([]byte(s), &j)
-        if err != nil {
-                return s, err
-        }
-
-        bytes, _ := json.Marshal(j)
-        return string(bytes[:]), nil
-}
diff --git a/vendor/github.com/hashicorp/terraform/helper/structure/suppress_json_diff.go b/vendor/github.com/hashicorp/terraform/helper/structure/suppress_json_diff.go
deleted file mode 100644
index 46f794a..0000000
--- a/vendor/github.com/hashicorp/terraform/helper/structure/suppress_json_diff.go
+++ /dev/null
@@ -1,21 +0,0 @@
-package structure
-
-import (
-        "reflect"
-
-        "github.com/hashicorp/terraform/helper/schema"
-)
-
-func SuppressJsonDiff(k, old, new string, d *schema.ResourceData) bool {
-        oldMap, err := ExpandJsonFromString(old)
-        if err != nil {
-                return false
-        }
-
-        newMap, err := ExpandJsonFromString(new)
-        if err != nil {
-                return false
-        }
-
-        return reflect.DeepEqual(oldMap, newMap)
-}
diff --git a/vendor/github.com/hashicorp/terraform/helper/validation/validation.go b/vendor/github.com/hashicorp/terraform/helper/validation/validation.go
deleted file mode 100644
index 7b894f5..0000000
--- a/vendor/github.com/hashicorp/terraform/helper/validation/validation.go
+++ /dev/null
@@ -1,108 +0,0 @@
-package validation
-
-import (
-        "fmt"
-        "net"
-        "strings"
-
-        "github.com/hashicorp/terraform/helper/schema"
-        "github.com/hashicorp/terraform/helper/structure"
-)
-
-// IntBetween returns a SchemaValidateFunc which tests if the provided value
-// is of type int and is between min and max (inclusive)
-func IntBetween(min, max int) schema.SchemaValidateFunc {
-        return func(i interface{}, k string) (s []string, es []error) {
-                v, ok := i.(int)
-                if !ok {
-                        es = append(es, fmt.Errorf("expected type of %s to be int", k))
-                        return
-                }
-
-                if v < min || v > max {
-                        es = append(es, fmt.Errorf("expected %s to be in the range (%d - %d), got %d", k, min, max, v))
-                        return
-                }
-
-                return
-        }
-}
-
-// StringInSlice returns a SchemaValidateFunc which tests if the provided value
-// is of type string and matches the value of an element in the valid slice
-// will test with in lower case if ignoreCase is true
-func StringInSlice(valid []string, ignoreCase bool) schema.SchemaValidateFunc {
-        return func(i interface{}, k string) (s []string, es []error) {
-                v, ok := i.(string)
-                if !ok {
-                        es = append(es, fmt.Errorf("expected type of %s to be string", k))
-                        return
-                }
-
-                for _, str := range valid {
-                        if v == str || (ignoreCase && strings.ToLower(v) == strings.ToLower(str)) {
-                                return
-                        }
-                }
-
-                es = append(es, fmt.Errorf("expected %s to be one of %v, got %s", k, valid, v))
-                return
-        }
-}
-
-// StringLenBetween returns a SchemaValidateFunc which tests if the provided value
-// is of type string and has length between min and max (inclusive)
-func StringLenBetween(min, max int) schema.SchemaValidateFunc {
-        return func(i interface{}, k string) (s []string, es []error) {
-                v, ok := i.(string)
-                if !ok {
-                        es = append(es, fmt.Errorf("expected type of %s to be string", k))
-                        return
-                }
-                if len(v) < min || len(v) > max {
-                        es = append(es, fmt.Errorf("expected length of %s to be in the range (%d - %d), got %s", k, min, max, v))
-                }
-                return
-        }
-}
-
-// CIDRNetwork returns a SchemaValidateFunc which tests if the provided value
-// is of type string, is in valid CIDR network notation, and has significant bits between min and max (inclusive)
-func CIDRNetwork(min, max int) schema.SchemaValidateFunc {
-        return func(i interface{}, k string) (s []string, es []error) {
-                v, ok := i.(string)
-                if !ok {
-                        es = append(es, fmt.Errorf("expected type of %s to be string", k))
-                        return
-                }
-
-                _, ipnet, err := net.ParseCIDR(v)
-                if err != nil {
-                        es = append(es, fmt.Errorf(
-                                "expected %s to contain a valid CIDR, got: %s with err: %s", k, v, err))
-                        return
-                }
-
-                if ipnet == nil || v != ipnet.String() {
-                        es = append(es, fmt.Errorf(
-                                "expected %s to contain a valid network CIDR, expected %s, got %s",
-                                k, ipnet, v))
-                }
-
-                sigbits, _ := ipnet.Mask.Size()
-                if sigbits < min || sigbits > max {
-                        es = append(es, fmt.Errorf(
-                                "expected %q to contain a network CIDR with between %d and %d significant bits, got: %d",
-                                k, min, max, sigbits))
-                }
-
-                return
-        }
-}
-
-func ValidateJsonString(v interface{}, k string) (ws []string, errors []error) {
-        if _, err := structure.NormalizeJsonString(v); err != nil {
-                errors = append(errors, fmt.Errorf("%q contains an invalid JSON: %s", k, err))
-        }
-        return
-}
diff --git a/vendor/github.com/hashicorp/terraform/terraform/graph_builder_refresh.go b/vendor/github.com/hashicorp/terraform/terraform/graph_builder_refresh.go
index 88ae338..0634f96 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/graph_builder_refresh.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/graph_builder_refresh.go
@@ -1,6 +1,8 @@
 package terraform
 
 import (
+        "log"
+
         "github.com/hashicorp/terraform/config"
         "github.com/hashicorp/terraform/config/module"
         "github.com/hashicorp/terraform/dag"
@@ -56,8 +58,16 @@ func (b *RefreshGraphBuilder) Steps() []GraphTransformer {
                 }
         }
 
-        concreteResource := func(a *NodeAbstractResource) dag.Vertex {
-                return &NodeRefreshableResource{
+        concreteManagedResource := func(a *NodeAbstractResource) dag.Vertex {
+                return &NodeRefreshableManagedResource{
+                        NodeAbstractCountResource: &NodeAbstractCountResource{
+                                NodeAbstractResource: a,
+                        },
+                }
+        }
+
+        concreteManagedResourceInstance := func(a *NodeAbstractResource) dag.Vertex {
+                return &NodeRefreshableManagedResourceInstance{
                         NodeAbstractResource: a,
                 }
         }
@@ -71,13 +81,25 @@ func (b *RefreshGraphBuilder) Steps() []GraphTransformer {
         }
 
         steps := []GraphTransformer{
-                // Creates all the resources represented in the state
-                &StateTransformer{
-                        Concrete: concreteResource,
-                        State:    b.State,
-                },
-
-                // Creates all the data resources that aren't in the state
+                // Creates all the managed resources that aren't in the state, but only if
+                // we have a state already. No resources in state means there's not
+                // anything to refresh.
+                func() GraphTransformer {
+                        if b.State.HasResources() {
+                                return &ConfigTransformer{
+                                        Concrete:   concreteManagedResource,
+                                        Module:     b.Module,
+                                        Unique:     true,
+                                        ModeFilter: true,
+                                        Mode:       config.ManagedResourceMode,
+                                }
+                        }
+                        log.Println("[TRACE] No managed resources in state during refresh, skipping managed resource transformer")
+                        return nil
+                }(),
+
+                // Creates all the data resources that aren't in the state. This will also
+                // add any orphans from scaling in as destroy nodes.
                 &ConfigTransformer{
                         Concrete:   concreteDataResource,
                         Module:     b.Module,
@@ -86,6 +108,15 @@ func (b *RefreshGraphBuilder) Steps() []GraphTransformer {
                         Mode:       config.DataResourceMode,
                 },
 
+                // Add any fully-orphaned resources from config (ones that have been
+                // removed completely, not ones that are just orphaned due to a scaled-in
+                // count.
+                &OrphanResourceTransformer{
+                        Concrete: concreteManagedResourceInstance,
+                        State:    b.State,
+                        Module:   b.Module,
+                },
+
                 // Attach the state
                 &AttachStateTransformer{State: b.State},
 
diff --git a/vendor/github.com/hashicorp/terraform/terraform/interpolate.go b/vendor/github.com/hashicorp/terraform/terraform/interpolate.go
index 19dcf21..0def295 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/interpolate.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/interpolate.go
@@ -731,6 +731,19 @@ func (i *Interpolater) resourceCountMax(
                 return count, nil
         }
 
+        // If we have no module state in the apply walk, that suggests we've hit
+        // a rather awkward edge-case: the resource this variable refers to
+        // has count = 0 and is the only resource processed so far on this walk,
+        // and so we've ended up not creating any resource states yet. We don't
+        // create a module state until the first resource is written into it,
+        // so the module state doesn't exist when we get here.
+        //
+        // In this case we act as we would if we had been passed a module
+        // with an empty resource state map.
+        if ms == nil {
+                return 0, nil
+        }
+
         // We need to determine the list of resource keys to get values from.
         // This needs to be sorted so the order is deterministic. We used to
         // use "cr.Count()" but that doesn't work if the count is interpolated
diff --git a/vendor/github.com/hashicorp/terraform/terraform/node_data_refresh.go b/vendor/github.com/hashicorp/terraform/terraform/node_data_refresh.go
index d504c89..45129b3 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/node_data_refresh.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/node_data_refresh.go
@@ -33,6 +33,17 @@ func (n *NodeRefreshableDataResource) DynamicExpand(ctx EvalContext) (*Graph, er
                 }
         }
 
+        // We also need a destroyable resource for orphans that are a result of a
+        // scaled-in count.
+        concreteResourceDestroyable := func(a *NodeAbstractResource) dag.Vertex {
+                // Add the config since we don't do that via transforms
+                a.Config = n.Config
+
+                return &NodeDestroyableDataResource{
+                        NodeAbstractResource: a,
+                }
+        }
+
         // Start creating the steps
         steps := []GraphTransformer{
                 // Expand the count.
@@ -42,6 +53,15 @@ func (n *NodeRefreshableDataResource) DynamicExpand(ctx EvalContext) (*Graph, er
                         Addr:     n.ResourceAddr(),
                 },
 
+                // Add the count orphans. As these are orphaned refresh nodes, we add them
+                // directly as NodeDestroyableDataResource.
+                &OrphanResourceCountTransformer{
+                        Concrete: concreteResourceDestroyable,
+                        Count:    count,
+                        Addr:     n.ResourceAddr(),
+                        State:    state,
+                },
+
                 // Attach the state
                 &AttachStateTransformer{State: state},
 
diff --git a/vendor/github.com/hashicorp/terraform/terraform/node_output.go b/vendor/github.com/hashicorp/terraform/terraform/node_output.go
index e28e6f0..9017a63 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/node_output.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/node_output.go
@@ -5,6 +5,7 @@ import (
         "strings"
 
         "github.com/hashicorp/terraform/config"
+        "github.com/hashicorp/terraform/dag"
 )
 
 // NodeApplyableOutput represents an output that is "applyable":
@@ -35,6 +36,14 @@ func (n *NodeApplyableOutput) RemoveIfNotTargeted() bool {
         return true
 }
 
+// GraphNodeTargetDownstream
+func (n *NodeApplyableOutput) TargetDownstream(targetedDeps, untargetedDeps *dag.Set) bool {
+        // If any of the direct dependencies of an output are targeted then
+        // the output must always be targeted as well, so its value will always
+        // be up-to-date at the completion of an apply walk.
+        return true
+}
+
 // GraphNodeReferenceable
 func (n *NodeApplyableOutput) ReferenceableName() []string {
         name := fmt.Sprintf("output.%s", n.Config.Name)
diff --git a/vendor/github.com/hashicorp/terraform/terraform/node_resource_refresh.go b/vendor/github.com/hashicorp/terraform/terraform/node_resource_refresh.go
index 3a44926..6ab9df7 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/node_resource_refresh.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/node_resource_refresh.go
@@ -4,21 +4,99 @@ import (
         "fmt"
 
         "github.com/hashicorp/terraform/config"
+        "github.com/hashicorp/terraform/dag"
 )
 
-// NodeRefreshableResource represents a resource that is "applyable":
+// NodeRefreshableManagedResource represents a resource that is expanabled into
+// NodeRefreshableManagedResourceInstance. Resource count orphans are also added.
+type NodeRefreshableManagedResource struct {
+        *NodeAbstractCountResource
+}
+
+// GraphNodeDynamicExpandable
+func (n *NodeRefreshableManagedResource) DynamicExpand(ctx EvalContext) (*Graph, error) {
+        // Grab the state which we read
+        state, lock := ctx.State()
+        lock.RLock()
+        defer lock.RUnlock()
+
+        // Expand the resource count which must be available by now from EvalTree
+        count, err := n.Config.Count()
+        if err != nil {
+                return nil, err
+        }
+
+        // The concrete resource factory we'll use
+        concreteResource := func(a *NodeAbstractResource) dag.Vertex {
+                // Add the config and state since we don't do that via transforms
+                a.Config = n.Config
+
+                return &NodeRefreshableManagedResourceInstance{
+                        NodeAbstractResource: a,
+                }
+        }
+
+        // Start creating the steps
+        steps := []GraphTransformer{
+                // Expand the count.
+                &ResourceCountTransformer{
+                        Concrete: concreteResource,
+                        Count:    count,
+                        Addr:     n.ResourceAddr(),
+                },
+
+                // Switch up any node missing state to a plannable resource. This helps
+                // catch cases where data sources depend on the counts from this resource
+                // during a scale out.
+                &ResourceRefreshPlannableTransformer{
+                        State: state,
+                },
+
+                // Add the count orphans to make sure these resources are accounted for
+                // during a scale in.
+                &OrphanResourceCountTransformer{
+                        Concrete: concreteResource,
+                        Count:    count,
+                        Addr:     n.ResourceAddr(),
+                        State:    state,
+                },
+
+                // Attach the state
+                &AttachStateTransformer{State: state},
+
+                // Targeting
+                &TargetsTransformer{ParsedTargets: n.Targets},
+
+                // Connect references so ordering is correct
+                &ReferenceTransformer{},
+
+                // Make sure there is a single root
+                &RootTransformer{},
+        }
+
+        // Build the graph
+        b := &BasicGraphBuilder{
+                Steps:    steps,
+                Validate: true,
+                Name:     "NodeRefreshableManagedResource",
+        }
+
+        return b.Build(ctx.Path())
+}
+
+// NodeRefreshableManagedResourceInstance represents a resource that is "applyable":
 // it is ready to be applied and is represented by a diff.
-type NodeRefreshableResource struct {
+type NodeRefreshableManagedResourceInstance struct {
         *NodeAbstractResource
 }
 
 // GraphNodeDestroyer
-func (n *NodeRefreshableResource) DestroyAddr() *ResourceAddress {
+func (n *NodeRefreshableManagedResourceInstance) DestroyAddr() *ResourceAddress {
         return n.Addr
 }
 
 // GraphNodeEvalable
-func (n *NodeRefreshableResource) EvalTree() EvalNode {
+func (n *NodeRefreshableManagedResourceInstance) EvalTree() EvalNode {
         // Eval info is different depending on what kind of resource this is
         switch mode := n.Addr.Mode; mode {
         case config.ManagedResourceMode:
@@ -44,7 +122,7 @@ func (n *NodeRefreshableResource) EvalTree() EvalNode {
         }
 }
 
-func (n *NodeRefreshableResource) evalTreeManagedResource() EvalNode {
+func (n *NodeRefreshableManagedResourceInstance) evalTreeManagedResource() EvalNode {
         addr := n.NodeAbstractResource.Addr
 
         // stateId is the ID to put into the state
diff --git a/vendor/github.com/hashicorp/terraform/terraform/transform_resource_refresh_plannable.go b/vendor/github.com/hashicorp/terraform/terraform/transform_resource_refresh_plannable.go
new file mode 100644
index 0000000..35358a3
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/terraform/transform_resource_refresh_plannable.go
@@ -0,0 +1,55 @@
+package terraform
+
+import (
+        "fmt"
+        "log"
+)
+
+// ResourceRefreshPlannableTransformer is a GraphTransformer that replaces any
+// nodes that don't have state yet exist in config with
+// NodePlannableResourceInstance.
+//
+// This transformer is used when expanding count on managed resource nodes
+// during the refresh phase to ensure that data sources that have
+// interpolations that depend on resources existing in the graph can be walked
+// properly.
+type ResourceRefreshPlannableTransformer struct {
+        // The full global state.
+        State *State
+}
+
+// Transform implements GraphTransformer for
+// ResourceRefreshPlannableTransformer.
+func (t *ResourceRefreshPlannableTransformer) Transform(g *Graph) error {
+nextVertex:
+        for _, v := range g.Vertices() {
+                addr := v.(*NodeRefreshableManagedResourceInstance).Addr
+
+                // Find the state for this address, if there is one
+                filter := &StateFilter{State: t.State}
+                results, err := filter.Filter(addr.String())
+                if err != nil {
+                        return err
+                }
+
+                // Check to see if we have a state for this resource. If we do, skip this
+                // node.
+                for _, result := range results {
+                        if _, ok := result.Value.(*ResourceState); ok {
+                                continue nextVertex
+                        }
+                }
+                // If we don't, convert this resource to a NodePlannableResourceInstance node
+                // with all of the data we need to make it happen.
+                log.Printf("[TRACE] No state for %s, converting to NodePlannableResourceInstance", addr.String())
+                new := &NodePlannableResourceInstance{
+                        NodeAbstractResource: v.(*NodeRefreshableManagedResourceInstance).NodeAbstractResource,
+                }
+                // Replace the node in the graph
+                if !g.Replace(v, new) {
+                        return fmt.Errorf("ResourceRefreshPlannableTransformer: Could not replace node %#v with %#v", v, new)
+                }
+        }
+
+        return nil
+}
diff --git a/vendor/github.com/hashicorp/terraform/terraform/transform_targets.go b/vendor/github.com/hashicorp/terraform/terraform/transform_targets.go
index 225ac4b..125f9e3 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/transform_targets.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/transform_targets.go
@@ -15,6 +15,21 @@ type GraphNodeTargetable interface {
         SetTargets([]ResourceAddress)
 }
 
+// GraphNodeTargetDownstream is an interface for graph nodes that need to
+// be remain present under targeting if any of their dependencies are targeted.
+// TargetDownstream is called with the set of vertices that are direct
+// dependencies for the node, and it should return true if the node must remain
+// in the graph in support of those dependencies.
+//
+// This is used in situations where the dependency edges are representing an
+// ordering relationship but the dependency must still be visited if its
+// dependencies are visited. This is true for outputs, for example, since
+// they must get updated if any of their dependent resources get updated,
+// which would not normally be true if one of their dependencies were targeted.
+type GraphNodeTargetDownstream interface {
+        TargetDownstream(targeted, untargeted *dag.Set) bool
+}
+
 // TargetsTransformer is a GraphTransformer that, when the user specifies a
 // list of resources to target, limits the graph to only those resources and
 // their dependencies.
@@ -84,7 +99,10 @@ func (t *TargetsTransformer) parseTargetAddresses() ([]ResourceAddress, error) {
 func (t *TargetsTransformer) selectTargetedNodes(
         g *Graph, addrs []ResourceAddress) (*dag.Set, error) {
         targetedNodes := new(dag.Set)
-        for _, v := range g.Vertices() {
+
+        vertices := g.Vertices()
+
+        for _, v := range vertices {
                 if t.nodeIsTarget(v, addrs) {
                         targetedNodes.Add(v)
 
@@ -112,6 +130,63 @@ func (t *TargetsTransformer) selectTargetedNodes(
                 }
         }
 
+        // Handle nodes that need to be included if their dependencies are included.
+        // This requires multiple passes since we need to catch transitive
+        // dependencies if and only if they are via other nodes that also
+        // support TargetDownstream. For example:
+        // output -> output -> targeted-resource: both outputs need to be targeted
+        // output -> non-targeted-resource -> targeted-resource: output not targeted
+        //
+        // We'll keep looping until we stop targeting more nodes.
+        queue := targetedNodes.List()
+        for len(queue) > 0 {
+                vertices := queue
+                queue = nil // ready to append for next iteration if neccessary
+                for _, v := range vertices {
+                        dependers := g.UpEdges(v)
+                        if dependers == nil {
+                                // indicates that there are no up edges for this node, so
+                                // we have nothing to do here.
+                                continue
+                        }
+
+                        dependers = dependers.Filter(func(dv interface{}) bool {
+                                // Can ignore nodes that are already targeted
+                                /*if targetedNodes.Include(dv) {
+                                        return false
+                                }*/
+
+                                _, ok := dv.(GraphNodeTargetDownstream)
+                                return ok
+                        })
+
+                        if dependers.Len() == 0 {
+                                continue
+                        }
+
+                        for _, dv := range dependers.List() {
+                                if targetedNodes.Include(dv) {
+                                        // Already present, so nothing to do
+                                        continue
+                                }
+
+                                // We'll give the node some information about what it's
+                                // depending on in case that informs its decision about whether
+                                // it is safe to be targeted.
+                                deps := g.DownEdges(v)
+                                depsTargeted := deps.Intersection(targetedNodes)
+                                depsUntargeted := deps.Difference(depsTargeted)
+
+                                if dv.(GraphNodeTargetDownstream).TargetDownstream(depsTargeted, depsUntargeted) {
+                                        targetedNodes.Add(dv)
+                                        // Need to visit this node on the next pass to see if it
+                                        // has any transitive dependers.
+                                        queue = append(queue, dv)
+                                }
+                        }
+                }
+        }
+
         return targetedNodes, nil
 }
 
diff --git a/vendor/github.com/hashicorp/terraform/terraform/user_agent.go b/vendor/github.com/hashicorp/terraform/terraform/user_agent.go
new file mode 100644
index 0000000..700be2a
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/terraform/user_agent.go
@@ -0,0 +1,14 @@
+package terraform
+
+import (
+        "fmt"
+        "runtime"
+)
+
+// The standard Terraform User-Agent format
+const UserAgent = "Terraform %s (%s)"
+
+// Generate a UserAgent string
+func UserAgentString() string {
+        return fmt.Sprintf(UserAgent, VersionString(), runtime.Version())
+}
diff --git a/vendor/github.com/hashicorp/terraform/terraform/version.go b/vendor/github.com/hashicorp/terraform/terraform/version.go
index 93fb429..cdfb8fb 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/version.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/version.go
@@ -7,12 +7,12 @@ import (
 )
 
 // The main version number that is being run at the moment.
-const Version = "0.9.5"
+const Version = "0.9.8"
 
 // A pre-release marker for the version. If this is "" (empty string)
 // then it means that it is a final release. Otherwise, this is a pre-release
 // such as "dev" (in development), "beta", "rc1", etc.
-const VersionPrerelease = ""
+var VersionPrerelease = ""
 
 // SemVersion is an instance of version.Version. This has the secondary
 // benefit of verifying during tests and init time that our version is a