alicloud.cms.getDatasets

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

const config = new pulumi.Config();
const name = config.get("name") || "terraform-example";
const defaultProject = new alicloud.log.Project("default", {projectName: name});
const defaultWorkspace = new alicloud.cms.Workspace("default", {
    workspaceName: name,
    slsProject: defaultProject.projectName,
});
const defaultDataset = new alicloud.cms.Dataset("default", {
    workspace: defaultWorkspace.workspaceName,
    datasetName: name,
    description: "terraform-example",
    schema: JSON.stringify({
        type: "record",
        name: "example",
        fields: [{
            name: "metric",
            type: "string",
        }],
    }),
});
const _default = alicloud.cms.getDatasetsOutput({
    workspace: defaultWorkspace.workspaceName,
    ids: [defaultDataset.id],
});
export const cmsDatasetId1 = _default.apply(_default => _default.datasets?.[0]?.id);

import pulumi
import json
import pulumi_alicloud as alicloud

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "terraform-example"
default_project = alicloud.log.Project("default", project_name=name)
default_workspace = alicloud.cms.Workspace("default",
    workspace_name=name,
    sls_project=default_project.project_name)
default_dataset = alicloud.cms.Dataset("default",
    workspace=default_workspace.workspace_name,
    dataset_name=name,
    description="terraform-example",
    schema=json.dumps({
        "type": "record",
        "name": "example",
        "fields": [{
            "name": "metric",
            "type": "string",
        }],
    }))
default = alicloud.cms.get_datasets_output(workspace=default_workspace.workspace_name,
    ids=[default_dataset.id])
