Actions in plan/changes (#37320)

* Add actions to the plans and change
* jsonplan - ignoring LinkedResources for now, those are not in the MVP
* pausing here: we'll work on the plan rendering later

Author: mildwonkey

internal/addrs/action.go

@@ -7,6 +7,9 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+
 	"github.com/hashicorp/terraform/internal/tfdiags"
 )
 
@@ -284,7 +287,7 @@ func (a AbsActionInstance) UniqueKey() UniqueKey {
 	return absActionInstanceKey(a.String())
 }
 
-func (r absActionInstanceKey) uniqueKeySigil() {}
+func (a absActionInstanceKey) uniqueKeySigil() {}
 
 // ConfigAction is the address for an action within the configuration.
 type ConfigAction struct {
@@ -337,7 +340,7 @@ type AbsActionInvocationInstance struct {
 	TriggerIndex       int
 
 	// TriggerBlockSourceRange is the location of the action_trigger block
-	// within the resources lifecyclye block that triggered this action.
+	// within the resources lifecycle block that triggered this action.
 	TriggerBlockSourceRange *tfdiags.SourceRange
 
 	// ActionReferenceSourceRange is the location of the action reference
@@ -348,3 +351,152 @@ type AbsActionInvocationInstance struct {
 func (a AbsActionInvocationInstance) String() string {
 	return fmt.Sprintf("%s.%d.%s", a.TriggeringResource.String(), a.TriggerIndex, a.Action.String())
 }
+
+// ParseAbsActionInstanceStr is a helper wrapper around
+// ParseAbsActionInstance that takes a string and parses it with the HCL
+// native syntax traversal parser before interpreting it.
+//
+// Error diagnostics are returned if either the parsing fails or the analysis
+// of the traversal fails. There is no way for the caller to distinguish the
+// two kinds of diagnostics programmatically. If error diagnostics are returned
+// the returned address may be incomplete.
+//
+// Since this function has no context about the source of the given string,
+// any returned diagnostics will not have meaningful source location
+// information.
+func ParseAbsActionInstanceStr(str string) (AbsActionInstance, tfdiags.Diagnostics) {
+	var diags tfdiags.Diagnostics
+
+	traversal, parseDiags := hclsyntax.ParseTraversalAbs([]byte(str), "", hcl.Pos{Line: 1, Column: 1})
+	diags = diags.Append(parseDiags)
+	if parseDiags.HasErrors() {
+		return AbsActionInstance{}, diags
+	}
+
+	addr, addrDiags := ParseAbsActionInstance(traversal)
+	diags = diags.Append(addrDiags)
+	return addr, diags
+}
+
+// ParseAbsActionInstance attempts to interpret the given traversal as an
+// absolute action instance address, using the same syntax as expected by
+// ParseTarget.
+//
+// If no error diagnostics are returned, the returned target includes the
+// address that was extracted and the source range it was extracted from.
+//
+// If error diagnostics are returned then the AbsResource value is invalid and
+// must not be used.
+func ParseAbsActionInstance(traversal hcl.Traversal) (AbsActionInstance, tfdiags.Diagnostics) {
+	moduleAddr, remain, diags := parseModuleInstancePrefix(traversal, false)
+	if diags.HasErrors() {
+		return AbsActionInstance{}, diags
+	}
+
+	if remain.IsRelative() {
+		// (relative means that there's either nothing left or what's next isn't an identifier)
+		diags = diags.Append(&hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Invalid action address",
+			Detail:   "Module path must be followed by an action instance address.",
+			Subject:  remain.SourceRange().Ptr(),
+		})
+		return AbsActionInstance{}, diags
+	}
+
+	if remain.RootName() != "action" {
+		diags = diags.Append(&hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Invalid address",
+			Detail:   "Action address must start with \"action.\".",
+			Subject:  remain[0].SourceRange().Ptr(),
+		})
+		return AbsActionInstance{}, diags
+	}
+	remain = remain[1:]
+
+	if len(remain) < 2 {
+		diags = diags.Append(&hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Invalid address",
+			Detail:   "Action specification must include an action type and name.",
+			Subject:  remain.SourceRange().Ptr(),
+		})
+		return AbsActionInstance{}, diags
+	}
+
+	var actionType, name string
+	switch tt := remain[0].(type) {
+	case hcl.TraverseRoot:
+		actionType = tt.Name
+	case hcl.TraverseAttr:
+		actionType = tt.Name
+	default:
+		diags = diags.Append(&hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Invalid action address",
+			Detail:   "An action name is required.",
+			Subject:  remain[0].SourceRange().Ptr(),
+		})
+		return AbsActionInstance{}, diags
+	}
+
+	switch tt := remain[1].(type) {
+	case hcl.TraverseAttr:
+		name = tt.Name
+	default:
+		diags = diags.Append(&hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Invalid address",
+			Detail:   "An action name is required.",
+			Subject:  remain[1].SourceRange().Ptr(),
+		})
+		return AbsActionInstance{}, diags
+	}
+
+	remain = remain[2:]
+	switch len(remain) {
+	case 0:
+		return moduleAddr.ActionInstance(actionType, name, NoKey), diags
+	case 1:
+		switch tt := remain[0].(type) {
+		case hcl.TraverseIndex:
+			key, err := ParseInstanceKey(tt.Key)
+			if err != nil {
+				diags = diags.Append(&hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid address",
+					Detail:   fmt.Sprintf("Invalid resource instance key: %s.", err),
+					Subject:  remain[0].SourceRange().Ptr(),
+				})
+				return AbsActionInstance{}, diags
+			}
+			return moduleAddr.ActionInstance(actionType, name, key), diags
+		case hcl.TraverseSplat:
+			// Not yet supported!
+			diags = diags.Append(&hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid address",
+				Detail:   "Action instance key must be given in square brackets.",
+				Subject:  remain[0].SourceRange().Ptr(),
+			})
+			return AbsActionInstance{}, diags
+		default:
+			diags = diags.Append(&hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid address",
+				Detail:   "Action instance key must be given in square brackets.",
+				Subject:  remain[0].SourceRange().Ptr(),
+			})
+			return AbsActionInstance{}, diags
+		}
+	default:
+		diags = diags.Append(&hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Invalid address",
+			Detail:   "Unexpected extra operators after address.",
+			Subject:  remain[1].SourceRange().Ptr(),
+		})
+		return AbsActionInstance{}, diags
+	}
+}

