harness.ApplicationGitSync

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

const default = harness.getSecretManager({
    "default": true,
});
const githubToken = new harness.EncryptedText("github_token", {
    name: "github_token",
    value: "<TOKEN>",
    secretManagerId: _default.then(_default => _default.id),
});
const myrepo = new harness.GitConnector("myrepo", {
    name: "myrepo",
    url: "https://github.com/someorg/myrepo",
    branch: "main",
    generateWebhookUrl: true,
    username: "someuser",
    passwordSecretId: githubToken.id,
    urlType: "REPO",
});
const example = new harness.Application("example", {name: "example-app"});
const exampleApplicationGitSync = new harness.ApplicationGitSync("example", {
    appId: example.id,
    connectorId: myrepo.id,
    branch: "main",
    enabled: false,
});

import pulumi
import pulumi_harness as harness

default = harness.get_secret_manager(default=True)
github_token = harness.EncryptedText("github_token",
    name="github_token",
    value="<TOKEN>",
    secret_manager_id=default.id)
myrepo = harness.GitConnector("myrepo",
    name="myrepo",
    url="https://github.com/someorg/myrepo",
    branch="main",
    generate_webhook_url=True,
    username="someuser",
    password_secret_id=github_token.id,
    url_type="REPO")
example = harness.Application("example", name="example-app")
example_application_git_sync = harness.ApplicationGitSync("example",
    app_id=example.id,
    connector_id=myrepo.id,
    branch="main",
    enabled=False)

package main

