pulumi-github-kotlin/com.pulumi.github.kotlin/RepositoryFile

RepositoryFile

class RepositoryFile : KotlinCustomResource

/* /* /* /* /* /* /* /* /* /* /* /* This resource allows you to create and manage files within a GitHub repository.

Example Usage

Existing Branch

import * as pulumi from "@pulumi/pulumi";
import * as github from "@pulumi/github";
const foo = new github.Repository("foo", {
    name: "tf-acc-test-%s",
    autoInit: true,
});
const fooRepositoryFile = new github.RepositoryFile("foo", {
    repository: foo.name,
    branch: "main",
    file: ".gitignore",
    content: "**/*.tfstate",
     commitMessage: "Managed by Pulumi",
     commitAuthor: "Terraform User",
     commitEmail: "terraform@example.com",
     overwriteOnCreate: true,
 });

import pulumi
import pulumi_github as github
foo = github.Repository("foo",
    name="tf-acc-test-%s",
    auto_init=True)
foo_repository_file = github.RepositoryFile("foo",
    repository=foo.name,
    branch="main",
    file=".gitignore",
    content="**/*.tfstate",
     commit_message="Managed by Pulumi",
     commit_author="Terraform User",
     commit_email="terraform@example.com",
     overwrite_on_create=True)

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Github = Pulumi.Github;
return await Deployment.RunAsync(() =>
{
    var foo = new Github.Repository("foo", new()
    {
        Name = "tf-acc-test-%s",
        AutoInit = true,
    });
    var fooRepositoryFile = new Github.RepositoryFile("foo", new()
    {
        Repository = foo.Name,
        Branch = "main",
        File = ".gitignore",
        Content = "**/*.tfstate",
         CommitMessage = "Managed by Pulumi",
         CommitAuthor = "Terraform User",
         CommitEmail = "terraform@example.com",
         OverwriteOnCreate = true,
     });
 });

