rabbitmq.Permissions

import pulumi
import pulumi_rabbitmq as rabbitmq

test = rabbitmq.VHost("test", name="test")
test_user = rabbitmq.User("test",
    name="mctest",
    password="foobar",
    tags=["administrator"])
test_permissions = rabbitmq.Permissions("test",
    user=test_user.name,
    vhost=test.name,
    permissions={
        "configure": ".*",
        "write": ".*",
        "read": ".*",
    })

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		test, err := rabbitmq.NewVHost(ctx, "test", &rabbitmq.VHostArgs{
			Name: pulumi.String("test"),
		})
		if err != nil {
			return err
		}
		testUser, err := rabbitmq.NewUser(ctx, "test", &rabbitmq.UserArgs{
			Name:     pulumi.String("mctest"),
			Password: pulumi.String("foobar"),
			Tags: pulumi.StringArray{
				pulumi.String("administrator"),
			},
		})
		if err != nil {
			return err
		}
		_, err = rabbitmq.NewPermissions(ctx, "test", &rabbitmq.PermissionsArgs{
			User:  testUser.Name,
			Vhost: test.Name,
			Permissions: &rabbitmq.PermissionsPermissionsArgs{
				Configure: pulumi.String(".*"),
				Write:     pulumi.String(".*"),
				Read:      pulumi.String(".*"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var test = new RabbitMQ.VHost("test", new()
    {
        Name = "test",
    });

    var testUser = new RabbitMQ.User("test", new()
    {
        Name = "mctest",
        Password = "foobar",
        Tags = new[]
        {
            "administrator",
        },
    });

    var testPermissions = new RabbitMQ.Permissions("test", new()
    {
        User = testUser.Name,
        Vhost = test.Name,
        PermissionDetails = new RabbitMQ.Inputs.PermissionsPermissionsArgs
        {
            Configure = ".*",
            Write = ".*",
            Read = ".*",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.rabbitmq.VHost;
import com.pulumi.rabbitmq.VHostArgs;
import com.pulumi.rabbitmq.User;
import com.pulumi.rabbitmq.UserArgs;
import com.pulumi.rabbitmq.Permissions;
import com.pulumi.rabbitmq.PermissionsArgs;
import com.pulumi.rabbitmq.inputs.PermissionsPermissionsArgs;
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 test = new VHost("test", VHostArgs.builder()
            .name("test")
            .build());

        var testUser = new User("testUser", UserArgs.builder()
            .name("mctest")
            .password("foobar")
            .tags("administrator")
            .build());

        var testPermissions = new Permissions("testPermissions", PermissionsArgs.builder()
            .user(testUser.name())
            .vhost(test.name())
            .permissions(PermissionsPermissionsArgs.builder()
                .configure(".*")
                .write(".*")
                .read(".*")
                .build())
            .build());

    }
}

resources:
  test:
    type: rabbitmq:VHost
    properties:
      name: test
  testUser:
    type: rabbitmq:User
    name: test
    properties:
      name: mctest
      password: foobar
      tags:
        - administrator
  testPermissions:
    type: rabbitmq:Permissions
    name: test
    properties:
      user: ${testUser.name}
      vhost: ${test.name}
      permissions:
        configure: .*
        write: .*
        read: .*

var permissionsResource = new RabbitMQ.Permissions("permissionsResource", new()
{
    PermissionDetails = new RabbitMQ.Inputs.PermissionsPermissionsArgs
    {
        Configure = "string",
        Read = "string",
        Write = "string",
    },
    User = "string",
    Vhost = "string",
});

example, err := rabbitmq.NewPermissions(ctx, "permissionsResource", &rabbitmq.PermissionsArgs{
	Permissions: &rabbitmq.PermissionsPermissionsArgs{
		Configure: pulumi.String("string"),
		Read:      pulumi.String("string"),
		Write:     pulumi.String("string"),
	},
	User:  pulumi.String("string"),
	Vhost: pulumi.String("string"),
})

var permissionsResource = new Permissions("permissionsResource", PermissionsArgs.builder()
    .permissions(PermissionsPermissionsArgs.builder()
        .configure("string")
        .read("string")
        .write("string")
        .build())
    .user("string")
    .vhost("string")
    .build());

permissions_resource = rabbitmq.Permissions("permissionsResource",
    permissions={
        "configure": "string",
        "read": "string",
        "write": "string",
    },
    user="string",
    vhost="string")

type: rabbitmq:Permissions
properties:
    permissions:
        configure: string
        read: string
        write: string
    user: string
    vhost: string