argocd.ApplicationSet

import * as pulumi from "@pulumi/pulumi";
import * as argocd from "@three14/pulumi-argocd";

// Clusters Generator
const clustersSelector = new argocd.ApplicationSet("clusters_selector", {
    metadata: {
        name: "clusters-selector",
    },
    spec: {
        generators: [{
            clusters: [{
                selector: {
                    matchLabels: {
                        "argocd.argoproj.io/secret-type": "cluster",
                    },
                },
            }],
        }],
        template: {
            metadata: {
                name: "{{name}}-clusters-selector",
            },
            spec: {
                sources: [{
                    repoUrl: "https://github.com/argoproj/argocd-example-apps/",
                    targetRevision: "HEAD",
                    path: "guestbook",
                }],
                destination: {
                    server: "{{server}}",
                    namespace: "default",
                },
            },
        },
    },
});
// Cluster Decision Resource Generator
const clusterDecisionResource = new argocd.ApplicationSet("cluster_decision_resource", {
    metadata: {
        name: "cluster-decision-resource",
    },
    spec: {
        generators: [{
            clusterDecisionResources: [{
                configMapRef: "my-configmap",
                name: "quak",
            }],
        }],
        template: {
            metadata: {
                name: "{{name}}-guestbook",
            },
            spec: {
                sources: [{
                    repoUrl: "https://github.com/argoproj/argocd-example-apps/",
                    targetRevision: "HEAD",
                    path: "guestbook",
                }],
                destination: {
                    server: "{{server}}",
                    namespace: "default",
                },
            },
        },
    },
});
// Git Generator - Directories
const gitDirectories = new argocd.ApplicationSet("git_directories", {
    metadata: {
        name: "git-directories",
    },
    spec: {
        generators: [{
            gits: [{
                repoUrl: "https://github.com/argoproj/argo-cd.git",
                revision: "HEAD",
                directories: [
                    {
                        path: "applicationset/examples/git-generator-directory/cluster-addons/*",
                    },
                    {
                        path: "applicationset/examples/git-generator-directory/excludes/cluster-addons/exclude-helm-guestbook",
                        exclude: true,
                    },
                ],
            }],
        }],
        template: {
            metadata: {
                name: "{{path.basename}}-git-directories",
            },
            spec: {
                sources: [{
                    repoUrl: "https://github.com/argoproj/argo-cd.git",
                    targetRevision: "HEAD",
                    path: "{{path}}",
                }],
                destination: {
                    server: "https://kubernetes.default.svc",
                    namespace: "{{path.basename}}",
                },
            },
        },
    },
});
// Git Generator - Files
const gitFiles = new argocd.ApplicationSet("git_files", {
    metadata: {
        name: "git-files",
    },
    spec: {
        generators: [{
            gits: [{
                repoUrl: "https://github.com/argoproj/argo-cd.git",
                revision: "HEAD",
                files: [{
                    path: "applicationset/examples/git-generator-files-discovery/cluster-config/**/config.json",
                }],
            }],
        }],
        template: {
            metadata: {
                name: "{{cluster.name}}-git-files",
            },
            spec: {
                sources: [{
                    repoUrl: "https://github.com/argoproj/argo-cd.git",
                    targetRevision: "HEAD",
                    path: "applicationset/examples/git-generator-files-discovery/apps/guestbook",
                }],
                destination: {
                    server: "{{cluster.address}}",
                    namespace: "guestbook",
                },
            },
        },
    },
});
// List Generator
const list = new argocd.ApplicationSet("list", {
    metadata: {
        name: "list",
    },
    spec: {
        generators: [{
            lists: [{
                elements: [
                    {
                        cluster: "engineering-dev",
                        url: "https://kubernetes.default.svc",
                    },
                    {
                        cluster: "engineering-prod",
                        url: "https://kubernetes.default.svc",
                        foo: "bar",
                    },
                ],
            }],
        }],
        template: {
            metadata: {
                name: "{{cluster}}-guestbook",
            },
            spec: {
                project: "my-project",
                sources: [{
                    repoUrl: "https://github.com/argoproj/argo-cd.git",
                    targetRevision: "HEAD",
                    path: "applicationset/examples/list-generator/guestbook/{{cluster}}",
                }],
                destination: {
                    server: "{{url}}",
                    namespace: "guestbook",
                },
            },
        },
    },
});
// Matrix Generator
const matrix = new argocd.ApplicationSet("matrix", {
    metadata: {
        name: "matrix",
    },
    spec: {
        generators: [{
            matrices: [{
                generators: [
                    {
                        gits: [{
                            repoUrl: "https://github.com/argoproj/argo-cd.git",
                            revision: "HEAD",
                            directories: [{
                                path: "applicationset/examples/matrix/cluster-addons/*",
                            }],
                        }],
                    },
                    {
                        clusters: [{
                            selector: {
                                matchLabels: {
                                    "argocd.argoproj.io/secret-type": "cluster",
                                },
                            },
                        }],
                    },
                ],
            }],
        }],
        template: {
            metadata: {
                name: "{{path.basename}}-{{name}}",
            },
            spec: {
                project: "default",
                sources: [{
                    repoUrl: "https://github.com/argoproj/argo-cd.git",
                    targetRevision: "HEAD",
                    path: "{{path}}",
                }],
                destination: {
                    server: "{{server}}",
                    namespace: "{{path.basename}}",
                },
            },
        },
    },
});
// Merge Generator
const merge = new argocd.ApplicationSet("merge", {
    metadata: {
        name: "merge",
    },
    spec: {
        generators: [{
            merges: [{
                mergeKeys: ["server"],
                generators: [
                    {
                        clusters: [{
                            values: {
                                kafka: "true",
                                redis: "false",
                            },
                        }],
                    },
                    {
                        clusters: [{
                            selector: {
                                matchLabels: {
                                    "use-kafka": "false",
                                },
                            },
                            values: {
                                kafka: "false",
                            },
                        }],
                    },
                    {
                        lists: [{
                            elements: [{
                                server: "https://2.4.6.8",
                                "values.redis": "true",
                            }],
                        }],
                    },
                ],
            }],
        }],
        template: {
            metadata: {
                name: "{{name}}",
            },
            spec: {
                project: "default",
                sources: [{
                    repoUrl: "https://github.com/argoproj/argo-cd.git",
                    path: "app",
                    targetRevision: "HEAD",
                    helm: {
                        parameters: [
                            {
                                name: "kafka",
                                value: "{{values.kafka}}",
                            },
                            {
                                name: "redis",
                                value: "{{values.redis}}",
                            },
                        ],
                    },
                }],
                destination: {
                    server: "{{server}}",
                    namespace: "default",
                },
            },
        },
    },
});
// Pull Request Generator - GitHub
const prGithub = new argocd.ApplicationSet("pr_github", {
    metadata: {
        name: "pr-github",
    },
    spec: {
        generators: [{
            pullRequests: [{
                github: {
                    api: "https://git.example.com/",
                    owner: "myorg",
                    repo: "myrepository",
                    appSecretName: "github-app-repo-creds",
                    tokenRef: {
                        secretName: "github-token",
                        key: "token",
                    },
                    labels: ["preview"],
                },
            }],
        }],
        template: {
            metadata: {
                name: "myapp-{{branch}}-{{number}}",
            },
            spec: {
                project: "default",
                sources: [{
                    repoUrl: "https://github.com/myorg/myrepo.git",
                    path: "kubernetes/",
                    targetRevision: "{{head_sha}}",
                    helm: {
                        parameters: [{
                            name: "image.tag",
                            value: "pull-{{head_sha}}",
                        }],
                    },
                }],
                destination: {
                    server: "https://kubernetes.default.svc",
                    namespace: "default",
                },
            },
        },
    },
});
// SCM Provider Generator - GitHub
const scmGithub = new argocd.ApplicationSet("scm_github", {
    metadata: {
        name: "scm-github",
    },
    spec: {
        generators: [{
            scmProviders: [{
                github: {
                    appSecretName: "gh-app-repo-creds",
                    organization: "myorg",
                },
            }],
        }],
        template: {
            metadata: {
                name: "{{repository}}",
            },
            spec: {
                project: "default",
                sources: [{
                    repoUrl: "{{url}}",
                    path: "kubernetes/",
                    targetRevision: "{{branch}}",
                }],
                destination: {
                    server: "https://kubernetes.default.svc",
                    namespace: "default",
                },
            },
        },
    },
});
// Progressive Sync - Rolling Update
const progressiveSync = new argocd.ApplicationSet("progressive_sync", {
    metadata: {
        name: "progressive-sync",
    },
    spec: {
        generators: [{
            lists: [{
                elements: [
                    {
                        cluster: "engineering-dev",
                        url: "https://1.2.3.4",
                        env: "env-dev",
                    },
                    {
                        cluster: "engineering-qa",
                        url: "https://2.4.6.8",
                        env: "env-qa",
                    },
                    {
                        cluster: "engineering-prod",
                        url: "https://9.8.7.6/",
                        env: "env-prod",
                    },
                ],
            }],
        }],
        strategy: {
            type: "RollingSync",
            rollingSyncs: [{
                steps: [
                    {
                        matchExpressions: [{
                            key: "envLabel",
                            operator: "In",
                            values: ["env-dev"],
                        }],
                    },
                    {
                        matchExpressions: [{
                            key: "envLabel",
                            operator: "In",
                            values: ["env-qa"],
                        }],
                        maxUpdate: "0",
                    },
                    {
                        matchExpressions: [{
                            key: "envLabel",
                            operator: "In",
                            values: ["env-prod"],
                        }],
                        maxUpdate: "10%",
                    },
                ],
            }],
        },
        goTemplate: true,
        template: {
            metadata: {
                name: "{{.cluster}}-guestbook",
                labels: {
                    envLabel: "{{.env}}",
                },
            },
            spec: {
                project: "default",
                sources: [{
                    repoUrl: "https://github.com/infra-team/cluster-deployments.git",
                    path: "guestbook/{{.cluster}}",
                    targetRevision: "HEAD",
                }],
                destination: {
                    server: "{{.url}}",
                    namespace: "guestbook",
                },
            },
        },
    },
});

