PSS: Update how commands access backends, so both backend and state_store configuration can be used

internal/command/apply.go

@@ -219,19 +219,15 @@ func (c *ApplyCommand) PrepareBackend(planFile *planfile.WrappedPlanFile, args *
 			))
 			return nil, diags
 		}
+		// TODO: Update BackendForLocalPlan to use state storage, and plan to be able to contain State Store config details
 		be, beDiags = c.BackendForLocalPlan(plan.Backend)
 	} else {
-		// Both new plans and saved cloud plans load their backend from config.
-		backendConfig, configDiags := c.loadBackendConfig(".")
-		diags = diags.Append(configDiags)
-		if configDiags.HasErrors() {
-			return nil, diags
-		}
 
-		be, beDiags = c.Backend(&BackendOpts{
-			BackendConfig: backendConfig,
-			ViewType:      viewType,
-		})
+		// Load the backend
+		//
+		// Note: Both new plans and saved cloud plans load their backend from config,
+		// hence the config parsing in the method below.
+		be, beDiags = c.backend(".", viewType)
 	}
 
 	diags = diags.Append(beDiags)

internal/command/autocomplete.go

@@ -4,6 +4,7 @@
 package command
 
 import (
+	"github.com/hashicorp/terraform/internal/command/arguments"
 	"github.com/posener/complete"
 )
 
@@ -48,19 +49,18 @@ func (m *Meta) completePredictWorkspaceName() complete.Predictor {
 			return nil
 		}
 
-		backendConfig, diags := m.loadBackendConfig(configPath)
+		b, diags := m.backend(configPath, arguments.ViewHuman)
 		if diags.HasErrors() {
 			return nil
 		}
 
-		b, diags := m.Backend(&BackendOpts{
-			BackendConfig: backendConfig,
-		})
-		if diags.HasErrors() {
+		names, _ := b.Workspaces()
+		if len(names) == 0 {
+			// Presence of the "default" isn't always guaranteed
+			// Backends will report it as always existing, pluggable
+			// state stores will only do so if it _actually_ exists.
 			return nil
 		}
-
-		names, _ := b.Workspaces()
 		return names
 	})
 }

internal/command/autocomplete_test.go