pulumi.export("cmsDatasetId1", default.datasets[0].id)

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/cms"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/log"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		name := "terraform-example"
		if param := cfg.Get("name"); param != "" {
			name = param
		}
		defaultProject, err := log.NewProject(ctx, "default", &log.ProjectArgs{
			ProjectName: pulumi.String(name),
		})
		if err != nil {
			return err
		}
		defaultWorkspace, err := cms.NewWorkspace(ctx, "default", &cms.WorkspaceArgs{
			WorkspaceName: pulumi.String(name),
			SlsProject:    defaultProject.ProjectName,
		})
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"type": "record",
			"name": "example",
			"fields": []map[string]string{
				{
					"name": "metric",
					"type": "string",
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		defaultDataset, err := cms.NewDataset(ctx, "default", &cms.DatasetArgs{
			Workspace:   defaultWorkspace.WorkspaceName,
			DatasetName: pulumi.String(name),
			Description: pulumi.String("terraform-example"),
			Schema:      pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		_default := cms.GetDatasetsOutput(ctx, cms.GetDatasetsOutputArgs{
			Workspace: defaultWorkspace.WorkspaceName,
			Ids: pulumi.StringArray{
				defaultDataset.ID().ToIDOutput().ToStringOutput(),
			},
		}, nil)
		ctx.Export("cmsDatasetId1", _default.ApplyT(func(_default cms.GetDatasetsResult) (*string, error) {
			return _default.Datasets[0].Id, nil
		}).(pulumi.StringPtrOutput))
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using AliCloud = Pulumi.AliCloud;

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var name = config.Get("name") ?? "terraform-example";
    var defaultProject = new AliCloud.Log.Project("default", new()
    {
        ProjectName = name,
    });

    var defaultWorkspace = new AliCloud.Cms.Workspace("default", new()
    {
        WorkspaceName = name,
        SlsProject = defaultProject.ProjectName,
    });

    var defaultDataset = new AliCloud.Cms.Dataset("default", new()
    {
        Workspace = defaultWorkspace.WorkspaceName,
        DatasetName = name,
        Description = "terraform-example",
        Schema = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["type"] = "record",
            ["name"] = "example",
            ["fields"] = new[]
            {
                new Dictionary<string, object?>
                {
                    ["name"] = "metric",
                    ["type"] = "string",
                },
            },
        }),
    });

    var @default = AliCloud.Cms.GetDatasets.Invoke(new()
    {
        Workspace = defaultWorkspace.WorkspaceName,
        Ids = new[]
        {
            defaultDataset.Id,
        },
    });

    return new Dictionary<string, object?>
    {
        ["cmsDatasetId1"] = @default.Apply(@default => @default.Apply(getDatasetsResult => getDatasetsResult.Datasets[0]?.Id)),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.log.Project;
import com.pulumi.alicloud.log.ProjectArgs;
import com.pulumi.alicloud.cms.Workspace;
import com.pulumi.alicloud.cms.WorkspaceArgs;
import com.pulumi.alicloud.cms.Dataset;
import com.pulumi.alicloud.cms.DatasetArgs;
import com.pulumi.alicloud.cms.CmsFunctions;
import com.pulumi.alicloud.cms.inputs.GetDatasetsArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import java.util.ArrayList;
import java.util.Arrays;
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 config = ctx.config();
        final var name = config.get("name").orElse("terraform-example");
        var defaultProject = new Project("defaultProject", ProjectArgs.builder()
            .projectName(name)
            .build());

        var defaultWorkspace = new Workspace("defaultWorkspace", WorkspaceArgs.builder()
            .workspaceName(name)
            .slsProject(defaultProject.projectName())
            .build());

        var defaultDataset = new Dataset("defaultDataset", DatasetArgs.builder()
            .workspace(defaultWorkspace.workspaceName())
            .datasetName(name)
            .description("terraform-example")
            .schema(serializeJson(
                jsonObject(
                    jsonProperty("type", "record"),
                    jsonProperty("name", "example"),
                    jsonProperty("fields", jsonArray(jsonObject(
                        jsonProperty("name", "metric"),
                        jsonProperty("type", "string")
                    )))
                )))
            .build());

        final var default = CmsFunctions.getDatasets(GetDatasetsArgs.builder()
            .workspace(defaultWorkspace.workspaceName())
            .ids(defaultDataset.id())
            .build());

        ctx.export("cmsDatasetId1", default_.applyValue(_default_ -> _default_.datasets()[0].id()));
    }
}

configuration:
  name:
    type: string
    default: terraform-example
resources:
  defaultProject:
    type: alicloud:log:Project
    name: default
    properties:
      projectName: ${name}
  defaultWorkspace:
    type: alicloud:cms:Workspace
    name: default
    properties:
      workspaceName: ${name}
      slsProject: ${defaultProject.projectName}
  defaultDataset:
    type: alicloud:cms:Dataset
    name: default
    properties:
      workspace: ${defaultWorkspace.workspaceName}
      datasetName: ${name}
      description: terraform-example
      schema:
        fn::toJSON:
          type: record
          name: example
          fields:
            - name: metric
              type: string
variables:
  default:
    fn::invoke:
      function: alicloud:cms:getDatasets
      arguments:
        workspace: ${defaultWorkspace.workspaceName}
        ids:
          - ${defaultDataset.id}
outputs:
  cmsDatasetId1: ${default.datasets[0].id}

pulumi {
  required_providers {
    alicloud = {
      source = "pulumi/alicloud"
    }
  }
}

data "alicloud_cms_getdatasets" "default" {
  workspace = alicloud_cms_workspace.default.workspace_name
  ids       = [alicloud_cms_dataset.default.id]
}

resource "alicloud_log_project" "default" {
  project_name = var.name
}
resource "alicloud_cms_workspace" "default" {
  workspace_name = var.name
  sls_project    = alicloud_log_project.default.project_name
}
resource "alicloud_cms_dataset" "default" {
  workspace    = alicloud_cms_workspace.default.workspace_name
  dataset_name = var.name
  description  = "terraform-example"
  schema = jsonencode({
    "type" = "record"
    "name" = "example"
    "fields" = [{
      "name" = "metric"
      "type" = "string"
    }]
  })
}
variable "name" {
  type    = string
  default = "terraform-example"
}
output "cmsDatasetId1" {
  value = data.alicloud_cms_getdatasets.default.datasets[0].id
}

function getDatasets(args: GetDatasetsArgs, opts?: InvokeOptions): Promise<GetDatasetsResult>
function getDatasetsOutput(args: GetDatasetsOutputArgs, opts?: InvokeOutputOptions): Output<GetDatasetsResult>

def get_datasets(dataset_name_regex: Optional[str] = None,
                 ids: Optional[Sequence[str]] = None,
                 output_file: Optional[str] = None,
                 workspace: Optional[str] = None,
                 opts: Optional[InvokeOptions] = None) -> GetDatasetsResult
def get_datasets_output(dataset_name_regex: pulumi.Input[Optional[str]] = None,
                 ids: pulumi.Input[Optional[Sequence[pulumi.Input[str]]]] = None,
                 output_file: pulumi.Input[Optional[str]] = None,
                 workspace: pulumi.Input[Optional[str]] = None,
                 opts: Optional[InvokeOutputOptions] = None) -> Output[GetDatasetsResult]

func GetDatasets(ctx *Context, args *GetDatasetsArgs, opts ...InvokeOption) (*GetDatasetsResult, error)
func GetDatasetsOutput(ctx *Context, args *GetDatasetsOutputArgs, opts ...InvokeOption) GetDatasetsResultOutput

public static class GetDatasets 
{
    public static Task<GetDatasetsResult> InvokeAsync(GetDatasetsArgs args, InvokeOptions? opts = null)
    public static Output<GetDatasetsResult> Invoke(GetDatasetsInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetDatasetsResult> Invoke(GetDatasetsInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetDatasetsResult> getDatasets(GetDatasetsArgs args, InvokeOptions options)
public static Output<GetDatasetsResult> getDatasets(GetDatasetsArgs args, InvokeOptions options)
public static Output<GetDatasetsResult> getDatasets(GetDatasetsArgs args, InvokeOutputOptions options)

fn::invoke:
  function: alicloud:cms/getDatasets:getDatasets
  arguments:
    # arguments dictionary

data "alicloud_cms_get_datasets" "name" {
    # arguments
}