Merge pull request #35367 from hashicorp/TF-10864

stacks: implement PlanTimestamp method on ExpressionScope

Author: DanielMSchmidt

internal/rpcapi/stacks_test.go

@@ -7,6 +7,7 @@ import (
 	"context"
 	"io"
 	"testing"
+	"time"
 
 	"github.com/google/go-cmp/cmp"
 	"github.com/hashicorp/go-slug/sourceaddrs"
@@ -290,6 +291,17 @@ func TestStacksPlanStackChanges(t *testing.T) {
 				},
 			},
 		},
+		{
+			Event: &terraform1.PlanStackChanges_Event_PlannedChange{
+				PlannedChange: &terraform1.PlannedChange{
+					Raw: []*anypb.Any{
+						mustMarshalAnyPb(&tfstackdata1.PlanTimestamp{
+							PlanTimestamp: time.Now().UTC().Format(time.RFC3339),
+						}),
+					},
+				},
+			},
+		},
 		{
 			Event: &terraform1.PlanStackChanges_Event_PlannedChange{
 				PlannedChange: &terraform1.PlannedChange{

internal/stacks/stackplan/from_proto.go

@@ -56,6 +56,12 @@ func LoadFromProto(msgs []*anypb.Any) (*Plan, error) {
 		case *tfstackdata1.PlanApplyable:
 			ret.Applyable = msg.Applyable
 
+		case *tfstackdata1.PlanTimestamp:
+			err = ret.PlanTimestamp.UnmarshalText([]byte(msg.PlanTimestamp))
+			if err != nil {
+				return nil, fmt.Errorf("invalid plan timestamp %q", msg.PlanTimestamp)
+			}
+
 		case *tfstackdata1.PlanRootInputValue:
 			addr := stackaddrs.InputVariable{
 				Name: msg.Name,

internal/stacks/stackplan/plan.go

@@ -4,6 +4,8 @@
 package stackplan
 
 import (
+	"time"
+
 	"github.com/zclconf/go-cty/cty"
 	"google.golang.org/protobuf/types/known/anypb"
 
@@ -50,6 +52,9 @@ type Plan struct {
 	// instances defined in the overall stack configuration, including any
 	// nested component instances from embedded stacks.
 	Components collections.Map[stackaddrs.AbsComponentInstance, *Component]
+
+	// PlanTimestamp is the time at which the plan was created.
+	PlanTimestamp time.Time
 }
 
 // RequiredProviderInstances returns a description of all of the provider

internal/stacks/stackplan/planned_change.go

@@ -590,6 +590,29 @@ func (pc *PlannedChangeHeader) PlannedChangeProto() (*terraform1.PlannedChange,
 	}, nil
 }
 
+// PlannedChangePlannedTimestamp is a special change type we emit to record the timestamp
+// of when the plan was generated. This is being used in the plantimestamp function.
+type PlannedChangePlannedTimestamp struct {
+	PlannedTimestamp time.Time
+}
+
+var _ PlannedChange = (*PlannedChangePlannedTimestamp)(nil)
+
+// PlannedChangeProto implements PlannedChange.
+func (pc *PlannedChangePlannedTimestamp) PlannedChangeProto() (*terraform1.PlannedChange, error) {
+	var raw anypb.Any
+	err := anypb.MarshalFrom(&raw, &tfstackdata1.PlanTimestamp{
+		PlanTimestamp: pc.PlannedTimestamp.Format(time.RFC3339),
+	}, proto.MarshalOptions{})
+	if err != nil {
+		return nil, err
+	}
+
+	return &terraform1.PlannedChange{
+		Raw: []*anypb.Any{&raw},
+	}, nil
+}
+
 // PlannedChangeApplyable is a special change type we typically append at the
 // end of the raw plan stream to represent that the planning process ran to
 // completion without encountering any errors, and therefore the plan could

internal/stacks/stackruntime/apply_test.go

@@ -5,8 +5,10 @@ package stackruntime
 
 import (
 	"context"
+	"fmt"
 	"path"
 	"sort"
+	"strings"
 	"testing"
 	"time"
 
@@ -501,6 +503,241 @@ func TestApplyWithCheckableObjects(t *testing.T) {
 	}
 }
 
+func TestApplyWithForcePlanTimestamp(t *testing.T) {
+	ctx := context.Background()
+	cfg := loadMainBundleConfigForTest(t, "with-plantimestamp")
+
+	forcedPlanTimestamp := "1991-08-25T20:57:08Z"
+	fakePlanTimestamp, err := time.Parse(time.RFC3339, forcedPlanTimestamp)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	changesCh := make(chan stackplan.PlannedChange)
+	diagsCh := make(chan tfdiags.Diagnostic)
+	req := PlanRequest{
+		Config: cfg,
+		ProviderFactories: map[addrs.Provider]providers.Factory{
+			addrs.NewDefaultProvider("testing"): func() (providers.Interface, error) {
+				return stacks_testing_provider.NewProvider(), nil
+			},
+		},
+		ForcePlanTimestamp: &fakePlanTimestamp,
+	}
+	resp := PlanResponse{
+		PlannedChanges: changesCh,
+		Diagnostics:    diagsCh,
+	}
+
+	go Plan(ctx, &req, &resp)
+	planChanges, diags := collectPlanOutput(changesCh, diagsCh)
+	if len(diags) > 0 {
+		t.Fatalf("expected no diagnostics, got %s", diags.ErrWithWarnings())
+	}
+	// Sanity check that the plan timestamp was set correctly
+	output := expectOutput(t, "plantimestamp", planChanges)
+	plantimestampValue, err := output.NewValue.Decode(cty.String)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if plantimestampValue.AsString() != forcedPlanTimestamp {
+		t.Errorf("expected plantimestamp to be %q, got %q", forcedPlanTimestamp, plantimestampValue.AsString())
+	}
+
+	var raw []*anypb.Any
+	for _, change := range planChanges {
+		proto, err := change.PlannedChangeProto()
+		if err != nil {
+			t.Fatal(err)
+		}
+		raw = append(raw, proto.Raw...)
+	}
+
+	applyReq := ApplyRequest{
+		Config:  cfg,
+		RawPlan: raw,
+		ProviderFactories: map[addrs.Provider]providers.Factory{
+			addrs.NewDefaultProvider("testing"): func() (providers.Interface, error) {
+				return stacks_testing_provider.NewProvider(), nil
+			},
+		},
+	}
+
+	applyChangesCh := make(chan stackstate.AppliedChange)
+	diagsCh = make(chan tfdiags.Diagnostic)
+
+	applyResp := ApplyResponse{
+		AppliedChanges: applyChangesCh,
+		Diagnostics:    diagsCh,
+	}
+
+	go Apply(ctx, &applyReq, &applyResp)
+	applyChanges, applyDiags := collectApplyOutput(applyChangesCh, diagsCh)
+	if len(applyDiags) > 0 {
+		t.Fatalf("expected no diagnostics, got %s", applyDiags.ErrWithWarnings())
+	}
+
+	wantChanges := []stackstate.AppliedChange{
+		&stackstate.AppliedChangeComponentInstance{
+			ComponentAddr: stackaddrs.AbsComponent{
+				Item: stackaddrs.Component{
+					Name: "second-self",
+				},
+			},
+			ComponentInstanceAddr: stackaddrs.AbsComponentInstance{
+				Item: stackaddrs.ComponentInstance{
+					Component: stackaddrs.Component{
+						Name: "second-self",
+					},
+				},
+			},
+			OutputValues: map[addrs.OutputValue]cty.Value{
+				// We want to make sure the plantimestamp is set correctly
+				{Name: "input"}: cty.StringVal(forcedPlanTimestamp),
+				// plantimestamp should also be set for the module runtime used in the components
+				{Name: "out"}: cty.StringVal(fmt.Sprintf("module-output-%s", forcedPlanTimestamp)),
+			},
+		},
+		&stackstate.AppliedChangeComponentInstance{
+			ComponentAddr: stackaddrs.AbsComponent{
+				Item: stackaddrs.Component{
+					Name: "self",
+				},
+			},
+			ComponentInstanceAddr: stackaddrs.AbsComponentInstance{
+				Item: stackaddrs.ComponentInstance{
+					Component: stackaddrs.Component{
+						Name: "self",
+					},
+				},
+			},
+			OutputValues: map[addrs.OutputValue]cty.Value{
+				// We want to make sure the plantimestamp is set correctly
+				{Name: "input"}: cty.StringVal(forcedPlanTimestamp),
+				// plantimestamp should also be set for the module runtime used in the components
+				{Name: "out"}: cty.StringVal(fmt.Sprintf("module-output-%s", forcedPlanTimestamp)),
+			},
+		},
+	}
+
+	sort.SliceStable(applyChanges, func(i, j int) bool {
+		return appliedChangeSortKey(applyChanges[i]) < appliedChangeSortKey(applyChanges[j])
+	})
+
+	if diff := cmp.Diff(wantChanges, applyChanges, ctydebug.CmpOptions, cmpCollectionsSet); diff != "" {
+		t.Errorf("wrong changes\n%s", diff)
+	}
+}
+
+func TestApplyWithDefaultPlanTimestamp(t *testing.T) {
+	ctx := context.Background()
+	cfg := loadMainBundleConfigForTest(t, "with-plantimestamp")
+
+	dayOfWritingThisTest := "2024-06-21T06:37:08Z"
+	dayOfWritingThisTestTime, err := time.Parse(time.RFC3339, dayOfWritingThisTest)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	changesCh := make(chan stackplan.PlannedChange)
+	diagsCh := make(chan tfdiags.Diagnostic)
+	req := PlanRequest{
+		Config: cfg,
+		ProviderFactories: map[addrs.Provider]providers.Factory{
+			addrs.NewDefaultProvider("testing"): func() (providers.Interface, error) {
+				return stacks_testing_provider.NewProvider(), nil
+			},
+		},
+	}
+	resp := PlanResponse{
+		PlannedChanges: changesCh,
+		Diagnostics:    diagsCh,
+	}
+
+	go Plan(ctx, &req, &resp)
+	planChanges, diags := collectPlanOutput(changesCh, diagsCh)
+	if len(diags) > 0 {
+		t.Fatalf("expected no diagnostics, got %s", diags.ErrWithWarnings())
+	}
+	// Sanity check that the plan timestamp was set correctly
+	output := expectOutput(t, "plantimestamp", planChanges)
+	plantimestampValue, err := output.NewValue.Decode(cty.String)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	plantimestamp, err := time.Parse(time.RFC3339, plantimestampValue.AsString())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if plantimestamp.Before(dayOfWritingThisTestTime) {
+		t.Errorf("expected plantimestamp to be later than %q, got %q", dayOfWritingThisTest, plantimestampValue.AsString())
+	}
+
+	var raw []*anypb.Any
+	for _, change := range planChanges {
+		proto, err := change.PlannedChangeProto()
+		if err != nil {
+			t.Fatal(err)
+		}
+		raw = append(raw, proto.Raw...)
+	}
+
+	applyReq := ApplyRequest{
+		Config:  cfg,
+		RawPlan: raw,
+		ProviderFactories: map[addrs.Provider]providers.Factory{
+			addrs.NewDefaultProvider("testing"): func() (providers.Interface, error) {
+				return stacks_testing_provider.NewProvider(), nil
+			},
+		},
+	}
+
+	applyChangesCh := make(chan stackstate.AppliedChange)
+	diagsCh = make(chan tfdiags.Diagnostic)
+
+	applyResp := ApplyResponse{
+		AppliedChanges: applyChangesCh,
+		Diagnostics:    diagsCh,
+	}
+
+	go Apply(ctx, &applyReq, &applyResp)
+	applyChanges, applyDiags := collectApplyOutput(applyChangesCh, diagsCh)
+	if len(applyDiags) > 0 {
+		t.Fatalf("expected no diagnostics, got %s", applyDiags.ErrWithWarnings())
+	}
+
+	for _, x := range applyChanges {
+		if v, ok := x.(*stackstate.AppliedChangeComponentInstance); ok {
+			if actualTimestampValue, ok := v.OutputValues[addrs.OutputValue{
+				Name: "input",
+			}]; ok {
+				actualTimestamp, err := time.Parse(time.RFC3339, actualTimestampValue.AsString())
+				if err != nil {
+					t.Fatalf("Could not parse component output value: %q", err)
+				}
+				if actualTimestamp.Before(dayOfWritingThisTestTime) {
+					t.Error("Timestamp is before day of writing this test, that should be incorrect.")
+				}
+			}
+
+			if actualTimestampValue, ok := v.OutputValues[addrs.OutputValue{
+				Name: "out",
+			}]; ok {
+				actualTimestamp, err := time.Parse(time.RFC3339, strings.ReplaceAll(actualTimestampValue.AsString(), "module-output-", ""))
+				if err != nil {
+					t.Fatalf("Could not parse component output value: %q", err)
+				}
+				if actualTimestamp.Before(dayOfWritingThisTestTime) {
+					t.Error("Timestamp is before day of writing this test, that should be incorrect.")
+				}
+			}
+		}
+	}
+}
+
 func collectApplyOutput(changesCh <-chan stackstate.AppliedChange, diagsCh <-chan tfdiags.Diagnostic) ([]stackstate.AppliedChange, tfdiags.Diagnostics) {
 	var changes []stackstate.AppliedChange
 	var diags tfdiags.Diagnostics

internal/stacks/stackruntime/helper_test.go

@@ -202,6 +202,10 @@ func plannedChangeSortKey(change stackplan.PlannedChange) string {
 		// There should only be a single applyable marker in a plan, so we can
 		// just return a static string here.
 		return "applyable"
+	case *stackplan.PlannedChangePlannedTimestamp:
+		// There should only be a single timestamp in a plan, so we can
+		// just return a static string here.
+		return "planned-timestamp"
 	default:
 		// This is only going to happen during tests, so we can panic here.
 		panic(fmt.Errorf("unrecognized planned change type: %T", change))

internal/stacks/stackruntime/internal/stackeval/applying_test.go

@@ -10,6 +10,7 @@ import (
 	"strings"
 	"sync"
 	"testing"
+	"time"
 
 	"github.com/davecgh/go-spew/spew"
 	"github.com/google/go-cmp/cmp"
@@ -128,6 +129,7 @@ func TestApply_componentOrdering(t *testing.T) {
 					}, nil
 				},
 			},
+			PlanTimestamp: time.Now().UTC(),
 		})
 
 		outp, outpTester := testPlanOutput(t)
@@ -287,6 +289,7 @@ func TestApply_componentOrdering(t *testing.T) {
 					}, nil
 				},
 			},
+			PlanTimestamp: time.Now().UTC(),
 		})
 
 		outp, outpTester := testPlanOutput(t)

internal/stacks/stackruntime/internal/stackeval/component_config.go

@@ -6,6 +6,7 @@ package stackeval
 import (
 	"context"
 	"fmt"
+	"time"
 
 	"github.com/apparentlymart/go-versions/versions"
 	"github.com/hashicorp/go-slug/sourceaddrs"
@@ -449,6 +450,12 @@ func (c *ComponentConfig) ResolveExpressionReference(ctx context.Context, ref st
 	return c.StackConfig(ctx).resolveExpressionReference(ctx, ref, nil, repetition)
 }
 
+// PlanTimestamp implements ExpressionScope, providing the timestamp at which
+// the current plan is being run.
+func (c *ComponentConfig) PlanTimestamp() time.Time {
+	return c.main.PlanTimestamp()
+}
+
 func (c *ComponentConfig) checkValid(ctx context.Context, phase EvalPhase) tfdiags.Diagnostics {
 	diags, err := c.validate.Do(ctx, func(ctx context.Context) (tfdiags.Diagnostics, error) {
 		var diags tfdiags.Diagnostics