package main
import (
	"github.com/pulumi/pulumi-github/sdk/v6/go/github"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		foo, err := github.NewRepository(ctx, "foo", &github.RepositoryArgs{
			Name:     pulumi.String("tf-acc-test-%s"),
			AutoInit: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = github.NewRepositoryFile(ctx, "foo", &github.RepositoryFileArgs{
			Repository:        foo.Name,
			Branch:            pulumi.String("main"),
			File:              pulumi.String(".gitignore"),
			Content:           pulumi.String("**/*.tfstate"),
 			CommitMessage:     pulumi.String("Managed by Pulumi"),
 			CommitAuthor:      pulumi.String("Terraform User"),
 			CommitEmail:       pulumi.String("terraform@example.com"),
 			OverwriteOnCreate: pulumi.Bool(true),
 		})
 		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.github.Repository;
import com.pulumi.github.RepositoryArgs;
import com.pulumi.github.RepositoryFile;
import com.pulumi.github.RepositoryFileArgs;
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 foo = new Repository("foo", RepositoryArgs.builder()
            .name("tf-acc-test-%s")
            .autoInit(true)
            .build());
        var fooRepositoryFile = new RepositoryFile("fooRepositoryFile", RepositoryFileArgs.builder()
            .repository(foo.name())
            .branch("main")
            .file(".gitignore")
            .content("**/*.tfstate")
             .commitMessage("Managed by Pulumi")
             .commitAuthor("Terraform User")
             .commitEmail("terraform@example.com")
             .overwriteOnCreate(true)
             .build());
     }
 }

resources:
  foo:
    type: github:Repository
    properties:
      name: tf-acc-test-%s
      autoInit: true
  fooRepositoryFile:
    type: github:RepositoryFile
    name: foo
    properties:
      repository: ${foo.name}
      branch: main
      file: .gitignore
      content: '**/*.tfstate'
       commitMessage: Managed by Pulumi
       commitAuthor: Terraform User
       commitEmail: terraform@example.com
       overwriteOnCreate: true

Auto Created Branch

import * as pulumi from "@pulumi/pulumi";
import * as github from "@pulumi/github";
const foo = new github.Repository("foo", {
    name: "tf-acc-test-%s",
    autoInit: true,
});
const fooRepositoryFile = new github.RepositoryFile("foo", {
    repository: foo.name,
    branch: "does/not/exist",
    file: ".gitignore",
    content: "**/*.tfstate",
     commitMessage: "Managed by Pulumi",
     commitAuthor: "Terraform User",
     commitEmail: "terraform@example.com",
     overwriteOnCreate: true,
     autocreateBranch: true,
 });

import pulumi
import pulumi_github as github
foo = github.Repository("foo",
    name="tf-acc-test-%s",
    auto_init=True)
foo_repository_file = github.RepositoryFile("foo",
    repository=foo.name,
    branch="does/not/exist",
    file=".gitignore",
    content="**/*.tfstate",
     commit_message="Managed by Pulumi",
     commit_author="Terraform User",
     commit_email="terraform@example.com",
     overwrite_on_create=True,
     autocreate_branch=True)

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Github = Pulumi.Github;
return await Deployment.RunAsync(() =>
{
    var foo = new Github.Repository("foo", new()
    {
        Name = "tf-acc-test-%s",
        AutoInit = true,
    });
    var fooRepositoryFile = new Github.RepositoryFile("foo", new()
    {
        Repository = foo.Name,
        Branch = "does/not/exist",
        File = ".gitignore",
        Content = "**/*.tfstate",
         CommitMessage = "Managed by Pulumi",
         CommitAuthor = "Terraform User",
         CommitEmail = "terraform@example.com",
         OverwriteOnCreate = true,
         AutocreateBranch = true,
     });
 });

package main
import (
	"github.com/pulumi/pulumi-github/sdk/v6/go/github"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		foo, err := github.NewRepository(ctx, "foo", &github.RepositoryArgs{
			Name:     pulumi.String("tf-acc-test-%s"),
			AutoInit: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = github.NewRepositoryFile(ctx, "foo", &github.RepositoryFileArgs{
			Repository:        foo.Name,
			Branch:            pulumi.String("does/not/exist"),
			File:              pulumi.String(".gitignore"),
			Content:           pulumi.String("**/*.tfstate"),
 			CommitMessage:     pulumi.String("Managed by Pulumi"),
 			CommitAuthor:      pulumi.String("Terraform User"),
 			CommitEmail:       pulumi.String("terraform@example.com"),
 			OverwriteOnCreate: pulumi.Bool(true),
 			AutocreateBranch:  pulumi.Bool(true),
 		})
 		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.github.Repository;
import com.pulumi.github.RepositoryArgs;
import com.pulumi.github.RepositoryFile;
import com.pulumi.github.RepositoryFileArgs;
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 foo = new Repository("foo", RepositoryArgs.builder()
            .name("tf-acc-test-%s")
            .autoInit(true)
            .build());
        var fooRepositoryFile = new RepositoryFile("fooRepositoryFile", RepositoryFileArgs.builder()
            .repository(foo.name())
            .branch("does/not/exist")
            .file(".gitignore")
            .content("**/*.tfstate")
             .commitMessage("Managed by Pulumi")
             .commitAuthor("Terraform User")
             .commitEmail("terraform@example.com")
             .overwriteOnCreate(true)
             .autocreateBranch(true)
             .build());
     }
 }

resources:
  foo:
    type: github:Repository
    properties:
      name: tf-acc-test-%s
      autoInit: true
  fooRepositoryFile:
    type: github:RepositoryFile
    name: foo
    properties:
      repository: ${foo.name}
      branch: does/not/exist
      file: .gitignore
      content: '**/*.tfstate'
       commitMessage: Managed by Pulumi
       commitAuthor: Terraform User
       commitEmail: terraform@example.com
       overwriteOnCreate: true
       autocreateBranch: true

Import

Repository files can be imported using a combination of the repo and file, e.g.

$ pulumi import github:index/repositoryFile:RepositoryFile gitignore example/.gitignore

To import a file from a branch other than the default branch, append : and the branch name, e.g.

$ pulumi import github:index/repositoryFile:RepositoryFile gitignore example/.gitignore:dev

Properties

autocreateBranch

val autocreateBranch: Output<Boolean>?

Automatically create the branch if it could not be found. Defaults to false. Subsequent reads if the branch is deleted will occur from 'autocreate_branch_source_branch'.

autocreateBranchSourceBranch

val autocreateBranchSourceBranch: Output<String>?

The branch name to start from, if 'autocreate_branch' is set. Defaults to 'main'.

autocreateBranchSourceSha

val autocreateBranchSourceSha: Output<String>

The commit hash to start from, if 'autocreate_branch' is set. Defaults to the tip of 'autocreate_branch_source_branch'. If provided, 'autocreate_branch_source_branch' is ignored.

branch

val branch: Output<String>?

Git branch (defaults to the repository's default branch). The branch must already exist, it will only be created automatically if 'autocreate_branch' is set true.

commitAuthor

val commitAuthor: Output<String>?

Committer author name to use. NOTE: GitHub app users may omit author and email information so GitHub can verify commits as the GitHub App. This maybe useful when a branch protection rule requires signed commits.

commitEmail

val commitEmail: Output<String>?

Committer email address to use. NOTE: GitHub app users may omit author and email information so GitHub can verify commits as the GitHub App. This may be useful when a branch protection rule requires signed commits.

commitMessage

val commitMessage: Output<String>

The commit message when creating, updating or deleting the managed file.

commitSha

val commitSha: Output<String>

The SHA of the commit that modified the file.

content

val content: Output<String>

The file content.

file

val file: Output<String>

The path of the file to manage.

val id: Output<String>

overwriteOnCreate

val overwriteOnCreate: Output<Boolean>?

Enable overwriting existing files. If set to true it will overwrite an existing file with the same name. If set to false it will fail if there is an existing file with the same name.

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

ref

val ref: Output<String>

The name of the commit/branch/tag.

repository

val repository: Output<String>

The repository to create the file in.

sha

val sha: Output<String>

The SHA blob of the file.

urn

val urn: Output<String>