cyral.getRepository

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

const mongo_repository = new cyral.Repository("mongo-repository", {
    type: "mongodb",
    repoNodes: [{
        host: "mongodb.cyral.com",
        port: 27017,
    }],
    mongodbSettings: {
        serverType: "standalone",
    },
});
const mysql_repository1 = new cyral.Repository("mysql-repository1", {
    type: "mysql",
    repoNodes: [{
        host: "mysql.com",
        port: 3306,
    }],
});
const mysql_repository2 = new cyral.Repository("mysql-repository2", {
    type: "mysql",
    repoNodes: [{
        host: "mysql2.com",
        port: 3306,
    }],
});
const specific_mysql_repo = cyral.getRepository({
    name: "tf-provider-mysql-repository1",
    type: "mysql",
});
const all_mysql_repos = cyral.getRepository({
    type: "mysql",
});
export const mysql1RepoId = specific_mysql_repo.then(specific_mysql_repo => specific_mysql_repo.repositoryLists?.[0]?.id);
export const allMysqlRepoIds = all_mysql_repos.then(all_mysql_repos => all_mysql_repos.repositoryLists);

import pulumi
import pulumi_cyral as cyral

mongo_repository = cyral.Repository("mongo-repository",
    type="mongodb",
    repo_nodes=[{
        "host": "mongodb.cyral.com",
        "port": 27017,
    }],
    mongodb_settings={
        "server_type": "standalone",
    })
mysql_repository1 = cyral.Repository("mysql-repository1",
    type="mysql",
    repo_nodes=[{
        "host": "mysql.com",
        "port": 3306,
    }])
mysql_repository2 = cyral.Repository("mysql-repository2",
    type="mysql",
    repo_nodes=[{
        "host": "mysql2.com",
        "port": 3306,
    }])
specific_mysql_repo = cyral.get_repository(name="tf-provider-mysql-repository1",
    type="mysql")
