harness.chaos.getExperiment

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

// ============================================================================
// Harness Chaos Experiment Data Source Examples
// ============================================================================
//
// The harness_chaos_experiment data source retrieves information about
// existing chaos experiments.
//
// Lookup Methods:
// 1. By identity (fast, direct GET) - RECOMMENDED
// 2. By name (slower, uses LIST + filter)
// ============================================================================
// ----------------------------------------------------------------------------
// Example 1: Lookup by Identity (Recommended)
// ----------------------------------------------------------------------------
// Fast lookup using the experiment's unique identity
const byIdentity = harness.chaos.getExperiment({
    orgId: "my_org",
    projectId: "my_project",
    identity: "my-chaos-experiment",
});
export const experimentId = byIdentity.then(byIdentity => byIdentity.experimentId);
export const experimentInfraType = byIdentity.then(byIdentity => byIdentity.infraType);
export const experimentTemplateName = byIdentity.then(byIdentity => byIdentity.templateDetails?.[0]?.templateName);
// ----------------------------------------------------------------------------
// Example 2: Lookup by Name
// ----------------------------------------------------------------------------
// Lookup using the experiment's display name (slower than identity lookup)
const byName = harness.chaos.getExperiment({
    orgId: "my_org",
    projectId: "my_project",
    name: "My Chaos Experiment",
});
export const experimentIdentity = byName.then(byName => byName.identity);
// ----------------------------------------------------------------------------
// Example 3: Use in Other Resources
// ----------------------------------------------------------------------------
// Reference experiment data in other resources
const existing = harness.chaos.getExperiment({
    orgId: "my_org",
    projectId: "my_project",
    identity: "prod-experiment",
});
// Example: Create monitoring based on experiment
const chaosMonitor = new harness.platform.MonitoredService("chaos_monitor", {
    orgIdentifier: existing.then(existing => existing.orgId),
    projectIdentifier: existing.then(existing => existing.projectId),
    identifier: existing.then(existing => `monitor-${existing.identity}`),
    name: existing.then(existing => `Monitor for ${existing.name}`),
    description: existing.then(existing => `Monitoring for: ${existing.description}`),
});

import pulumi
import pulumi_harness as harness

# ============================================================================
# Harness Chaos Experiment Data Source Examples
# ============================================================================
#
# The harness_chaos_experiment data source retrieves information about
# existing chaos experiments.
#
# Lookup Methods:
# 1. By identity (fast, direct GET) - RECOMMENDED
# 2. By name (slower, uses LIST + filter)
# ============================================================================
# ----------------------------------------------------------------------------
# Example 1: Lookup by Identity (Recommended)
# ----------------------------------------------------------------------------
# Fast lookup using the experiment's unique identity
by_identity = harness.chaos.get_experiment(org_id="my_org",
    project_id="my_project",
    identity="my-chaos-experiment")
pulumi.export("experimentId", by_identity.experiment_id)
pulumi.export("experimentInfraType", by_identity.infra_type)
pulumi.export("experimentTemplateName", by_identity.template_details[0].template_name)
# ----------------------------------------------------------------------------
# Example 2: Lookup by Name
# ----------------------------------------------------------------------------
# Lookup using the experiment's display name (slower than identity lookup)
by_name = harness.chaos.get_experiment(org_id="my_org",
    project_id="my_project",
    name="My Chaos Experiment")
pulumi.export("experimentIdentity", by_name.identity)
# ----------------------------------------------------------------------------
# Example 3: Use in Other Resources
# ----------------------------------------------------------------------------
# Reference experiment data in other resources
existing = harness.chaos.get_experiment(org_id="my_org",
    project_id="my_project",
    identity="prod-experiment")
# Example: Create monitoring based on experiment
chaos_monitor = harness.platform.MonitoredService("chaos_monitor",
    org_identifier=existing.org_id,
    project_identifier=existing.project_id,
    identifier=f"monitor-{existing.identity}",
    name=f"Monitor for {existing.name}",
    description=f"Monitoring for: {existing.description}")

package main