import pulumi
import pulumi_argocd as argocd

# Clusters Generator
clusters_selector = argocd.ApplicationSet("clusters_selector",
    metadata={
        "name": "clusters-selector",
    },
    spec={
        "generators": [{
            "clusters": [{
                "selector": {
                    "match_labels": {
                        "argocd.argoproj.io/secret-type": "cluster",
                    },
                },
            }],
        }],
        "template": {
            "metadata": {
                "name": "{{name}}-clusters-selector",
            },
            "spec": {
                "sources": [{
                    "repo_url": "https://github.com/argoproj/argocd-example-apps/",
                    "target_revision": "HEAD",
                    "path": "guestbook",
                }],
                "destination": {
                    "server": "{{server}}",
                    "namespace": "default",
                },
            },
        },
    })
# Cluster Decision Resource Generator
cluster_decision_resource = argocd.ApplicationSet("cluster_decision_resource",
    metadata={
        "name": "cluster-decision-resource",
    },
    spec={
        "generators": [{
            "cluster_decision_resources": [{
                "config_map_ref": "my-configmap",
                "name": "quak",
            }],
        }],
        "template": {
            "metadata": {
                "name": "{{name}}-guestbook",
            },
            "spec": {
                "sources": [{
                    "repo_url": "https://github.com/argoproj/argocd-example-apps/",
                    "target_revision": "HEAD",
                    "path": "guestbook",
                }],
                "destination": {
                    "server": "{{server}}",
                    "namespace": "default",
                },
            },
        },
    })