internal/addrs/action_test.go

@@ -341,3 +341,75 @@ func TestAbsActionUniqueKey(t *testing.T) {
 		})
 	}
 }
+
+func TestParseAbsActionInstance(t *testing.T) {
+	tests := []struct {
+		input     string
+		want      AbsActionInstance
+		expectErr bool
+	}{
+		{
+			"",
+			AbsActionInstance{},
+			true,
+		},
+		{
+			"action.example.foo",
+			AbsActionInstance{
+				Action: ActionInstance{
+					Action: Action{
+						Type: "example",
+						Name: "foo",
+					},
+					Key: NoKey,
+				},
+				Module: RootModuleInstance,
+			},
+			false,
+		},
+		{
+			"action.example.foo[0]",
+			AbsActionInstance{
+				Action: ActionInstance{
+					Action: Action{
+						Type: "example",
+						Name: "foo",
+					},
+					Key: IntKey(0),
+				},
+				Module: RootModuleInstance,
+			},
+			false,
+		},
+		{
+			"action.example.foo[\"bar\"]",
+			AbsActionInstance{
+				Action: ActionInstance{
+					Action: Action{
+						Type: "example",
+						Name: "foo",
+					},
+					Key: StringKey("bar"),
+				},
+				Module: RootModuleInstance,
+			},
+			false,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(fmt.Sprintf("ParseAbsActionStr(%s)", test.input), func(t *testing.T) {
+			got, gotDiags := ParseAbsActionInstanceStr(test.input)
+			if gotDiags.HasErrors() != test.expectErr {
+				if !test.expectErr {
+					t.Fatalf("wrong results! Expected success, got error: %s\n", gotDiags.Err())
+				} else {
+					t.Fatal("wrong results! Expected error(s), got success!")
+				}
+			}
+			if !got.Equal(test.want) {
+				t.Fatalf("wrong result! Got %s, wanted %s", got.String(), test.want.String())
+			}
+		})
+	}
+}

internal/command/jsonformat/plan.go

@@ -7,11 +7,10 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"slices"
 	"sort"
 	"strings"
 
-	"slices"
-
 	"github.com/hashicorp/terraform/internal/command/format"
 	"github.com/hashicorp/terraform/internal/command/jsonformat/computed"
 	"github.com/hashicorp/terraform/internal/command/jsonformat/computed/renderers"
@@ -33,6 +32,7 @@ type Plan struct {
 	ResourceDrift      []jsonplan.ResourceChange         `json:"resource_drift,omitempty"`
 	RelevantAttributes []jsonplan.ResourceAttr           `json:"relevant_attributes,omitempty"`
 	DeferredChanges    []jsonplan.DeferredResourceChange `json:"deferred_changes,omitempty"`
+	ActionInvocations  []jsonplan.ActionInvocation       `json:"action_invocations,omitempty"`
 
 	ProviderFormatVersion string                            `json:"provider_format_version"`
 	ProviderSchemas       map[string]*jsonprovider.Provider `json:"provider_schemas,omitempty"`

internal/command/jsonformat/state_test.go

@@ -9,19 +9,17 @@ import (
 
 	"github.com/google/go-cmp/cmp"
 	"github.com/mitchellh/colorstring"
-
-	"github.com/hashicorp/terraform/internal/command/jsonprovider"
-	"github.com/hashicorp/terraform/internal/command/jsonstate"
-	testing_provider "github.com/hashicorp/terraform/internal/providers/testing"
-	"github.com/hashicorp/terraform/internal/states/statefile"
-	"github.com/hashicorp/terraform/internal/terminal"
-
 	"github.com/zclconf/go-cty/cty"
 
 	"github.com/hashicorp/terraform/internal/addrs"
+	"github.com/hashicorp/terraform/internal/command/jsonprovider"
+	"github.com/hashicorp/terraform/internal/command/jsonstate"
 	"github.com/hashicorp/terraform/internal/configs/configschema"
 	"github.com/hashicorp/terraform/internal/providers"
+	testing_provider "github.com/hashicorp/terraform/internal/providers/testing"
 	"github.com/hashicorp/terraform/internal/states"
+	"github.com/hashicorp/terraform/internal/states/statefile"
+	"github.com/hashicorp/terraform/internal/terminal"
 	"github.com/hashicorp/terraform/internal/terraform"
 )
 

internal/command/jsonplan/action_invocations.go

@@ -0,0 +1,34 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: BUSL-1.1
+
+package jsonplan
+
+import (
+	"github.com/hashicorp/terraform/internal/plans"
+)
+
+type ActionInvocation struct {
+	// Address is the absolute action address
+	Address string `json:"address,omitempty"`
+
+	// ProviderName allows the property "type" to be interpreted unambiguously
+	// in the unusual situation where a provider offers a type whose
+	// name does not start with its own name, such as the "googlebeta" provider
+	// offering "google_compute_instance".
+	ProviderName string `json:"provider_name,omitempty"`
+}
+
+func MarshalActionInvocations(actions []*plans.ActionInvocationInstanceSrc) ([]ActionInvocation, error) {
+	ret := make([]ActionInvocation, 0, len(actions))
+
+	for _, action := range actions {
+		ai := ActionInvocation{
+			Address:      action.Addr.String(),
+			ProviderName: action.ProviderAddr.String(),
+		}
+
+		ret = append(ret, ai)
+	}
+
+	return ret, nil
+}