nomad.getNamespaces

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

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

import pulumi
import pulumi_nomad as nomad

namespaces = nomad.get_namespaces()
namespace = []
def create_namespace(range_body):
    for range in [{"value": i} for i in range(0, range_body)]:
        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\"
}}
"""))

(len(namespaces.namespaces)).apply(create_namespace)

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 Pulumi;
using Nomad = Pulumi.Nomad;

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

    var @namespace = new List<Nomad.AclPolicy>();
    for (var rangeIndex = 0; rangeIndex < namespaces.Apply(getNamespacesResult => getNamespacesResult.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