# Git Generator - Directories
git_directories = argocd.ApplicationSet("git_directories",
    metadata={
        "name": "git-directories",
    },
    spec={
        "generators": [{
            "gits": [{
                "repo_url": "https://github.com/argoproj/argo-cd.git",
                "revision": "HEAD",
                "directories": [
                    {
                        "path": "applicationset/examples/git-generator-directory/cluster-addons/*",
                    },
                    {
                        "path": "applicationset/examples/git-generator-directory/excludes/cluster-addons/exclude-helm-guestbook",
                        "exclude": True,
                    },
                ],
            }],
        }],
        "template": {
            "metadata": {
                "name": "{{path.basename}}-git-directories",
            },
            "spec": {
                "sources": [{
                    "repo_url": "https://github.com/argoproj/argo-cd.git",
                    "target_revision": "HEAD",
                    "path": "{{path}}",
                }],
                "destination": {
                    "server": "https://kubernetes.default.svc",
                    "namespace": "{{path.basename}}",
                },
            },
        },
    })
# Git Generator - Files
git_files = argocd.ApplicationSet("git_files",
    metadata={
        "name": "git-files",
    },
    spec={
        "generators": [{
            "gits": [{
                "repo_url": "https://github.com/argoproj/argo-cd.git",
                "revision": "HEAD",
                "files": [{
                    "path": "applicationset/examples/git-generator-files-discovery/cluster-config/**/config.json",
                }],
            }],
        }],
        "template": {
            "metadata": {
                "name": "{{cluster.name}}-git-files",
            },
            "spec": {
                "sources": [{
                    "repo_url": "https://github.com/argoproj/argo-cd.git",
                    "target_revision": "HEAD",
                    "path": "applicationset/examples/git-generator-files-discovery/apps/guestbook",
                }],
                "destination": {
                    "server": "{{cluster.address}}",
                    "namespace": "guestbook",
                },
            },
        },
    })
# List Generator
list = argocd.ApplicationSet("list",
    metadata={
        "name": "list",
    },
    spec={
        "generators": [{
            "lists": [{
                "elements": [
                    {
                        "cluster": "engineering-dev",
                        "url": "https://kubernetes.default.svc",
                    },
                    {
                        "cluster": "engineering-prod",
                        "url": "https://kubernetes.default.svc",
                        "foo": "bar",
                    },
                ],
            }],
        }],
        "template": {
            "metadata": {
                "name": "{{cluster}}-guestbook",
            },
            "spec": {
                "project": "my-project",
                "sources": [{
                    "repo_url": "https://github.com/argoproj/argo-cd.git",
                    "target_revision": "HEAD",
                    "path": "applicationset/examples/list-generator/guestbook/{{cluster}}",
                }],
                "destination": {
                    "server": "{{url}}",
                    "namespace": "guestbook",
                },
            },
        },
    })
# Matrix Generator
matrix = argocd.ApplicationSet("matrix",
    metadata={
        "name": "matrix",
    },
    spec={
        "generators": [{
            "matrices": [{
                "generators": [
                    {
                        "gits": [{
                            "repo_url": "https://github.com/argoproj/argo-cd.git",
                            "revision": "HEAD",
                            "directories": [{
                                "path": "applicationset/examples/matrix/cluster-addons/*",
                            }],
                        }],
                    },
                    {
                        "clusters": [{
                            "selector": {
                                "match_labels": {
                                    "argocd.argoproj.io/secret-type": "cluster",
                                },
                            },
                        }],
                    },
                ],
            }],
        }],
        "template": {
            "metadata": {
                "name": "{{path.basename}}-{{name}}",
            },
            "spec": {
                "project": "default",
                "sources": [{
                    "repo_url": "https://github.com/argoproj/argo-cd.git",
                    "target_revision": "HEAD",
                    "path": "{{path}}",
                }],
                "destination": {
                    "server": "{{server}}",
                    "namespace": "{{path.basename}}",
                },
            },
        },
    })
# Merge Generator
merge = argocd.ApplicationSet("merge",
    metadata={
        "name": "merge",
    },
    spec={
        "generators": [{
            "merges": [{
                "merge_keys": ["server"],
                "generators": [
                    {
                        "clusters": [{
                            "values": {
                                "kafka": "true",
                                "redis": "false",
                            },
                        }],
                    },
                    {
                        "clusters": [{
                            "selector": {
                                "match_labels": {
                                    "use-kafka": "false",
                                },
                            },
                            "values": {
                                "kafka": "false",
                            },
                        }],
                    },
                    {
                        "lists": [{
                            "elements": [{
                                "server": "https://2.4.6.8",
                                "values.redis": "true",
                            }],
                        }],
                    },
                ],
            }],
        }],
        "template": {
            "metadata": {
                "name": "{{name}}",
            },
            "spec": {
                "project": "default",
                "sources": [{
                    "repo_url": "https://github.com/argoproj/argo-cd.git",
                    "path": "app",
                    "target_revision": "HEAD",
                    "helm": {
                        "parameters": [
                            {
                                "name": "kafka",
                                "value": "{{values.kafka}}",
                            },
                            {
                                "name": "redis",
                                "value": "{{values.redis}}",
                            },
                        ],
                    },
                }],
                "destination": {
                    "server": "{{server}}",
                    "namespace": "default",
                },
            },
        },
    })
