pulumi-gcp-kotlin/com.pulumi.gcp.sourcerepo.kotlin/Repository

Repository

class Repository : KotlinCustomResource

A repository (or repo) is a Git repository storing versioned source content. To get more information about Repository, see:

API documentation
How-to Guides

Official Documentation

Example Usage

Sourcerepo Repository Basic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const my_repo = new gcp.sourcerepo.Repository("my-repo", {name: "my/repository"});

import pulumi
import pulumi_gcp as gcp
my_repo = gcp.sourcerepo.Repository("my-repo", name="my/repository")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var my_repo = new Gcp.SourceRepo.Repository("my-repo", new()
    {
        Name = "my/repository",
    });
});

package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/sourcerepo"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := sourcerepo.NewRepository(ctx, "my-repo", &sourcerepo.RepositoryArgs{
			Name: pulumi.String("my/repository"),
		})
		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.sourcerepo.Repository;
import com.pulumi.gcp.sourcerepo.RepositoryArgs;
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 my_repo = new Repository("my-repo", RepositoryArgs.builder()
            .name("my/repository")
            .build());
    }
}

resources:
  my-repo:
    type: gcp:sourcerepo:Repository
    properties:
      name: my/repository

Sourcerepo Repository Full

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const testAccount = new gcp.serviceaccount.Account("test_account", {
    accountId: "my-account",
    displayName: "Test Service Account",
});
const topic = new gcp.pubsub.Topic("topic", {name: "my-topic"});
const my_repo = new gcp.sourcerepo.Repository("my-repo", {
    name: "my-repository",
    pubsubConfigs: [{
        topic: topic.id,
        messageFormat: "JSON",
        serviceAccountEmail: testAccount.email,
    }],
});

import pulumi
import pulumi_gcp as gcp
test_account = gcp.serviceaccount.Account("test_account",
    account_id="my-account",
    display_name="Test Service Account")
topic = gcp.pubsub.Topic("topic", name="my-topic")
my_repo = gcp.sourcerepo.Repository("my-repo",
    name="my-repository",
    pubsub_configs=[{
        "topic": topic.id,
        "message_format": "JSON",
        "service_account_email": test_account.email,
    }])

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var testAccount = new Gcp.ServiceAccount.Account("test_account", new()
    {
        AccountId = "my-account",
        DisplayName = "Test Service Account",
    });
    var topic = new Gcp.PubSub.Topic("topic", new()
    {
        Name = "my-topic",
    });
    var my_repo = new Gcp.SourceRepo.Repository("my-repo", new()
    {
        Name = "my-repository",
        PubsubConfigs = new[]
        {
            new Gcp.SourceRepo.Inputs.RepositoryPubsubConfigArgs
            {
                Topic = topic.Id,
                MessageFormat = "JSON",
                ServiceAccountEmail = testAccount.Email,
            },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/pubsub"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/serviceaccount"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/sourcerepo"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		testAccount, err := serviceaccount.NewAccount(ctx, "test_account", &serviceaccount.AccountArgs{
			AccountId:   pulumi.String("my-account"),
			DisplayName: pulumi.String("Test Service Account"),
		})
		if err != nil {
			return err
		}
		topic, err := pubsub.NewTopic(ctx, "topic", &pubsub.TopicArgs{
			Name: pulumi.String("my-topic"),
		})
		if err != nil {
			return err
		}
		_, err = sourcerepo.NewRepository(ctx, "my-repo", &sourcerepo.RepositoryArgs{
			Name: pulumi.String("my-repository"),
			PubsubConfigs: sourcerepo.RepositoryPubsubConfigArray{
				&sourcerepo.RepositoryPubsubConfigArgs{
					Topic:               topic.ID(),
					MessageFormat:       pulumi.String("JSON"),
					ServiceAccountEmail: testAccount.Email,
				},
			},
		})
		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.serviceaccount.Account;
import com.pulumi.gcp.serviceaccount.AccountArgs;
import com.pulumi.gcp.pubsub.Topic;
import com.pulumi.gcp.pubsub.TopicArgs;
import com.pulumi.gcp.sourcerepo.Repository;
import com.pulumi.gcp.sourcerepo.RepositoryArgs;
import com.pulumi.gcp.sourcerepo.inputs.RepositoryPubsubConfigArgs;
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 testAccount = new Account("testAccount", AccountArgs.builder()
            .accountId("my-account")
            .displayName("Test Service Account")
            .build());
        var topic = new Topic("topic", TopicArgs.builder()
            .name("my-topic")
            .build());
        var my_repo = new Repository("my-repo", RepositoryArgs.builder()
            .name("my-repository")
            .pubsubConfigs(RepositoryPubsubConfigArgs.builder()
                .topic(topic.id())
                .messageFormat("JSON")
                .serviceAccountEmail(testAccount.email())
                .build())
            .build());
    }
}

resources:
  testAccount:
    type: gcp:serviceaccount:Account
    name: test_account
    properties:
      accountId: my-account
      displayName: Test Service Account
  topic:
    type: gcp:pubsub:Topic
    properties:
      name: my-topic
  my-repo:
    type: gcp:sourcerepo:Repository
    properties:
      name: my-repository
      pubsubConfigs:
        - topic: ${topic.id}
          messageFormat: JSON
          serviceAccountEmail: ${testAccount.email}

Import

Repository can be imported using any of these accepted formats:

projects/{{project}}/repos/{{name}}
{{name}} When using the pulumi import command, Repository can be imported using one of the formats above. For example:

$ pulumi import gcp:sourcerepo/repository:Repository default projects/{{project}}/repos/{{name}}

$ pulumi import gcp:sourcerepo/repository:Repository default {{name}}

Properties

createIgnoreAlreadyExists

val createIgnoreAlreadyExists: Output<Boolean>?

If set to true, skip repository creation if a repository with the same name already exists.

val id: Output<String>

name

val name: Output<String>

Resource name of the repository, of the form {{repo}}. The repo name may contain slashes. eg, name/with/slash

project

val project: Output<String>

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

pubsubConfigs

val pubsubConfigs: Output<List<RepositoryPubsubConfig>>?

How this repository publishes a change in the repository through Cloud Pub/Sub. Keyed by the topic names. Structure is documented below.

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

size

val size: Output<Int>

The disk usage of the repo, in bytes.

url

val url: Output<String>

URL to clone the repository from Google Cloud Source Repositories.

urn

val urn: Output<String>