nomad.getNamespaces

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

export = async () => {
    const namespaces = await nomad.getNamespaces({});
    const namespace: nomad.AclPolicy[] = [];
    for (const range = {value: 0}; range.value < namespaces.namespaces.length; range.value++) {
        namespace.push(new nomad.AclPolicy(`namespace-${range.value}`, {
            name: `namespace-${namespaces[range.value]}`,
            description: `Write to the namespace ${namespaces[range.value]}`,
            rulesHcl: `namespace "${namespaces[range.value]}" {
  policy = "write"
}
`,
        }));
    }
}

import pulumi
import pulumi_nomad as nomad

namespaces = nomad.get_namespaces()
namespace = []
for range in [{"value": i} for i in range(0, len(namespaces.namespaces))]:
    namespace.append(nomad.AclPolicy(f"namespace-{range['value']}",
        name=f"namespace-{namespaces[range['value']]}",
        description=f"Write to the namespace {namespaces[range['value']]}",
        rules_hcl=f"""namespace "{namespaces[range["value"]]}" {{
  policy = "write"
}}
"""))

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-nomad/sdk/v2/go/nomad"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		namespaces, err := nomad.GetNamespaces(ctx, map[string]interface{}{}, nil)
		if err != nil {
			return err
		}
		var namespace []*nomad.AclPolicy
		for index := 0; index < int(len(namespaces.Namespaces)); index++ {
			key0 := index
			val0 := index
			__res, err := nomad.NewAclPolicy(ctx, fmt.Sprintf("namespace-%v", key0), &nomad.AclPolicyArgs{
				Name:        pulumi.Sprintf("namespace-%v", namespaces[val0]),
				Description: pulumi.Sprintf("Write to the namespace %v", namespaces[val0]),
				RulesHcl:    pulumi.Sprintf("namespace \"%v\" {\n  policy = \"write\"\n}\n", namespaces[val0]),
			})
			if err != nil {
				return err
			}
			namespace = append(namespace, __res)
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Pulumi;
using Nomad = Pulumi.Nomad;

return await Deployment.RunAsync(async() => 
{
    var namespaces = await Nomad.GetNamespaces.InvokeAsync();

    var @namespace = new List<Nomad.AclPolicy>();
    for (var rangeIndex = 0; rangeIndex < namespaces.Namespaces.Length; rangeIndex++)
    {
        var range = new { Value = rangeIndex };
        @namespace.Add(new Nomad.AclPolicy($"namespace-{range.Value}", new()
        {
            Name = $"namespace-{namespaces[range.Value]}",
            Description = $"Write to the namespace {namespaces[range.Value]}",
            RulesHcl = @$"namespace ""{namespaces[range.Value]}"" {{
  policy = ""write""
}}
",
        }));
    }
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.nomad.NomadFunctions;
import com.pulumi.nomad.AclPolicy;
import com.pulumi.nomad.AclPolicyArgs;
import com.pulumi.codegen.internal.KeyedValue;
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 namespaces = NomadFunctions.getNamespaces(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference);

        for (var i = 0; i < namespaces.namespaces().length(); i++) {
            new AclPolicy("namespace-" + i, AclPolicyArgs.builder()
                .name(String.format("namespace-%s", namespaces[range.value()]))
                .description(String.format("Write to the namespace %s", namespaces[range.value()]))
                .rulesHcl("""
namespace "%s" {
  policy = "write"
}
", namespaces[range.value()]))
                .build());

        
}
    }
}

function getNamespaces(opts?: InvokeOptions): Promise<GetNamespacesResult>
function getNamespacesOutput(opts?: InvokeOptions): Output<GetNamespacesResult>

def get_namespaces(opts: Optional[InvokeOptions] = None) -> GetNamespacesResult
def get_namespaces_output(opts: Optional[InvokeOptions] = None) -> Output[GetNamespacesResult]

func GetNamespaces(ctx *Context, opts ...InvokeOption) (*GetNamespacesResult, error)
func GetNamespacesOutput(ctx *Context, opts ...InvokeOption) GetNamespacesResultOutput

public static class GetNamespaces 
{
    public static Task<GetNamespacesResult> InvokeAsync(InvokeOptions? opts = null)
    public static Output<GetNamespacesResult> Invoke(InvokeOptions? opts = null)
}

public static CompletableFuture<GetNamespacesResult> getNamespaces(InvokeOptions options)
public static Output<GetNamespacesResult> getNamespaces(InvokeOptions options)

fn::invoke:
  function: nomad:index/getNamespaces:getNamespaces
  arguments:
    # arguments dictionary