Mutahhir/stacks/actions sro

internal/plans/planfile/tfplan.go

@@ -26,8 +26,10 @@ import (
 	"github.com/hashicorp/terraform/version"
 )
 
-const tfplanFormatVersion = 3
-const tfplanFilename = "tfplan"
+const (
+	tfplanFormatVersion = 3
+	tfplanFilename      = "tfplan"
+)
 
 // ---------------------------------------------------------------------------
 // This file deals with the internal structure of the "tfplan" sub-file within
@@ -403,7 +405,6 @@ func ActionFromProto(rawAction planproto.Action) (plans.Action, error) {
 	default:
 		return plans.NoOp, fmt.Errorf("invalid change action %s", rawAction)
 	}
-
 }
 
 func changeFromTfplan(rawChange *planproto.Change) (*plans.ChangeSrc, error) {
@@ -1389,6 +1390,10 @@ func actionInvocationFromTfplan(rawAction *planproto.ActionInvocationInstance) (
 	return ret, nil
 }
 
+func ActionInvocationToProto(action *plans.ActionInvocationInstanceSrc) (*planproto.ActionInvocationInstance, error) {
+	return actionInvocationToTfPlan(action)
+}
+
 func actionInvocationToTfPlan(action *plans.ActionInvocationInstanceSrc) (*planproto.ActionInvocationInstance, error) {
 	if action == nil {
 		return nil, nil

internal/rpcapi/dependencies_provider_schema.go

@@ -141,18 +141,23 @@ func providerSchemaToProto(schemaResp providers.GetProviderSchemaResponse) *depe
 
 	mrtSchemas := make(map[string]*dependencies.Schema, len(schemaResp.ResourceTypes))
 	drtSchemas := make(map[string]*dependencies.Schema, len(schemaResp.DataSources))
+	actionSchemas := make(map[string]*dependencies.ActionSchema, len(schemaResp.Actions))
 
 	for name, elem := range schemaResp.ResourceTypes {
 		mrtSchemas[name] = schemaElementToProto(elem)
 	}
 	for name, elem := range schemaResp.DataSources {
 		drtSchemas[name] = schemaElementToProto(elem)
 	}
+	for name, elem := range schemaResp.Actions {
+		actionSchemas[name] = actionElementToProto(elem)
+	}
 
 	return &dependencies.ProviderSchema{
 		ProviderConfig:       schemaElementToProto(schemaResp.Provider),
 		ManagedResourceTypes: mrtSchemas,
 		DataResourceTypes:    drtSchemas,
+		ActionTypes:          actionSchemas,
 	}
 }
 
@@ -162,6 +167,14 @@ func schemaElementToProto(elem providers.Schema) *dependencies.Schema {
 	}
 }
 
+func actionElementToProto(elem providers.ActionSchema) *dependencies.ActionSchema {
+	return &dependencies.ActionSchema{
+		Schema: &dependencies.Schema{
+			Block: schemaBlockToProto(elem.ConfigSchema),
+		},
+	}
+}
+
 func schemaBlockToProto(block *configschema.Block) *dependencies.Schema_Block {
 	if block == nil {
 		return &dependencies.Schema_Block{}

internal/rpcapi/stacks.go

@@ -917,7 +917,6 @@ func (s *stacksServer) CloseTerraformState(ctx context.Context, request *stacks.
 }
 
 func (s *stacksServer) MigrateTerraformState(request *stacks.MigrateTerraformState_Request, server stacks.Stacks_MigrateTerraformStateServer) error {
-
 	previousStateHandle := handle[*states.State](request.StateHandle)
 	previousState := s.handles.TerraformState(previousStateHandle)
 	if previousState == nil {
@@ -1196,6 +1195,26 @@ func stackChangeHooks(send func(*stacks.StackChangeProgress) error, mainStackSou
 			return span
 		},
 
+		ReportActionInvocationPlanned: func(ctx context.Context, span any, ai *hooks.ActionInvocation) any {
+			span.(trace.Span).AddEvent("planned action invocation", trace.WithAttributes(
+				attribute.String("component_instance", ai.Addr.Component.String()),
+				attribute.String("resource_instance", ai.Addr.Item.String()),
+			))
+
+			inv, err := actionInvocationPlanned(ai)
+			if err != nil {
+				return span
+			}
+
+			send(&stacks.StackChangeProgress{
+				Event: &stacks.StackChangeProgress_ActionInvocationPlanned_{
+					ActionInvocationPlanned: inv,
+				},
+			})
+
+			return span
+		},
+
 		ReportResourceInstanceDeferred: func(ctx context.Context, span any, change *hooks.DeferredResourceInstanceChange) any {
 			span.(trace.Span).AddEvent("deferred resource instance", trace.WithAttributes(
 				attribute.String("component_instance", change.Change.Addr.Component.String()),
@@ -1306,6 +1325,38 @@ func resourceInstancePlanned(ric *hooks.ResourceInstanceChange) (*stacks.StackCh
 	}, nil
 }
 
+func actionInvocationPlanned(ai *hooks.ActionInvocation) (*stacks.StackChangeProgress_ActionInvocationPlanned, error) {
+	res := &stacks.StackChangeProgress_ActionInvocationPlanned{
+		Addr:         stacks.NewActionInvocationInStackAddr(ai.Addr),
+		ProviderAddr: ai.ProviderAddr.String(),
+	}
+
+	switch trig := ai.Trigger.(type) {
+	case *plans.LifecycleActionTrigger:
+		res.ActionTrigger = &stacks.StackChangeProgress_ActionInvocationPlanned_LifecycleActionTrigger{
+			LifecycleActionTrigger: &stacks.StackChangeProgress_LifecycleActionTrigger{
+				TriggeringResourceAddress: stacks.NewResourceInstanceInStackAddr(
+					stackaddrs.AbsResourceInstance{
+						Component: ai.Addr.Component,
+						Item:      trig.TriggeringResourceAddr,
+					},
+				),
+				TriggerEvent:            stacks.StackChangeProgress_ActionTriggerEvent(trig.TriggerEvent()),
+				ActionTriggerBlockIndex: int64(trig.ActionTriggerBlockIndex),
+				ActionsListIndex:        int64(trig.ActionsListIndex),
+			},
+		}
+	case *plans.InvokeActionTrigger:
+		res.ActionTrigger = &stacks.StackChangeProgress_ActionInvocationPlanned_InvokeActionTrigger{
+			InvokeActionTrigger: &stacks.StackChangeProgress_InvokeActionTrigger{},
+		}
+	default:
+		return nil, fmt.Errorf("unsupported action invocation trigger type")
+	}
+
+	return res, nil
+}
+
 func evtComponentInstanceStatus(ci stackaddrs.AbsComponentInstance, status hooks.ComponentInstanceStatus) *stacks.StackChangeProgress {
 	return &stacks.StackChangeProgress{
 		Event: &stacks.StackChangeProgress_ComponentInstanceStatus_{