elasticstack.getElasticsearchIngestProcessorPipeline

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

const appendTags = elasticstack.getElasticsearchIngestProcessorAppend({
    field: "tags",
    values: [
        "production",
        "{{{app}}}",
        "{{{owner}}}",
    ],
});
const pipelineA = new elasticstack.ElasticsearchIngestPipeline("pipelineA", {processors: [appendTags.then(appendTags => appendTags.json)]});
const fingerprint = elasticstack.getElasticsearchIngestProcessorFingerprint({
    fields: ["owner"],
});
const pipeline = elasticstack.getElasticsearchIngestProcessorPipelineOutput({
    name: pipelineA.name,
});
const pipelineB = new elasticstack.ElasticsearchIngestPipeline("pipelineB", {processors: [
    pipeline.apply(pipeline => pipeline.json),
    fingerprint.then(fingerprint => fingerprint.json),
]});

import pulumi
import pulumi_elasticstack as elasticstack

append_tags = elasticstack.get_elasticsearch_ingest_processor_append(field="tags",
    values=[
        "production",
        "{{{app}}}",
        "{{{owner}}}",
    ])
pipeline_a = elasticstack.ElasticsearchIngestPipeline("pipelineA", processors=[append_tags.json])
fingerprint = elasticstack.get_elasticsearch_ingest_processor_fingerprint(fields=["owner"])
pipeline = elasticstack.get_elasticsearch_ingest_processor_pipeline_output(name=pipeline_a.name)
pipeline_b = elasticstack.ElasticsearchIngestPipeline("pipelineB", processors=[
    pipeline.json,
    fingerprint.json,
])

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/elasticstack/elasticstack"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		appendTags, err := elasticstack.GetElasticsearchIngestProcessorAppend(ctx, &elasticstack.GetElasticsearchIngestProcessorAppendArgs{
			Field: "tags",
			Values: []string{
				"production",
				"{{{app}}}",
				"{{{owner}}}",
			},
		}, nil)
		if err != nil {
			return err
		}
		pipelineA, err := elasticstack.NewElasticsearchIngestPipeline(ctx, "pipelineA", &elasticstack.ElasticsearchIngestPipelineArgs{
			Processors: pulumi.StringArray{
				pulumi.String(appendTags.Json),
			},
		})
		if err != nil {
			return err
		}
		fingerprint, err := elasticstack.GetElasticsearchIngestProcessorFingerprint(ctx, &elasticstack.GetElasticsearchIngestProcessorFingerprintArgs{
			Fields: []string{
				"owner",
			},
		}, nil)
		if err != nil {
			return err
		}
		pipeline := elasticstack.GetElasticsearchIngestProcessorPipelineOutput(ctx, elasticstack.GetElasticsearchIngestProcessorPipelineOutputArgs{
			Name: pipelineA.Name,
		}, nil)
		_, err = elasticstack.NewElasticsearchIngestPipeline(ctx, "pipelineB", &elasticstack.ElasticsearchIngestPipelineArgs{
			Processors: pulumi.StringArray{
				pulumi.String(pipeline.ApplyT(func(pipeline elasticstack.GetElasticsearchIngestProcessorPipelineResult) (*string, error) {
					return &pipeline.Json, nil
				}).(pulumi.StringPtrOutput)),
				pulumi.String(fingerprint.Json),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var appendTags = Elasticstack.GetElasticsearchIngestProcessorAppend.Invoke(new()
    {
        Field = "tags",
        Values = new[]
        {
            "production",
            "{{{app}}}",
            "{{{owner}}}",
        },
    });

    var pipelineA = new Elasticstack.ElasticsearchIngestPipeline("pipelineA", new()
    {
        Processors = new[]
        {
            appendTags.Apply(getElasticsearchIngestProcessorAppendResult => getElasticsearchIngestProcessorAppendResult.Json),
        },
    });

    var fingerprint = Elasticstack.GetElasticsearchIngestProcessorFingerprint.Invoke(new()
    {
        Fields = new[]
        {
            "owner",
        },
    });

    var pipeline = Elasticstack.GetElasticsearchIngestProcessorPipeline.Invoke(new()
    {
        Name = pipelineA.Name,
    });

    var pipelineB = new Elasticstack.ElasticsearchIngestPipeline("pipelineB", new()
    {
        Processors = new[]
        {
            pipeline.Apply(getElasticsearchIngestProcessorPipelineResult => getElasticsearchIngestProcessorPipelineResult.Json),
            fingerprint.Apply(getElasticsearchIngestProcessorFingerprintResult => getElasticsearchIngestProcessorFingerprintResult.Json),
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.elasticstack.ElasticstackFunctions;
import com.pulumi.elasticstack.inputs.GetElasticsearchIngestProcessorAppendArgs;
import com.pulumi.elasticstack.ElasticsearchIngestPipeline;
import com.pulumi.elasticstack.ElasticsearchIngestPipelineArgs;
import com.pulumi.elasticstack.inputs.GetElasticsearchIngestProcessorFingerprintArgs;
import com.pulumi.elasticstack.inputs.GetElasticsearchIngestProcessorPipelineArgs;
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) {
        final var appendTags = ElasticstackFunctions.getElasticsearchIngestProcessorAppend(GetElasticsearchIngestProcessorAppendArgs.builder()
            .field("tags")
            .values(            
                "production",
                "{{{app}}}",
                "{{{owner}}}")
            .build());

        var pipelineA = new ElasticsearchIngestPipeline("pipelineA", ElasticsearchIngestPipelineArgs.builder()
            .processors(appendTags.applyValue(getElasticsearchIngestProcessorAppendResult -> getElasticsearchIngestProcessorAppendResult.json()))
            .build());

        final var fingerprint = ElasticstackFunctions.getElasticsearchIngestProcessorFingerprint(GetElasticsearchIngestProcessorFingerprintArgs.builder()
            .fields("owner")
            .build());

        final var pipeline = ElasticstackFunctions.getElasticsearchIngestProcessorPipeline(GetElasticsearchIngestProcessorPipelineArgs.builder()
            .name(pipelineA.name())
            .build());

        var pipelineB = new ElasticsearchIngestPipeline("pipelineB", ElasticsearchIngestPipelineArgs.builder()
            .processors(            
                pipeline.applyValue(getElasticsearchIngestProcessorPipelineResult -> getElasticsearchIngestProcessorPipelineResult).applyValue(pipeline -> pipeline.applyValue(getElasticsearchIngestProcessorPipelineResult -> getElasticsearchIngestProcessorPipelineResult.json())),
                fingerprint.applyValue(getElasticsearchIngestProcessorFingerprintResult -> getElasticsearchIngestProcessorFingerprintResult.json()))
            .build());

    }
}

resources:
  pipelineA:
    type: elasticstack:ElasticsearchIngestPipeline
    properties:
      processors:
        - ${appendTags.json}
  pipelineB:
    type: elasticstack:ElasticsearchIngestPipeline
    properties:
      processors:
        - ${pipeline.json}
        - ${fingerprint.json}
variables:
  appendTags:
    fn::invoke:
      function: elasticstack:getElasticsearchIngestProcessorAppend
      arguments:
        field: tags
        values:
          - production
          - '{{{app}}}'
          - '{{{owner}}}'
  fingerprint:
    fn::invoke:
      function: elasticstack:getElasticsearchIngestProcessorFingerprint
      arguments:
        fields:
          - owner
  pipeline:
    fn::invoke:
      function: elasticstack:getElasticsearchIngestProcessorPipeline
      arguments:
        name: ${pipelineA.name}

function getElasticsearchIngestProcessorPipeline(args: GetElasticsearchIngestProcessorPipelineArgs, opts?: InvokeOptions): Promise<GetElasticsearchIngestProcessorPipelineResult>
function getElasticsearchIngestProcessorPipelineOutput(args: GetElasticsearchIngestProcessorPipelineOutputArgs, opts?: InvokeOptions): Output<GetElasticsearchIngestProcessorPipelineResult>

def get_elasticsearch_ingest_processor_pipeline(description: Optional[str] = None,
                                                if_: Optional[str] = None,
                                                ignore_failure: Optional[bool] = None,
                                                name: Optional[str] = None,
                                                on_failures: Optional[Sequence[str]] = None,
                                                tag: Optional[str] = None,
                                                opts: Optional[InvokeOptions] = None) -> GetElasticsearchIngestProcessorPipelineResult
def get_elasticsearch_ingest_processor_pipeline_output(description: Optional[pulumi.Input[str]] = None,
                                                if_: Optional[pulumi.Input[str]] = None,
                                                ignore_failure: Optional[pulumi.Input[bool]] = None,
                                                name: Optional[pulumi.Input[str]] = None,
                                                on_failures: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                                                tag: Optional[pulumi.Input[str]] = None,
                                                opts: Optional[InvokeOptions] = None) -> Output[GetElasticsearchIngestProcessorPipelineResult]

func GetElasticsearchIngestProcessorPipeline(ctx *Context, args *GetElasticsearchIngestProcessorPipelineArgs, opts ...InvokeOption) (*GetElasticsearchIngestProcessorPipelineResult, error)
func GetElasticsearchIngestProcessorPipelineOutput(ctx *Context, args *GetElasticsearchIngestProcessorPipelineOutputArgs, opts ...InvokeOption) GetElasticsearchIngestProcessorPipelineResultOutput

public static class GetElasticsearchIngestProcessorPipeline 
{
    public static Task<GetElasticsearchIngestProcessorPipelineResult> InvokeAsync(GetElasticsearchIngestProcessorPipelineArgs args, InvokeOptions? opts = null)
    public static Output<GetElasticsearchIngestProcessorPipelineResult> Invoke(GetElasticsearchIngestProcessorPipelineInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetElasticsearchIngestProcessorPipelineResult> getElasticsearchIngestProcessorPipeline(GetElasticsearchIngestProcessorPipelineArgs args, InvokeOptions options)
public static Output<GetElasticsearchIngestProcessorPipelineResult> getElasticsearchIngestProcessorPipeline(GetElasticsearchIngestProcessorPipelineArgs args, InvokeOptions options)

fn::invoke:
  function: elasticstack:index/getElasticsearchIngestProcessorPipeline:getElasticsearchIngestProcessorPipeline
  arguments:
    # arguments dictionary