pulumi-azure-kotlin/com.pulumi.azure.datafactory.kotlin/TriggerTumblingWindowArgs

TriggerTumblingWindowArgs

data class TriggerTumblingWindowArgs(val activated: Output<Boolean>? = null, val additionalProperties: Output<Map<String, String>>? = null, val annotations: Output<List<String>>? = null, val dataFactoryId: Output<String>? = null, val delay: Output<String>? = null, val description: Output<String>? = null, val endTime: Output<String>? = null, val frequency: Output<String>? = null, val interval: Output<Int>? = null, val maxConcurrency: Output<Int>? = null, val name: Output<String>? = null, val pipeline: Output<TriggerTumblingWindowPipelineArgs>? = null, val retry: Output<TriggerTumblingWindowRetryArgs>? = null, val startTime: Output<String>? = null, val triggerDependencies: Output<List<TriggerTumblingWindowTriggerDependencyArgs>>? = null) : ConvertibleToJava<TriggerTumblingWindowArgs>

Manages a Tumbling Window Trigger inside an Azure Data Factory.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";
const example = new azure.core.ResourceGroup("example", {
    name: "example-resources",
    location: "West Europe",
});
const exampleFactory = new azure.datafactory.Factory("example", {
    name: "example",
    location: example.location,
    resourceGroupName: example.name,
});
const examplePipeline = new azure.datafactory.Pipeline("example", {
    name: "example",
    dataFactoryId: exampleFactory.id,
});
const exampleTriggerTumblingWindow = new azure.datafactory.TriggerTumblingWindow("example", {
    name: "example",
    dataFactoryId: exampleFactory.id,
    startTime: "2022-09-21T00:00:00Z",
    endTime: "2022-09-21T08:00:00Z",
    frequency: "Minute",
    interval: 15,
    delay: "16:00:00",
    annotations: [
        "example1",
        "example2",
        "example3",
    ],
    description: "example description",
    retry: {
        count: 1,
        interval: 30,
    },
    pipeline: {
        name: examplePipeline.name,
        parameters: {
            Env: "Prod",
        },
    },
    triggerDependencies: [{
        size: "24:00:00",
        offset: "-24:00:00",
    }],
    additionalProperties: {
        foo: "value1",
        bar: "value2",
    },
});
Content copied to clipboard
import pulumi
import pulumi_azure as azure
example = azure.core.ResourceGroup("example",
    name="example-resources",
    location="West Europe")
example_factory = azure.datafactory.Factory("example",
    name="example",
    location=example.location,
    resource_group_name=example.name)
example_pipeline = azure.datafactory.Pipeline("example",
    name="example",
    data_factory_id=example_factory.id)
