pulumi-gcp-kotlin/com.pulumi.gcp.securesourcemanager.kotlin/BranchRule

BranchRule

class BranchRule : KotlinCustomResource

BranchRule is the protection rule to enforce pre-defined rules on designated branches within a repository. To get more information about BranchRule, see:

Example Usage

Secure Source Manager Branch Rule Basic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const instance = new gcp.securesourcemanager.Instance("instance", {
    location: "us-central1",
    instanceId: "my-basic-instance",
});
const repository = new gcp.securesourcemanager.Repository("repository", {
    repositoryId: "my-basic-repository",
    location: instance.location,
    instance: instance.name,
});
const basic = new gcp.securesourcemanager.BranchRule("basic", {
    branchRuleId: "my-basic-branchrule",
    repositoryId: repository.repositoryId,
    location: repository.location,
    includePattern: "main",
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
instance = gcp.securesourcemanager.Instance("instance",
    location="us-central1",
    instance_id="my-basic-instance")
repository = gcp.securesourcemanager.Repository("repository",
    repository_id="my-basic-repository",
    location=instance.location,
    instance=instance.name)
basic = gcp.securesourcemanager.BranchRule("basic",
    branch_rule_id="my-basic-branchrule",
    repository_id=repository.repository_id,
    location=repository.location,
    include_pattern="main")
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var instance = new Gcp.SecureSourceManager.Instance("instance", new()
    {
        Location = "us-central1",
        InstanceId = "my-basic-instance",
    });
    var repository = new Gcp.SecureSourceManager.Repository("repository", new()
    {
        RepositoryId = "my-basic-repository",
        Location = instance.Location,
        Instance = instance.Name,
    });
    var basic = new Gcp.SecureSourceManager.BranchRule("basic", new()
    {
        BranchRuleId = "my-basic-branchrule",
        RepositoryId = repository.RepositoryId,
        Location = repository.Location,
        IncludePattern = "main",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/securesourcemanager"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		instance, err := securesourcemanager.NewInstance(ctx, "instance", &securesourcemanager.InstanceArgs{
			Location:   pulumi.String("us-central1"),
			InstanceId: pulumi.String("my-basic-instance"),
		})
		if err != nil {
			return err
		}
		repository, err := securesourcemanager.NewRepository(ctx, "repository", &securesourcemanager.RepositoryArgs{
			RepositoryId: pulumi.String("my-basic-repository"),
			Location:     instance.Location,
			Instance:     instance.Name,
		})
		if err != nil {
			return err
		}
		_, err = securesourcemanager.NewBranchRule(ctx, "basic", &securesourcemanager.BranchRuleArgs{
			BranchRuleId:   pulumi.String("my-basic-branchrule"),
			RepositoryId:   repository.RepositoryId,
			Location:       repository.Location,
			IncludePattern: pulumi.String("main"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.securesourcemanager.Instance;
import com.pulumi.gcp.securesourcemanager.InstanceArgs;
import com.pulumi.gcp.securesourcemanager.Repository;
import com.pulumi.gcp.securesourcemanager.RepositoryArgs;
import com.pulumi.gcp.securesourcemanager.BranchRule;
import com.pulumi.gcp.securesourcemanager.BranchRuleArgs;
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 instance = new Instance("instance", InstanceArgs.builder()
            .location("us-central1")
            .instanceId("my-basic-instance")
            .build());
        var repository = new Repository("repository", RepositoryArgs.builder()
            .repositoryId("my-basic-repository")
            .location(instance.location())
            .instance(instance.name())
            .build());
        var basic = new BranchRule("basic", BranchRuleArgs.builder()
            .branchRuleId("my-basic-branchrule")
            .repositoryId(repository.repositoryId())
            .location(repository.location())
            .includePattern("main")
            .build());
    }
}
Content copied to clipboard
resources:
  instance:
    type: gcp:securesourcemanager:Instance
    properties:
      location: us-central1
      instanceId: my-basic-instance
  repository:
    type: gcp:securesourcemanager:Repository
    properties:
      repositoryId: my-basic-repository
      location: ${instance.location}
      instance: ${instance.name}
  basic:
    type: gcp:securesourcemanager:BranchRule
    properties:
      branchRuleId: my-basic-branchrule
      repositoryId: ${repository.repositoryId}
      location: ${repository.location}
      includePattern: main
Content copied to clipboard

Secure Source Manager Branch Rule With Fields

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const instance = new gcp.securesourcemanager.Instance("instance", {
    location: "us-central1",
    instanceId: "my-initial-instance",
});
const repository = new gcp.securesourcemanager.Repository("repository", {
    repositoryId: "my-initial-repository",
    instance: instance.name,
    location: instance.location,
});
const _default = new gcp.securesourcemanager.BranchRule("default", {
    branchRuleId: "my-initial-branchrule",
    location: repository.location,
    repositoryId: repository.repositoryId,
    includePattern: "test",
    minimumApprovalsCount: 2,
    minimumReviewsCount: 2,
    requireCommentsResolved: true,
    requireLinearHistory: true,
    requirePullRequest: true,
    disabled: false,
    allowStaleReviews: false,
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
instance = gcp.securesourcemanager.Instance("instance",
    location="us-central1",
    instance_id="my-initial-instance")
repository = gcp.securesourcemanager.Repository("repository",
    repository_id="my-initial-repository",
    instance=instance.name,
    location=instance.location)
default = gcp.securesourcemanager.BranchRule("default",
    branch_rule_id="my-initial-branchrule",
    location=repository.location,
    repository_id=repository.repository_id,
    include_pattern="test",
    minimum_approvals_count=2,
    minimum_reviews_count=2,
    require_comments_resolved=True,
    require_linear_history=True,
    require_pull_request=True,
    disabled=False,
    allow_stale_reviews=False)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var instance = new Gcp.SecureSourceManager.Instance("instance", new()
    {
        Location = "us-central1",
        InstanceId = "my-initial-instance",
    });
    var repository = new Gcp.SecureSourceManager.Repository("repository", new()
    {
        RepositoryId = "my-initial-repository",
        Instance = instance.Name,
        Location = instance.Location,
    });
    var @default = new Gcp.SecureSourceManager.BranchRule("default", new()
    {
        BranchRuleId = "my-initial-branchrule",
        Location = repository.Location,
        RepositoryId = repository.RepositoryId,
        IncludePattern = "test",
        MinimumApprovalsCount = 2,
        MinimumReviewsCount = 2,
        RequireCommentsResolved = true,
        RequireLinearHistory = true,
        RequirePullRequest = true,
        Disabled = false,
        AllowStaleReviews = false,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/securesourcemanager"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		instance, err := securesourcemanager.NewInstance(ctx, "instance", &securesourcemanager.InstanceArgs{
			Location:   pulumi.String("us-central1"),
			InstanceId: pulumi.String("my-initial-instance"),
		})
		if err != nil {
			return err
		}
		repository, err := securesourcemanager.NewRepository(ctx, "repository", &securesourcemanager.RepositoryArgs{
			RepositoryId: pulumi.String("my-initial-repository"),
			Instance:     instance.Name,
			Location:     instance.Location,
		})
		if err != nil {
			return err
		}
		_, err = securesourcemanager.NewBranchRule(ctx, "default", &securesourcemanager.BranchRuleArgs{
			BranchRuleId:            pulumi.String("my-initial-branchrule"),
			Location:                repository.Location,
			RepositoryId:            repository.RepositoryId,
			IncludePattern:          pulumi.String("test"),
			MinimumApprovalsCount:   pulumi.Int(2),
			MinimumReviewsCount:     pulumi.Int(2),
			RequireCommentsResolved: pulumi.Bool(true),
			RequireLinearHistory:    pulumi.Bool(true),
			RequirePullRequest:      pulumi.Bool(true),
			Disabled:                pulumi.Bool(false),
			AllowStaleReviews:       pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.securesourcemanager.Instance;
import com.pulumi.gcp.securesourcemanager.InstanceArgs;
import com.pulumi.gcp.securesourcemanager.Repository;
import com.pulumi.gcp.securesourcemanager.RepositoryArgs;
import com.pulumi.gcp.securesourcemanager.BranchRule;
import com.pulumi.gcp.securesourcemanager.BranchRuleArgs;
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 instance = new Instance("instance", InstanceArgs.builder()
            .location("us-central1")
            .instanceId("my-initial-instance")
            .build());
        var repository = new Repository("repository", RepositoryArgs.builder()
            .repositoryId("my-initial-repository")
            .instance(instance.name())
            .location(instance.location())
            .build());
        var default_ = new BranchRule("default", BranchRuleArgs.builder()
            .branchRuleId("my-initial-branchrule")
            .location(repository.location())
            .repositoryId(repository.repositoryId())
            .includePattern("test")
            .minimumApprovalsCount(2)
            .minimumReviewsCount(2)
            .requireCommentsResolved(true)
            .requireLinearHistory(true)
            .requirePullRequest(true)
            .disabled(false)
            .allowStaleReviews(false)
            .build());
    }
}
Content copied to clipboard
resources:
  instance:
    type: gcp:securesourcemanager:Instance
    properties:
      location: us-central1
      instanceId: my-initial-instance
  repository:
    type: gcp:securesourcemanager:Repository
    properties:
      repositoryId: my-initial-repository
      instance: ${instance.name}
      location: ${instance.location}
  default:
    type: gcp:securesourcemanager:BranchRule
    properties:
      branchRuleId: my-initial-branchrule
      location: ${repository.location}
      repositoryId: ${repository.repositoryId}
      includePattern: test
      minimumApprovalsCount: 2
      minimumReviewsCount: 2
      requireCommentsResolved: true
      requireLinearHistory: true
      requirePullRequest: true
      disabled: false
      allowStaleReviews: false
Content copied to clipboard

Import

BranchRule can be imported using any of these accepted formats:

  • projects/{{project}}/locations/{{location}}/repositories/{{repository_id}}/branchRules/{{branch_rule_id}}

  • {{project}}/{{location}}/{{repository_id}}/{{branch_rule_id}}

  • {{location}}/{{repository_id}}/{{branch_rule_id}}

  • {{branch_rule_id}} When using the pulumi import command, BranchRule can be imported using one of the formats above. For example:

$ pulumi import gcp:securesourcemanager/branchRule:BranchRule default projects/{{project}}/locations/{{location}}/repositories/{{repository_id}}/branchRules/{{branch_rule_id}}
Content copied to clipboard
$ pulumi import gcp:securesourcemanager/branchRule:BranchRule default {{project}}/{{location}}/{{repository_id}}/{{branch_rule_id}}
Content copied to clipboard
$ pulumi import gcp:securesourcemanager/branchRule:BranchRule default {{location}}/{{repository_id}}/{{branch_rule_id}}
Content copied to clipboard
$ pulumi import gcp:securesourcemanager/branchRule:BranchRule default {{branch_rule_id}}
Content copied to clipboard

Properties

Link copied to clipboard
val allowStaleReviews: Output<Boolean>?

Determines if allow stale reviews or approvals before merging to the branch.

Link copied to clipboard
val branchRuleId: Output<String>

The ID for the BranchRule.

Link copied to clipboard
val createTime: Output<String>

Time the BranchRule was created in UTC.

Link copied to clipboard
val disabled: Output<Boolean>?

Determines if the branch rule is disabled or not.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val includePattern: Output<String>

The BranchRule matches branches based on the specified regular expression. Use .* to match all branches.

Link copied to clipboard
val location: Output<String>

The location for the Repository.

Link copied to clipboard
val minimumApprovalsCount: Output<Int>?

The minimum number of approvals required for the branch rule to be matched.

Link copied to clipboard
val minimumReviewsCount: Output<Int>?

The minimum number of reviews required for the branch rule to be matched.

Link copied to clipboard
val name: Output<String>

The resource name for the BranchRule.

Link copied to clipboard
val project: Output<String>

The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val repositoryId: Output<String>

The ID for the Repository.

Link copied to clipboard
val requireCommentsResolved: Output<Boolean>?

Determines if require comments resolved before merging to the branch.

Link copied to clipboard
val requireLinearHistory: Output<Boolean>?

Determines if require linear history before merging to the branch.

Link copied to clipboard
val requirePullRequest: Output<Boolean>?

Determines if the branch rule requires a pull request or not.

Link copied to clipboard
val uid: Output<String>

Unique identifier of the BranchRule.

Link copied to clipboard
val updateTime: Output<String>

Time the BranchRule was updated in UTC.

Link copied to clipboard
val urn: Output<String>