rabbitmq.TopicPermissions

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_topic_permissions = rabbitmq.TopicPermissions("test",
    user=test_user.name,
    vhost=test.name,
    permissions=[{
        "exchange": "amq.topic",
        "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.NewTopicPermissions(ctx, "test", &rabbitmq.TopicPermissionsArgs{
			User:  testUser.Name,
			Vhost: test.Name,
			Permissions: rabbitmq.TopicPermissionsPermissionArray{
				&rabbitmq.TopicPermissionsPermissionArgs{
					Exchange: pulumi.String("amq.topic"),
					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 testTopicPermissions = new RabbitMQ.TopicPermissions("test", new()
    {
        User = testUser.Name,
        Vhost = test.Name,
        Permissions = new[]
        {
            new RabbitMQ.Inputs.TopicPermissionsPermissionArgs
            {
                Exchange = "amq.topic",
                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.TopicPermissions;
import com.pulumi.rabbitmq.TopicPermissionsArgs;
import com.pulumi.rabbitmq.inputs.TopicPermissionsPermissionArgs;
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 testTopicPermissions = new TopicPermissions("testTopicPermissions", TopicPermissionsArgs.builder()
            .user(testUser.name())
            .vhost(test.name())
            .permissions(TopicPermissionsPermissionArgs.builder()
                .exchange("amq.topic")
                .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
  testTopicPermissions:
    type: rabbitmq:TopicPermissions
    name: test
    properties:
      user: ${testUser.name}
      vhost: ${test.name}
      permissions:
        - exchange: amq.topic
          write: .*
          read: .*

var topicPermissionsResource = new RabbitMQ.TopicPermissions("topicPermissionsResource", new()
{
    Permissions = new[]
    {
        new RabbitMQ.Inputs.TopicPermissionsPermissionArgs
        {
            Exchange = "string",
            Read = "string",
            Write = "string",
        },
    },
    User = "string",
    Vhost = "string",
});

example, err := rabbitmq.NewTopicPermissions(ctx, "topicPermissionsResource", &rabbitmq.TopicPermissionsArgs{
	Permissions: rabbitmq.TopicPermissionsPermissionArray{
		&rabbitmq.TopicPermissionsPermissionArgs{
			Exchange: pulumi.String("string"),
			Read:     pulumi.String("string"),
			Write:    pulumi.String("string"),
		},
	},
	User:  pulumi.String("string"),
	Vhost: pulumi.String("string"),
})

var topicPermissionsResource = new TopicPermissions("topicPermissionsResource", TopicPermissionsArgs.builder()
    .permissions(TopicPermissionsPermissionArgs.builder()
        .exchange("string")
        .read("string")
        .write("string")
        .build())
    .user("string")
    .vhost("string")
    .build());

topic_permissions_resource = rabbitmq.TopicPermissions("topicPermissionsResource",
    permissions=[{
        "exchange": "string",
        "read": "string",
        "write": "string",
    }],
    user="string",
    vhost="string")

type: rabbitmq:TopicPermissions
properties:
    permissions:
        - exchange: string
          read: string
          write: string
    user: string
    vhost: string