harness.chaos.ActionTemplate

import * as pulumi from "@pulumi/pulumi";
import * as harness from "@pulumi/harness";

// ============================================================================
// Harness Chaos Action Template Resource Examples
// ============================================================================
//
// Action templates define reusable actions for chaos experiments.
// These examples are based on TESTED configurations from the e2e-test suite.
//
// Key Points:
// - Actions can be delay, script, or container type
// - Runtime inputs with defaults: "<+input>.default('value')"
// - Container actions support full Kubernetes pod configuration
// ============================================================================
// ----------------------------------------------------------------------------
// Example 1: Container Action with Runtime Inputs (TESTED ✅)
// ----------------------------------------------------------------------------
// Most common pattern: container action with runtime inputs and defaults
const containerWithRuntimeInputs = new harness.chaos.ActionTemplate("container_with_runtime_inputs", {
    orgId: _this.id,
    projectId: thisHarnessPlatformProject.id,
    hubIdentity: projectLevel.identity,
    identity: "container-action-template",
    name: "Container Action Template",
    description: "Container action with runtime inputs and defaults",
    type: "container",
    infrastructureType: "<+input>.default('Kubernetes')",
    tags: [
        "container",
        "kubernetes",
        "runtime-inputs",
    ],
    containerAction: {
        image: "<+input>.default('busybox:latest')",
        commands: ["<+input>.default('sh')"],
        args: "echo 'Running container action'; sleep 15",
        namespace: "<+input>.default('default')",
        nodeSelector: {
            disktype: "ssd",
            zone: "us-west-1a",
        },
        labels: {
            app: "chaos-action",
            environment: "production",
            "managed-by": "terraform",
        },
        annotations: {
            description: "Chaos container action",
            owner: "chaos-team",
        },
        envs: [
            {
                name: "TEST_VAR",
                value: "<+input>.default('test_value')",
            },
            {
                name: "ANOTHER_VAR",
                value: "<+input>.default('another_value')",
            },
        ],
        resources: {
            limits: {
                cpu: "500m",
                memory: "512Mi",
            },
            requests: {
                cpu: "250m",
                memory: "256Mi",
            },
        },
    },
    runProperties: {
        timeout: "<+input>.default('60s')",
        interval: "<+input>.default('15s')",
    },
    variables: [
        {
            name: "container_image",
            value: "<+input>",
            type: "string",
            required: true,
            description: "Container image to use (runtime input)",
        },
        {
            name: "namespace",
            value: "<+input>",
            type: "string",
            required: false,
            description: "Kubernetes namespace (runtime input)",
        },
    ],
}, {
    dependsOn: [projectLevel],
});
// ----------------------------------------------------------------------------
// Example 2: Simple Delay Action (TESTED ✅)
// ----------------------------------------------------------------------------
// Delay action for adding wait time in experiments
const delayAction = new harness.chaos.ActionTemplate("delay_action", {
    orgId: _this.id,
    projectId: thisHarnessPlatformProject.id,
    hubIdentity: projectLevel.identity,
    identity: "delay-action-template",
    name: "Delay Action Template",
    description: "Simple delay action for wait time",
    type: "delay",
    infrastructureType: "Kubernetes",
    tags: [
        "delay",
        "wait",
    ],
    delayAction: {
        duration: "<+input>.default('30s')",
    },
    runProperties: {
        timeout: "60s",
    },
}, {
    dependsOn: [projectLevel],
});
// ----------------------------------------------------------------------------
// Example 3: Script Action (TESTED ✅)
// ----------------------------------------------------------------------------
// Custom script action for flexible operations
const scriptAction = new harness.chaos.ActionTemplate("script_action", {
    orgId: _this.id,
    projectId: thisHarnessPlatformProject.id,
    hubIdentity: projectLevel.identity,
    identity: "script-action-template",
    name: "Script Action Template",
    description: "Custom script action for chaos operations",
    type: "script",
    infrastructureType: "<+input>.default('Kubernetes')",
    tags: [
        "script",
        "custom",
    ],
    customScriptAction: {
        script: `#!/bin/bash
echo \\"Running custom chaos script\\"
echo \\"Target: <+input>\\"
sleep 10
echo \\"Script completed\\"
`,
        shell: "bash",
        envs: [{
            name: "TARGET",
            value: "<+input>.default('default-target')",
        }],
    },
    runProperties: {
        timeout: "<+input>.default('120s')",
        interval: "30s",
    },
    variables: [{
        name: "target_resource",
        value: "<+input>",
        type: "string",
        required: true,
        description: "Target resource for the script",
    }],
}, {
    dependsOn: [projectLevel],
});

