Rr/stacks/actions sro

internal/command/views/json/message_types.go

@@ -12,11 +12,12 @@ const (
 	MessageDiagnostic MessageType = "diagnostic"
 
 	// Operation results
-	MessageResourceDrift           MessageType = "resource_drift"
-	MessagePlannedChange           MessageType = "planned_change"
-	MessagePlannedActionInvocation MessageType = "planned_action_invocation"
-	MessageChangeSummary           MessageType = "change_summary"
-	MessageOutputs                 MessageType = "outputs"
+	MessageResourceDrift            MessageType = "resource_drift"
+	MessagePlannedChange            MessageType = "planned_change"
+	MessagePlannedActionInvocation  MessageType = "planned_action_invocation"
+	MessageAppliedActionInvocation  MessageType = "applied_action_invocation"
+	MessageChangeSummary            MessageType = "change_summary"
+	MessageOutputs                  MessageType = "outputs"
 
 	// Hook-driven messages
 	MessageApplyStart        MessageType = "apply_start"

internal/command/views/json_view.go

@@ -103,6 +103,14 @@ func (v *JSONView) PlannedActionInvocation(action *json.ActionInvocation) {
 	)
 }
 
+func (v *JSONView) AppliedActionInvocation(action *json.ActionInvocation) {
+	v.log.Info(
+		fmt.Sprintf("applied action invocation: %s", action.Action.Action),
+		"type", json.MessageAppliedActionInvocation,
+		"invocation", action,
+	)
+}
+
 func (v *JSONView) ResourceDrift(c *json.ResourceInstanceChange) {
 	v.log.Info(
 		fmt.Sprintf("%s: Drift detected (%s)", c.Resource.Addr, c.Action),

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
@@ -198,7 +200,7 @@ func readTfplan(r io.Reader) (*plans.Plan, error) {
 	}
 
 	for _, rawAction := range rawPlan.ActionInvocations {
-		action, err := actionInvocationFromTfplan(rawAction)
+		action, err := ActionInvocationFromTfplan(rawAction)
 		if err != nil {
 			// errors from actionInvocationFromTfplan already include context
 			return nil, err
@@ -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) {
@@ -563,7 +564,7 @@ func deferredActionInvocationFromTfplan(dai *planproto.DeferredActionInvocation)
 		return nil, fmt.Errorf("deferred action invocation object is absent")
 	}
 
-	actionInvocation, err := actionInvocationFromTfplan(dai.ActionInvocation)
+	actionInvocation, err := ActionInvocationFromTfplan(dai.ActionInvocation)
 	if err != nil {
 		return nil, err
 	}
@@ -1314,7 +1315,7 @@ func CheckResultsToPlanProto(checkResults *states.CheckResults) ([]*planproto.Ch
 	}
 }
 
-func actionInvocationFromTfplan(rawAction *planproto.ActionInvocationInstance) (*plans.ActionInvocationInstanceSrc, error) {
+func ActionInvocationFromTfplan(rawAction *planproto.ActionInvocationInstance) (*plans.ActionInvocationInstanceSrc, error) {
 	if rawAction == nil {
 		// Should never happen in practice, since protobuf can't represent
 		// a nil value in a list.
@@ -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

@@ -8,6 +8,7 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"log"
 	"time"
 
 	"github.com/hashicorp/go-slug/sourceaddrs"
@@ -917,7 +918,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 +1196,81 @@ 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
+		},
+
+		ReportActionInvocationStatus: func(ctx context.Context, span any, status *hooks.ActionInvocationStatusHookData) any {
+			log.Printf("[DEBUG] ReportActionInvocationStatus called: Action=%s, Status=%s, Provider=%s",
+				status.Addr.Item.String(), status.Status.String(), status.ProviderAddr.String())
+
+			span.(trace.Span).AddEvent("action invocation status", trace.WithAttributes(
+				attribute.String("component_instance", status.Addr.Component.String()),
+				attribute.String("action_instance", status.Addr.Item.String()),
+				attribute.String("status", status.Status.String()),
+			))
+
+			protoStatus := status.Status.ForProtobuf()
+			log.Printf("[DEBUG] Sending ActionInvocationStatus to gRPC client: Addr=%s, Status=%d (proto)",
+				status.Addr.String(), protoStatus)
+
+			send(&stacks.StackChangeProgress{
+				Event: &stacks.StackChangeProgress_ActionInvocationStatus_{
+					ActionInvocationStatus: &stacks.StackChangeProgress_ActionInvocationStatus{
+						Addr:         stacks.NewActionInvocationInStackAddr(status.Addr),
+						Status:       protoStatus,
+						ProviderAddr: status.ProviderAddr.String(),
+					},
+				},
+			})
+
+			log.Printf("[DEBUG] ActionInvocationStatus event successfully sent to client")
+			return span
+		},
+
+		ReportActionInvocationProgress: func(ctx context.Context, span any, progress *hooks.ActionInvocationProgressHookData) any {
+			log.Printf("[DEBUG] ReportActionInvocationProgress called: Action=%s, Message=%s, Provider=%s",
+				progress.Addr.Item.String(), progress.Message, progress.ProviderAddr.String())
+
+			span.(trace.Span).AddEvent("action invocation progress", trace.WithAttributes(
+				attribute.String("component_instance", progress.Addr.Component.String()),
+				attribute.String("action_instance", progress.Addr.Item.String()),
+				attribute.String("message", progress.Message),
+			))
+
+			log.Printf("[DEBUG] Sending ActionInvocationProgress to gRPC client: Addr=%s, Message=%s",
+				progress.Addr.String(), progress.Message)
+
+			send(&stacks.StackChangeProgress{
+				Event: &stacks.StackChangeProgress_ActionInvocationProgress_{
+					ActionInvocationProgress: &stacks.StackChangeProgress_ActionInvocationProgress{
+						Addr:         stacks.NewActionInvocationInStackAddr(progress.Addr),
+						Message:      progress.Message,
+						ProviderAddr: progress.ProviderAddr.String(),
+					},
+				},
+			})
+
+			log.Printf("[DEBUG] ActionInvocationProgress event successfully sent to client")
+			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 +1381,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_{