@@ -4,37 +4,124 @@
 package command
 
 import (
-	"io/ioutil"
-	"os"
 	"reflect"
 	"testing"
 
 	"github.com/hashicorp/cli"
+	"github.com/hashicorp/terraform/internal/addrs"
+	"github.com/hashicorp/terraform/internal/command/workdir"
+	"github.com/hashicorp/terraform/internal/providers"
 	"github.com/posener/complete"
 )
 
 func TestMetaCompletePredictWorkspaceName(t *testing.T) {
-	// Create a temporary working directory that is empty
-	td := t.TempDir()
-	os.MkdirAll(td, 0755)
-	t.Chdir(td)
 
-	// make sure a vars file doesn't interfere
-	err := ioutil.WriteFile(DefaultVarsFilename, nil, 0644)
-	if err != nil {
-		t.Fatal(err)
-	}
+	t.Run("test autocompletion using the local backend", func(t *testing.T) {
+		// Create a temporary working directory that is empty
+		td := t.TempDir()
+		t.Chdir(td)
 
-	ui := new(cli.MockUi)
-	meta := &Meta{Ui: ui}
+		ui := new(cli.MockUi)
+		meta := &Meta{Ui: ui}
 
-	predictor := meta.completePredictWorkspaceName()
+		predictor := meta.completePredictWorkspaceName()
 
-	got := predictor.Predict(complete.Args{
-		Last: "",
+		got := predictor.Predict(complete.Args{
+			Last: "",
+		})
+		want := []string{"default"}
+		if !reflect.DeepEqual(got, want) {
+			t.Errorf("wrong result\ngot:  %#v\nwant: %#v", got, want)
+		}
+	})
+
+	t.Run("test autocompletion using a state store", func(t *testing.T) {
+		// Create a temporary working directory with state_store config
+		td := t.TempDir()
+		testCopyDir(t, testFixturePath("state-store-unchanged"), td)
+		t.Chdir(td)
+
+		// Set up pluggable state store provider mock
+		mockProvider := mockPluggableStateStorageProvider()
+		// Mock the existence of workspaces
+		mockProvider.MockStates = map[string]interface{}{
+			"default": true,
+			"foobar":  true,
+		}
+		mockProviderAddress := addrs.NewDefaultProvider("test")
+		providerSource, close := newMockProviderSource(t, map[string][]string{
+			"hashicorp/test": {"1.0.0"},
+		})
+		defer close()
+
+		ui := new(cli.MockUi)
+		view, _ := testView(t)
+		wd := workdir.NewDir(".")
+		wd.OverrideOriginalWorkingDir(td)
+		meta := Meta{
+			WorkingDir:                wd, // Use the test's temp dir
+			Ui:                        ui,
+			View:                      view,
+			AllowExperimentalFeatures: true,
+			testingOverrides: &testingOverrides{
+				Providers: map[addrs.Provider]providers.Factory{
+					mockProviderAddress: providers.FactoryFixed(mockProvider),
+				},
+			},
+			ProviderSource: providerSource,
+		}
+
+		predictor := meta.completePredictWorkspaceName()
+
+		got := predictor.Predict(complete.Args{
+			Last: "",
+		})
+		want := []string{"default", "foobar"}
+		if !reflect.DeepEqual(got, want) {
+			t.Errorf("wrong result\ngot:  %#v\nwant: %#v", got, want)
+		}
+	})
+
+	t.Run("test autocompletion using a state store containing no workspaces", func(t *testing.T) {
+		// Create a temporary working directory with state_store config
+		td := t.TempDir()
+		testCopyDir(t, testFixturePath("state-store-unchanged"), td)
+		t.Chdir(td)
+
+		// Set up pluggable state store provider mock
+		mockProvider := mockPluggableStateStorageProvider()
+		// No workspaces exist in the mock
+		mockProvider.MockStates = map[string]interface{}{}
+		mockProviderAddress := addrs.NewDefaultProvider("test")
+		providerSource, close := newMockProviderSource(t, map[string][]string{
+			"hashicorp/test": {"1.0.0"},
+		})
+		defer close()
+
+		ui := new(cli.MockUi)
+		view, _ := testView(t)
+		wd := workdir.NewDir(".")
+		wd.OverrideOriginalWorkingDir(td)
+		meta := Meta{
+			WorkingDir:                wd, // Use the test's temp dir
+			Ui:                        ui,
+			View:                      view,
+			AllowExperimentalFeatures: true,
+			testingOverrides: &testingOverrides{
+				Providers: map[addrs.Provider]providers.Factory{
+					mockProviderAddress: providers.FactoryFixed(mockProvider),
+				},
+			},
+			ProviderSource: providerSource,
+		}
+
+		predictor := meta.completePredictWorkspaceName()
+
+		got := predictor.Predict(complete.Args{
+			Last: "",
+		})
+		if got != nil {
+			t.Errorf("wrong result\ngot:  %#v\nwant: %#v", got, nil)
+		}
 	})
-	want := []string{"default"}
-	if !reflect.DeepEqual(got, want) {
-		t.Errorf("wrong result\ngot:  %#v\nwant: %#v", got, want)
-	}
 }

internal/command/console.go

@@ -53,17 +53,8 @@ func (c *ConsoleCommand) Run(args []string) int {
 
 	var diags tfdiags.Diagnostics
 
-	backendConfig, backendDiags := c.loadBackendConfig(configPath)
-	diags = diags.Append(backendDiags)
-	if diags.HasErrors() {
-		c.showDiagnostics(diags)
-		return 1
-	}
-
 	// Load the backend
-	b, backendDiags := c.Backend(&BackendOpts{
-		BackendConfig: backendConfig,
-	})
+	b, backendDiags := c.backend(configPath, arguments.ViewHuman)
 	diags = diags.Append(backendDiags)
 	if backendDiags.HasErrors() {
 		c.showDiagnostics(diags)

internal/command/graph.go

@@ -68,17 +68,8 @@ func (c *GraphCommand) Run(args []string) int {
 
 	var diags tfdiags.Diagnostics
 
-	backendConfig, backendDiags := c.loadBackendConfig(configPath)
-	diags = diags.Append(backendDiags)
-	if diags.HasErrors() {
-		c.showDiagnostics(diags)
-		return 1
-	}
-
 	// Load the backend
-	b, backendDiags := c.Backend(&BackendOpts{
-		BackendConfig: backendConfig,
-	})
+	b, backendDiags := c.backend(".", arguments.ViewHuman)
 	diags = diags.Append(backendDiags)
 	if backendDiags.HasErrors() {
 		c.showDiagnostics(diags)

internal/command/import.go

@@ -164,9 +164,7 @@ func (c *ImportCommand) Run(args []string) int {
 	}
 
 	// Load the backend
-	b, backendDiags := c.Backend(&BackendOpts{
-		BackendConfig: config.Module.Backend,
-	})
+	b, backendDiags := c.backend(".", arguments.ViewHuman)
 	diags = diags.Append(backendDiags)
 	if backendDiags.HasErrors() {
 		c.showDiagnostics(diags)

internal/command/meta_backend.go

@@ -1580,6 +1580,82 @@ func (m *Meta) updateSavedBackendHash(cHash int, sMgr *clistate.LocalState) tfdi
 	return diags
 }
 
+// backend returns an operations backend that may use a backend, cloud, or state_store block for state storage.
+// Based on the supplied config, it prepares arguments to pass into (Meta).Backend, which returns the operations backend.
+//
+// This method should be used in NON-init operations only; it's incapable of processing new init command CLI flags used
+// for partial configuration, however it will use the backend state file to use partial configuration from a previous
+// init command.
+func (m *Meta) backend(configPath string, viewType arguments.ViewType) (backendrun.OperationsBackend, tfdiags.Diagnostics) {
+	var diags tfdiags.Diagnostics
+
+	if configPath == "" {
+		configPath = "."
+	}
+
+	// Only return error diagnostics at this point. Any warnings will be caught
+	// again later and duplicated in the output.
+	root, mDiags := m.loadSingleModule(configPath)
+	if mDiags.HasErrors() {
+		diags = diags.Append(mDiags)
+		return nil, diags
+	}
+
+	var opts *BackendOpts
+	switch {
+	case root.Backend != nil:
+		opts = &BackendOpts{
+			BackendConfig: root.Backend,
+			ViewType:      viewType,
+		}
+	case root.CloudConfig != nil:
+		backendConfig := root.CloudConfig.ToBackendConfig()
+		opts = &BackendOpts{
+			BackendConfig: &backendConfig,
+			ViewType:      viewType,
+		}
+	case root.StateStore != nil:
+		// In addition to config, use of a state_store requires
+		// provider factory and provider locks data
+		locks, lDiags := m.lockedDependencies()
+		diags = diags.Append(lDiags)
+		if lDiags.HasErrors() {
+			return nil, diags
+		}
+
+		factory, fDiags := m.GetStateStoreProviderFactory(root.StateStore, locks)
+		diags = diags.Append(fDiags)
+		if fDiags.HasErrors() {
+			return nil, diags
+		}
+
+		opts = &BackendOpts{
+			StateStoreConfig: root.StateStore,
+			ProviderFactory:  factory,
+			Locks:            locks,
+			ViewType:         viewType,
+		}
+	default:
+		// there is no config; defaults to local state storage
+		opts = &BackendOpts{
+			ViewType: viewType,
+		}
+	}
+
+	// This method should not be used for init commands,
+	// so we always set this value as false.
+	opts.Init = false
+
+	// Load the backend
+	be, beDiags := m.Backend(opts)
+	diags = diags.Append(beDiags)
+	if beDiags.HasErrors() {
+		return nil, diags
+	}
+
+	return be, diags
+}
+
 //-------------------------------------------------------------------
 // State Store Config Scenarios
 // The functions below cover handling all the various scenarios that