# Pull Request Generator - GitHub
pr_github = argocd.ApplicationSet("pr_github",
    metadata={
        "name": "pr-github",
    },
    spec={
        "generators": [{
            "pull_requests": [{
                "github": {
                    "api": "https://git.example.com/",
                    "owner": "myorg",
                    "repo": "myrepository",
                    "app_secret_name": "github-app-repo-creds",
                    "token_ref": {
                        "secret_name": "github-token",
                        "key": "token",
                    },
                    "labels": ["preview"],
                },
            }],
        }],
        "template": {
            "metadata": {
                "name": "myapp-{{branch}}-{{number}}",
            },
            "spec": {
                "project": "default",
                "sources": [{
                    "repo_url": "https://github.com/myorg/myrepo.git",
                    "path": "kubernetes/",
                    "target_revision": "{{head_sha}}",
                    "helm": {
                        "parameters": [{
                            "name": "image.tag",
                            "value": "pull-{{head_sha}}",
                        }],
                    },
                }],
                "destination": {
                    "server": "https://kubernetes.default.svc",
                    "namespace": "default",
                },
            },
        },
    })
# SCM Provider Generator - GitHub
scm_github = argocd.ApplicationSet("scm_github",
    metadata={
        "name": "scm-github",
    },
    spec={
        "generators": [{
            "scm_providers": [{
                "github": {
                    "app_secret_name": "gh-app-repo-creds",
                    "organization": "myorg",
                },
            }],
        }],
        "template": {
            "metadata": {
                "name": "{{repository}}",
            },
            "spec": {
                "project": "default",
                "sources": [{
                    "repo_url": "{{url}}",
                    "path": "kubernetes/",
                    "target_revision": "{{branch}}",
                }],
                "destination": {
                    "server": "https://kubernetes.default.svc",
                    "namespace": "default",
                },
            },
        },
    })
# Progressive Sync - Rolling Update
progressive_sync = argocd.ApplicationSet("progressive_sync",
    metadata={
        "name": "progressive-sync",
    },
    spec={
        "generators": [{
            "lists": [{
                "elements": [
                    {
                        "cluster": "engineering-dev",
                        "url": "https://1.2.3.4",
                        "env": "env-dev",
                    },
                    {
                        "cluster": "engineering-qa",
                        "url": "https://2.4.6.8",
                        "env": "env-qa",
                    },
                    {
                        "cluster": "engineering-prod",
                        "url": "https://9.8.7.6/",
                        "env": "env-prod",
                    },
                ],
            }],
        }],
        "strategy": {
            "type": "RollingSync",
            "rolling_syncs": [{
                "steps": [
                    {
                        "match_expressions": [{
                            "key": "envLabel",
                            "operator": "In",
                            "values": ["env-dev"],
                        }],
                    },
                    {
                        "match_expressions": [{
                            "key": "envLabel",
                            "operator": "In",
                            "values": ["env-qa"],
                        }],
                        "max_update": "0",
                    },
                    {
                        "match_expressions": [{
                            "key": "envLabel",
                            "operator": "In",
                            "values": ["env-prod"],
                        }],
                        "max_update": "10%",
                    },
                ],
            }],
        },
        "go_template": True,
        "template": {
            "metadata": {
                "name": "{{.cluster}}-guestbook",
                "labels": {
                    "envLabel": "{{.env}}",
                },
            },
            "spec": {
                "project": "default",
                "sources": [{
                    "repo_url": "https://github.com/infra-team/cluster-deployments.git",
                    "path": "guestbook/{{.cluster}}",
                    "target_revision": "HEAD",
                }],
                "destination": {
                    "server": "{{.url}}",
                    "namespace": "guestbook",
                },
            },
        },
    })

package main

