Implement the Enterprise enhanced remote backend

backend/backend.go

@@ -15,14 +15,29 @@ import (
  "github.com/hashicorp/terraform/terraform"
 )
 
-// This is the name of the default, initial state that every backend
-// must have. This state cannot be deleted.
+// DefaultStateName is the name of the default, initial state that every
+// backend must have. This state cannot be deleted.
 const DefaultStateName = "default"
 
-// Error value to return when a named state operation isn't supported.
 // This must be returned rather than a custom error so that the Terraform
 // CLI can detect it and handle it appropriately.
-var ErrNamedStatesNotSupported = errors.New("named states not supported")
+var (
+ // ErrNamedStatesNotSupported is returned when a named state operation
+ // isn't supported.
+ ErrNamedStatesNotSupported = errors.New("named states not supported")
+
+ // ErrDefaultStateNotSupported is returned when an operation does not support
+ // using the default state, but requires a named state to be selected.
+ ErrDefaultStateNotSupported = errors.New("default state not supported\n\n" +
+ "You can create a new workspace wth the \"workspace new\" command")
+
+ // ErrOperationNotSupported is returned when an unsupported operation
+ // is detected by the configured backend.
+ ErrOperationNotSupported = errors.New("operation not supported")
+)
+
+// InitFn is used to initialize a new backend.
+type InitFn func() Backend
 
 // Backend is the minimal interface that must be implemented to enable Terraform.
 type Backend interface {

backend/init/init.go

@@ -3,14 +3,17 @@
 package init
 
 import (
+ "os"
  "sync"
 
  "github.com/hashicorp/terraform/backend"
+ "github.com/hashicorp/terraform/svchost/disco"
  "github.com/hashicorp/terraform/terraform"
 
  backendAtlas "github.com/hashicorp/terraform/backend/atlas"
  backendLegacy "github.com/hashicorp/terraform/backend/legacy"
  backendLocal "github.com/hashicorp/terraform/backend/local"
+ backendRemote "github.com/hashicorp/terraform/backend/remote"
  backendAzure "github.com/hashicorp/terraform/backend/remote-state/azure"
  backendConsul "github.com/hashicorp/terraform/backend/remote-state/consul"
  backendEtcdv3 "github.com/hashicorp/terraform/backend/remote-state/etcdv3"
@@ -32,17 +35,27 @@ import (
 // complex structures and supporting that over the plugin system is currently
 // prohibitively difficult. For those wanting to implement a custom backend,
 // they can do so with recompilation.
-var backends map[string]func() backend.Backend
+var backends map[string]backend.InitFn
 var backendsLock sync.Mutex
 
-func init() {
- // Our hardcoded backends. We don't need to acquire a lock here
- // since init() code is serial and can't spawn goroutines.
- backends = map[string]func() backend.Backend{
+// Init initializes the backends map with all our hardcoded backends.
+func Init(services *disco.Disco) {
+ backendsLock.Lock()
+ defer backendsLock.Unlock()
+
+ backends = map[string]backend.InitFn{
+ // Enhanced backends.
  "local": func() backend.Backend { return backendLocal.New() },
- "atlas": func() backend.Backend { return backendAtlas.New() },
- "azure": deprecateBackend(backendAzure.New(),
- `Warning: "azure" name is deprecated, please use "azurerm"`),
+ "remote": func() backend.Backend {
+ b := backendRemote.New(services)
+ if os.Getenv("TF_FORCE_LOCAL_BACKEND") != "" {
+ return backendLocal.NewWithBackend(b)
+ }
+ return b
+ },
+
+ // Remote State backends.
+ "atlas": func() backend.Backend { return backendAtlas.New() },
  "azurerm": func() backend.Backend { return backendAzure.New() },
  "consul": func() backend.Backend { return backendConsul.New() },
  "etcdv3": func() backend.Backend { return backendEtcdv3.New() },
@@ -51,6 +64,10 @@ func init() {
  "manta": func() backend.Backend { return backendManta.New() },
  "s3": func() backend.Backend { return backendS3.New() },
  "swift": func() backend.Backend { return backendSwift.New() },
+
+ // Deprecated backends.
+ "azure": deprecateBackend(backendAzure.New(),
+ `Warning: "azure" name is deprecated, please use "azurerm"`),
  }
 
  // Add the legacy remote backends that haven't yet been converted to
@@ -60,7 +77,7 @@ func init() {
 
 // Backend returns the initialization factory for the given backend, or
 // nil if none exists.
-func Backend(name string) func() backend.Backend {
+func Backend(name string) backend.InitFn {
  backendsLock.Lock()
  defer backendsLock.Unlock()
  return backends[name]
@@ -73,7 +90,7 @@ func Backend(name string) func() backend.Backend {
 // This method sets this backend globally and care should be taken to do
 // this only before Terraform is executing to prevent odd behavior of backends
 // changing mid-execution.
-func Set(name string, f func() backend.Backend) {
+func Set(name string, f backend.InitFn) {
  backendsLock.Lock()
  defer backendsLock.Unlock()
 
@@ -101,7 +118,7 @@ func (b deprecatedBackendShim) Validate(c *terraform.ResourceConfig) ([]string,
 
 // DeprecateBackend can be used to wrap a backend to retrun a deprecation
 // warning during validation.
-func deprecateBackend(b backend.Backend, message string) func() backend.Backend {
+func deprecateBackend(b backend.Backend, message string) backend.InitFn {
  // Since a Backend wrapped by deprecatedBackendShim can no longer be
  // asserted as an Enhanced or Local backend, disallow those types here
  // entirely. If something other than a basic backend.Backend needs to be

backend/init/init_test.go

@@ -0,0 +1,110 @@
+package init
+
+import (
+ "os"
+ "reflect"
+ "testing"
+
+ backendLocal "github.com/hashicorp/terraform/backend/local"
+)
+
+func TestInit_backend(t *testing.T) {
+ // Initialize the backends map
+ Init(nil)
+
+ backends := []struct {
+ Name string
+ Type string
+ }{
+ {
+ "local",
+ "*local.Local",
+ }, {
+ "remote",
+ "*remote.Remote",
+ }, {
+ "atlas",
+ "*atlas.Backend",
+ }, {
+ "azurerm",
+ "*azure.Backend",
+ }, {
+ "consul",
+ "*consul.Backend",
+ }, {
+ "etcdv3",
+ "*etcd.Backend",
+ }, {
+ "gcs",
+ "*gcs.Backend",
+ }, {
+ "inmem",
+ "*inmem.Backend",
+ }, {
+ "manta",
+ "*manta.Backend",
+ }, {
+ "s3",
+ "*s3.Backend",
+ }, {
+ "swift",
+ "*swift.Backend",
+ }, {
+ "azure",
+ "init.deprecatedBackendShim",
+ },
+ }
+
+ // Make sure we get the requested backend
+ for _, b := range backends {
+ f := Backend(b.Name)
+ bType := reflect.TypeOf(f()).String()
+
+ if bType != b.Type {
+ t.Fatalf("expected backend %q to be %q, got: %q", b.Name, b.Type, bType)
+ }
+ }
+}
+
+func TestInit_forceLocalBackend(t *testing.T) {
+ // Initialize the backends map
+ Init(nil)
+
+ enhancedBackends := []struct {
+ Name string
+ Type string
+ }{
+ {
+ "local",
+ "nil",
+ }, {
+ "remote",
+ "*remote.Remote",
+ },
+ }
+
+ // Set the TF_FORCE_LOCAL_BACKEND flag so all enhanced backends will
+ // return a local.Local backend with themselves as embedded backend.
+ if err := os.Setenv("TF_FORCE_LOCAL_BACKEND", "1"); err != nil {
+ t.Fatalf("error setting environment variable TF_FORCE_LOCAL_BACKEND: %v", err)
+ }
+
+ // Make sure we always get the local backend.
+ for _, b := range enhancedBackends {
+ f := Backend(b.Name)
+
+ local, ok := f().(*backendLocal.Local)
+ if !ok {
+ t.Fatalf("expected backend %q to be \"*local.Local\", got: %T", b.Name, f())
+ }
+
+ bType := "nil"
+ if local.Backend != nil {
+ bType = reflect.TypeOf(local.Backend).String()
+ }
+
+ if bType != b.Type {
+ t.Fatalf("expected local.Backend to be %s, got: %s", b.Type, bType)
+ }
+ }
+}

backend/legacy/legacy.go

@@ -12,8 +12,8 @@ import (
 //
 // If a type is already in the map, it will not be added. This will allow
 // us to slowly convert the legacy types to first-class backends.
-func Init(m map[string]func() backend.Backend) {
- for k, _ := range remote.BuiltinClients {
+func Init(m map[string]backend.InitFn) {
+ for k := range remote.BuiltinClients {
  if _, ok := m[k]; !ok {
  // Copy the "k" value since the variable "k" is reused for
  // each key (address doesn't change).

backend/legacy/legacy_test.go

@@ -8,7 +8,7 @@ import (
 )
 
 func TestInit(t *testing.T) {
- m := make(map[string]func() backend.Backend)
+ m := make(map[string]backend.InitFn)
  Init(m)
 
  for k, _ := range remote.BuiltinClients {
@@ -24,7 +24,7 @@ func TestInit(t *testing.T) {
 }
 
 func TestInit_ignoreExisting(t *testing.T) {
- m := make(map[string]func() backend.Backend)
+ m := make(map[string]backend.InitFn)
  m["local"] = nil
  Init(m)
 

backend/local/testing.go

@@ -99,6 +99,50 @@ func (b *TestLocalSingleState) DeleteState(string) error {
  return backend.ErrNamedStatesNotSupported
 }
 
+// TestNewLocalNoDefault is a factory for creating a TestLocalNoDefaultState.
+// This function matches the signature required for backend/init.
+func TestNewLocalNoDefault() backend.Backend {
+ return &TestLocalNoDefaultState{Local: New()}
+}
+
+// TestLocalNoDefaultState is a backend implementation that wraps
+// Local and modifies it to support named states, but not the
+// default state. It returns ErrDefaultStateNotSupported when the
+// DefaultStateName is used.
+type TestLocalNoDefaultState struct {
+ *Local
+}
+
+func (b *TestLocalNoDefaultState) State(name string) (state.State, error) {
+ if name == backend.DefaultStateName {
+ return nil, backend.ErrDefaultStateNotSupported
+ }
+ return b.Local.State(name)
+}
+
+func (b *TestLocalNoDefaultState) States() ([]string, error) {
+ states, err := b.Local.States()
+ if err != nil {
+ return nil, err
+ }
+
+ filtered := states[:0]
+ for _, name := range states {
+ if name != backend.DefaultStateName {
+ filtered = append(filtered, name)
+ }
+ }
+
+ return filtered, nil
+}
+
+func (b *TestLocalNoDefaultState) DeleteState(name string) error {
+ if name == backend.DefaultStateName {
+ return backend.ErrDefaultStateNotSupported
+ }
+ return b.Local.DeleteState(name)
+}
+
 func testTempDir(t *testing.T) string {
  d, err := ioutil.TempDir("", "tf")
  if err != nil {