gcp.cloudbuild.Trigger

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

return await Deployment.RunAsync(() => 
{
    var filename_trigger = new Gcp.CloudBuild.Trigger("filename-trigger", new()
    {
        Filename = "cloudbuild.yaml",
        Location = "us-central1",
        Substitutions = 
        {
            { "_BAZ", "qux" },
            { "_FOO", "bar" },
        },
        TriggerTemplate = new Gcp.CloudBuild.Inputs.TriggerTriggerTemplateArgs
        {
            BranchName = "main",
            RepoName = "my-repo",
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/cloudbuild"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudbuild.NewTrigger(ctx, "filename-trigger", &cloudbuild.TriggerArgs{
			Filename: pulumi.String("cloudbuild.yaml"),
			Location: pulumi.String("us-central1"),
			Substitutions: pulumi.StringMap{
				"_BAZ": pulumi.String("qux"),
				"_FOO": pulumi.String("bar"),
			},
			TriggerTemplate: &cloudbuild.TriggerTriggerTemplateArgs{
				BranchName: pulumi.String("main"),
				RepoName:   pulumi.String("my-repo"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.cloudbuild.Trigger;
import com.pulumi.gcp.cloudbuild.TriggerArgs;
import com.pulumi.gcp.cloudbuild.inputs.TriggerTriggerTemplateArgs;
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 filename_trigger = new Trigger("filename-trigger", TriggerArgs.builder()        
            .filename("cloudbuild.yaml")
            .location("us-central1")
            .substitutions(Map.ofEntries(
                Map.entry("_BAZ", "qux"),
                Map.entry("_FOO", "bar")
            ))
            .triggerTemplate(TriggerTriggerTemplateArgs.builder()
                .branchName("main")
                .repoName("my-repo")
                .build())
            .build());

    }
}

import pulumi
import pulumi_gcp as gcp

filename_trigger = gcp.cloudbuild.Trigger("filename-trigger",
    filename="cloudbuild.yaml",
    location="us-central1",
    substitutions={
        "_BAZ": "qux",
        "_FOO": "bar",
    },
    trigger_template=gcp.cloudbuild.TriggerTriggerTemplateArgs(
        branch_name="main",
        repo_name="my-repo",
    ))

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

const filename_trigger = new gcp.cloudbuild.Trigger("filename-trigger", {
    filename: "cloudbuild.yaml",
    location: "us-central1",
    substitutions: {
        _BAZ: "qux",
        _FOO: "bar",
    },
    triggerTemplate: {
        branchName: "main",
        repoName: "my-repo",
    },
});

resources:
  filename-trigger:
    type: gcp:cloudbuild:Trigger
    properties:
      filename: cloudbuild.yaml
      location: us-central1
      substitutions:
        _BAZ: qux
        _FOO: bar
      triggerTemplate:
        branchName: main
        repoName: my-repo

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

return await Deployment.RunAsync(() => 
{
    var project = Gcp.Organizations.GetProject.Invoke();

    var cloudbuildServiceAccount = new Gcp.ServiceAccount.Account("cloudbuildServiceAccount", new()
    {
        AccountId = "cloud-sa",
    });

    var actAs = new Gcp.Projects.IAMMember("actAs", new()
    {
        Project = project.Apply(getProjectResult => getProjectResult.ProjectId),
        Role = "roles/iam.serviceAccountUser",
        Member = cloudbuildServiceAccount.Email.Apply(email => $"serviceAccount:{email}"),
    });

    var logsWriter = new Gcp.Projects.IAMMember("logsWriter", new()
    {
        Project = project.Apply(getProjectResult => getProjectResult.ProjectId),
        Role = "roles/logging.logWriter",
        Member = cloudbuildServiceAccount.Email.Apply(email => $"serviceAccount:{email}"),
    });

    var service_account_trigger = new Gcp.CloudBuild.Trigger("service-account-trigger", new()
    {
        TriggerTemplate = new Gcp.CloudBuild.Inputs.TriggerTriggerTemplateArgs
        {
            BranchName = "main",
            RepoName = "my-repo",
        },
        ServiceAccount = cloudbuildServiceAccount.Id,
        Filename = "cloudbuild.yaml",
    }, new CustomResourceOptions
    {
        DependsOn = new[]
        {
            actAs,
            logsWriter,
        },
    });

});

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/cloudbuild"
	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/organizations"
	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/projects"
	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/serviceAccount"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		project, err := organizations.LookupProject(ctx, nil, nil)
		if err != nil {
			return err
		}
		cloudbuildServiceAccount, err := serviceAccount.NewAccount(ctx, "cloudbuildServiceAccount", &serviceAccount.AccountArgs{
			AccountId: pulumi.String("cloud-sa"),
		})
		if err != nil {
			return err
		}
		actAs, err := projects.NewIAMMember(ctx, "actAs", &projects.IAMMemberArgs{
			Project: *pulumi.String(project.ProjectId),
			Role:    pulumi.String("roles/iam.serviceAccountUser"),
			Member: cloudbuildServiceAccount.Email.ApplyT(func(email string) (string, error) {
				return fmt.Sprintf("serviceAccount:%v", email), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		logsWriter, err := projects.NewIAMMember(ctx, "logsWriter", &projects.IAMMemberArgs{
			Project: *pulumi.String(project.ProjectId),
			Role:    pulumi.String("roles/logging.logWriter"),
			Member: cloudbuildServiceAccount.Email.ApplyT(func(email string) (string, error) {
				return fmt.Sprintf("serviceAccount:%v", email), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		_, err = cloudbuild.NewTrigger(ctx, "service-account-trigger", &cloudbuild.TriggerArgs{
			TriggerTemplate: &cloudbuild.TriggerTriggerTemplateArgs{
				BranchName: pulumi.String("main"),
				RepoName:   pulumi.String("my-repo"),
			},
			ServiceAccount: cloudbuildServiceAccount.ID(),
			Filename:       pulumi.String("cloudbuild.yaml"),
		}, pulumi.DependsOn([]pulumi.Resource{
			actAs,
			logsWriter,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.cloudbuild.Trigger;
import com.pulumi.gcp.cloudbuild.TriggerArgs;
import com.pulumi.gcp.cloudbuild.inputs.TriggerBuildArgs;
import com.pulumi.gcp.cloudbuild.inputs.TriggerBuildArtifactsArgs;
import com.pulumi.gcp.cloudbuild.inputs.TriggerBuildArtifactsObjectsArgs;
import com.pulumi.gcp.cloudbuild.inputs.TriggerBuildAvailableSecretsArgs;
import com.pulumi.gcp.cloudbuild.inputs.TriggerBuildOptionsArgs;
import com.pulumi.gcp.cloudbuild.inputs.TriggerBuildSourceArgs;
import com.pulumi.gcp.cloudbuild.inputs.TriggerBuildSourceStorageSourceArgs;
import com.pulumi.gcp.cloudbuild.inputs.TriggerTriggerTemplateArgs;
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 build_trigger = new Trigger("build-trigger", TriggerArgs.builder()        
            .build(TriggerBuildArgs.builder()
                .artifacts(TriggerBuildArtifactsArgs.builder()
                    .images("gcr.io/$PROJECT_ID/$REPO_NAME:$COMMIT_SHA")
                    .objects(TriggerBuildArtifactsObjectsArgs.builder()
                        .location("gs://bucket/path/to/somewhere/")
                        .paths("path")
                        .build())
                    .build())
                .availableSecrets(TriggerBuildAvailableSecretsArgs.builder()
                    .secretManager(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                    .build())
                .logsBucket("gs://mybucket/logs")
                .options(TriggerBuildOptionsArgs.builder()
                    .diskSizeGb(100)
                    .dynamicSubstitutions(true)
                    .env("ekey = evalue")
                    .logStreamingOption("STREAM_OFF")
                    .logging("LEGACY")
                    .machineType("N1_HIGHCPU_8")
                    .requestedVerifyOption("VERIFIED")
                    .secretEnv("secretenv = svalue")
                    .sourceProvenanceHash("MD5")
                    .substitutionOption("ALLOW_LOOSE")
                    .volumes(TriggerBuildOptionsVolumeArgs.builder()
                        .name("v1")
                        .path("v1")
                        .build())
                    .workerPool("pool")
                    .build())
                .queueTtl("20s")
                .secrets(TriggerBuildSecretArgs.builder()
                    .kmsKeyName("projects/myProject/locations/global/keyRings/keyring-name/cryptoKeys/key-name")
                    .secretEnv(Map.of("PASSWORD", "ZW5jcnlwdGVkLXBhc3N3b3JkCg=="))
                    .build())
                .source(TriggerBuildSourceArgs.builder()
                    .storageSource(TriggerBuildSourceStorageSourceArgs.builder()
                        .bucket("mybucket")
                        .object("source_code.tar.gz")
                        .build())
                    .build())
                .steps(                
                    TriggerBuildStepArgs.builder()
                        .args(                        
                            "cp",
                            "gs://mybucket/remotefile.zip",
                            "localfile.zip")
                        .name("gcr.io/cloud-builders/gsutil")
                        .secretEnv("MY_SECRET")
                        .timeout("120s")
                        .build(),
                    TriggerBuildStepArgs.builder()
                        .name("ubuntu")
                        .script("echo hello")
                        .build())
                .substitutions(Map.ofEntries(
                    Map.entry("_BAZ", "qux"),
                    Map.entry("_FOO", "bar")
                ))
                .tags(                
                    "build",
                    "newFeature")
                .build())
            .location("global")
            .triggerTemplate(TriggerTriggerTemplateArgs.builder()
                .branchName("main")
                .repoName("my-repo")
                .build())
            .build());

    }
}

import pulumi
import pulumi_gcp as gcp

project = gcp.organizations.get_project()
cloudbuild_service_account = gcp.service_account.Account("cloudbuildServiceAccount", account_id="cloud-sa")
act_as = gcp.projects.IAMMember("actAs",
    project=project.project_id,
    role="roles/iam.serviceAccountUser",
    member=cloudbuild_service_account.email.apply(lambda email: f"serviceAccount:{email}"))
logs_writer = gcp.projects.IAMMember("logsWriter",
    project=project.project_id,
    role="roles/logging.logWriter",
    member=cloudbuild_service_account.email.apply(lambda email: f"serviceAccount:{email}"))
service_account_trigger = gcp.cloudbuild.Trigger("service-account-trigger",
    trigger_template=gcp.cloudbuild.TriggerTriggerTemplateArgs(
        branch_name="main",
        repo_name="my-repo",
    ),
    service_account=cloudbuild_service_account.id,
    filename="cloudbuild.yaml",
    opts=pulumi.ResourceOptions(depends_on=[
            act_as,
            logs_writer,
        ]))

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

const project = gcp.organizations.getProject({});
const cloudbuildServiceAccount = new gcp.serviceaccount.Account("cloudbuildServiceAccount", {accountId: "cloud-sa"});
const actAs = new gcp.projects.IAMMember("actAs", {
    project: project.then(project => project.projectId),
    role: "roles/iam.serviceAccountUser",
    member: pulumi.interpolate`serviceAccount:${cloudbuildServiceAccount.email}`,
});
const logsWriter = new gcp.projects.IAMMember("logsWriter", {
    project: project.then(project => project.projectId),
    role: "roles/logging.logWriter",
    member: pulumi.interpolate`serviceAccount:${cloudbuildServiceAccount.email}`,
});
const service_account_trigger = new gcp.cloudbuild.Trigger("service-account-trigger", {
    triggerTemplate: {
        branchName: "main",
        repoName: "my-repo",
    },
    serviceAccount: cloudbuildServiceAccount.id,
    filename: "cloudbuild.yaml",
}, {
    dependsOn: [
        actAs,
        logsWriter,
    ],
});

resources:
  build-trigger:
    type: gcp:cloudbuild:Trigger
    properties:
      build:
        artifacts:
          images:
            - gcr.io/$PROJECT_ID/$REPO_NAME:$COMMIT_SHA
          objects:
            location: gs://bucket/path/to/somewhere/
            paths:
              - path
        availableSecrets:
          secretManager:
            - env: MY_SECRET
              versionName: projects/myProject/secrets/mySecret/versions/latest
        logsBucket: gs://mybucket/logs
        options:
          diskSizeGb: 100
          dynamicSubstitutions: true
          env:
            - ekey = evalue
          logStreamingOption: STREAM_OFF
          logging: LEGACY
          machineType: N1_HIGHCPU_8
          requestedVerifyOption: VERIFIED
          secretEnv:
            - secretenv = svalue
          sourceProvenanceHash:
            - MD5
          substitutionOption: ALLOW_LOOSE
          volumes:
            - name: v1
              path: v1
          workerPool: pool
        queueTtl: 20s
        secrets:
          - kmsKeyName: projects/myProject/locations/global/keyRings/keyring-name/cryptoKeys/key-name
            secretEnv:
              PASSWORD: ZW5jcnlwdGVkLXBhc3N3b3JkCg==
        source:
          storageSource:
            bucket: mybucket
            object: source_code.tar.gz
        steps:
          - args:
              - cp
              - gs://mybucket/remotefile.zip
              - localfile.zip
            name: gcr.io/cloud-builders/gsutil
            secretEnv:
              - MY_SECRET
            timeout: 120s
          - name: ubuntu
            script: echo hello
        substitutions:
          _BAZ: qux
          _FOO: bar
        tags:
          - build
          - newFeature
      location: global
      triggerTemplate:
        branchName: main
        repoName: my-repo

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

return await Deployment.RunAsync(() => 
{
    var include_build_logs_trigger = new Gcp.CloudBuild.Trigger("include-build-logs-trigger", new()
    {
        Filename = "cloudbuild.yaml",
        Github = new Gcp.CloudBuild.Inputs.TriggerGithubArgs
        {
            Name = "terraform-provider-google-beta",
            Owner = "hashicorp",
            Push = new Gcp.CloudBuild.Inputs.TriggerGithubPushArgs
            {
                Branch = "^main$",
            },
        },
        IncludeBuildLogs = "INCLUDE_BUILD_LOGS_WITH_STATUS",
        Location = "us-central1",
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/cloudbuild"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudbuild.NewTrigger(ctx, "include-build-logs-trigger", &cloudbuild.TriggerArgs{
			Filename: pulumi.String("cloudbuild.yaml"),
			Github: &cloudbuild.TriggerGithubArgs{
				Name:  pulumi.String("terraform-provider-google-beta"),
				Owner: pulumi.String("hashicorp"),
				Push: &cloudbuild.TriggerGithubPushArgs{
					Branch: pulumi.String("^main$"),
				},
			},
			IncludeBuildLogs: pulumi.String("INCLUDE_BUILD_LOGS_WITH_STATUS"),
			Location:         pulumi.String("us-central1"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.organizations.OrganizationsFunctions;
import com.pulumi.gcp.organizations.inputs.GetProjectArgs;
import com.pulumi.gcp.serviceAccount.Account;
import com.pulumi.gcp.serviceAccount.AccountArgs;
import com.pulumi.gcp.projects.IAMMember;
import com.pulumi.gcp.projects.IAMMemberArgs;
import com.pulumi.gcp.cloudbuild.Trigger;
import com.pulumi.gcp.cloudbuild.TriggerArgs;
import com.pulumi.gcp.cloudbuild.inputs.TriggerTriggerTemplateArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        final var project = OrganizationsFunctions.getProject();

        var cloudbuildServiceAccount = new Account("cloudbuildServiceAccount", AccountArgs.builder()        
            .accountId("cloud-sa")
            .build());

        var actAs = new IAMMember("actAs", IAMMemberArgs.builder()        
            .project(project.applyValue(getProjectResult -> getProjectResult.projectId()))
            .role("roles/iam.serviceAccountUser")
            .member(cloudbuildServiceAccount.email().applyValue(email -> String.format("serviceAccount:%s", email)))
            .build());

        var logsWriter = new IAMMember("logsWriter", IAMMemberArgs.builder()        
            .project(project.applyValue(getProjectResult -> getProjectResult.projectId()))
            .role("roles/logging.logWriter")
            .member(cloudbuildServiceAccount.email().applyValue(email -> String.format("serviceAccount:%s", email)))
            .build());

        var service_account_trigger = new Trigger("service-account-trigger", TriggerArgs.builder()        
            .triggerTemplate(TriggerTriggerTemplateArgs.builder()
                .branchName("main")
                .repoName("my-repo")
                .build())
            .serviceAccount(cloudbuildServiceAccount.id())
            .filename("cloudbuild.yaml")
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    actAs,
                    logsWriter)
                .build());

    }
}

import pulumi
import pulumi_gcp as gcp

include_build_logs_trigger = gcp.cloudbuild.Trigger("include-build-logs-trigger",
    filename="cloudbuild.yaml",
    github=gcp.cloudbuild.TriggerGithubArgs(
        name="terraform-provider-google-beta",
        owner="hashicorp",
        push=gcp.cloudbuild.TriggerGithubPushArgs(
            branch="^main$",
        ),
    ),
    include_build_logs="INCLUDE_BUILD_LOGS_WITH_STATUS",
    location="us-central1")

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

const include_build_logs_trigger = new gcp.cloudbuild.Trigger("include-build-logs-trigger", {
    filename: "cloudbuild.yaml",
    github: {
        name: "terraform-provider-google-beta",
        owner: "hashicorp",
        push: {
            branch: "^main$",
        },
    },
    includeBuildLogs: "INCLUDE_BUILD_LOGS_WITH_STATUS",
    location: "us-central1",
});

resources:
  service-account-trigger:
    type: gcp:cloudbuild:Trigger
    properties:
      triggerTemplate:
        branchName: main
        repoName: my-repo
      serviceAccount: ${cloudbuildServiceAccount.id}
      filename: cloudbuild.yaml
    options:
      dependson:
        - ${actAs}
        - ${logsWriter}
  cloudbuildServiceAccount:
    type: gcp:serviceAccount:Account
    properties:
      accountId: cloud-sa
  actAs:
    type: gcp:projects:IAMMember
    properties:
      project: ${project.projectId}
      role: roles/iam.serviceAccountUser
      member: serviceAccount:${cloudbuildServiceAccount.email}
  logsWriter:
    type: gcp:projects:IAMMember
    properties:
      project: ${project.projectId}
      role: roles/logging.logWriter
      member: serviceAccount:${cloudbuildServiceAccount.email}
variables:
  project:
    fn::invoke:
      Function: gcp:organizations:getProject
      Arguments: {}

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

return await Deployment.RunAsync(() => 
{
    var mytopic = new Gcp.PubSub.Topic("mytopic");

    var pubsub_config_trigger = new Gcp.CloudBuild.Trigger("pubsub-config-trigger", new()
    {
        Location = "us-central1",
        Description = "acceptance test example pubsub build trigger",
        PubsubConfig = new Gcp.CloudBuild.Inputs.TriggerPubsubConfigArgs
        {
            Topic = mytopic.Id,
        },
        SourceToBuild = new Gcp.CloudBuild.Inputs.TriggerSourceToBuildArgs
        {
            Uri = "https://hashicorp/terraform-provider-google-beta",
            Ref = "refs/heads/main",
            RepoType = "GITHUB",
        },
        GitFileSource = new Gcp.CloudBuild.Inputs.TriggerGitFileSourceArgs
        {
            Path = "cloudbuild.yaml",
            Uri = "https://hashicorp/terraform-provider-google-beta",
            Revision = "refs/heads/main",
            RepoType = "GITHUB",
        },
        Substitutions = 
        {
            { "_ACTION", "$(body.message.data.action)" },
        },
        Filter = "_ACTION.matches('INSERT')",
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/cloudbuild"
	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/pubsub"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		mytopic, err := pubsub.NewTopic(ctx, "mytopic", nil)
		if err != nil {
			return err
		}
		_, err = cloudbuild.NewTrigger(ctx, "pubsub-config-trigger", &cloudbuild.TriggerArgs{
			Location:    pulumi.String("us-central1"),
			Description: pulumi.String("acceptance test example pubsub build trigger"),
			PubsubConfig: &cloudbuild.TriggerPubsubConfigArgs{
				Topic: mytopic.ID(),
			},
			SourceToBuild: &cloudbuild.TriggerSourceToBuildArgs{
				Uri:      pulumi.String("https://hashicorp/terraform-provider-google-beta"),
				Ref:      pulumi.String("refs/heads/main"),
				RepoType: pulumi.String("GITHUB"),
			},
			GitFileSource: &cloudbuild.TriggerGitFileSourceArgs{
				Path:     pulumi.String("cloudbuild.yaml"),
				Uri:      pulumi.String("https://hashicorp/terraform-provider-google-beta"),
				Revision: pulumi.String("refs/heads/main"),
				RepoType: pulumi.String("GITHUB"),
			},
			Substitutions: pulumi.StringMap{
				"_ACTION": pulumi.String("$(body.message.data.action)"),
			},
			Filter: pulumi.String("_ACTION.matches('INSERT')"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.cloudbuild.Trigger;
import com.pulumi.gcp.cloudbuild.TriggerArgs;
import com.pulumi.gcp.cloudbuild.inputs.TriggerGithubArgs;
import com.pulumi.gcp.cloudbuild.inputs.TriggerGithubPushArgs;
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 include_build_logs_trigger = new Trigger("include-build-logs-trigger", TriggerArgs.builder()        
            .filename("cloudbuild.yaml")
            .github(TriggerGithubArgs.builder()
                .name("terraform-provider-google-beta")
                .owner("hashicorp")
                .push(TriggerGithubPushArgs.builder()
                    .branch("^main$")
                    .build())
                .build())
            .includeBuildLogs("INCLUDE_BUILD_LOGS_WITH_STATUS")
            .location("us-central1")
            .build());

    }
}

import pulumi
import pulumi_gcp as gcp

mytopic = gcp.pubsub.Topic("mytopic")
pubsub_config_trigger = gcp.cloudbuild.Trigger("pubsub-config-trigger",
    location="us-central1",
    description="acceptance test example pubsub build trigger",
    pubsub_config=gcp.cloudbuild.TriggerPubsubConfigArgs(
        topic=mytopic.id,
    ),
    source_to_build=gcp.cloudbuild.TriggerSourceToBuildArgs(
        uri="https://hashicorp/terraform-provider-google-beta",
        ref="refs/heads/main",
        repo_type="GITHUB",
    ),
    git_file_source=gcp.cloudbuild.TriggerGitFileSourceArgs(
        path="cloudbuild.yaml",
        uri="https://hashicorp/terraform-provider-google-beta",
        revision="refs/heads/main",
        repo_type="GITHUB",
    ),
    substitutions={
        "_ACTION": "$(body.message.data.action)",
    },
    filter="_ACTION.matches('INSERT')")

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

const mytopic = new gcp.pubsub.Topic("mytopic", {});
const pubsub_config_trigger = new gcp.cloudbuild.Trigger("pubsub-config-trigger", {
    location: "us-central1",
    description: "acceptance test example pubsub build trigger",
    pubsubConfig: {
        topic: mytopic.id,
    },
    sourceToBuild: {
        uri: "https://hashicorp/terraform-provider-google-beta",
        ref: "refs/heads/main",
        repoType: "GITHUB",
    },
    gitFileSource: {
        path: "cloudbuild.yaml",
        uri: "https://hashicorp/terraform-provider-google-beta",
        revision: "refs/heads/main",
        repoType: "GITHUB",
    },
    substitutions: {
        _ACTION: "$(body.message.data.action)",
    },
    filter: "_ACTION.matches('INSERT')",
});

resources:
  include-build-logs-trigger:
    type: gcp:cloudbuild:Trigger
    properties:
      filename: cloudbuild.yaml
      github:
        name: terraform-provider-google-beta
        owner: hashicorp
        push:
          branch: ^main$
      includeBuildLogs: INCLUDE_BUILD_LOGS_WITH_STATUS
      location: us-central1

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

return await Deployment.RunAsync(() => 
{
    var webhookTriggerSecretKey = new Gcp.SecretManager.Secret("webhookTriggerSecretKey", new()
    {
        SecretId = "webhook-trigger-secret-key",
        Replication = new Gcp.SecretManager.Inputs.SecretReplicationArgs
        {
            UserManaged = new Gcp.SecretManager.Inputs.SecretReplicationUserManagedArgs
            {
                Replicas = new[]
                {
                    new Gcp.SecretManager.Inputs.SecretReplicationUserManagedReplicaArgs
                    {
                        Location = "us-central1",
                    },
                },
            },
        },
    });

    var webhookTriggerSecretKeyData = new Gcp.SecretManager.SecretVersion("webhookTriggerSecretKeyData", new()
    {
        Secret = webhookTriggerSecretKey.Id,
        SecretData = "secretkeygoeshere",
    });

    var project = Gcp.Organizations.GetProject.Invoke();

    var secretAccessor = Gcp.Organizations.GetIAMPolicy.Invoke(new()
    {
        Bindings = new[]
        {
            new Gcp.Organizations.Inputs.GetIAMPolicyBindingInputArgs
            {
                Role = "roles/secretmanager.secretAccessor",
                Members = new[]
                {
                    $"serviceAccount:service-{project.Apply(getProjectResult => getProjectResult.Number)}@gcp-sa-cloudbuild.iam.gserviceaccount.com",
                },
            },
        },
    });

    var policy = new Gcp.SecretManager.SecretIamPolicy("policy", new()
    {
        Project = webhookTriggerSecretKey.Project,
        SecretId = webhookTriggerSecretKey.SecretId,
        PolicyData = secretAccessor.Apply(getIAMPolicyResult => getIAMPolicyResult.PolicyData),
    });

    var webhook_config_trigger = new Gcp.CloudBuild.Trigger("webhook-config-trigger", new()
    {
        Description = "acceptance test example webhook build trigger",
        WebhookConfig = new Gcp.CloudBuild.Inputs.TriggerWebhookConfigArgs
        {
            Secret = webhookTriggerSecretKeyData.Id,
        },
        SourceToBuild = new Gcp.CloudBuild.Inputs.TriggerSourceToBuildArgs
        {
            Uri = "https://hashicorp/terraform-provider-google-beta",
            Ref = "refs/heads/main",
            RepoType = "GITHUB",
        },
        GitFileSource = new Gcp.CloudBuild.Inputs.TriggerGitFileSourceArgs
        {
            Path = "cloudbuild.yaml",
            Uri = "https://hashicorp/terraform-provider-google-beta",
            Revision = "refs/heads/main",
            RepoType = "GITHUB",
        },
    });

});

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/cloudbuild"
	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/organizations"
	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/secretmanager"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		webhookTriggerSecretKey, err := secretmanager.NewSecret(ctx, "webhookTriggerSecretKey", &secretmanager.SecretArgs{
			SecretId: pulumi.String("webhook-trigger-secret-key"),
			Replication: &secretmanager.SecretReplicationArgs{
				UserManaged: &secretmanager.SecretReplicationUserManagedArgs{
					Replicas: secretmanager.SecretReplicationUserManagedReplicaArray{
						&secretmanager.SecretReplicationUserManagedReplicaArgs{
							Location: pulumi.String("us-central1"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		webhookTriggerSecretKeyData, err := secretmanager.NewSecretVersion(ctx, "webhookTriggerSecretKeyData", &secretmanager.SecretVersionArgs{
			Secret:     webhookTriggerSecretKey.ID(),
			SecretData: pulumi.String("secretkeygoeshere"),
		})
		if err != nil {
			return err
		}
		project, err := organizations.LookupProject(ctx, nil, nil)
		if err != nil {
			return err
		}
		secretAccessor, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/secretmanager.secretAccessor",
					Members: []string{
						fmt.Sprintf("serviceAccount:service-%v@gcp-sa-cloudbuild.iam.gserviceaccount.com", project.Number),
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = secretmanager.NewSecretIamPolicy(ctx, "policy", &secretmanager.SecretIamPolicyArgs{
			Project:    webhookTriggerSecretKey.Project,
			SecretId:   webhookTriggerSecretKey.SecretId,
			PolicyData: *pulumi.String(secretAccessor.PolicyData),
		})
		if err != nil {
			return err
		}
		_, err = cloudbuild.NewTrigger(ctx, "webhook-config-trigger", &cloudbuild.TriggerArgs{
			Description: pulumi.String("acceptance test example webhook build trigger"),
			WebhookConfig: &cloudbuild.TriggerWebhookConfigArgs{
				Secret: webhookTriggerSecretKeyData.ID(),
			},
			SourceToBuild: &cloudbuild.TriggerSourceToBuildArgs{
				Uri:      pulumi.String("https://hashicorp/terraform-provider-google-beta"),
				Ref:      pulumi.String("refs/heads/main"),
				RepoType: pulumi.String("GITHUB"),
			},
			GitFileSource: &cloudbuild.TriggerGitFileSourceArgs{
				Path:     pulumi.String("cloudbuild.yaml"),
				Uri:      pulumi.String("https://hashicorp/terraform-provider-google-beta"),
				Revision: pulumi.String("refs/heads/main"),
				RepoType: pulumi.String("GITHUB"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.pubsub.Topic;
import com.pulumi.gcp.cloudbuild.Trigger;
import com.pulumi.gcp.cloudbuild.TriggerArgs;
import com.pulumi.gcp.cloudbuild.inputs.TriggerPubsubConfigArgs;
import com.pulumi.gcp.cloudbuild.inputs.TriggerSourceToBuildArgs;
import com.pulumi.gcp.cloudbuild.inputs.TriggerGitFileSourceArgs;
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 mytopic = new Topic("mytopic");

        var pubsub_config_trigger = new Trigger("pubsub-config-trigger", TriggerArgs.builder()        
            .location("us-central1")
            .description("acceptance test example pubsub build trigger")
            .pubsubConfig(TriggerPubsubConfigArgs.builder()
                .topic(mytopic.id())
                .build())
            .sourceToBuild(TriggerSourceToBuildArgs.builder()
                .uri("https://hashicorp/terraform-provider-google-beta")
                .ref("refs/heads/main")
                .repoType("GITHUB")
                .build())
            .gitFileSource(TriggerGitFileSourceArgs.builder()
                .path("cloudbuild.yaml")
                .uri("https://hashicorp/terraform-provider-google-beta")
                .revision("refs/heads/main")
                .repoType("GITHUB")
                .build())
            .substitutions(Map.of("_ACTION", "$(body.message.data.action)"))
            .filter("_ACTION.matches('INSERT')")
            .build());

    }
}

import pulumi
import pulumi_gcp as gcp

webhook_trigger_secret_key = gcp.secretmanager.Secret("webhookTriggerSecretKey",
    secret_id="webhook-trigger-secret-key",
    replication=gcp.secretmanager.SecretReplicationArgs(
        user_managed=gcp.secretmanager.SecretReplicationUserManagedArgs(
            replicas=[gcp.secretmanager.SecretReplicationUserManagedReplicaArgs(
                location="us-central1",
            )],
        ),
    ))
webhook_trigger_secret_key_data = gcp.secretmanager.SecretVersion("webhookTriggerSecretKeyData",
    secret=webhook_trigger_secret_key.id,
    secret_data="secretkeygoeshere")
project = gcp.organizations.get_project()
secret_accessor = gcp.organizations.get_iam_policy(bindings=[gcp.organizations.GetIAMPolicyBindingArgs(
    role="roles/secretmanager.secretAccessor",
    members=[f"serviceAccount:service-{project.number}@gcp-sa-cloudbuild.iam.gserviceaccount.com"],
)])
policy = gcp.secretmanager.SecretIamPolicy("policy",
    project=webhook_trigger_secret_key.project,
    secret_id=webhook_trigger_secret_key.secret_id,
    policy_data=secret_accessor.policy_data)
webhook_config_trigger = gcp.cloudbuild.Trigger("webhook-config-trigger",
    description="acceptance test example webhook build trigger",
    webhook_config=gcp.cloudbuild.TriggerWebhookConfigArgs(
        secret=webhook_trigger_secret_key_data.id,
    ),
    source_to_build=gcp.cloudbuild.TriggerSourceToBuildArgs(
        uri="https://hashicorp/terraform-provider-google-beta",
        ref="refs/heads/main",
        repo_type="GITHUB",
    ),
    git_file_source=gcp.cloudbuild.TriggerGitFileSourceArgs(
        path="cloudbuild.yaml",
        uri="https://hashicorp/terraform-provider-google-beta",
        revision="refs/heads/main",
        repo_type="GITHUB",
    ))

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

const webhookTriggerSecretKey = new gcp.secretmanager.Secret("webhookTriggerSecretKey", {
    secretId: "webhook-trigger-secret-key",
    replication: {
        userManaged: {
            replicas: [{
                location: "us-central1",
            }],
        },
    },
});
const webhookTriggerSecretKeyData = new gcp.secretmanager.SecretVersion("webhookTriggerSecretKeyData", {
    secret: webhookTriggerSecretKey.id,
    secretData: "secretkeygoeshere",
});
const project = gcp.organizations.getProject({});
const secretAccessor = project.then(project => gcp.organizations.getIAMPolicy({
    bindings: [{
        role: "roles/secretmanager.secretAccessor",
        members: [`serviceAccount:service-${project.number}@gcp-sa-cloudbuild.iam.gserviceaccount.com`],
    }],
}));
const policy = new gcp.secretmanager.SecretIamPolicy("policy", {
    project: webhookTriggerSecretKey.project,
    secretId: webhookTriggerSecretKey.secretId,
    policyData: secretAccessor.then(secretAccessor => secretAccessor.policyData),
});
const webhook_config_trigger = new gcp.cloudbuild.Trigger("webhook-config-trigger", {
    description: "acceptance test example webhook build trigger",
    webhookConfig: {
        secret: webhookTriggerSecretKeyData.id,
    },
    sourceToBuild: {
        uri: "https://hashicorp/terraform-provider-google-beta",
        ref: "refs/heads/main",
        repoType: "GITHUB",
    },
    gitFileSource: {
        path: "cloudbuild.yaml",
        uri: "https://hashicorp/terraform-provider-google-beta",
        revision: "refs/heads/main",
        repoType: "GITHUB",
    },
});

resources:
  mytopic:
    type: gcp:pubsub:Topic
  pubsub-config-trigger:
    type: gcp:cloudbuild:Trigger
    properties:
      location: us-central1
      description: acceptance test example pubsub build trigger
      pubsubConfig:
        topic: ${mytopic.id}
      sourceToBuild:
        uri: https://hashicorp/terraform-provider-google-beta
        ref: refs/heads/main
        repoType: GITHUB
      gitFileSource:
        path: cloudbuild.yaml
        uri: https://hashicorp/terraform-provider-google-beta
        revision: refs/heads/main
        repoType: GITHUB
      substitutions:
        _ACTION: $(body.message.data.action)
      filter: _ACTION.matches('INSERT')

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

return await Deployment.RunAsync(() => 
{
    var manual_trigger = new Gcp.CloudBuild.Trigger("manual-trigger", new()
    {
        ApprovalConfig = new Gcp.CloudBuild.Inputs.TriggerApprovalConfigArgs
        {
            ApprovalRequired = true,
        },
        GitFileSource = new Gcp.CloudBuild.Inputs.TriggerGitFileSourceArgs
        {
            Path = "cloudbuild.yaml",
            RepoType = "GITHUB",
            Revision = "refs/heads/main",
            Uri = "https://hashicorp/terraform-provider-google-beta",
        },
        SourceToBuild = new Gcp.CloudBuild.Inputs.TriggerSourceToBuildArgs
        {
            Ref = "refs/heads/main",
            RepoType = "GITHUB",
            Uri = "https://hashicorp/terraform-provider-google-beta",
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/cloudbuild"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudbuild.NewTrigger(ctx, "manual-trigger", &cloudbuild.TriggerArgs{
			ApprovalConfig: &cloudbuild.TriggerApprovalConfigArgs{
				ApprovalRequired: pulumi.Bool(true),
			},
			GitFileSource: &cloudbuild.TriggerGitFileSourceArgs{
				Path:     pulumi.String("cloudbuild.yaml"),
				RepoType: pulumi.String("GITHUB"),
				Revision: pulumi.String("refs/heads/main"),
				Uri:      pulumi.String("https://hashicorp/terraform-provider-google-beta"),
			},
			SourceToBuild: &cloudbuild.TriggerSourceToBuildArgs{
				Ref:      pulumi.String("refs/heads/main"),
				RepoType: pulumi.String("GITHUB"),
				Uri:      pulumi.String("https://hashicorp/terraform-provider-google-beta"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.secretmanager.Secret;
import com.pulumi.gcp.secretmanager.SecretArgs;
import com.pulumi.gcp.secretmanager.inputs.SecretReplicationArgs;
import com.pulumi.gcp.secretmanager.inputs.SecretReplicationUserManagedArgs;
import com.pulumi.gcp.secretmanager.SecretVersion;
import com.pulumi.gcp.secretmanager.SecretVersionArgs;
import com.pulumi.gcp.organizations.OrganizationsFunctions;
import com.pulumi.gcp.organizations.inputs.GetProjectArgs;
import com.pulumi.gcp.organizations.inputs.GetIAMPolicyArgs;
import com.pulumi.gcp.secretmanager.SecretIamPolicy;
import com.pulumi.gcp.secretmanager.SecretIamPolicyArgs;
import com.pulumi.gcp.cloudbuild.Trigger;
import com.pulumi.gcp.cloudbuild.TriggerArgs;
import com.pulumi.gcp.cloudbuild.inputs.TriggerWebhookConfigArgs;
import com.pulumi.gcp.cloudbuild.inputs.TriggerSourceToBuildArgs;
import com.pulumi.gcp.cloudbuild.inputs.TriggerGitFileSourceArgs;
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 webhookTriggerSecretKey = new Secret("webhookTriggerSecretKey", SecretArgs.builder()        
            .secretId("webhook-trigger-secret-key")
            .replication(SecretReplicationArgs.builder()
                .userManaged(SecretReplicationUserManagedArgs.builder()
                    .replicas(SecretReplicationUserManagedReplicaArgs.builder()
                        .location("us-central1")
                        .build())
                    .build())
                .build())
            .build());

        var webhookTriggerSecretKeyData = new SecretVersion("webhookTriggerSecretKeyData", SecretVersionArgs.builder()        
            .secret(webhookTriggerSecretKey.id())
            .secretData("secretkeygoeshere")
            .build());

        final var project = OrganizationsFunctions.getProject();

        final var secretAccessor = OrganizationsFunctions.getIAMPolicy(GetIAMPolicyArgs.builder()
            .bindings(GetIAMPolicyBindingArgs.builder()
                .role("roles/secretmanager.secretAccessor")
                .members(String.format("serviceAccount:service-%s@gcp-sa-cloudbuild.iam.gserviceaccount.com", project.applyValue(getProjectResult -> getProjectResult.number())))
                .build())
            .build());

        var policy = new SecretIamPolicy("policy", SecretIamPolicyArgs.builder()        
            .project(webhookTriggerSecretKey.project())
            .secretId(webhookTriggerSecretKey.secretId())
            .policyData(secretAccessor.applyValue(getIAMPolicyResult -> getIAMPolicyResult.policyData()))
            .build());

        var webhook_config_trigger = new Trigger("webhook-config-trigger", TriggerArgs.builder()        
            .description("acceptance test example webhook build trigger")
            .webhookConfig(TriggerWebhookConfigArgs.builder()
                .secret(webhookTriggerSecretKeyData.id())
                .build())
            .sourceToBuild(TriggerSourceToBuildArgs.builder()
                .uri("https://hashicorp/terraform-provider-google-beta")
                .ref("refs/heads/main")
                .repoType("GITHUB")
                .build())
            .gitFileSource(TriggerGitFileSourceArgs.builder()
                .path("cloudbuild.yaml")
                .uri("https://hashicorp/terraform-provider-google-beta")
                .revision("refs/heads/main")
                .repoType("GITHUB")
                .build())
            .build());

    }
}