example_trigger_tumbling_window = azure.datafactory.TriggerTumblingWindow("example",
    name="example",
    data_factory_id=example_factory.id,
    start_time="2022-09-21T00:00:00Z",
    end_time="2022-09-21T08:00:00Z",
    frequency="Minute",
    interval=15,
    delay="16:00:00",
    annotations=[
        "example1",
        "example2",
        "example3",
    ],
    description="example description",
    retry={
        "count": 1,
        "interval": 30,
    },
    pipeline={
        "name": example_pipeline.name,
        "parameters": {
            "Env": "Prod",
        },
    },
    trigger_dependencies=[{
        "size": "24:00:00",
        "offset": "-24:00:00",
    }],
    additional_properties={
        "foo": "value1",
        "bar": "value2",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;
return await Deployment.RunAsync(() =>
{
    var example = new Azure.Core.ResourceGroup("example", new()
    {
        Name = "example-resources",
        Location = "West Europe",
    });
    var exampleFactory = new Azure.DataFactory.Factory("example", new()
    {
        Name = "example",
        Location = example.Location,
        ResourceGroupName = example.Name,
    });
    var examplePipeline = new Azure.DataFactory.Pipeline("example", new()
    {
        Name = "example",
        DataFactoryId = exampleFactory.Id,
    });
    var exampleTriggerTumblingWindow = new Azure.DataFactory.TriggerTumblingWindow("example", new()
    {
        Name = "example",
        DataFactoryId = exampleFactory.Id,
        StartTime = "2022-09-21T00:00:00Z",
        EndTime = "2022-09-21T08:00:00Z",
        Frequency = "Minute",
        Interval = 15,
        Delay = "16:00:00",
        Annotations = new[]
        {
            "example1",
            "example2",
            "example3",
        },
        Description = "example description",
        Retry = new Azure.DataFactory.Inputs.TriggerTumblingWindowRetryArgs
        {
            Count = 1,
            Interval = 30,
        },
        Pipeline = new Azure.DataFactory.Inputs.TriggerTumblingWindowPipelineArgs
        {
            Name = examplePipeline.Name,
            Parameters =
            {
                { "Env", "Prod" },
            },
        },
        TriggerDependencies = new[]
        {
            new Azure.DataFactory.Inputs.TriggerTumblingWindowTriggerDependencyArgs
            {
                Size = "24:00:00",
                Offset = "-24:00:00",
            },
        },
        AdditionalProperties =
        {
            { "foo", "value1" },
            { "bar", "value2" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/datafactory"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
			Name:     pulumi.String("example-resources"),
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		exampleFactory, err := datafactory.NewFactory(ctx, "example", &datafactory.FactoryArgs{
			Name:              pulumi.String("example"),
			Location:          example.Location,
			ResourceGroupName: example.Name,
		})
		if err != nil {
			return err
		}
		examplePipeline, err := datafactory.NewPipeline(ctx, "example", &datafactory.PipelineArgs{
			Name:          pulumi.String("example"),
			DataFactoryId: exampleFactory.ID(),
		})
		if err != nil {
			return err
		}
		_, err = datafactory.NewTriggerTumblingWindow(ctx, "example", &datafactory.TriggerTumblingWindowArgs{
			Name:          pulumi.String("example"),
			DataFactoryId: exampleFactory.ID(),
			StartTime:     pulumi.String("2022-09-21T00:00:00Z"),
			EndTime:       pulumi.String("2022-09-21T08:00:00Z"),
			Frequency:     pulumi.String("Minute"),
			Interval:      pulumi.Int(15),
			Delay:         pulumi.String("16:00:00"),
			Annotations: pulumi.StringArray{
				pulumi.String("example1"),
				pulumi.String("example2"),
				pulumi.String("example3"),
			},
			Description: pulumi.String("example description"),
			Retry: &datafactory.TriggerTumblingWindowRetryArgs{
				Count:    pulumi.Int(1),
				Interval: pulumi.Int(30),
			},
			Pipeline: &datafactory.TriggerTumblingWindowPipelineArgs{
				Name: examplePipeline.Name,
				Parameters: pulumi.StringMap{
					"Env": pulumi.String("Prod"),
				},
			},
			TriggerDependencies: datafactory.TriggerTumblingWindowTriggerDependencyArray{
				&datafactory.TriggerTumblingWindowTriggerDependencyArgs{
					Size:   pulumi.String("24:00:00"),
					Offset: pulumi.String("-24:00:00"),
				},
			},
			AdditionalProperties: pulumi.StringMap{
				"foo": pulumi.String("value1"),
				"bar": pulumi.String("value2"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.azure.datafactory.Factory;
import com.pulumi.azure.datafactory.FactoryArgs;
import com.pulumi.azure.datafactory.Pipeline;
import com.pulumi.azure.datafactory.PipelineArgs;
import com.pulumi.azure.datafactory.TriggerTumblingWindow;
import com.pulumi.azure.datafactory.TriggerTumblingWindowArgs;
import com.pulumi.azure.datafactory.inputs.TriggerTumblingWindowRetryArgs;
import com.pulumi.azure.datafactory.inputs.TriggerTumblingWindowPipelineArgs;
import com.pulumi.azure.datafactory.inputs.TriggerTumblingWindowTriggerDependencyArgs;
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) {
        var example = new ResourceGroup("example", ResourceGroupArgs.builder()
            .name("example-resources")
            .location("West Europe")
            .build());
        var exampleFactory = new Factory("exampleFactory", FactoryArgs.builder()
            .name("example")
            .location(example.location())
            .resourceGroupName(example.name())
            .build());
        var examplePipeline = new Pipeline("examplePipeline", PipelineArgs.builder()
            .name("example")
            .dataFactoryId(exampleFactory.id())
            .build());
        var exampleTriggerTumblingWindow = new TriggerTumblingWindow("exampleTriggerTumblingWindow", TriggerTumblingWindowArgs.builder()
            .name("example")
            .dataFactoryId(exampleFactory.id())
            .startTime("2022-09-21T00:00:00Z")
            .endTime("2022-09-21T08:00:00Z")
            .frequency("Minute")
            .interval(15)
            .delay("16:00:00")
            .annotations(
                "example1",
                "example2",
                "example3")
            .description("example description")
            .retry(TriggerTumblingWindowRetryArgs.builder()
                .count(1)
                .interval(30)
                .build())
            .pipeline(TriggerTumblingWindowPipelineArgs.builder()
                .name(examplePipeline.name())
                .parameters(Map.of("Env", "Prod"))
                .build())
            .triggerDependencies(TriggerTumblingWindowTriggerDependencyArgs.builder()
                .size("24:00:00")
                .offset("-24:00:00")
                .build())
            .additionalProperties(Map.ofEntries(
                Map.entry("foo", "value1"),
                Map.entry("bar", "value2")
            ))
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: azure:core:ResourceGroup
    properties:
      name: example-resources
      location: West Europe
  exampleFactory:
    type: azure:datafactory:Factory
    name: example
    properties:
      name: example
      location: ${example.location}
      resourceGroupName: ${example.name}
  examplePipeline:
    type: azure:datafactory:Pipeline
    name: example
    properties:
      name: example
      dataFactoryId: ${exampleFactory.id}
  exampleTriggerTumblingWindow:
    type: azure:datafactory:TriggerTumblingWindow
    name: example
    properties:
      name: example
      dataFactoryId: ${exampleFactory.id}
      startTime: 2022-09-21T00:00:00Z
      endTime: 2022-09-21T08:00:00Z
      frequency: Minute
      interval: 15
      delay: 16:00:00
      annotations:
        - example1
        - example2
        - example3
      description: example description
      retry:
        count: 1
        interval: 30
      pipeline:
        name: ${examplePipeline.name}
        parameters:
          Env: Prod
      triggerDependencies:
        - size: 24:00:00
          offset: -24:00:00
      additionalProperties:
        foo: value1
        bar: value2
Content copied to clipboard

Import

Data Factory Tumbling Window Trigger can be imported using the resource id, e.g.

$ pulumi import azure:datafactory/triggerTumblingWindow:TriggerTumblingWindow example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/example/providers/Microsoft.DataFactory/factories/example/triggers/example
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(activated: Output<Boolean>? = null, additionalProperties: Output<Map<String, String>>? = null, annotations: Output<List<String>>? = null, dataFactoryId: Output<String>? = null, delay: Output<String>? = null, description: Output<String>? = null, endTime: Output<String>? = null, frequency: Output<String>? = null, interval: Output<Int>? = null, maxConcurrency: Output<Int>? = null, name: Output<String>? = null, pipeline: Output<TriggerTumblingWindowPipelineArgs>? = null, retry: Output<TriggerTumblingWindowRetryArgs>? = null, startTime: Output<String>? = null, triggerDependencies: Output<List<TriggerTumblingWindowTriggerDependencyArgs>>? = null)

Properties

Link copied to clipboard
val activated: Output<Boolean>? = null

Specifies if the Data Factory Tumbling Window Trigger is activated. Defaults to true.

Link copied to clipboard
val additionalProperties: Output<Map<String, String>>? = null

A map of additional properties to associate with the Data Factory Tumbling Window Trigger.

Link copied to clipboard
val annotations: Output<List<String>>? = null

List of tags that can be used for describing the Data Factory Tumbling Window Trigger.

Link copied to clipboard
val dataFactoryId: Output<String>? = null

The ID of Data Factory in which to associate the Trigger with. Changing this forces a new resource.

Link copied to clipboard
val delay: Output<String>? = null

Specifies how long the trigger waits before triggering new run. formatted as an D.HH:MM:SS.

Link copied to clipboard
val description: Output<String>? = null

The description for the Data Factory Tumbling Window Trigger.

Link copied to clipboard
val endTime: Output<String>? = null

Specifies the end time of Tumbling Window, formatted as an RFC3339 string.

Link copied to clipboard
val frequency: Output<String>? = null

Specifies the frequency of Tumbling Window. Possible values are Hour, Minute and Month. Changing this forces a new resource.

Link copied to clipboard
val interval: Output<Int>? = null

Specifies the interval of Tumbling Window. Changing this forces a new resource.

Link copied to clipboard
val maxConcurrency: Output<Int>? = null

The max number for simultaneous trigger run fired by Tumbling Window. Possible values are between 1 and 50. Defaults to 50.

Link copied to clipboard
val name: Output<String>? = null

Specifies the name of the Data Factory Tumbling Window Trigger. Changing this forces a new resource to be created.

Link copied to clipboard
val pipeline: Output<TriggerTumblingWindowPipelineArgs>? = null

A pipeline block as defined below.

Link copied to clipboard
val retry: Output<TriggerTumblingWindowRetryArgs>? = null

A retry block as defined below.

Link copied to clipboard
val startTime: Output<String>? = null

Specifies the start time of Tumbling Window, formatted as an RFC3339 string. Changing this forces a new resource.

Link copied to clipboard
val triggerDependencies: Output<List<TriggerTumblingWindowTriggerDependencyArgs>>? = null

One or more trigger_dependency block as defined below.

Functions

Link copied to clipboard
open override fun toJava(): TriggerTumblingWindowArgs