added flatten interpolation function

.travis.yml

@@ -2,7 +2,8 @@ dist: trusty
 sudo: false
 language: go
 go:
-- 1.8.1
+- 1.8.3
+- 1.9rc1
 
 # add TF_CONSUL_TEST=1 to run consul tests
 # they were causing timouts in travis

CHANGELOG.md

@@ -1,4 +1,33 @@
-## 0.10.1 (Unreleased)
+## 0.10.3 (Unreleased)
+
+## 0.10.2 (August 16, 2017)
+
+BUG FIXES:
+
+* tools/terraform-bundle: Add missing Ui to ProviderInstaller (fix crash) ([#15826](https://github.com/hashicorp/terraform/issues/15826))
+* go-plugin: crash when server emits non-key-value JSON ([go-plugin#43](https://github.com/hashicorp/go-plugin/pull/43))
+
+## 0.10.1 (August 15, 2017)
+
+BUG FIXES:
+
+* Fix `terraform state rm` and `mv` commands to work correctly with remote state backends ([#15652](https://github.com/hashicorp/terraform/issues/15652))
+* Fix errors when interpolations fail during input ([#15780](https://github.com/hashicorp/terraform/issues/15780))
+* Backoff retries in remote-execution provisioner ([#15772](https://github.com/hashicorp/terraform/issues/15772))
+* Load plugins from `~/.terraform.d/plugins/OS_ARCH/` and `.terraformrc` ([#15769](https://github.com/hashicorp/terraform/issues/15769))
+* The `import` command was ignoring the remote state configuration ([#15768](https://github.com/hashicorp/terraform/issues/15768))
+* Don't allow leading slashes in s3 bucket names for remote state ([#15738](https://github.com/hashicorp/terraform/issues/15738))
+
+IMPROVEMENTS:
+
+* helper/schema: Add `GetOkExists` schema function ([#15723](https://github.com/hashicorp/terraform/issues/15723))
+* helper/schema: Make 'id' a reserved field name ([#15695](https://github.com/hashicorp/terraform/issues/15695))
+* command/init: Display version + source when initializing plugins ([#15804](https://github.com/hashicorp/terraform/issues/15804))
+
+INTERNAL CHANGES:
+
+* DiffFieldReader.ReadField caches results to optimize deeply nested schemas ([#15663](https://github.com/hashicorp/terraform/issues/15663))
+
 
 ## 0.10.0 (August 2, 2017)
 

Dockerfile

@@ -14,6 +14,7 @@ MAINTAINER "HashiCorp Terraform Team <terraform@hashicorp.com>"
 RUN apk add --update git bash openssh
 
 ENV TF_DEV=true
+ENV TF_RELEASE=1
 
 WORKDIR $GOPATH/src/github.com/hashicorp/terraform
 COPY . .

Vagrantfile

@@ -5,7 +5,7 @@
 VAGRANTFILE_API_VERSION = "2"
 
 # Software version variables
-GOVERSION = "1.8.1"
+GOVERSION = "1.8.3"
 UBUNTUVERSION = "16.04"
 
 # CPU and RAM can be adjusted depending on your system

backend/remote-state/consul/backend_test.go

@@ -22,7 +22,7 @@ func newConsulTestServer(t *testing.T) *testutil.TestServer {
 		t.Skip()
 	}
 
-	srv := testutil.NewTestServerConfig(t, func(c *testutil.TestServerConfig) {
+	srv, _ := testutil.NewTestServerConfigT(t, func(c *testutil.TestServerConfig) {
 		c.LogLevel = "warn"
 
 		if !testing.Verbose() {

backend/remote-state/consul/client.go

@@ -367,14 +367,7 @@ func (c *RemoteClient) createSession() (string, error) {
 	log.Println("[INFO] created consul lock session", id)
 
 	// keep the session renewed
-	// we need an adapter to convert the session Done() channel to a
-	// non-directional channel to satisfy the RenewPeriodic signature.
-	done := make(chan struct{})
-	go func() {
-		<-ctx.Done()
-		close(done)
-	}()
-	go session.RenewPeriodic(lockSessionTTL, id, nil, done)
+	go session.RenewPeriodic(lockSessionTTL, id, nil, ctx.Done())
 
 	return id, nil
 }

backend/remote-state/inmem/backend.go

@@ -2,40 +2,207 @@ package inmem
 
 import (
 	"context"
+	"errors"
+	"fmt"
+	"sort"
+	"sync"
+	"time"
 
 	"github.com/hashicorp/terraform/backend"
-	"github.com/hashicorp/terraform/backend/remote-state"
 	"github.com/hashicorp/terraform/helper/schema"
 	"github.com/hashicorp/terraform/state"
 	"github.com/hashicorp/terraform/state/remote"
+	"github.com/hashicorp/terraform/terraform"
 )
 
+// we keep the states and locks in package-level variables, so that they can be
+// accessed from multiple instances of the backend. This better emulates
+// backend instances accessing a single remote data store.
+var (
+	states stateMap
+	locks  lockMap
+)
+
+func init() {
+	Reset()
+}
+
+// Reset clears out all existing state and lock data.
+// This is used to initialize the package during init, as well as between
+// tests.
+func Reset() {
+	states = stateMap{
+		m: map[string]*remote.State{},
+	}
+
+	locks = lockMap{
+		m: map[string]*state.LockInfo{},
+	}
+}
+
 // New creates a new backend for Inmem remote state.
 func New() backend.Backend {
-	return &remotestate.Backend{
-		ConfigureFunc: configure,
-
-		// Set the schema
-		Backend: &schema.Backend{
-			Schema: map[string]*schema.Schema{
-				"lock_id": &schema.Schema{
-					Type:        schema.TypeString,
-					Optional:    true,
-					Description: "initializes the state in a locked configuration",
-				},
+	// Set the schema
+	s := &schema.Backend{
+		Schema: map[string]*schema.Schema{
+			"lock_id": &schema.Schema{
+				Type:        schema.TypeString,
+				Optional:    true,
+				Description: "initializes the state in a locked configuration",
 			},
 		},
 	}
+	backend := &Backend{Backend: s}
+	backend.Backend.ConfigureFunc = backend.configure
+	return backend
+}
+
+type Backend struct {
+	*schema.Backend
 }
 
-func configure(ctx context.Context) (remote.Client, error) {
+func (b *Backend) configure(ctx context.Context) error {
+	states.Lock()
+	defer states.Unlock()
+
+	defaultClient := &RemoteClient{
+		Name: backend.DefaultStateName,
+	}
+
+	states.m[backend.DefaultStateName] = &remote.State{
+		Client: defaultClient,
+	}
+
+	// set the default client lock info per the test config
 	data := schema.FromContextBackendConfig(ctx)
 	if v, ok := data.GetOk("lock_id"); ok && v.(string) != "" {
 		info := state.NewLockInfo()
 		info.ID = v.(string)
 		info.Operation = "test"
 		info.Info = "test config"
-		return &RemoteClient{LockInfo: info}, nil
+
+		locks.lock(backend.DefaultStateName, info)
+	}
+
+	return nil
+}
+
+func (b *Backend) States() ([]string, error) {
+	states.Lock()
+	defer states.Unlock()
+
+	var workspaces []string
+
+	for s := range states.m {
+		workspaces = append(workspaces, s)
+	}
+
+	sort.Strings(workspaces)
+	return workspaces, nil
+}
+
+func (b *Backend) DeleteState(name string) error {
+	states.Lock()
+	defer states.Unlock()
+
+	if name == backend.DefaultStateName || name == "" {
+		return fmt.Errorf("can't delete default state")
+	}
+
+	delete(states.m, name)
+	return nil
+}
+
+func (b *Backend) State(name string) (state.State, error) {
+	states.Lock()
+	defer states.Unlock()
+
+	s := states.m[name]
+	if s == nil {
+		s = &remote.State{
+			Client: &RemoteClient{
+				Name: name,
+			},
+		}
+		states.m[name] = s
+
+		// to most closely replicate other implementations, we are going to
+		// take a lock and create a new state if it doesn't exist.
+		lockInfo := state.NewLockInfo()
+		lockInfo.Operation = "init"
+		lockID, err := s.Lock(lockInfo)
+		if err != nil {
+			return nil, fmt.Errorf("failed to lock inmem state: %s", err)
+		}
+		defer s.Unlock(lockID)
+
+		// If we have no state, we have to create an empty state
+		if v := s.State(); v == nil {
+			if err := s.WriteState(terraform.NewState()); err != nil {
+				return nil, err
+			}
+			if err := s.PersistState(); err != nil {
+				return nil, err
+			}
+		}
 	}
-	return &RemoteClient{}, nil
+
+	return s, nil
+}
+
+type stateMap struct {
+	sync.Mutex
+	m map[string]*remote.State
+}
+
+// Global level locks for inmem backends.
+type lockMap struct {
+	sync.Mutex
+	m map[string]*state.LockInfo
+}
+
+func (l *lockMap) lock(name string, info *state.LockInfo) (string, error) {
+	l.Lock()
+	defer l.Unlock()
+
+	lockInfo := l.m[name]
+	if lockInfo != nil {
+		lockErr := &state.LockError{
+			Info: lockInfo,
+		}
+
+		lockErr.Err = errors.New("state locked")
+		// make a copy of the lock info to avoid any testing shenanigans
+		*lockErr.Info = *lockInfo
+		return "", lockErr
+	}
+
+	info.Created = time.Now().UTC()
+	l.m[name] = info
+
+	return info.ID, nil
+}
+
+func (l *lockMap) unlock(name, id string) error {
+	l.Lock()
+	defer l.Unlock()
+
+	lockInfo := l.m[name]
+
+	if lockInfo == nil {
+		return errors.New("state not locked")
+	}
+
+	lockErr := &state.LockError{
+		Info: &state.LockInfo{},
+	}
+
+	if id != lockInfo.ID {
+		lockErr.Err = errors.New("invalid lock id")
+		*lockErr.Info = *lockInfo
+		return lockErr
+	}
+
+	delete(l.m, name)
+	return nil
 }