import pulumi
import pulumi_harness as harness

# ============================================================================
# Harness Chaos Action Template Resource Examples
# ============================================================================
#
# Action templates define reusable actions for chaos experiments.
# These examples are based on TESTED configurations from the e2e-test suite.
#
# Key Points:
# - Actions can be delay, script, or container type
# - Runtime inputs with defaults: "<+input>.default('value')"
# - Container actions support full Kubernetes pod configuration
# ============================================================================
# ----------------------------------------------------------------------------
# Example 1: Container Action with Runtime Inputs (TESTED ✅)
# ----------------------------------------------------------------------------
# Most common pattern: container action with runtime inputs and defaults
container_with_runtime_inputs = harness.chaos.ActionTemplate("container_with_runtime_inputs",
    org_id=this["id"],
    project_id=this_harness_platform_project["id"],
    hub_identity=project_level["identity"],
    identity="container-action-template",
    name="Container Action Template",
    description="Container action with runtime inputs and defaults",
    type="container",
    infrastructure_type="<+input>.default('Kubernetes')",
    tags=[
        "container",
        "kubernetes",
        "runtime-inputs",
    ],
    container_action={
        "image": "<+input>.default('busybox:latest')",
        "commands": ["<+input>.default('sh')"],
        "args": "echo 'Running container action'; sleep 15",
        "namespace": "<+input>.default('default')",
        "node_selector": {
            "disktype": "ssd",
            "zone": "us-west-1a",
        },
        "labels": {
            "app": "chaos-action",
            "environment": "production",
            "managed-by": "terraform",
        },
        "annotations": {
            "description": "Chaos container action",
            "owner": "chaos-team",
        },
        "envs": [
            {
                "name": "TEST_VAR",
                "value": "<+input>.default('test_value')",
            },
            {
                "name": "ANOTHER_VAR",
                "value": "<+input>.default('another_value')",
            },
        ],
        "resources": {
            "limits": {
                "cpu": "500m",
                "memory": "512Mi",
            },
            "requests": {
                "cpu": "250m",
                "memory": "256Mi",
            },
        },
    },
    run_properties={
        "timeout": "<+input>.default('60s')",
        "interval": "<+input>.default('15s')",
    },
    variables=[
        {
            "name": "container_image",
            "value": "<+input>",
            "type": "string",
            "required": True,
            "description": "Container image to use (runtime input)",
        },
        {
            "name": "namespace",
            "value": "<+input>",
            "type": "string",
            "required": False,
            "description": "Kubernetes namespace (runtime input)",
        },
    ],
    opts = pulumi.ResourceOptions(depends_on=[project_level]))
# ----------------------------------------------------------------------------
# Example 2: Simple Delay Action (TESTED ✅)
# ----------------------------------------------------------------------------
# Delay action for adding wait time in experiments
delay_action = harness.chaos.ActionTemplate("delay_action",
    org_id=this["id"],
    project_id=this_harness_platform_project["id"],
    hub_identity=project_level["identity"],
    identity="delay-action-template",
    name="Delay Action Template",
    description="Simple delay action for wait time",
    type="delay",
    infrastructure_type="Kubernetes",
    tags=[
        "delay",
        "wait",
    ],
    delay_action={
        "duration": "<+input>.default('30s')",
    },
    run_properties={
        "timeout": "60s",
    },
    opts = pulumi.ResourceOptions(depends_on=[project_level]))
