pulumi-github-kotlin/com.pulumi.github.kotlin/RepositoryFileArgs

RepositoryFileArgs

data class RepositoryFileArgs(val autocreateBranch: Output<Boolean>? = null, val autocreateBranchSourceBranch: Output<String>? = null, val autocreateBranchSourceSha: Output<String>? = null, val branch: Output<String>? = null, val commitAuthor: Output<String>? = null, val commitEmail: Output<String>? = null, val commitMessage: Output<String>? = null, val content: Output<String>? = null, val file: Output<String>? = null, val overwriteOnCreate: Output<Boolean>? = null, val repository: Output<String>? = null) : ConvertibleToJava<RepositoryFileArgs>

/* /* /* /* /* /* /* /* /* /* /* /* 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,
 });
Content copied to clipboard
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)
Content copied to clipboard
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,
     });
 });
Content copied to clipboard
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
 	})
 }
Content copied to clipboard
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());
     }
 }
Content copied to clipboard
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
Content copied to clipboard

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,
 });
Content copied to clipboard
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)
Content copied to clipboard
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,
     });
 });
Content copied to clipboard
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
 	})
 }
Content copied to clipboard
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());
     }
 }
Content copied to clipboard
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
Content copied to clipboard

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
Content copied to clipboard

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
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(autocreateBranch: Output<Boolean>? = null, autocreateBranchSourceBranch: Output<String>? = null, autocreateBranchSourceSha: Output<String>? = null, branch: Output<String>? = null, commitAuthor: Output<String>? = null, commitEmail: Output<String>? = null, commitMessage: Output<String>? = null, content: Output<String>? = null, file: Output<String>? = null, overwriteOnCreate: Output<Boolean>? = null, repository: Output<String>? = null)

Properties

Link copied to clipboard
val autocreateBranch: Output<Boolean>? = null

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'.

Link copied to clipboard
val autocreateBranchSourceBranch: Output<String>? = null

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

Link copied to clipboard
val autocreateBranchSourceSha: Output<String>? = null

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.

Link copied to clipboard
val branch: Output<String>? = null

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.

Link copied to clipboard
val commitAuthor: Output<String>? = null

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.

Link copied to clipboard
val commitEmail: Output<String>? = null

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.

Link copied to clipboard
val commitMessage: Output<String>? = null

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

Link copied to clipboard
val content: Output<String>? = null

The file content.

Link copied to clipboard
val file: Output<String>? = null

The path of the file to manage.

Link copied to clipboard
val overwriteOnCreate: Output<Boolean>? = null

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.

Link copied to clipboard
val repository: Output<String>? = null

The repository to create the file in.

Functions

Link copied to clipboard
open override fun toJava(): RepositoryFileArgs