import (
	"fmt"

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// ============================================================================
		// Harness Chaos Experiment Data Source Examples
		// ============================================================================
		//
		// The harness_chaos_experiment data source retrieves information about
		// existing chaos experiments.
		//
		// Lookup Methods:
		// 1. By identity (fast, direct GET) - RECOMMENDED
		// 2. By name (slower, uses LIST + filter)
		// ============================================================================
		// ----------------------------------------------------------------------------
		// Example 1: Lookup by Identity (Recommended)
		// ----------------------------------------------------------------------------
		// Fast lookup using the experiment's unique identity
		byIdentity, err := chaos.LookupExperiment(ctx, &chaos.LookupExperimentArgs{
			OrgId:     "my_org",
			ProjectId: "my_project",
			Identity:  pulumi.StringRef("my-chaos-experiment"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("experimentId", byIdentity.ExperimentId)
		ctx.Export("experimentInfraType", byIdentity.InfraType)
		ctx.Export("experimentTemplateName", byIdentity.TemplateDetails[0].TemplateName)
		// ----------------------------------------------------------------------------
		// Example 2: Lookup by Name
		// ----------------------------------------------------------------------------
		// Lookup using the experiment's display name (slower than identity lookup)
		byName, err := chaos.LookupExperiment(ctx, &chaos.LookupExperimentArgs{
			OrgId:     "my_org",
			ProjectId: "my_project",
			Name:      pulumi.StringRef("My Chaos Experiment"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("experimentIdentity", byName.Identity)
		// ----------------------------------------------------------------------------
		// Example 3: Use in Other Resources
		// ----------------------------------------------------------------------------
		// Reference experiment data in other resources
		existing, err := chaos.LookupExperiment(ctx, &chaos.LookupExperimentArgs{
			OrgId:     "my_org",
			ProjectId: "my_project",
			Identity:  pulumi.StringRef("prod-experiment"),
		}, nil)
		if err != nil {
			return err
		}
		// Example: Create monitoring based on experiment
		_, err = platform.NewMonitoredService(ctx, "chaos_monitor", &platform.MonitoredServiceArgs{
			OrgIdentifier:     existing.OrgId,
			ProjectIdentifier: existing.ProjectId,
			Identifier:        pulumi.Sprintf("monitor-%v", existing.Identity),
			Name:              fmt.Sprintf("Monitor for %v", existing.Name),
			Description:       fmt.Sprintf("Monitoring for: %v", existing.Description),
		})
		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 Experiment Data Source Examples
    // ============================================================================
    //
    // The harness_chaos_experiment data source retrieves information about
    // existing chaos experiments.
    //
    // Lookup Methods:
    // 1. By identity (fast, direct GET) - RECOMMENDED
    // 2. By name (slower, uses LIST + filter)
    // ============================================================================
    // ----------------------------------------------------------------------------
    // Example 1: Lookup by Identity (Recommended)
    // ----------------------------------------------------------------------------
    // Fast lookup using the experiment's unique identity
    var byIdentity = Harness.Chaos.GetExperiment.Invoke(new()
    {
        OrgId = "my_org",
        ProjectId = "my_project",
        Identity = "my-chaos-experiment",
    });

    // ----------------------------------------------------------------------------
    // Example 2: Lookup by Name
    // ----------------------------------------------------------------------------
    // Lookup using the experiment's display name (slower than identity lookup)
    var byName = Harness.Chaos.GetExperiment.Invoke(new()
    {
        OrgId = "my_org",
        ProjectId = "my_project",
        Name = "My Chaos Experiment",
    });

    // ----------------------------------------------------------------------------
    // Example 3: Use in Other Resources
    // ----------------------------------------------------------------------------
    // Reference experiment data in other resources
    var existing = Harness.Chaos.GetExperiment.Invoke(new()
    {
        OrgId = "my_org",
        ProjectId = "my_project",
        Identity = "prod-experiment",
    });

    // Example: Create monitoring based on experiment
    var chaosMonitor = new Harness.Platform.MonitoredService("chaos_monitor", new()
    {
        OrgIdentifier = existing.Apply(getExperimentResult => getExperimentResult.OrgId),
        ProjectIdentifier = existing.Apply(getExperimentResult => getExperimentResult.ProjectId),
        Identifier = $"monitor-{existing.Apply(getExperimentResult => getExperimentResult.Identity)}",
        Name = $"Monitor for {existing.Apply(getExperimentResult => getExperimentResult.Name)}",
        Description = $"Monitoring for: {existing.Apply(getExperimentResult => getExperimentResult.Description)}",
    });

    return new Dictionary<string, object?>
    {
        ["experimentId"] = byIdentity.Apply(getExperimentResult => getExperimentResult.ExperimentId),
        ["experimentInfraType"] = byIdentity.Apply(getExperimentResult => getExperimentResult.InfraType),
        ["experimentTemplateName"] = byIdentity.Apply(getExperimentResult => getExperimentResult.TemplateDetails[0]?.TemplateName),
        ["experimentIdentity"] = byName.Apply(getExperimentResult => getExperimentResult.Identity),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.harness.chaos.ChaosFunctions;
import com.pulumi.harness.chaos.inputs.GetExperimentArgs;
import com.pulumi.harness.platform.MonitoredService;
import com.pulumi.harness.platform.MonitoredServiceArgs;
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 Experiment Data Source Examples
        // ============================================================================
        //
        // The harness_chaos_experiment data source retrieves information about
        // existing chaos experiments.
        //
        // Lookup Methods:
        // 1. By identity (fast, direct GET) - RECOMMENDED
        // 2. By name (slower, uses LIST + filter)
        // ============================================================================
        // ----------------------------------------------------------------------------
        // Example 1: Lookup by Identity (Recommended)
        // ----------------------------------------------------------------------------
        // Fast lookup using the experiment's unique identity
        final var byIdentity = ChaosFunctions.getExperiment(GetExperimentArgs.builder()
            .orgId("my_org")
            .projectId("my_project")
            .identity("my-chaos-experiment")
            .build());

        ctx.export("experimentId", byIdentity.experimentId());
        ctx.export("experimentInfraType", byIdentity.infraType());
        ctx.export("experimentTemplateName", byIdentity.templateDetails()[0].templateName());
        // ----------------------------------------------------------------------------
        // Example 2: Lookup by Name
        // ----------------------------------------------------------------------------
        // Lookup using the experiment's display name (slower than identity lookup)
        final var byName = ChaosFunctions.getExperiment(GetExperimentArgs.builder()
            .orgId("my_org")
            .projectId("my_project")
            .name("My Chaos Experiment")
            .build());

        ctx.export("experimentIdentity", byName.identity());
        // ----------------------------------------------------------------------------
        // Example 3: Use in Other Resources
        // ----------------------------------------------------------------------------
        // Reference experiment data in other resources
        final var existing = ChaosFunctions.getExperiment(GetExperimentArgs.builder()
            .orgId("my_org")
            .projectId("my_project")
            .identity("prod-experiment")
            .build());

        // Example: Create monitoring based on experiment
        var chaosMonitor = new MonitoredService("chaosMonitor", MonitoredServiceArgs.builder()
            .orgIdentifier(existing.orgId())
            .projectIdentifier(existing.projectId())
            .identifier(String.format("monitor-%s", existing.identity()))
            .name(String.format("Monitor for %s", existing.name()))
            .description(String.format("Monitoring for: %s", existing.description()))
            .build());

    }
}

resources:
  # Example: Create monitoring based on experiment
  chaosMonitor:
    type: harness:platform:MonitoredService
    name: chaos_monitor
    properties:
      orgIdentifier: ${existing.orgId}
      projectIdentifier: ${existing.projectId}
      identifier: monitor-${existing.identity}
      name: Monitor for ${existing.name}
      description: 'Monitoring for: ${existing.description}'
variables:
  # ============================================================================
  # Harness Chaos Experiment Data Source Examples
  # ============================================================================
  #
  # The harness_chaos_experiment data source retrieves information about
  # existing chaos experiments.
  #
  # Lookup Methods:
  # 1. By identity (fast, direct GET) - RECOMMENDED
  # 2. By name (slower, uses LIST + filter)
  # ============================================================================

  # ----------------------------------------------------------------------------
  # Example 1: Lookup by Identity (Recommended)
  # ----------------------------------------------------------------------------
  # Fast lookup using the experiment's unique identity
  byIdentity:
    fn::invoke:
      function: harness:chaos:getExperiment
      arguments:
        orgId: my_org
        projectId: my_project
        identity: my-chaos-experiment
  # ----------------------------------------------------------------------------
  # Example 2: Lookup by Name
  # ----------------------------------------------------------------------------
  # Lookup using the experiment's display name (slower than identity lookup)
  byName:
    fn::invoke:
      function: harness:chaos:getExperiment
      arguments:
        orgId: my_org
        projectId: my_project
        name: My Chaos Experiment
  # ----------------------------------------------------------------------------
  # Example 3: Use in Other Resources
  # ----------------------------------------------------------------------------
  # Reference experiment data in other resources
  existing:
    fn::invoke:
      function: harness:chaos:getExperiment
      arguments:
        orgId: my_org
        projectId: my_project
        identity: prod-experiment
outputs:
  # Use the retrieved data
  experimentId: ${byIdentity.experimentId}
  experimentInfraType: ${byIdentity.infraType}
  experimentTemplateName: ${byIdentity.templateDetails[0].templateName}
  experimentIdentity: ${byName.identity}

function getExperiment(args: GetExperimentArgs, opts?: InvokeOptions): Promise<GetExperimentResult>
function getExperimentOutput(args: GetExperimentOutputArgs, opts?: InvokeOptions): Output<GetExperimentResult>

def get_experiment(identity: Optional[str] = None,
                   name: Optional[str] = None,
                   org_id: Optional[str] = None,
                   project_id: Optional[str] = None,
                   opts: Optional[InvokeOptions] = None) -> GetExperimentResult
def get_experiment_output(identity: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   org_id: Optional[pulumi.Input[str]] = None,
                   project_id: Optional[pulumi.Input[str]] = None,
                   opts: Optional[InvokeOptions] = None) -> Output[GetExperimentResult]

func LookupExperiment(ctx *Context, args *LookupExperimentArgs, opts ...InvokeOption) (*LookupExperimentResult, error)
func LookupExperimentOutput(ctx *Context, args *LookupExperimentOutputArgs, opts ...InvokeOption) LookupExperimentResultOutput

public static class GetExperiment 
{
    public static Task<GetExperimentResult> InvokeAsync(GetExperimentArgs args, InvokeOptions? opts = null)
    public static Output<GetExperimentResult> Invoke(GetExperimentInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetExperimentResult> getExperiment(GetExperimentArgs args, InvokeOptions options)
public static Output<GetExperimentResult> getExperiment(GetExperimentArgs args, InvokeOptions options)

fn::invoke:
  function: harness:chaos/getExperiment:getExperiment
  arguments:
    # arguments dictionary