harness.platform.JenkinsConnector

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

return await Deployment.RunAsync(() => 
{
    // Auth mechanism bearer token
    var test = new Harness.Platform.JenkinsConnector("test", new()
    {
        Auth = new Harness.Platform.Inputs.JenkinsConnectorAuthArgs
        {
            JenkinsBearerToken = new Harness.Platform.Inputs.JenkinsConnectorAuthJenkinsBearerTokenArgs
            {
                TokenRef = $"account.{harness_platform_secret_text.Test.Id}",
            },
            Type = "Bearer Token(HTTP Header)",
        },
        DelegateSelectors = new[]
        {
            "harness-delegate",
        },
        Description = "test",
        Identifier = "identifier",
        JenkinsUrl = "https://jenkinss.com/",
        Tags = new[]
        {
            "foo:bar",
        },
    });

});

package main

import (
	"fmt"

	"github.com/lbrlabs/pulumi-harness/sdk/go/harness/platform"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := platform.NewJenkinsConnector(ctx, "test", &platform.JenkinsConnectorArgs{
			Auth: &platform.JenkinsConnectorAuthArgs{
				JenkinsBearerToken: &platform.JenkinsConnectorAuthJenkinsBearerTokenArgs{
					TokenRef: pulumi.String(fmt.Sprintf("account.%v", harness_platform_secret_text.Test.Id)),
				},
				Type: pulumi.String("Bearer Token(HTTP Header)"),
			},
			DelegateSelectors: pulumi.StringArray{
				pulumi.String("harness-delegate"),
			},
			Description: pulumi.String("test"),
			Identifier:  pulumi.String("identifier"),
			JenkinsUrl:  pulumi.String("https://jenkinss.com/"),
			Tags: pulumi.StringArray{
				pulumi.String("foo:bar"),
			},
		})
		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.harness.platform.JenkinsConnector;
import com.pulumi.harness.platform.JenkinsConnectorArgs;
import com.pulumi.harness.platform.inputs.JenkinsConnectorAuthArgs;
import com.pulumi.harness.platform.inputs.JenkinsConnectorAuthJenkinsBearerTokenArgs;
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 test = new JenkinsConnector("test", JenkinsConnectorArgs.builder()        
            .auth(JenkinsConnectorAuthArgs.builder()
                .jenkinsBearerToken(JenkinsConnectorAuthJenkinsBearerTokenArgs.builder()
                    .tokenRef(String.format("account.%s", harness_platform_secret_text.test().id()))
                    .build())
                .type("Bearer Token(HTTP Header)")
                .build())
            .delegateSelectors("harness-delegate")
            .description("test")
            .identifier("identifier")
            .jenkinsUrl("https://jenkinss.com/")
            .tags("foo:bar")
            .build());

    }
}

import pulumi
import lbrlabs_pulumi_harness as harness

# Auth mechanism bearer token
test = harness.platform.JenkinsConnector("test",
    auth=harness.platform.JenkinsConnectorAuthArgs(
        jenkins_bearer_token=harness.platform.JenkinsConnectorAuthJenkinsBearerTokenArgs(
            token_ref=f"account.{harness_platform_secret_text['test']['id']}",
        ),
        type="Bearer Token(HTTP Header)",
    ),
    delegate_selectors=["harness-delegate"],
    description="test",
    identifier="identifier",
    jenkins_url="https://jenkinss.com/",
    tags=["foo:bar"])

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

// Auth mechanism bearer token
const test = new harness.platform.JenkinsConnector("test", {
    auth: {
        jenkinsBearerToken: {
            tokenRef: `account.${harness_platform_secret_text.test.id}`,
        },
        type: "Bearer Token(HTTP Header)",
    },
    delegateSelectors: ["harness-delegate"],
    description: "test",
    identifier: "identifier",
    jenkinsUrl: "https://jenkinss.com/",
    tags: ["foo:bar"],
});

resources:
  # Auth mechanism bearer token
  test:
    type: harness:platform:JenkinsConnector
    properties:
      auth:
        jenkinsBearerToken:
          tokenRef: account.${harness_platform_secret_text.test.id}
        type: Bearer Token(HTTP Header)
      delegateSelectors:
        - harness-delegate
      description: test
      identifier: identifier
      jenkinsUrl: https://jenkinss.com/
      tags:
        - foo:bar