# ----------------------------------------------------------------------------
# Example 3: Script Action (TESTED ✅)
# ----------------------------------------------------------------------------
# Custom script action for flexible operations
script_action = harness.chaos.ActionTemplate("script_action",
    org_id=this["id"],
    project_id=this_harness_platform_project["id"],
    hub_identity=project_level["identity"],
    identity="script-action-template",
    name="Script Action Template",
    description="Custom script action for chaos operations",
    type="script",
    infrastructure_type="<+input>.default('Kubernetes')",
    tags=[
        "script",
        "custom",
    ],
    custom_script_action={
        "script": """#!/bin/bash
echo \"Running custom chaos script\"
echo \"Target: <+input>\"
sleep 10
echo \"Script completed\"
""",
        "shell": "bash",
        "envs": [{
            "name": "TARGET",
            "value": "<+input>.default('default-target')",
        }],
    },
    run_properties={
        "timeout": "<+input>.default('120s')",
        "interval": "30s",
    },
    variables=[{
        "name": "target_resource",
        "value": "<+input>",
        "type": "string",
        "required": True,
        "description": "Target resource for the script",
    }],
    opts = pulumi.ResourceOptions(depends_on=[project_level]))

package main

import (
	"github.com/pulumi/pulumi-harness/sdk/go/harness/chaos"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// ============================================================================
		// Harness Chaos Action Template Resource Examples
		// ============================================================================
		//
		// Action templates define reusable actions for chaos experiments.
		// These examples are based on TESTED configurations from the e2e-test suite.
		//
		// Key Points:
		// - Actions can be delay, script, or container type
		// - Runtime inputs with defaults: "<+input>.default('value')"
		// - Container actions support full Kubernetes pod configuration
		// ============================================================================
		// ----------------------------------------------------------------------------
		// Example 1: Container Action with Runtime Inputs (TESTED ✅)
		// ----------------------------------------------------------------------------
		// Most common pattern: container action with runtime inputs and defaults
		_, err := chaos.NewActionTemplate(ctx, "container_with_runtime_inputs", &chaos.ActionTemplateArgs{
			OrgId:              pulumi.Any(this.Id),
			ProjectId:          pulumi.Any(thisHarnessPlatformProject.Id),
			HubIdentity:        pulumi.Any(projectLevel.Identity),
			Identity:           pulumi.String("container-action-template"),
			Name:               pulumi.String("Container Action Template"),
			Description:        pulumi.String("Container action with runtime inputs and defaults"),
			Type:               pulumi.String("container"),
			InfrastructureType: pulumi.String("<+input>.default('Kubernetes')"),
			Tags: pulumi.StringArray{
				pulumi.String("container"),
				pulumi.String("kubernetes"),
				pulumi.String("runtime-inputs"),
			},
			ContainerAction: &chaos.ActionTemplateContainerActionArgs{
				Image: pulumi.String("<+input>.default('busybox:latest')"),
				Commands: pulumi.StringArray{
					pulumi.String("<+input>.default('sh')"),
				},
				Args:      pulumi.String("echo 'Running container action'; sleep 15"),
				Namespace: pulumi.String("<+input>.default('default')"),
				NodeSelector: pulumi.StringMap{
					"disktype": pulumi.String("ssd"),
					"zone":     pulumi.String("us-west-1a"),
				},
				Labels: pulumi.StringMap{
					"app":         pulumi.String("chaos-action"),
					"environment": pulumi.String("production"),
					"managed-by":  pulumi.String("terraform"),
				},
				Annotations: pulumi.StringMap{
					"description": pulumi.String("Chaos container action"),
					"owner":       pulumi.String("chaos-team"),
				},
				Envs: chaos.ActionTemplateContainerActionEnvArray{
					&chaos.ActionTemplateContainerActionEnvArgs{
						Name:  pulumi.String("TEST_VAR"),
						Value: pulumi.String("<+input>.default('test_value')"),
					},
					&chaos.ActionTemplateContainerActionEnvArgs{
						Name:  pulumi.String("ANOTHER_VAR"),
						Value: pulumi.String("<+input>.default('another_value')"),
					},
				},
				Resources: &chaos.ActionTemplateContainerActionResourcesArgs{
					Limits: pulumi.StringMap{
						"cpu":    pulumi.String("500m"),
						"memory": pulumi.String("512Mi"),
					},
					Requests: pulumi.StringMap{
						"cpu":    pulumi.String("250m"),
						"memory": pulumi.String("256Mi"),
					},
				},
			},
			RunProperties: &chaos.ActionTemplateRunPropertiesArgs{
				Timeout:  pulumi.String("<+input>.default('60s')"),
				Interval: pulumi.String("<+input>.default('15s')"),
			},
			Variables: chaos.ActionTemplateVariableArray{
				&chaos.ActionTemplateVariableArgs{
					Name:        pulumi.String("container_image"),
					Value:       pulumi.String("<+input>"),
					Type:        pulumi.String("string"),
					Required:    pulumi.Bool(true),
					Description: pulumi.String("Container image to use (runtime input)"),
				},
				&chaos.ActionTemplateVariableArgs{
					Name:        pulumi.String("namespace"),
					Value:       pulumi.String("<+input>"),
					Type:        pulumi.String("string"),
					Required:    pulumi.Bool(false),
					Description: pulumi.String("Kubernetes namespace (runtime input)"),
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			projectLevel,
		}))
		if err != nil {
			return err
		}
		// ----------------------------------------------------------------------------
		// Example 2: Simple Delay Action (TESTED ✅)
		// ----------------------------------------------------------------------------
		// Delay action for adding wait time in experiments
		_, err = chaos.NewActionTemplate(ctx, "delay_action", &chaos.ActionTemplateArgs{
			OrgId:              pulumi.Any(this.Id),
			ProjectId:          pulumi.Any(thisHarnessPlatformProject.Id),
			HubIdentity:        pulumi.Any(projectLevel.Identity),
			Identity:           pulumi.String("delay-action-template"),
			Name:               pulumi.String("Delay Action Template"),
			Description:        pulumi.String("Simple delay action for wait time"),
			Type:               pulumi.String("delay"),
			InfrastructureType: pulumi.String("Kubernetes"),
			Tags: pulumi.StringArray{
				pulumi.String("delay"),
				pulumi.String("wait"),
			},
			DelayAction: &chaos.ActionTemplateDelayActionArgs{
				Duration: pulumi.String("<+input>.default('30s')"),
			},
			RunProperties: &chaos.ActionTemplateRunPropertiesArgs{
				Timeout: pulumi.String("60s"),
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			projectLevel,
		}))
		if err != nil {
			return err
		}
		// ----------------------------------------------------------------------------
		// Example 3: Script Action (TESTED ✅)
		// ----------------------------------------------------------------------------
		// Custom script action for flexible operations
		_, err = chaos.NewActionTemplate(ctx, "script_action", &chaos.ActionTemplateArgs{
			OrgId:              pulumi.Any(this.Id),
			ProjectId:          pulumi.Any(thisHarnessPlatformProject.Id),
			HubIdentity:        pulumi.Any(projectLevel.Identity),
			Identity:           pulumi.String("script-action-template"),
			Name:               pulumi.String("Script Action Template"),
			Description:        pulumi.String("Custom script action for chaos operations"),
			Type:               pulumi.String("script"),
			InfrastructureType: pulumi.String("<+input>.default('Kubernetes')"),
			Tags: pulumi.StringArray{
				pulumi.String("script"),
				pulumi.String("custom"),
			},
			CustomScriptAction: &chaos.ActionTemplateCustomScriptActionArgs{
				Script: `#!/bin/bash
echo \"Running custom chaos script\"
echo \"Target: <+input>\"
sleep 10
echo \"Script completed\"
`,
				Shell: "bash",
				Envs: chaos.ActionTemplateCustomScriptActionEnvArray{
					&chaos.ActionTemplateCustomScriptActionEnvArgs{
						Name:  pulumi.String("TARGET"),
						Value: pulumi.String("<+input>.default('default-target')"),
					},
				},
			},
			RunProperties: &chaos.ActionTemplateRunPropertiesArgs{
				Timeout:  pulumi.String("<+input>.default('120s')"),
				Interval: pulumi.String("30s"),
			},
			Variables: chaos.ActionTemplateVariableArray{
				&chaos.ActionTemplateVariableArgs{
					Name:        pulumi.String("target_resource"),
					Value:       pulumi.String("<+input>"),
					Type:        pulumi.String("string"),
					Required:    pulumi.Bool(true),
					Description: pulumi.String("Target resource for the script"),
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			projectLevel,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Harness = Pulumi.Harness;

return await Deployment.RunAsync(() => 
{
    // ============================================================================
    // Harness Chaos Action Template Resource Examples
    // ============================================================================
    //
    // Action templates define reusable actions for chaos experiments.
    // These examples are based on TESTED configurations from the e2e-test suite.
    //
    // Key Points:
    // - Actions can be delay, script, or container type
    // - Runtime inputs with defaults: "<+input>.default('value')"
    // - Container actions support full Kubernetes pod configuration
    // ============================================================================
    // ----------------------------------------------------------------------------
    // Example 1: Container Action with Runtime Inputs (TESTED ✅)
    // ----------------------------------------------------------------------------
    // Most common pattern: container action with runtime inputs and defaults
    var containerWithRuntimeInputs = new Harness.Chaos.ActionTemplate("container_with_runtime_inputs", new()
    {
        OrgId = @this.Id,
        ProjectId = thisHarnessPlatformProject.Id,
        HubIdentity = projectLevel.Identity,
        Identity = "container-action-template",
        Name = "Container Action Template",
        Description = "Container action with runtime inputs and defaults",
        Type = "container",
        InfrastructureType = "<+input>.default('Kubernetes')",
        Tags = new[]
        {
            "container",
            "kubernetes",
            "runtime-inputs",
        },
        ContainerAction = new Harness.Chaos.Inputs.ActionTemplateContainerActionArgs
        {
            Image = "<+input>.default('busybox:latest')",
            Commands = new[]
            {
                "<+input>.default('sh')",
            },
            Args = "echo 'Running container action'; sleep 15",
            Namespace = "<+input>.default('default')",
            NodeSelector = 
            {
                { "disktype", "ssd" },
                { "zone", "us-west-1a" },
            },
            Labels = 
            {
                { "app", "chaos-action" },
                { "environment", "production" },
                { "managed-by", "terraform" },
            },
            Annotations = 
            {
                { "description", "Chaos container action" },
                { "owner", "chaos-team" },
            },
            Envs = new[]
            {
                new Harness.Chaos.Inputs.ActionTemplateContainerActionEnvArgs
                {
                    Name = "TEST_VAR",
                    Value = "<+input>.default('test_value')",
                },
                new Harness.Chaos.Inputs.ActionTemplateContainerActionEnvArgs
                {
                    Name = "ANOTHER_VAR",
                    Value = "<+input>.default('another_value')",
                },
            },
            Resources = new Harness.Chaos.Inputs.ActionTemplateContainerActionResourcesArgs
            {
                Limits = 
                {
                    { "cpu", "500m" },
                    { "memory", "512Mi" },
                },
                Requests = 
                {
                    { "cpu", "250m" },
                    { "memory", "256Mi" },
                },
            },
        },
        RunProperties = new Harness.Chaos.Inputs.ActionTemplateRunPropertiesArgs
        {
            Timeout = "<+input>.default('60s')",
            Interval = "<+input>.default('15s')",
        },
        Variables = new[]
        {
            new Harness.Chaos.Inputs.ActionTemplateVariableArgs
            {
                Name = "container_image",
                Value = "<+input>",
                Type = "string",
                Required = true,
                Description = "Container image to use (runtime input)",
            },
            new Harness.Chaos.Inputs.ActionTemplateVariableArgs
            {
                Name = "namespace",
                Value = "<+input>",
                Type = "string",
                Required = false,
                Description = "Kubernetes namespace (runtime input)",
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            projectLevel,
        },
    });

    // ----------------------------------------------------------------------------
    // Example 2: Simple Delay Action (TESTED ✅)
    // ----------------------------------------------------------------------------
    // Delay action for adding wait time in experiments
    var delayAction = new Harness.Chaos.ActionTemplate("delay_action", new()
    {
        OrgId = @this.Id,
        ProjectId = thisHarnessPlatformProject.Id,
        HubIdentity = projectLevel.Identity,
        Identity = "delay-action-template",
        Name = "Delay Action Template",
        Description = "Simple delay action for wait time",
        Type = "delay",
        InfrastructureType = "Kubernetes",
        Tags = new[]
        {
            "delay",
            "wait",
        },
        DelayAction = new Harness.Chaos.Inputs.ActionTemplateDelayActionArgs
        {
            Duration = "<+input>.default('30s')",
        },
        RunProperties = new Harness.Chaos.Inputs.ActionTemplateRunPropertiesArgs
        {
            Timeout = "60s",
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            projectLevel,
        },
    });

    // ----------------------------------------------------------------------------
    // Example 3: Script Action (TESTED ✅)
    // ----------------------------------------------------------------------------
    // Custom script action for flexible operations
    var scriptAction = new Harness.Chaos.ActionTemplate("script_action", new()
    {
        OrgId = @this.Id,
        ProjectId = thisHarnessPlatformProject.Id,
        HubIdentity = projectLevel.Identity,
        Identity = "script-action-template",
        Name = "Script Action Template",
        Description = "Custom script action for chaos operations",
        Type = "script",
        InfrastructureType = "<+input>.default('Kubernetes')",
        Tags = new[]
        {
            "script",
            "custom",
        },
        CustomScriptAction = new Harness.Chaos.Inputs.ActionTemplateCustomScriptActionArgs
        {
            Script = @"#!/bin/bash
echo \""Running custom chaos script\""
echo \""Target: <+input>\""
sleep 10
echo \""Script completed\""
",
            Shell = "bash",
            Envs = new[]
            {
                new Harness.Chaos.Inputs.ActionTemplateCustomScriptActionEnvArgs
                {
                    Name = "TARGET",
                    Value = "<+input>.default('default-target')",
                },
            },
        },
        RunProperties = new Harness.Chaos.Inputs.ActionTemplateRunPropertiesArgs
        {
            Timeout = "<+input>.default('120s')",
            Interval = "30s",
        },
        Variables = new[]
        {
            new Harness.Chaos.Inputs.ActionTemplateVariableArgs
            {
                Name = "target_resource",
                Value = "<+input>",
                Type = "string",
                Required = true,
                Description = "Target resource for the script",
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            projectLevel,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.harness.chaos.ActionTemplate;
import com.pulumi.harness.chaos.ActionTemplateArgs;
import com.pulumi.harness.chaos.inputs.ActionTemplateContainerActionArgs;
import com.pulumi.harness.chaos.inputs.ActionTemplateContainerActionResourcesArgs;
import com.pulumi.harness.chaos.inputs.ActionTemplateRunPropertiesArgs;
import com.pulumi.harness.chaos.inputs.ActionTemplateVariableArgs;
import com.pulumi.harness.chaos.inputs.ActionTemplateDelayActionArgs;
import com.pulumi.harness.chaos.inputs.ActionTemplateCustomScriptActionArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        // ============================================================================
        // Harness Chaos Action Template Resource Examples
        // ============================================================================
        //
        // Action templates define reusable actions for chaos experiments.
        // These examples are based on TESTED configurations from the e2e-test suite.
        //
        // Key Points:
        // - Actions can be delay, script, or container type
        // - Runtime inputs with defaults: "<+input>.default('value')"
        // - Container actions support full Kubernetes pod configuration
        // ============================================================================
        // ----------------------------------------------------------------------------
        // Example 1: Container Action with Runtime Inputs (TESTED ✅)
        // ----------------------------------------------------------------------------
        // Most common pattern: container action with runtime inputs and defaults
        var containerWithRuntimeInputs = new ActionTemplate("containerWithRuntimeInputs", ActionTemplateArgs.builder()
            .orgId(this_.id())
            .projectId(thisHarnessPlatformProject.id())
            .hubIdentity(projectLevel.identity())
            .identity("container-action-template")
            .name("Container Action Template")
            .description("Container action with runtime inputs and defaults")
            .type("container")
            .infrastructureType("<+input>.default('Kubernetes')")
            .tags(            
                "container",
                "kubernetes",
                "runtime-inputs")
            .containerAction(ActionTemplateContainerActionArgs.builder()
                .image("<+input>.default('busybox:latest')")
                .commands("<+input>.default('sh')")
                .args("echo 'Running container action'; sleep 15")
                .namespace("<+input>.default('default')")
                .nodeSelector(Map.ofEntries(
                    Map.entry("disktype", "ssd"),
                    Map.entry("zone", "us-west-1a")
                ))
                .labels(Map.ofEntries(
                    Map.entry("app", "chaos-action"),
                    Map.entry("environment", "production"),
                    Map.entry("managed-by", "terraform")
                ))
                .annotations(Map.ofEntries(
                    Map.entry("description", "Chaos container action"),
                    Map.entry("owner", "chaos-team")
                ))
                .envs(                
                    ActionTemplateContainerActionEnvArgs.builder()
                        .name("TEST_VAR")
                        .value("<+input>.default('test_value')")
                        .build(),
                    ActionTemplateContainerActionEnvArgs.builder()
                        .name("ANOTHER_VAR")
                        .value("<+input>.default('another_value')")
                        .build())
                .resources(ActionTemplateContainerActionResourcesArgs.builder()
                    .limits(Map.ofEntries(
                        Map.entry("cpu", "500m"),
                        Map.entry("memory", "512Mi")
                    ))
                    .requests(Map.ofEntries(
                        Map.entry("cpu", "250m"),
                        Map.entry("memory", "256Mi")
                    ))
                    .build())
                .build())
            .runProperties(ActionTemplateRunPropertiesArgs.builder()
                .timeout("<+input>.default('60s')")
                .interval("<+input>.default('15s')")
                .build())
            .variables(            
                ActionTemplateVariableArgs.builder()
                    .name("container_image")
                    .value("<+input>")
                    .type("string")
                    .required(true)
                    .description("Container image to use (runtime input)")
                    .build(),
                ActionTemplateVariableArgs.builder()
                    .name("namespace")
                    .value("<+input>")
                    .type("string")
                    .required(false)
                    .description("Kubernetes namespace (runtime input)")
                    .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(projectLevel)
                .build());

        // ----------------------------------------------------------------------------
        // Example 2: Simple Delay Action (TESTED ✅)
        // ----------------------------------------------------------------------------
        // Delay action for adding wait time in experiments
        var delayAction = new ActionTemplate("delayAction", ActionTemplateArgs.builder()
            .orgId(this_.id())
            .projectId(thisHarnessPlatformProject.id())
            .hubIdentity(projectLevel.identity())
            .identity("delay-action-template")
            .name("Delay Action Template")
            .description("Simple delay action for wait time")
            .type("delay")
            .infrastructureType("Kubernetes")
            .tags(            
                "delay",
                "wait")
            .delayAction(ActionTemplateDelayActionArgs.builder()
                .duration("<+input>.default('30s')")
                .build())
            .runProperties(ActionTemplateRunPropertiesArgs.builder()
                .timeout("60s")
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(projectLevel)
                .build());

        // ----------------------------------------------------------------------------
        // Example 3: Script Action (TESTED ✅)
        // ----------------------------------------------------------------------------
        // Custom script action for flexible operations
        var scriptAction = new ActionTemplate("scriptAction", ActionTemplateArgs.builder()
            .orgId(this_.id())
            .projectId(thisHarnessPlatformProject.id())
            .hubIdentity(projectLevel.identity())
            .identity("script-action-template")
            .name("Script Action Template")
            .description("Custom script action for chaos operations")
            .type("script")
            .infrastructureType("<+input>.default('Kubernetes')")
            .tags(            
                "script",
                "custom")
            .customScriptAction(ActionTemplateCustomScriptActionArgs.builder()
                .script("""
#!/bin/bash
echo \"Running custom chaos script\"
echo \"Target: <+input>\"
sleep 10
echo \"Script completed\"
                """)
                .shell("bash")
                .envs(ActionTemplateCustomScriptActionEnvArgs.builder()
                    .name("TARGET")
                    .value("<+input>.default('default-target')")
                    .build())
                .build())
            .runProperties(ActionTemplateRunPropertiesArgs.builder()
                .timeout("<+input>.default('120s')")
                .interval("30s")
                .build())
            .variables(ActionTemplateVariableArgs.builder()
                .name("target_resource")
                .value("<+input>")
                .type("string")
                .required(true)
                .description("Target resource for the script")
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(projectLevel)
                .build());

    }
}

resources:
  # ============================================================================
  # Harness Chaos Action Template Resource Examples
  # ============================================================================
  #
  # Action templates define reusable actions for chaos experiments.
  # These examples are based on TESTED configurations from the e2e-test suite.
  #
  # Key Points:
  # - Actions can be delay, script, or container type
  # - Runtime inputs with defaults: "<+input>.default('value')"
  # - Container actions support full Kubernetes pod configuration
  # ============================================================================

  # ----------------------------------------------------------------------------
  # Example 1: Container Action with Runtime Inputs (TESTED ✅)
  # ----------------------------------------------------------------------------
  # Most common pattern: container action with runtime inputs and defaults
  containerWithRuntimeInputs:
    type: harness:chaos:ActionTemplate
    name: container_with_runtime_inputs
    properties:
      orgId: ${this.id}
      projectId: ${thisHarnessPlatformProject.id}
      hubIdentity: ${projectLevel.identity}
      identity: container-action-template
      name: Container Action Template
      description: Container action with runtime inputs and defaults
      type: container
      infrastructureType: <+input>.default('Kubernetes')
      tags:
        - container
        - kubernetes
        - runtime-inputs
      containerAction:
        image: <+input>.default('busybox:latest')
        commands:
          - <+input>.default('sh')
        args: echo 'Running container action'; sleep 15
        namespace: <+input>.default('default')
        nodeSelector:
          disktype: ssd
          zone: us-west-1a
        labels:
          app: chaos-action
          environment: production
          managed-by: terraform
        annotations:
          description: Chaos container action
          owner: chaos-team
        envs:
          - name: TEST_VAR
            value: <+input>.default('test_value')
          - name: ANOTHER_VAR
            value: <+input>.default('another_value')
        resources:
          limits:
            cpu: 500m
            memory: 512Mi
          requests:
            cpu: 250m
            memory: 256Mi
      runProperties:
        timeout: <+input>.default('60s')
        interval: <+input>.default('15s')
      variables:
        - name: container_image
          value: <+input>
          type: string
          required: true
          description: Container image to use (runtime input)
        - name: namespace
          value: <+input>
          type: string
          required: false
          description: Kubernetes namespace (runtime input)
    options:
      dependsOn:
        - ${projectLevel}
  # ----------------------------------------------------------------------------
  # Example 2: Simple Delay Action (TESTED ✅)
  # ----------------------------------------------------------------------------
  # Delay action for adding wait time in experiments
  delayAction:
    type: harness:chaos:ActionTemplate
    name: delay_action
    properties:
      orgId: ${this.id}
      projectId: ${thisHarnessPlatformProject.id}
      hubIdentity: ${projectLevel.identity}
      identity: delay-action-template
      name: Delay Action Template
      description: Simple delay action for wait time
      type: delay
      infrastructureType: Kubernetes
      tags:
        - delay
        - wait
      delayAction:
        duration: <+input>.default('30s')
      runProperties:
        timeout: 60s
    options:
      dependsOn:
        - ${projectLevel}
  # ----------------------------------------------------------------------------
  # Example 3: Script Action (TESTED ✅)
  # ----------------------------------------------------------------------------
  # Custom script action for flexible operations
  scriptAction:
    type: harness:chaos:ActionTemplate
    name: script_action
    properties:
      orgId: ${this.id}
      projectId: ${thisHarnessPlatformProject.id}
      hubIdentity: ${projectLevel.identity}
      identity: script-action-template
      name: Script Action Template
      description: Custom script action for chaos operations
      type: script
      infrastructureType: <+input>.default('Kubernetes')
      tags:
        - script
        - custom
      customScriptAction:
        script: |
          #!/bin/bash
          echo \"Running custom chaos script\"
          echo \"Target: <+input>\"
          sleep 10
          echo \"Script completed\"
        shell: bash
        envs:
          - name: TARGET
            value: <+input>.default('default-target')
      runProperties:
        timeout: <+input>.default('120s')
        interval: 30s
      variables:
        - name: target_resource
          value: <+input>
          type: string
          required: true
          description: Target resource for the script
    options:
      dependsOn:
        - ${projectLevel}