import (
	"github.com/Three141/pulumi-argocd/sdk/go/argocd"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Clusters Generator
		_, err := argocd.NewApplicationSet(ctx, "clusters_selector", &argocd.ApplicationSetArgs{
			Metadata: &argocd.ApplicationSetMetadataArgs{
				Name: pulumi.String("clusters-selector"),
			},
			Spec: &argocd.ApplicationSetSpecArgs{
				Generators: argocd.ApplicationSetSpecGeneratorArray{
					&argocd.ApplicationSetSpecGeneratorArgs{
						Clusters: argocd.ApplicationSetSpecGeneratorClusterArray{
							&argocd.ApplicationSetSpecGeneratorClusterArgs{
								Selector: &argocd.ApplicationSetSpecGeneratorClusterSelectorArgs{
									MatchLabels: pulumi.StringMap{
										"argocd.argoproj.io/secret-type": pulumi.String("cluster"),
									},
								},
							},
						},
					},
				},
				Template: &argocd.ApplicationSetSpecTemplateArgs{
					Metadata: &argocd.ApplicationSetSpecTemplateMetadataArgs{
						Name: pulumi.String("{{name}}-clusters-selector"),
					},
					Spec: &argocd.ApplicationSetSpecTemplateSpecArgs{
						Sources: argocd.ApplicationSetSpecTemplateSpecSourceArray{
							&argocd.ApplicationSetSpecTemplateSpecSourceArgs{
								RepoUrl:        pulumi.String("https://github.com/argoproj/argocd-example-apps/"),
								TargetRevision: pulumi.String("HEAD"),
								Path:           pulumi.String("guestbook"),
							},
						},
						Destination: &argocd.ApplicationSetSpecTemplateSpecDestinationArgs{
							Server:    pulumi.String("{{server}}"),
							Namespace: pulumi.String("default"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		// Cluster Decision Resource Generator
		_, err = argocd.NewApplicationSet(ctx, "cluster_decision_resource", &argocd.ApplicationSetArgs{
			Metadata: &argocd.ApplicationSetMetadataArgs{
				Name: pulumi.String("cluster-decision-resource"),
			},
			Spec: &argocd.ApplicationSetSpecArgs{
				Generators: argocd.ApplicationSetSpecGeneratorArray{
					&argocd.ApplicationSetSpecGeneratorArgs{
						ClusterDecisionResources: argocd.ApplicationSetSpecGeneratorClusterDecisionResourceArray{
							&argocd.ApplicationSetSpecGeneratorClusterDecisionResourceArgs{
								ConfigMapRef: pulumi.String("my-configmap"),
								Name:         pulumi.String("quak"),
							},
						},
					},
				},
				Template: &argocd.ApplicationSetSpecTemplateArgs{
					Metadata: &argocd.ApplicationSetSpecTemplateMetadataArgs{
						Name: pulumi.String("{{name}}-guestbook"),
					},
					Spec: &argocd.ApplicationSetSpecTemplateSpecArgs{
						Sources: argocd.ApplicationSetSpecTemplateSpecSourceArray{
							&argocd.ApplicationSetSpecTemplateSpecSourceArgs{
								RepoUrl:        pulumi.String("https://github.com/argoproj/argocd-example-apps/"),
								TargetRevision: pulumi.String("HEAD"),
								Path:           pulumi.String("guestbook"),
							},
						},
						Destination: &argocd.ApplicationSetSpecTemplateSpecDestinationArgs{
							Server:    pulumi.String("{{server}}"),
							Namespace: pulumi.String("default"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		// Git Generator - Directories
		_, err = argocd.NewApplicationSet(ctx, "git_directories", &argocd.ApplicationSetArgs{
			Metadata: &argocd.ApplicationSetMetadataArgs{
				Name: pulumi.String("git-directories"),
			},
			Spec: &argocd.ApplicationSetSpecArgs{
				Generators: argocd.ApplicationSetSpecGeneratorArray{
					&argocd.ApplicationSetSpecGeneratorArgs{
						Gits: argocd.ApplicationSetSpecGeneratorGitArray{
							&argocd.ApplicationSetSpecGeneratorGitArgs{
								RepoUrl:  pulumi.String("https://github.com/argoproj/argo-cd.git"),
								Revision: pulumi.String("HEAD"),
								Directories: argocd.ApplicationSetSpecGeneratorGitDirectoryArray{
									&argocd.ApplicationSetSpecGeneratorGitDirectoryArgs{
										Path: pulumi.String("applicationset/examples/git-generator-directory/cluster-addons/*"),
									},
									&argocd.ApplicationSetSpecGeneratorGitDirectoryArgs{
										Path:    pulumi.String("applicationset/examples/git-generator-directory/excludes/cluster-addons/exclude-helm-guestbook"),
										Exclude: pulumi.Bool(true),
									},
								},
							},
						},
					},
				},
				Template: &argocd.ApplicationSetSpecTemplateArgs{
					Metadata: &argocd.ApplicationSetSpecTemplateMetadataArgs{
						Name: pulumi.String("{{path.basename}}-git-directories"),
					},
					Spec: &argocd.ApplicationSetSpecTemplateSpecArgs{
						Sources: argocd.ApplicationSetSpecTemplateSpecSourceArray{
							&argocd.ApplicationSetSpecTemplateSpecSourceArgs{
								RepoUrl:        pulumi.String("https://github.com/argoproj/argo-cd.git"),
								TargetRevision: pulumi.String("HEAD"),
								Path:           pulumi.String("{{path}}"),
							},
						},
						Destination: &argocd.ApplicationSetSpecTemplateSpecDestinationArgs{
							Server:    pulumi.String("https://kubernetes.default.svc"),
							Namespace: pulumi.String("{{path.basename}}"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		// Git Generator - Files
		_, err = argocd.NewApplicationSet(ctx, "git_files", &argocd.ApplicationSetArgs{
			Metadata: &argocd.ApplicationSetMetadataArgs{
				Name: pulumi.String("git-files"),
			},
			Spec: &argocd.ApplicationSetSpecArgs{
				Generators: argocd.ApplicationSetSpecGeneratorArray{
					&argocd.ApplicationSetSpecGeneratorArgs{
						Gits: argocd.ApplicationSetSpecGeneratorGitArray{
							&argocd.ApplicationSetSpecGeneratorGitArgs{
								RepoUrl:  pulumi.String("https://github.com/argoproj/argo-cd.git"),
								Revision: pulumi.String("HEAD"),
								Files: argocd.ApplicationSetSpecGeneratorGitFileArray{
									&argocd.ApplicationSetSpecGeneratorGitFileArgs{
										Path: pulumi.String("applicationset/examples/git-generator-files-discovery/cluster-config/**/config.json"),
									},
								},
							},
						},
					},
				},
				Template: &argocd.ApplicationSetSpecTemplateArgs{
					Metadata: &argocd.ApplicationSetSpecTemplateMetadataArgs{
						Name: pulumi.String("{{cluster.name}}-git-files"),
					},
					Spec: &argocd.ApplicationSetSpecTemplateSpecArgs{
						Sources: argocd.ApplicationSetSpecTemplateSpecSourceArray{
							&argocd.ApplicationSetSpecTemplateSpecSourceArgs{
								RepoUrl:        pulumi.String("https://github.com/argoproj/argo-cd.git"),
								TargetRevision: pulumi.String("HEAD"),
								Path:           pulumi.String("applicationset/examples/git-generator-files-discovery/apps/guestbook"),
							},
						},
						Destination: &argocd.ApplicationSetSpecTemplateSpecDestinationArgs{
							Server:    pulumi.String("{{cluster.address}}"),
							Namespace: pulumi.String("guestbook"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		// List Generator
		_, err = argocd.NewApplicationSet(ctx, "list", &argocd.ApplicationSetArgs{
			Metadata: &argocd.ApplicationSetMetadataArgs{
				Name: pulumi.String("list"),
			},
			Spec: &argocd.ApplicationSetSpecArgs{
				Generators: argocd.ApplicationSetSpecGeneratorArray{
					&argocd.ApplicationSetSpecGeneratorArgs{
						Lists: argocd.ApplicationSetSpecGeneratorListArray{
							&argocd.ApplicationSetSpecGeneratorListArgs{
								Elements: pulumi.StringMapArray{
									pulumi.StringMap{
										"cluster": pulumi.String("engineering-dev"),
										"url":     pulumi.String("https://kubernetes.default.svc"),
									},
									pulumi.StringMap{
										"cluster": pulumi.String("engineering-prod"),
										"url":     pulumi.String("https://kubernetes.default.svc"),
										"foo":     pulumi.String("bar"),
									},
								},
							},
						},
					},
				},
				Template: &argocd.ApplicationSetSpecTemplateArgs{
					Metadata: &argocd.ApplicationSetSpecTemplateMetadataArgs{
						Name: pulumi.String("{{cluster}}-guestbook"),
					},
					Spec: &argocd.ApplicationSetSpecTemplateSpecArgs{
						Project: pulumi.String("my-project"),
						Sources: argocd.ApplicationSetSpecTemplateSpecSourceArray{
							&argocd.ApplicationSetSpecTemplateSpecSourceArgs{
								RepoUrl:        pulumi.String("https://github.com/argoproj/argo-cd.git"),
								TargetRevision: pulumi.String("HEAD"),
								Path:           pulumi.String("applicationset/examples/list-generator/guestbook/{{cluster}}"),
							},
						},
						Destination: &argocd.ApplicationSetSpecTemplateSpecDestinationArgs{
							Server:    pulumi.String("{{url}}"),
							Namespace: pulumi.String("guestbook"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		// Matrix Generator
		_, err = argocd.NewApplicationSet(ctx, "matrix", &argocd.ApplicationSetArgs{
			Metadata: &argocd.ApplicationSetMetadataArgs{
				Name: pulumi.String("matrix"),
			},
			Spec: &argocd.ApplicationSetSpecArgs{
				Generators: argocd.ApplicationSetSpecGeneratorArray{
					&argocd.ApplicationSetSpecGeneratorArgs{
						Matrices: argocd.ApplicationSetSpecGeneratorMatrixArray{
							&argocd.ApplicationSetSpecGeneratorMatrixArgs{
								Generators: argocd.ApplicationSetSpecGeneratorMatrixGeneratorArray{
									&argocd.ApplicationSetSpecGeneratorMatrixGeneratorArgs{
										Gits: argocd.ApplicationSetSpecGeneratorMatrixGeneratorGitArray{
											&argocd.ApplicationSetSpecGeneratorMatrixGeneratorGitArgs{
												RepoUrl:  pulumi.String("https://github.com/argoproj/argo-cd.git"),
												Revision: pulumi.String("HEAD"),
												Directories: argocd.ApplicationSetSpecGeneratorMatrixGeneratorGitDirectoryArray{
													&argocd.ApplicationSetSpecGeneratorMatrixGeneratorGitDirectoryArgs{
														Path: pulumi.String("applicationset/examples/matrix/cluster-addons/*"),
													},
												},
											},
										},
									},
									&argocd.ApplicationSetSpecGeneratorMatrixGeneratorArgs{
										Clusters: argocd.ApplicationSetSpecGeneratorMatrixGeneratorClusterArray{
											&argocd.ApplicationSetSpecGeneratorMatrixGeneratorClusterArgs{
												Selector: &argocd.ApplicationSetSpecGeneratorMatrixGeneratorClusterSelectorArgs{
													MatchLabels: pulumi.StringMap{
														"argocd.argoproj.io/secret-type": pulumi.String("cluster"),
													},
												},
											},
										},
									},
								},
							},
						},
					},
				},
				Template: &argocd.ApplicationSetSpecTemplateArgs{
					Metadata: &argocd.ApplicationSetSpecTemplateMetadataArgs{
						Name: pulumi.String("{{path.basename}}-{{name}}"),
					},
					Spec: &argocd.ApplicationSetSpecTemplateSpecArgs{
						Project: pulumi.String("default"),
						Sources: argocd.ApplicationSetSpecTemplateSpecSourceArray{
							&argocd.ApplicationSetSpecTemplateSpecSourceArgs{
								RepoUrl:        pulumi.String("https://github.com/argoproj/argo-cd.git"),
								TargetRevision: pulumi.String("HEAD"),
								Path:           pulumi.String("{{path}}"),
							},
						},
						Destination: &argocd.ApplicationSetSpecTemplateSpecDestinationArgs{
							Server:    pulumi.String("{{server}}"),
							Namespace: pulumi.String("{{path.basename}}"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		// Merge Generator
		_, err = argocd.NewApplicationSet(ctx, "merge", &argocd.ApplicationSetArgs{
			Metadata: &argocd.ApplicationSetMetadataArgs{
				Name: pulumi.String("merge"),
			},
			Spec: &argocd.ApplicationSetSpecArgs{
				Generators: argocd.ApplicationSetSpecGeneratorArray{
					&argocd.ApplicationSetSpecGeneratorArgs{
						Merges: argocd.ApplicationSetSpecGeneratorMergeArray{
							&argocd.ApplicationSetSpecGeneratorMergeArgs{
								MergeKeys: pulumi.StringArray{
									pulumi.String("server"),
								},
								Generators: argocd.ApplicationSetSpecGeneratorMergeGeneratorArray{
									&argocd.ApplicationSetSpecGeneratorMergeGeneratorArgs{
										Clusters: argocd.ApplicationSetSpecGeneratorMergeGeneratorClusterArray{
											&argocd.ApplicationSetSpecGeneratorMergeGeneratorClusterArgs{
												Values: pulumi.StringMap{
													"kafka": pulumi.String("true"),
													"redis": pulumi.String("false"),
												},
											},
										},
									},
									&argocd.ApplicationSetSpecGeneratorMergeGeneratorArgs{
										Clusters: argocd.ApplicationSetSpecGeneratorMergeGeneratorClusterArray{
											&argocd.ApplicationSetSpecGeneratorMergeGeneratorClusterArgs{
												Selector: &argocd.ApplicationSetSpecGeneratorMergeGeneratorClusterSelectorArgs{
													MatchLabels: pulumi.StringMap{
														"use-kafka": pulumi.String("false"),
													},
												},
												Values: pulumi.StringMap{
													"kafka": pulumi.String("false"),
												},
											},
										},
									},
									&argocd.ApplicationSetSpecGeneratorMergeGeneratorArgs{
										Lists: argocd.ApplicationSetSpecGeneratorMergeGeneratorListArray{
											&argocd.ApplicationSetSpecGeneratorMergeGeneratorListArgs{
												Elements: pulumi.StringMapArray{
													pulumi.StringMap{
														"server":       pulumi.String("https://2.4.6.8"),
														"values.redis": pulumi.String("true"),
													},
												},
											},
										},
									},
								},
							},
						},
					},
				},
				Template: &argocd.ApplicationSetSpecTemplateArgs{
					Metadata: &argocd.ApplicationSetSpecTemplateMetadataArgs{
						Name: pulumi.String("{{name}}"),
					},
					Spec: &argocd.ApplicationSetSpecTemplateSpecArgs{
						Project: pulumi.String("default"),
						Sources: argocd.ApplicationSetSpecTemplateSpecSourceArray{
							&argocd.ApplicationSetSpecTemplateSpecSourceArgs{
								RepoUrl:        pulumi.String("https://github.com/argoproj/argo-cd.git"),
								Path:           pulumi.String("app"),
								TargetRevision: pulumi.String("HEAD"),
								Helm: &argocd.ApplicationSetSpecTemplateSpecSourceHelmArgs{
									Parameters: argocd.ApplicationSetSpecTemplateSpecSourceHelmParameterArray{
										&argocd.ApplicationSetSpecTemplateSpecSourceHelmParameterArgs{
											Name:  pulumi.String("kafka"),
											Value: pulumi.String("{{values.kafka}}"),
										},
										&argocd.ApplicationSetSpecTemplateSpecSourceHelmParameterArgs{
											Name:  pulumi.String("redis"),
											Value: pulumi.String("{{values.redis}}"),
										},
									},
								},
							},
						},
						Destination: &argocd.ApplicationSetSpecTemplateSpecDestinationArgs{
							Server:    pulumi.String("{{server}}"),
							Namespace: pulumi.String("default"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		// Pull Request Generator - GitHub
		_, err = argocd.NewApplicationSet(ctx, "pr_github", &argocd.ApplicationSetArgs{
			Metadata: &argocd.ApplicationSetMetadataArgs{
				Name: pulumi.String("pr-github"),
			},
			Spec: &argocd.ApplicationSetSpecArgs{
				Generators: argocd.ApplicationSetSpecGeneratorArray{
					&argocd.ApplicationSetSpecGeneratorArgs{
						PullRequests: argocd.ApplicationSetSpecGeneratorPullRequestArray{
							&argocd.ApplicationSetSpecGeneratorPullRequestArgs{
								Github: &argocd.ApplicationSetSpecGeneratorPullRequestGithubArgs{
									Api:           pulumi.String("https://git.example.com/"),
									Owner:         pulumi.String("myorg"),
									Repo:          pulumi.String("myrepository"),
									AppSecretName: pulumi.String("github-app-repo-creds"),
									TokenRef: &argocd.ApplicationSetSpecGeneratorPullRequestGithubTokenRefArgs{
										SecretName: pulumi.String("github-token"),
										Key:        pulumi.String("token"),
									},
									Labels: pulumi.StringArray{
										pulumi.String("preview"),
									},
								},
							},
						},
					},
				},
				Template: &argocd.ApplicationSetSpecTemplateArgs{
					Metadata: &argocd.ApplicationSetSpecTemplateMetadataArgs{
						Name: pulumi.String("myapp-{{branch}}-{{number}}"),
					},
					Spec: &argocd.ApplicationSetSpecTemplateSpecArgs{
						Project: pulumi.String("default"),
						Sources: argocd.ApplicationSetSpecTemplateSpecSourceArray{
							&argocd.ApplicationSetSpecTemplateSpecSourceArgs{
								RepoUrl:        pulumi.String("https://github.com/myorg/myrepo.git"),
								Path:           pulumi.String("kubernetes/"),
								TargetRevision: pulumi.String("{{head_sha}}"),
								Helm: &argocd.ApplicationSetSpecTemplateSpecSourceHelmArgs{
									Parameters: argocd.ApplicationSetSpecTemplateSpecSourceHelmParameterArray{
										&argocd.ApplicationSetSpecTemplateSpecSourceHelmParameterArgs{
											Name:  pulumi.String("image.tag"),
											Value: pulumi.String("pull-{{head_sha}}"),
										},
									},
								},
							},
						},
						Destination: &argocd.ApplicationSetSpecTemplateSpecDestinationArgs{
							Server:    pulumi.String("https://kubernetes.default.svc"),
							Namespace: pulumi.String("default"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		// SCM Provider Generator - GitHub
		_, err = argocd.NewApplicationSet(ctx, "scm_github", &argocd.ApplicationSetArgs{
			Metadata: &argocd.ApplicationSetMetadataArgs{
				Name: pulumi.String("scm-github"),
			},
			Spec: &argocd.ApplicationSetSpecArgs{
				Generators: argocd.ApplicationSetSpecGeneratorArray{
					&argocd.ApplicationSetSpecGeneratorArgs{
						ScmProviders: argocd.ApplicationSetSpecGeneratorScmProviderArray{
							&argocd.ApplicationSetSpecGeneratorScmProviderArgs{
								Github: &argocd.ApplicationSetSpecGeneratorScmProviderGithubArgs{
									AppSecretName: pulumi.String("gh-app-repo-creds"),
									Organization:  pulumi.String("myorg"),
								},
							},
						},
					},
				},
				Template: &argocd.ApplicationSetSpecTemplateArgs{
					Metadata: &argocd.ApplicationSetSpecTemplateMetadataArgs{
						Name: pulumi.String("{{repository}}"),
					},
					Spec: &argocd.ApplicationSetSpecTemplateSpecArgs{
						Project: pulumi.String("default"),
						Sources: argocd.ApplicationSetSpecTemplateSpecSourceArray{
							&argocd.ApplicationSetSpecTemplateSpecSourceArgs{
								RepoUrl:        pulumi.String("{{url}}"),
								Path:           pulumi.String("kubernetes/"),
								TargetRevision: pulumi.String("{{branch}}"),
							},
						},
						Destination: &argocd.ApplicationSetSpecTemplateSpecDestinationArgs{
							Server:    pulumi.String("https://kubernetes.default.svc"),
							Namespace: pulumi.String("default"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		// Progressive Sync - Rolling Update
		_, err = argocd.NewApplicationSet(ctx, "progressive_sync", &argocd.ApplicationSetArgs{
			Metadata: &argocd.ApplicationSetMetadataArgs{
				Name: pulumi.String("progressive-sync"),
			},
			Spec: &argocd.ApplicationSetSpecArgs{
				Generators: argocd.ApplicationSetSpecGeneratorArray{
					&argocd.ApplicationSetSpecGeneratorArgs{
						Lists: argocd.ApplicationSetSpecGeneratorListArray{
							&argocd.ApplicationSetSpecGeneratorListArgs{
								Elements: pulumi.StringMapArray{
									pulumi.StringMap{
										"cluster": pulumi.String("engineering-dev"),
										"url":     pulumi.String("https://1.2.3.4"),
										"env":     pulumi.String("env-dev"),
									},
									pulumi.StringMap{
										"cluster": pulumi.String("engineering-qa"),
										"url":     pulumi.String("https://2.4.6.8"),
										"env":     pulumi.String("env-qa"),
									},
									pulumi.StringMap{
										"cluster": pulumi.String("engineering-prod"),
										"url":     pulumi.String("https://9.8.7.6/"),
										"env":     pulumi.String("env-prod"),
									},
								},
							},
						},
					},
				},
				Strategy: &argocd.ApplicationSetSpecStrategyArgs{
					Type: pulumi.String("RollingSync"),
					RollingSyncs: argocd.ApplicationSetSpecStrategyRollingSyncArray{
						&argocd.ApplicationSetSpecStrategyRollingSyncArgs{
							Steps: argocd.ApplicationSetSpecStrategyRollingSyncStepArray{
								&argocd.ApplicationSetSpecStrategyRollingSyncStepArgs{
									MatchExpressions: argocd.ApplicationSetSpecStrategyRollingSyncStepMatchExpressionArray{
										&argocd.ApplicationSetSpecStrategyRollingSyncStepMatchExpressionArgs{
											Key:      pulumi.String("envLabel"),
											Operator: pulumi.String("In"),
											Values: pulumi.StringArray{
												pulumi.String("env-dev"),
											},
										},
									},
								},
								&argocd.ApplicationSetSpecStrategyRollingSyncStepArgs{
									MatchExpressions: argocd.ApplicationSetSpecStrategyRollingSyncStepMatchExpressionArray{
										&argocd.ApplicationSetSpecStrategyRollingSyncStepMatchExpressionArgs{
											Key:      pulumi.String("envLabel"),
											Operator: pulumi.String("In"),
											Values: pulumi.StringArray{
												pulumi.String("env-qa"),
											},
										},
									},
									MaxUpdate: pulumi.String("0"),
								},
								&argocd.ApplicationSetSpecStrategyRollingSyncStepArgs{
									MatchExpressions: argocd.ApplicationSetSpecStrategyRollingSyncStepMatchExpressionArray{
										&argocd.ApplicationSetSpecStrategyRollingSyncStepMatchExpressionArgs{
											Key:      pulumi.String("envLabel"),
											Operator: pulumi.String("In"),
											Values: pulumi.StringArray{
												pulumi.String("env-prod"),
											},
										},
									},
									MaxUpdate: pulumi.String("10%"),
								},
							},
						},
					},
				},
				GoTemplate: pulumi.Bool(true),
				Template: &argocd.ApplicationSetSpecTemplateArgs{
					Metadata: &argocd.ApplicationSetSpecTemplateMetadataArgs{
						Name: pulumi.String("{{.cluster}}-guestbook"),
						Labels: pulumi.StringMap{
							"envLabel": pulumi.String("{{.env}}"),
						},
					},
					Spec: &argocd.ApplicationSetSpecTemplateSpecArgs{
						Project: pulumi.String("default"),
						Sources: argocd.ApplicationSetSpecTemplateSpecSourceArray{
							&argocd.ApplicationSetSpecTemplateSpecSourceArgs{
								RepoUrl:        pulumi.String("https://github.com/infra-team/cluster-deployments.git"),
								Path:           pulumi.String("guestbook/{{.cluster}}"),
								TargetRevision: pulumi.String("HEAD"),
							},
						},
						Destination: &argocd.ApplicationSetSpecTemplateSpecDestinationArgs{
							Server:    pulumi.String("{{.url}}"),
							Namespace: pulumi.String("guestbook"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}