From 9b12e4fe6f3c95986f1f3ec791636c58ca7e7583 Mon Sep 17 00:00:00 2001
From: Jake Champlin <jake@gnu.space>
Date: Fri, 9 Jun 2017 17:54:32 +0000
Subject: Transfer of provider code

---
 .../hashicorp/terraform/config/config.go           |  64 +--------
 .../terraform/config/interpolate_funcs.go          |  48 +++++++
 vendor/github.com/hashicorp/terraform/dag/set.go   |  14 ++
 .../hashicorp/terraform/helper/acctest/acctest.go  |   2 -
 .../hashicorp/terraform/helper/acctest/random.go   |  93 -------------
 .../terraform/helper/acctest/remotetests.go        |  27 ----
 .../hashicorp/terraform/helper/resource/testing.go | 148 +++++++++++++++++++++
 .../terraform/helper/schema/provisioner.go         |  30 ++++-
 .../hashicorp/terraform/helper/schema/schema.go    |   4 +-
 .../terraform/helper/structure/expand_json.go      |  11 --
 .../terraform/helper/structure/flatten_json.go     |  16 ---
 .../terraform/helper/structure/normalize_json.go   |  24 ----
 .../helper/structure/suppress_json_diff.go         |  21 ---
 .../terraform/helper/validation/validation.go      | 108 ---------------
 .../terraform/terraform/graph_builder_refresh.go   |  49 +++++--
 .../hashicorp/terraform/terraform/interpolate.go   |  13 ++
 .../terraform/terraform/node_data_refresh.go       |  20 +++
 .../hashicorp/terraform/terraform/node_output.go   |   9 ++
 .../terraform/terraform/node_resource_refresh.go   |  88 +++++++++++-
 .../transform_resource_refresh_plannable.go        |  55 ++++++++
 .../terraform/terraform/transform_targets.go       |  77 ++++++++++-
 .../hashicorp/terraform/terraform/user_agent.go    |  14 ++
 .../hashicorp/terraform/terraform/version.go       |   4 +-
 23 files changed, 553 insertions(+), 386 deletions(-)
 delete mode 100644 vendor/github.com/hashicorp/terraform/helper/acctest/acctest.go
 delete mode 100644 vendor/github.com/hashicorp/terraform/helper/acctest/random.go
 delete mode 100644 vendor/github.com/hashicorp/terraform/helper/acctest/remotetests.go
 delete mode 100644 vendor/github.com/hashicorp/terraform/helper/structure/expand_json.go
 delete mode 100644 vendor/github.com/hashicorp/terraform/helper/structure/flatten_json.go
 delete mode 100644 vendor/github.com/hashicorp/terraform/helper/structure/normalize_json.go
 delete mode 100644 vendor/github.com/hashicorp/terraform/helper/structure/suppress_json_diff.go
 delete mode 100644 vendor/github.com/hashicorp/terraform/helper/validation/validation.go
 create mode 100644 vendor/github.com/hashicorp/terraform/terraform/transform_resource_refresh_plannable.go
 create mode 100644 vendor/github.com/hashicorp/terraform/terraform/user_agent.go

(limited to 'vendor/github.com/hashicorp/terraform')

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
-- 
cgit v1.2.3