PSS: Refactor Plan struct to reference Backend and StateStore via pointers, update calling code (#37946)

* refactor: Update Plan struct's Backend field to be a pointer

* fix: Add some refactorings or protections against nil pointers when accessing the Backend field on a Plan struct

* refactor: Update Plan struct's StateStore field to be a pointer, update a nil check in calling code.

Author: SarahFrench

internal/backend/local/backend_local_test.go

@@ -160,7 +160,7 @@ func TestLocalRun_stalePlan(t *testing.T) {
 	plan := &plans.Plan{
 		UIMode:  plans.NormalMode,
 		Changes: plans.NewChangesSrc(),
-		Backend: plans.Backend{
+		Backend: &plans.Backend{
 			Type:   "local",
 			Config: backendConfigRaw,
 		},

internal/backend/local/backend_plan.go

@@ -158,7 +158,7 @@ func (b *Local) opPlan(
 			op.ReportResult(runningOp, diags)
 			return
 		}
-		plan.Backend = *op.PlanOutBackend
+		plan.Backend = op.PlanOutBackend
 
 		// We may have updated the state in the refresh step above, but we
 		// will freeze that updated state in the plan file for now and

internal/command/apply.go

@@ -210,7 +210,7 @@ func (c *ApplyCommand) PrepareBackend(planFile *planfile.WrappedPlanFile, args *
 			))
 			return nil, diags
 		}
-		if plan.Backend.Config == nil {
+		if plan.Backend == nil {
 			// Should never happen; always indicates a bug in the creation of the plan file
 			diags = diags.Append(tfdiags.Sourceless(
 				tfdiags.Error,
@@ -220,7 +220,7 @@ 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)
+		be, beDiags = c.BackendForLocalPlan(*plan.Backend)
 	} else {
 
 		// Load the backend

internal/command/apply_test.go

@@ -821,7 +821,7 @@ func TestApply_plan_remoteState(t *testing.T) {
 		t.Fatal(err)
 	}
 	planPath := testPlanFile(t, snap, state, &plans.Plan{
-		Backend: plans.Backend{
+		Backend: &plans.Backend{
 			Type:   "http",
 			Config: backendConfigRaw,
 		},

internal/command/command_test.go

@@ -188,7 +188,7 @@ func testPlan(t *testing.T) *plans.Plan {
 	}
 
 	return &plans.Plan{
-		Backend: plans.Backend{
+		Backend: &plans.Backend{
 			// This is just a placeholder so that the plan file can be written
 			// out. Caller may wish to override it to something more "real"
 			// where the plan will actually be subsequently applied.

internal/command/graph_test.go

@@ -325,7 +325,7 @@ func TestGraph_applyPhaseSavedPlan(t *testing.T) {
 		},
 	})
 
-	plan.Backend = plans.Backend{
+	plan.Backend = &plans.Backend{
 		// Doesn't actually matter since we aren't going to activate the backend
 		// for this command anyway, but we need something here for the plan
 		// file writer to succeed.

internal/command/plan_test.go

@@ -447,6 +447,9 @@ func TestPlan_outBackend(t *testing.T) {
 		t.Fatalf("Expected empty plan to be written to plan file, got: %s", spew.Sdump(plan))
 	}
 
+	if plan.Backend == nil {
+		t.Fatal("unexpected nil Backend")
+	}
 	if got, want := plan.Backend.Type, "http"; got != want {
 		t.Errorf("wrong backend type %q; want %q", got, want)
 	}

internal/plans/plan.go

@@ -74,8 +74,8 @@ type Plan struct {
 	ActionTargetAddrs         []addrs.Targetable
 	ForceReplaceAddrs         []addrs.AbsResourceInstance
 
-	Backend    Backend
-	StateStore StateStore
+	Backend    *Backend
+	StateStore *StateStore
 
 	// Complete is true if Terraform considers this to be a "complete" plan,
 	// which is to say that it includes a planned action (even if no-op)

internal/plans/planfile/planfile_test.go

@@ -63,7 +63,7 @@ func TestRoundtrip(t *testing.T) {
 		VariableValues: map[string]plans.DynamicValue{
 			"foo": plans.DynamicValue([]byte("foo placeholder")),
 		},
-		Backend: plans.Backend{
+		Backend: &plans.Backend{
 			Type:      "local",
 			Config:    plans.DynamicValue([]byte("config placeholder")),
 			Workspace: "default",

internal/plans/planfile/tfplan.go

@@ -222,7 +222,7 @@ func readTfplan(r io.Reader) (*plans.Plan, error) {
 		if err != nil {
 			return nil, fmt.Errorf("plan file has invalid backend configuration: %s", err)
 		}
-		plan.Backend = plans.Backend{
+		plan.Backend = &plans.Backend{
 			Type:      rawBackend.Type,
 			Config:    config,
 			Workspace: rawBackend.Workspace,
@@ -243,7 +243,7 @@ func readTfplan(r io.Reader) (*plans.Plan, error) {
 			return nil, fmt.Errorf("plan file has invalid state_store provider version: %s", err)
 		}
 
-		plan.StateStore = plans.StateStore{
+		plan.StateStore = &plans.StateStore{
 			Type:      rawStateStore.Type,
 			Provider:  provider,
 			Config:    config,
@@ -737,25 +737,23 @@ func writeTfplan(plan *plans.Plan, w io.Writer) error {
 	}
 
 	// Store details about accessing state
-	backendInUse := plan.Backend.Type != "" && plan.Backend.Config != nil
-	stateStoreInUse := plan.StateStore.Type != "" && plan.StateStore.Config != nil
 	switch {
-	case !backendInUse && !stateStoreInUse:
+	case plan.Backend == nil && plan.StateStore == nil:
 		// This suggests a bug in the code that created the plan, since it
 		// ought to always have either a backend or state_store populated, even if it's the default
 		// "local" backend with a local state file.
 		return fmt.Errorf("plan does not have a backend or state_store configuration")
-	case backendInUse && stateStoreInUse:
+	case plan.Backend != nil && plan.StateStore != nil:
 		// This suggests a bug in the code that created the plan, since it
 		// should never have both a backend and state_store populated.
 		return fmt.Errorf("plan contains both backend and state_store configurations, only one is expected")
-	case backendInUse:
+	case plan.Backend != nil:
 		rawPlan.Backend = &planproto.Backend{
 			Type:      plan.Backend.Type,
 			Config:    valueToTfplan(plan.Backend.Config),
 			Workspace: plan.Backend.Workspace,
 		}
-	case stateStoreInUse:
+	case plan.StateStore != nil:
 		rawPlan.StateStore = &planproto.StateStore{
 			Type: plan.StateStore.Type,
 			Provider: &planproto.Provider{