xenorchestra.Acl

import * as pulumi from "@pulumi/pulumi";
import * as xenorchestra from "@pulumi/xenorchestra";
import * as xenorchestra from "@vates/pulumi-xenorchestra";

const pool = xenorchestra.getXoaPool({
    nameLabel: "Your pool",
});
const user = xenorchestra.getXoaUser({
    username: "my-username",
});
const acl = new xenorchestra.Acl("acl", {
    subject: user.then(user => user.id),
    object: pool.then(pool => pool.id),
    action: "operator",
});

import pulumi
import pulumi_xenorchestra as xenorchestra

pool = xenorchestra.get_xoa_pool(name_label="Your pool")
user = xenorchestra.get_xoa_user(username="my-username")
acl = xenorchestra.Acl("acl",
    subject=user.id,
    object=pool.id,
    action="operator")

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/vatesfr/pulumi-xenorchestra/sdk/go/xenorchestra"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		pool, err := xenorchestra.GetXoaPool(ctx, &xenorchestra.GetXoaPoolArgs{
			NameLabel: "Your pool",
		}, nil)
		if err != nil {
			return err
		}
		user, err := xenorchestra.GetXoaUser(ctx, &xenorchestra.GetXoaUserArgs{
			Username: "my-username",
		}, nil)
		if err != nil {
			return err
		}
		_, err = xenorchestra.NewAcl(ctx, "acl", &xenorchestra.AclArgs{
			Subject: pulumi.String(user.Id),
			Object:  pulumi.String(pool.Id),
			Action:  pulumi.String("operator"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var pool = Xenorchestra.GetXoaPool.Invoke(new()
    {
        NameLabel = "Your pool",
    });

    var user = Xenorchestra.GetXoaUser.Invoke(new()
    {
        Username = "my-username",
    });

    var acl = new Xenorchestra.Acl("acl", new()
    {
        Subject = user.Apply(getXoaUserResult => getXoaUserResult.Id),
        Object = pool.Apply(getXoaPoolResult => getXoaPoolResult.Id),
        Action = "operator",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.xenorchestra.XenorchestraFunctions;
import com.pulumi.xenorchestra.inputs.GetXoaPoolArgs;
import com.pulumi.xenorchestra.inputs.GetXoaUserArgs;
import com.pulumi.xenorchestra.Acl;
import com.pulumi.xenorchestra.AclArgs;
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 pool = XenorchestraFunctions.getXoaPool(GetXoaPoolArgs.builder()
            .nameLabel("Your pool")
            .build());

        final var user = XenorchestraFunctions.getXoaUser(GetXoaUserArgs.builder()
            .username("my-username")
            .build());

        var acl = new Acl("acl", AclArgs.builder()
            .subject(user.applyValue(getXoaUserResult -> getXoaUserResult.id()))
            .object(pool.applyValue(getXoaPoolResult -> getXoaPoolResult.id()))
            .action("operator")
            .build());

    }
}

resources:
  acl:
    type: xenorchestra:Acl
    properties:
      subject: ${user.id}
      object: ${pool.id}
      action: operator
variables:
  pool:
    fn::invoke:
      function: xenorchestra:getXoaPool
      arguments:
        nameLabel: Your pool
  user:
    fn::invoke:
      function: xenorchestra:getXoaUser
      arguments:
        username: my-username

var aclResource = new Xenorchestra.Acl("aclResource", new()
{
    Action = "string",
    Object = "string",
    Subject = "string",
});

example, err := xenorchestra.NewAcl(ctx, "aclResource", &xenorchestra.AclArgs{
	Action:  pulumi.String("string"),
	Object:  pulumi.String("string"),
	Subject: pulumi.String("string"),
})

var aclResource = new Acl("aclResource", AclArgs.builder()
    .action("string")
    .object("string")
    .subject("string")
    .build());

acl_resource = xenorchestra.Acl("aclResource",
    action="string",
    object="string",
    subject="string")

const aclResource = new xenorchestra.Acl("aclResource", {
    action: "string",
    object: "string",
    subject: "string",
});

type: xenorchestra:Acl
properties:
    action: string
    object: string
    subject: string