all_mysql_repos = cyral.get_repository(type="mysql")
pulumi.export("mysql1RepoId", specific_mysql_repo.repository_lists[0].id)
pulumi.export("allMysqlRepoIds", all_mysql_repos.repository_lists)

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/cyral/v4/cyral"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cyral.NewRepository(ctx, "mongo-repository", &cyral.RepositoryArgs{
			Type: pulumi.String("mongodb"),
			RepoNodes: cyral.RepositoryRepoNodeArray{
				&cyral.RepositoryRepoNodeArgs{
					Host: pulumi.String("mongodb.cyral.com"),
					Port: pulumi.Float64(27017),
				},
			},
			MongodbSettings: &cyral.RepositoryMongodbSettingsArgs{
				ServerType: pulumi.String("standalone"),
			},
		})
		if err != nil {
			return err
		}
		_, err = cyral.NewRepository(ctx, "mysql-repository1", &cyral.RepositoryArgs{
			Type: pulumi.String("mysql"),
			RepoNodes: cyral.RepositoryRepoNodeArray{
				&cyral.RepositoryRepoNodeArgs{
					Host: pulumi.String("mysql.com"),
					Port: pulumi.Float64(3306),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = cyral.NewRepository(ctx, "mysql-repository2", &cyral.RepositoryArgs{
			Type: pulumi.String("mysql"),
			RepoNodes: cyral.RepositoryRepoNodeArray{
				&cyral.RepositoryRepoNodeArgs{
					Host: pulumi.String("mysql2.com"),
					Port: pulumi.Float64(3306),
				},
			},
		})
		if err != nil {
			return err
		}
		specific_mysql_repo, err := cyral.LookupRepository(ctx, &cyral.LookupRepositoryArgs{
			Name: pulumi.StringRef("tf-provider-mysql-repository1"),
			Type: pulumi.StringRef("mysql"),
		}, nil)
		if err != nil {
			return err
		}
		all_mysql_repos, err := cyral.LookupRepository(ctx, &cyral.LookupRepositoryArgs{
			Type: pulumi.StringRef("mysql"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("mysql1RepoId", specific_mysql_repo.RepositoryLists[0].Id)
		ctx.Export("allMysqlRepoIds", all_mysql_repos.RepositoryLists)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var mongo_repository = new Cyral.Repository("mongo-repository", new()
    {
        Type = "mongodb",
        RepoNodes = new[]
        {
            new Cyral.Inputs.RepositoryRepoNodeArgs
            {
                Host = "mongodb.cyral.com",
                Port = 27017,
            },
        },
        MongodbSettings = new Cyral.Inputs.RepositoryMongodbSettingsArgs
        {
            ServerType = "standalone",
        },
    });

    var mysql_repository1 = new Cyral.Repository("mysql-repository1", new()
    {
        Type = "mysql",
        RepoNodes = new[]
        {
            new Cyral.Inputs.RepositoryRepoNodeArgs
            {
                Host = "mysql.com",
                Port = 3306,
            },
        },
    });

    var mysql_repository2 = new Cyral.Repository("mysql-repository2", new()
    {
        Type = "mysql",
        RepoNodes = new[]
        {
            new Cyral.Inputs.RepositoryRepoNodeArgs
            {
                Host = "mysql2.com",
                Port = 3306,
            },
        },
    });

    var specific_mysql_repo = Cyral.GetRepository.Invoke(new()
    {
        Name = "tf-provider-mysql-repository1",
        Type = "mysql",
    });

    var all_mysql_repos = Cyral.GetRepository.Invoke(new()
    {
        Type = "mysql",
    });

    return new Dictionary<string, object?>
    {
        ["mysql1RepoId"] = specific_mysql_repo.Apply(specific_mysql_repo => specific_mysql_repo.Apply(getRepositoryResult => getRepositoryResult.RepositoryLists[0]?.Id)),
        ["allMysqlRepoIds"] = all_mysql_repos.Apply(all_mysql_repos => all_mysql_repos.Apply(getRepositoryResult => getRepositoryResult.RepositoryLists)),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.cyral.Repository;
import com.pulumi.cyral.RepositoryArgs;
import com.pulumi.cyral.inputs.RepositoryRepoNodeArgs;
import com.pulumi.cyral.inputs.RepositoryMongodbSettingsArgs;
import com.pulumi.cyral.CyralFunctions;
import com.pulumi.cyral.inputs.GetRepositoryArgs;
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 mongo_repository = new Repository("mongo-repository", RepositoryArgs.builder()
            .type("mongodb")
            .repoNodes(RepositoryRepoNodeArgs.builder()
                .host("mongodb.cyral.com")
                .port(27017)
                .build())
            .mongodbSettings(RepositoryMongodbSettingsArgs.builder()
                .serverType("standalone")
                .build())
            .build());

        var mysql_repository1 = new Repository("mysql-repository1", RepositoryArgs.builder()
            .type("mysql")
            .repoNodes(RepositoryRepoNodeArgs.builder()
                .host("mysql.com")
                .port(3306)
                .build())
            .build());

        var mysql_repository2 = new Repository("mysql-repository2", RepositoryArgs.builder()
            .type("mysql")
            .repoNodes(RepositoryRepoNodeArgs.builder()
                .host("mysql2.com")
                .port(3306)
                .build())
            .build());

        final var specific-mysql-repo = CyralFunctions.getRepository(GetRepositoryArgs.builder()
            .name("tf-provider-mysql-repository1")
            .type("mysql")
            .build());

        final var all-mysql-repos = CyralFunctions.getRepository(GetRepositoryArgs.builder()
            .type("mysql")
            .build());

        ctx.export("mysql1RepoId", specific_mysql_repo.repositoryLists()[0].id());
        ctx.export("allMysqlRepoIds", all_mysql_repos.repositoryLists());
    }
}

resources:
  mongo-repository:
    type: cyral:Repository
    properties:
      type: mongodb
      repoNodes:
        - host: mongodb.cyral.com
          port: 27017
      mongodbSettings:
        serverType: standalone
  mysql-repository1:
    type: cyral:Repository
    properties:
      type: mysql
      repoNodes:
        - host: mysql.com
          port: 3306
  mysql-repository2:
    type: cyral:Repository
    properties:
      type: mysql
      repoNodes:
        - host: mysql2.com
          port: 3306
variables:
  specific-mysql-repo:
    fn::invoke:
      function: cyral:getRepository
      arguments:
        name: tf-provider-mysql-repository1
        type: mysql
  all-mysql-repos:
    fn::invoke:
      function: cyral:getRepository
      arguments:
        type: mysql
outputs:
  mysql1RepoId: ${["specific-mysql-repo"].repositoryLists[0].id}
  allMysqlRepoIds: ${["all-mysql-repos"].repositoryLists}

function getRepository(args: GetRepositoryArgs, opts?: InvokeOptions): Promise<GetRepositoryResult>
function getRepositoryOutput(args: GetRepositoryOutputArgs, opts?: InvokeOptions): Output<GetRepositoryResult>

def get_repository(id: Optional[str] = None,
                   name: Optional[str] = None,
                   type: Optional[str] = None,
                   opts: Optional[InvokeOptions] = None) -> GetRepositoryResult
def get_repository_output(id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   type: Optional[pulumi.Input[str]] = None,
                   opts: Optional[InvokeOptions] = None) -> Output[GetRepositoryResult]

func LookupRepository(ctx *Context, args *LookupRepositoryArgs, opts ...InvokeOption) (*LookupRepositoryResult, error)
func LookupRepositoryOutput(ctx *Context, args *LookupRepositoryOutputArgs, opts ...InvokeOption) LookupRepositoryResultOutput

public static class GetRepository 
{
    public static Task<GetRepositoryResult> InvokeAsync(GetRepositoryArgs args, InvokeOptions? opts = null)
    public static Output<GetRepositoryResult> Invoke(GetRepositoryInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetRepositoryResult> getRepository(GetRepositoryArgs args, InvokeOptions options)
public static Output<GetRepositoryResult> getRepository(GetRepositoryArgs args, InvokeOptions options)

fn::invoke:
  function: cyral:index/getRepository:getRepository
  arguments:
    # arguments dictionary