databricks.getMetastore

import pulumi
import pulumi_aws as aws
import pulumi_databricks as databricks

metastore = aws.s3.BucketV2("metastore",
    bucket=f"{prefix}-metastore",
    force_destroy=True)
this_metastore = databricks.Metastore("this",
    name="primary",
    storage_root=metastore.id.apply(lambda id: f"s3://{id}/metastore"),
    owner=unity_admin_group,
    force_destroy=True)
this = databricks.get_metastore_output(metastore_id=this_metastore.id)
pulumi.export("someMetastore", this.metastore_info)

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/s3"
	"github.com/pulumi/pulumi-databricks/sdk/go/databricks"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		metastore, err := s3.NewBucketV2(ctx, "metastore", &s3.BucketV2Args{
			Bucket:       pulumi.Sprintf("%v-metastore", prefix),
			ForceDestroy: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		thisMetastore, err := databricks.NewMetastore(ctx, "this", &databricks.MetastoreArgs{
			Name: pulumi.String("primary"),
			StorageRoot: metastore.ID().ApplyT(func(id string) (string, error) {
				return fmt.Sprintf("s3://%v/metastore", id), nil
			}).(pulumi.StringOutput),
			Owner:        pulumi.Any(unityAdminGroup),
			ForceDestroy: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		this := databricks.LookupMetastoreOutput(ctx, databricks.GetMetastoreOutputArgs{
			MetastoreId: thisMetastore.ID(),
		}, nil)
		ctx.Export("someMetastore", this.ApplyT(func(this databricks.GetMetastoreResult) (databricks.GetMetastoreMetastoreInfo, error) {
			return this.MetastoreInfo, nil
		}).(databricks.GetMetastoreMetastoreInfoOutput))
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
using Databricks = Pulumi.Databricks;

return await Deployment.RunAsync(() => 
{
    var metastore = new Aws.S3.BucketV2("metastore", new()
    {
        Bucket = $"{prefix}-metastore",
        ForceDestroy = true,
    });

    var thisMetastore = new Databricks.Metastore("this", new()
    {
        Name = "primary",
        StorageRoot = metastore.Id.Apply(id => $"s3://{id}/metastore"),
        Owner = unityAdminGroup,
        ForceDestroy = true,
    });

    var @this = Databricks.GetMetastore.Invoke(new()
    {
        MetastoreId = thisMetastore.Id,
    });

    return new Dictionary<string, object?>
    {
        ["someMetastore"] = @this.Apply(@this => @this.Apply(getMetastoreResult => getMetastoreResult.MetastoreInfo)),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.s3.BucketV2;
import com.pulumi.aws.s3.BucketV2Args;
import com.pulumi.databricks.Metastore;
import com.pulumi.databricks.MetastoreArgs;
import com.pulumi.databricks.DatabricksFunctions;
import com.pulumi.databricks.inputs.GetMetastoreArgs;
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 metastore = new BucketV2("metastore", BucketV2Args.builder()
            .bucket(String.format("%s-metastore", prefix))
            .forceDestroy(true)
            .build());

        var thisMetastore = new Metastore("thisMetastore", MetastoreArgs.builder()
            .name("primary")
            .storageRoot(metastore.id().applyValue(id -> String.format("s3://%s/metastore", id)))
            .owner(unityAdminGroup)
            .forceDestroy(true)
            .build());

        final var this = DatabricksFunctions.getMetastore(GetMetastoreArgs.builder()
            .metastoreId(thisMetastore.id())
            .build());

        ctx.export("someMetastore", this_.applyValue(this_ -> this_.metastoreInfo()));
    }
}

resources:
  metastore:
    type: aws:s3:BucketV2
    properties:
      bucket: ${prefix}-metastore
      forceDestroy: true
  thisMetastore:
    type: databricks:Metastore
    name: this
    properties:
      name: primary
      storageRoot: s3://${metastore.id}/metastore
      owner: ${unityAdminGroup}
      forceDestroy: true
variables:
  this:
    fn::invoke:
      function: databricks:getMetastore
      arguments:
        metastoreId: ${thisMetastore.id}
outputs:
  someMetastore: ${this.metastoreInfo}

def get_metastore(id: Optional[str] = None,
                  metastore_id: Optional[str] = None,
                  metastore_info: Optional[GetMetastoreMetastoreInfo] = None,
                  name: Optional[str] = None,
                  region: Optional[str] = None,
                  opts: Optional[InvokeOptions] = None) -> GetMetastoreResult
def get_metastore_output(id: Optional[pulumi.Input[str]] = None,
                  metastore_id: Optional[pulumi.Input[str]] = None,
                  metastore_info: Optional[pulumi.Input[GetMetastoreMetastoreInfoArgs]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  region: Optional[pulumi.Input[str]] = None,
                  opts: Optional[InvokeOptions] = None) -> Output[GetMetastoreResult]

func LookupMetastore(ctx *Context, args *LookupMetastoreArgs, opts ...InvokeOption) (*LookupMetastoreResult, error)
func LookupMetastoreOutput(ctx *Context, args *LookupMetastoreOutputArgs, opts ...InvokeOption) LookupMetastoreResultOutput

public static class GetMetastore 
{
    public static Task<GetMetastoreResult> InvokeAsync(GetMetastoreArgs args, InvokeOptions? opts = null)
    public static Output<GetMetastoreResult> Invoke(GetMetastoreInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetMetastoreResult> getMetastore(GetMetastoreArgs args, InvokeOptions options)
public static Output<GetMetastoreResult> getMetastore(GetMetastoreArgs args, InvokeOptions options)

fn::invoke:
  function: databricks:index/getMetastore:getMetastore
  arguments:
    # arguments dictionary