import (
	"github.com/pulumi/pulumi-harness/sdk/go/harness"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_default, err := harness.GetSecretManager(ctx, &harness.GetSecretManagerArgs{
			Default: pulumi.BoolRef(true),
		}, nil)
		if err != nil {
			return err
		}
		githubToken, err := harness.NewEncryptedText(ctx, "github_token", &harness.EncryptedTextArgs{
			Name:            pulumi.String("github_token"),
			Value:           pulumi.String("<TOKEN>"),
			SecretManagerId: pulumi.String(_default.Id),
		})
		if err != nil {
			return err
		}
		myrepo, err := harness.NewGitConnector(ctx, "myrepo", &harness.GitConnectorArgs{
			Name:               pulumi.String("myrepo"),
			Url:                pulumi.String("https://github.com/someorg/myrepo"),
			Branch:             pulumi.String("main"),
			GenerateWebhookUrl: pulumi.Bool(true),
			Username:           pulumi.String("someuser"),
			PasswordSecretId:   githubToken.ID(),
			UrlType:            pulumi.String("REPO"),
		})
		if err != nil {
			return err
		}
		example, err := harness.NewApplication(ctx, "example", &harness.ApplicationArgs{
			Name: pulumi.String("example-app"),
		})
		if err != nil {
			return err
		}
		_, err = harness.NewApplicationGitSync(ctx, "example", &harness.ApplicationGitSyncArgs{
			AppId:       example.ID(),
			ConnectorId: myrepo.ID(),
			Branch:      pulumi.String("main"),
			Enabled:     pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var @default = Harness.GetSecretManager.Invoke(new()
    {
        Default = true,
    });

    var githubToken = new Harness.EncryptedText("github_token", new()
    {
        Name = "github_token",
        Value = "<TOKEN>",
        SecretManagerId = @default.Apply(@default => @default.Apply(getSecretManagerResult => getSecretManagerResult.Id)),
    });

    var myrepo = new Harness.GitConnector("myrepo", new()
    {
        Name = "myrepo",
        Url = "https://github.com/someorg/myrepo",
        Branch = "main",
        GenerateWebhookUrl = true,
        Username = "someuser",
        PasswordSecretId = githubToken.Id,
        UrlType = "REPO",
    });

    var example = new Harness.Application("example", new()
    {
        Name = "example-app",
    });

    var exampleApplicationGitSync = new Harness.ApplicationGitSync("example", new()
    {
        AppId = example.Id,
        ConnectorId = myrepo.Id,
        Branch = "main",
        Enabled = false,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.harness.HarnessFunctions;
import com.pulumi.harness.inputs.GetSecretManagerArgs;
import com.pulumi.harness.EncryptedText;
import com.pulumi.harness.EncryptedTextArgs;
import com.pulumi.harness.GitConnector;
import com.pulumi.harness.GitConnectorArgs;
import com.pulumi.harness.Application;
import com.pulumi.harness.ApplicationArgs;
import com.pulumi.harness.ApplicationGitSync;
import com.pulumi.harness.ApplicationGitSyncArgs;
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 default = HarnessFunctions.getSecretManager(GetSecretManagerArgs.builder()
            .default_(true)
            .build());

        var githubToken = new EncryptedText("githubToken", EncryptedTextArgs.builder()
            .name("github_token")
            .value("<TOKEN>")
            .secretManagerId(default_.id())
            .build());

        var myrepo = new GitConnector("myrepo", GitConnectorArgs.builder()
            .name("myrepo")
            .url("https://github.com/someorg/myrepo")
            .branch("main")
            .generateWebhookUrl(true)
            .username("someuser")
            .passwordSecretId(githubToken.id())
            .urlType("REPO")
            .build());

        var example = new Application("example", ApplicationArgs.builder()
            .name("example-app")
            .build());

        var exampleApplicationGitSync = new ApplicationGitSync("exampleApplicationGitSync", ApplicationGitSyncArgs.builder()
            .appId(example.id())
            .connectorId(myrepo.id())
            .branch("main")
            .enabled(false)
            .build());

    }
}

resources:
  githubToken:
    type: harness:EncryptedText
    name: github_token
    properties:
      name: github_token
      value: <TOKEN>
      secretManagerId: ${default.id}
  myrepo:
    type: harness:GitConnector
    properties:
      name: myrepo
      url: https://github.com/someorg/myrepo
      branch: main
      generateWebhookUrl: true
      username: someuser
      passwordSecretId: ${githubToken.id}
      urlType: REPO
  example:
    type: harness:Application
    properties:
      name: example-app
  exampleApplicationGitSync:
    type: harness:ApplicationGitSync
    name: example
    properties:
      appId: ${example.id}
      connectorId: ${myrepo.id}
      branch: main
      enabled: false
variables:
  default:
    fn::invoke:
      Function: harness:getSecretManager
      Arguments:
        default: true

var applicationGitSyncResource = new Harness.ApplicationGitSync("applicationGitSyncResource", new()
{
    AppId = "string",
    Branch = "string",
    ConnectorId = "string",
    Enabled = false,
    RepositoryName = "string",
});

example, err := harness.NewApplicationGitSync(ctx, "applicationGitSyncResource", &harness.ApplicationGitSyncArgs{
	AppId:          pulumi.String("string"),
	Branch:         pulumi.String("string"),
	ConnectorId:    pulumi.String("string"),
	Enabled:        pulumi.Bool(false),
	RepositoryName: pulumi.String("string"),
})

var applicationGitSyncResource = new ApplicationGitSync("applicationGitSyncResource", ApplicationGitSyncArgs.builder()
    .appId("string")
    .branch("string")
    .connectorId("string")
    .enabled(false)
    .repositoryName("string")
    .build());

application_git_sync_resource = harness.ApplicationGitSync("applicationGitSyncResource",
    app_id="string",
    branch="string",
    connector_id="string",
    enabled=False,
    repository_name="string")

const applicationGitSyncResource = new harness.ApplicationGitSync("applicationGitSyncResource", {
    appId: "string",
    branch: "string",
    connectorId: "string",
    enabled: false,
    repositoryName: "string",
});

type: harness:ApplicationGitSync
properties:
    appId: string
    branch: string
    connectorId: string
    enabled: false
    repositoryName: string