Add filesystem state store (no locking) and E2E test

Author: SarahFrench

internal/command/e2etest/primary_test.go

@@ -15,6 +15,7 @@ import (
 	"github.com/hashicorp/terraform/internal/e2e"
 	"github.com/hashicorp/terraform/internal/getproviders"
 	"github.com/hashicorp/terraform/internal/plans"
+	"github.com/hashicorp/terraform/internal/states/statefile"
 	"github.com/zclconf/go-cty/cty"
 )
 
@@ -249,6 +250,85 @@ func TestPrimary_stateStore(t *testing.T) {
 	}
 	t.Parallel()
 
+	tf := e2e.NewBinary(t, terraformBin, "testdata/full-workflow-with-state-store-fs")
+
+	// In order to test integration with PSS we need a provider plugin implementing a state store.
+	// Here will build the simple6 (built with protocol v6) provider, which implements PSS.
+	simple6Provider := filepath.Join(tf.WorkDir(), "terraform-provider-simple6")
+	simple6ProviderExe := e2e.GoBuild("github.com/hashicorp/terraform/internal/provider-simple-v6/main", simple6Provider)
+
+	// Move the provider binaries into a directory that we will point terraform
+	// to using the -plugin-dir cli flag.
+	platform := getproviders.CurrentPlatform.String()
+	hashiDir := "cache/registry.terraform.io/hashicorp/"
+	if err := os.MkdirAll(tf.Path(hashiDir, "simple6/0.0.1/", platform), os.ModePerm); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Rename(simple6ProviderExe, tf.Path(hashiDir, "simple6/0.0.1/", platform, "terraform-provider-simple6")); err != nil {
+		t.Fatal(err)
+	}
+
+	//// INIT
+	stdout, stderr, err := tf.Run("init", "-enable-pluggable-state-storage-experiment=true", "-plugin-dir=cache", "-no-color")
+	if err != nil {
+		t.Fatalf("unexpected init error: %s\nstderr:\n%s", err, stderr)
+	}
+
+	if !strings.Contains(stdout, "Terraform created an empty state file for the default workspace") {
+		t.Errorf("notice about creating the default workspace is missing from init output:\n%s", stdout)
+	}
+
+	//// PLAN
+	// No separate plan step; this test lets the apply make a plan.
+
+	//// APPLY
+	stdout, stderr, err = tf.Run("apply", "-auto-approve", "-no-color")
+	if err != nil {
+		t.Fatalf("unexpected apply error: %s\nstderr:\n%s", err, stderr)
+	}
+
+	if !strings.Contains(stdout, "Resources: 1 added, 0 changed, 0 destroyed") {
+		t.Errorf("incorrect apply tally; want 1 added:\n%s", stdout)
+	}
+
+	// Check the statefile saved by the fs state store.
+	path := "terraform.tfstate.d/default/terraform.tfstate"
+	f, err := tf.OpenFile(path)
+	if err != nil {
+		t.Fatalf("unexpected error opening state file %s: %s\nstderr:\n%s", path, err, stderr)
+	}
+	defer f.Close()
+
+	stateFile, err := statefile.Read(f)
+	if err != nil {
+		t.Fatalf("unexpected error reading statefile %s: %s\nstderr:\n%s", path, err, stderr)
+	}
+
+	r := stateFile.State.RootModule().Resources
+	if len(r) != 1 {
+		t.Fatalf("expected state to include one resource, but got %d", len(r))
+	}
+	if _, ok := r["terraform_data.my-data"]; !ok {
+		t.Fatalf("expected state to include terraform_data.my-data but it's missing")
+	}
+}
+
+// Requires TF_TEST_EXPERIMENTS to be set in the environment
+func TestPrimary_stateStore_inMem(t *testing.T) {
+	if v := os.Getenv("TF_TEST_EXPERIMENTS"); v == "" {
+		t.Skip("can't run without enabling experiments in the executable terraform binary, enable with TF_TEST_EXPERIMENTS=1")
+	}
+
+	if !canRunGoBuild {
+		// We're running in a separate-build-then-run context, so we can't
+		// currently execute this test which depends on being able to build
+		// new executable at runtime.
+		//
+		// (See the comment on canRunGoBuild's declaration for more information.)
+		t.Skip("can't run without building a new provider executable")
+	}
+	t.Parallel()
+
 	tf := e2e.NewBinary(t, terraformBin, "testdata/full-workflow-with-state-store-inmem")
 
 	// In order to test integration with PSS we need a provider plugin implementing a state store.
@@ -268,6 +348,9 @@ func TestPrimary_stateStore(t *testing.T) {
 	}
 
 	//// INIT
+	//
+	// Note - the inmem PSS implementation means that the default workspace state created during init
+	// is lost as soon as the command completes.
 	stdout, stderr, err := tf.Run("init", "-enable-pluggable-state-storage-experiment=true", "-plugin-dir=cache", "-no-color")
 	if err != nil {
 		t.Fatalf("unexpected init error: %s\nstderr:\n%s", err, stderr)
@@ -281,6 +364,9 @@ func TestPrimary_stateStore(t *testing.T) {
 	// No separate plan step; this test lets the apply make a plan.
 
 	//// APPLY
+	//
+	// Note - the inmem PSS implementation means that writing to the default workspace during apply
+	// is creating the default state file for the first time.
 	stdout, stderr, err = tf.Run("apply", "-auto-approve", "-no-color")
 	if err != nil {
 		t.Fatalf("unexpected apply error: %s\nstderr:\n%s", err, stderr)

internal/provider-simple-v6/provider.go

@@ -24,6 +24,7 @@ type simple struct {
 	schema providers.GetProviderSchemaResponse
 
 	inMem *InMemStoreSingle
+	fs    *FsStore
 }
 
 // Provider returns an instance of providers.Interface
@@ -109,7 +110,8 @@ func provider() simple {
 			},
 			Actions: map[string]providers.ActionSchema{},
 			StateStores: map[string]providers.Schema{
-				inMemStoreName: stateStoreInMemGetSchema(),
+				inMemStoreName: stateStoreInMemGetSchema(), // simple6_inmem
+				fsStoreName:    stateStoreFsGetSchema(),    // simple6_fs
 			},
 			ServerCapabilities: providers.ServerCapabilities{
 				PlanDestroy:               true,
@@ -134,7 +136,9 @@ func provider() simple {
 			},
 		},
 
-		inMem: &InMemStoreSingle{}, // default workspace doesn't exist by default here; needs explicit creation via init command
+		// default workspaces doesn't exist by default here; needs explicit creation via init command
+		inMem: &InMemStoreSingle{},
+		fs:    &FsStore{},
 	}
 
 	return provider
@@ -353,6 +357,9 @@ func (s simple) ValidateStateStoreConfig(req providers.ValidateStateStoreConfigR
 	if req.TypeName == inMemStoreName {
 		return s.inMem.ValidateStateStoreConfig(req)
 	}
+	if req.TypeName == fsStoreName {
+		return s.fs.ValidateStateStoreConfig(req)
+	}
 
 	var resp providers.ValidateStateStoreConfigResponse
 	resp.Diagnostics.Append(fmt.Errorf("unsupported state store type %q", req.TypeName))
@@ -363,6 +370,9 @@ func (s simple) ConfigureStateStore(req providers.ConfigureStateStoreRequest) pr
 	if req.TypeName == inMemStoreName {
 		return s.inMem.ConfigureStateStore(req)
 	}
+	if req.TypeName == fsStoreName {
+		return s.fs.ConfigureStateStore(req)
+	}
 
 	var resp providers.ConfigureStateStoreResponse
 	resp.Diagnostics.Append(fmt.Errorf("unsupported state store type %q", req.TypeName))
@@ -373,6 +383,9 @@ func (s simple) ReadStateBytes(req providers.ReadStateBytesRequest) providers.Re
 	if req.TypeName == inMemStoreName {
 		return s.inMem.ReadStateBytes(req)
 	}
+	if req.TypeName == fsStoreName {
+		return s.fs.ReadStateBytes(req)
+	}
 
 	var resp providers.ReadStateBytesResponse
 	resp.Diagnostics.Append(fmt.Errorf("unsupported state store type %q", req.TypeName))
@@ -383,6 +396,9 @@ func (s simple) WriteStateBytes(req providers.WriteStateBytesRequest) providers.
 	if req.TypeName == inMemStoreName {
 		return s.inMem.WriteStateBytes(req)
 	}
+	if req.TypeName == fsStoreName {
+		return s.fs.WriteStateBytes(req)
+	}
 
 	var resp providers.WriteStateBytesResponse
 	resp.Diagnostics.Append(fmt.Errorf("unsupported state store type %q", req.TypeName))
@@ -393,6 +409,9 @@ func (s simple) LockState(req providers.LockStateRequest) providers.LockStateRes
 	if req.TypeName == inMemStoreName {
 		return s.inMem.LockState(req)
 	}
+	if req.TypeName == fsStoreName {
+		return s.fs.LockState(req)
+	}
 
 	var resp providers.LockStateResponse
 	resp.Diagnostics.Append(fmt.Errorf("unsupported state store type %q", req.TypeName))
@@ -403,6 +422,9 @@ func (s simple) UnlockState(req providers.UnlockStateRequest) providers.UnlockSt
 	if req.TypeName == inMemStoreName {
 		return s.inMem.UnlockState(req)
 	}
+	if req.TypeName == fsStoreName {
+		return s.fs.UnlockState(req)
+	}
 
 	var resp providers.UnlockStateResponse
 	resp.Diagnostics.Append(fmt.Errorf("unsupported state store type %q", req.TypeName))
@@ -413,6 +435,9 @@ func (s simple) GetStates(req providers.GetStatesRequest) providers.GetStatesRes
 	if req.TypeName == inMemStoreName {
 		return s.inMem.GetStates(req)
 	}
+	if req.TypeName == fsStoreName {
+		return s.fs.GetStates(req)
+	}
 
 	var resp providers.GetStatesResponse
 	resp.Diagnostics.Append(fmt.Errorf("unsupported state store type %q", req.TypeName))
@@ -423,6 +448,9 @@ func (s simple) DeleteState(req providers.DeleteStateRequest) providers.DeleteSt
 	if req.TypeName == inMemStoreName {
 		return s.inMem.DeleteState(req)
 	}
+	if req.TypeName == fsStoreName {
+		return s.fs.DeleteState(req)
+	}
 
 	var resp providers.DeleteStateResponse
 	resp.Diagnostics.Append(fmt.Errorf("unsupported state store type %q", req.TypeName))