acl.go

// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT.
// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***

package tailscale

import (
	"context"
	"reflect"

	"errors"
	"github.com/pulumi/pulumi-tailscale/sdk/go/tailscale/internal"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

// The acl resource allows you to configure a Tailscale ACL. See https://tailscale.com/kb/1018/acls for more information. Note that this resource will completely overwrite existing ACL contents for a given tailnet.
//
// If tests are defined in the ACL (the top-level "tests" section), ACL validation will occur before creation and update operations are applied.
//
// ## Example Usage
//
// ```go
// package main
//
// import (
//
//	"encoding/json"
//
//	"github.com/pulumi/pulumi-tailscale/sdk/go/tailscale"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			tmpJSON0, err := json.Marshal(map[string]interface{}{
//				"acls": []map[string]interface{}{
//					map[string]interface{}{
//						"action": "accept",
//						"users": []string{
//							"*",
//						},
//						"ports": []string{
//							"*:*",
//						},
//					},
//				},
//			})
//			if err != nil {
//				return err
//			}
//			json0 := string(tmpJSON0)
//			_, err = tailscale.NewAcl(ctx, "asJson", &tailscale.AclArgs{
//				Acl: pulumi.String(json0),
//			})
//			if err != nil {
//				return err
//			}
//			_, err = tailscale.NewAcl(ctx, "asHujson", &tailscale.AclArgs{
//				Acl: pulumi.String(`  {
//	    // Comments in HuJSON policy are preserved when the policy is applied.
//	    "acls": [
//	      {
//	        // Allow all users access to all ports.
//	        action = "accept",
//	        users  = ["*"],
//	        ports  = ["*:*"],
//	      },
//	    ],
//	  }
//
// `),
//
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
//
// ## Import
//
// ID doesn't matter.
//
// ```sh
// $ pulumi import tailscale:index/acl:Acl sample_acl acl
// ```
type Acl struct {
	pulumi.CustomResourceState

	// The policy that defines which devices and users are allowed to connect in your network. Can be either a JSON or a HuJSON string.
	Acl pulumi.StringOutput `pulumi:"acl"`
	// If true, will skip requirement to import acl before allowing changes. Be careful, can cause ACL to be overwritten
	OverwriteExistingContent pulumi.BoolPtrOutput `pulumi:"overwriteExistingContent"`
}

// NewAcl registers a new resource with the given unique name, arguments, and options.
func NewAcl(ctx *pulumi.Context,
	name string, args *AclArgs, opts ...pulumi.ResourceOption) (*Acl, error) {
	if args == nil {
		return nil, errors.New("missing one or more required arguments")
	}

	if args.Acl == nil {
		return nil, errors.New("invalid value for required argument 'Acl'")
	}
	opts = internal.PkgResourceDefaultOpts(opts)
	var resource Acl
	err := ctx.RegisterResource("tailscale:index/acl:Acl", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// GetAcl gets an existing Acl resource's state with the given name, ID, and optional
// state properties that are used to uniquely qualify the lookup (nil if not required).
func GetAcl(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *AclState, opts ...pulumi.ResourceOption) (*Acl, error) {
	var resource Acl
	err := ctx.ReadResource("tailscale:index/acl:Acl", name, id, state, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// Input properties used for looking up and filtering Acl resources.
type aclState struct {
	// The policy that defines which devices and users are allowed to connect in your network. Can be either a JSON or a HuJSON string.
	Acl *string `pulumi:"acl"`
	// If true, will skip requirement to import acl before allowing changes. Be careful, can cause ACL to be overwritten
	OverwriteExistingContent *bool `pulumi:"overwriteExistingContent"`
}

type AclState struct {
	// The policy that defines which devices and users are allowed to connect in your network. Can be either a JSON or a HuJSON string.
	Acl pulumi.StringPtrInput
	// If true, will skip requirement to import acl before allowing changes. Be careful, can cause ACL to be overwritten
	OverwriteExistingContent pulumi.BoolPtrInput
}

func (AclState) ElementType() reflect.Type {
	return reflect.TypeOf((*aclState)(nil)).Elem()
}

type aclArgs struct {
	// The policy that defines which devices and users are allowed to connect in your network. Can be either a JSON or a HuJSON string.
	Acl string `pulumi:"acl"`
	// If true, will skip requirement to import acl before allowing changes. Be careful, can cause ACL to be overwritten
	OverwriteExistingContent *bool `pulumi:"overwriteExistingContent"`
}

// The set of arguments for constructing a Acl resource.
type AclArgs struct {
	// The policy that defines which devices and users are allowed to connect in your network. Can be either a JSON or a HuJSON string.
	Acl pulumi.StringInput
	// If true, will skip requirement to import acl before allowing changes. Be careful, can cause ACL to be overwritten
	OverwriteExistingContent pulumi.BoolPtrInput
}

func (AclArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*aclArgs)(nil)).Elem()
}

type AclInput interface {
	pulumi.Input

	ToAclOutput() AclOutput
	ToAclOutputWithContext(ctx context.Context) AclOutput
}

func (*Acl) ElementType() reflect.Type {
	return reflect.TypeOf((**Acl)(nil)).Elem()
}

func (i *Acl) ToAclOutput() AclOutput {
	return i.ToAclOutputWithContext(context.Background())
}

func (i *Acl) ToAclOutputWithContext(ctx context.Context) AclOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AclOutput)
}

// AclArrayInput is an input type that accepts AclArray and AclArrayOutput values.
// You can construct a concrete instance of `AclArrayInput` via:
//
//	AclArray{ AclArgs{...} }
type AclArrayInput interface {
	pulumi.Input

	ToAclArrayOutput() AclArrayOutput
	ToAclArrayOutputWithContext(context.Context) AclArrayOutput
}

type AclArray []AclInput

func (AclArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]*Acl)(nil)).Elem()
}

func (i AclArray) ToAclArrayOutput() AclArrayOutput {
	return i.ToAclArrayOutputWithContext(context.Background())
}

func (i AclArray) ToAclArrayOutputWithContext(ctx context.Context) AclArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AclArrayOutput)
}

// AclMapInput is an input type that accepts AclMap and AclMapOutput values.
// You can construct a concrete instance of `AclMapInput` via:
//
//	AclMap{ "key": AclArgs{...} }
type AclMapInput interface {
	pulumi.Input

	ToAclMapOutput() AclMapOutput
	ToAclMapOutputWithContext(context.Context) AclMapOutput
}

type AclMap map[string]AclInput

func (AclMap) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string]*Acl)(nil)).Elem()
}

func (i AclMap) ToAclMapOutput() AclMapOutput {
	return i.ToAclMapOutputWithContext(context.Background())
}

func (i AclMap) ToAclMapOutputWithContext(ctx context.Context) AclMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AclMapOutput)
}

type AclOutput struct{ *pulumi.OutputState }

func (AclOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**Acl)(nil)).Elem()
}

func (o AclOutput) ToAclOutput() AclOutput {
	return o
}

func (o AclOutput) ToAclOutputWithContext(ctx context.Context) AclOutput {
	return o
}

// The policy that defines which devices and users are allowed to connect in your network. Can be either a JSON or a HuJSON string.
func (o AclOutput) Acl() pulumi.StringOutput {
	return o.ApplyT(func(v *Acl) pulumi.StringOutput { return v.Acl }).(pulumi.StringOutput)
}

// If true, will skip requirement to import acl before allowing changes. Be careful, can cause ACL to be overwritten
func (o AclOutput) OverwriteExistingContent() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *Acl) pulumi.BoolPtrOutput { return v.OverwriteExistingContent }).(pulumi.BoolPtrOutput)
}

type AclArrayOutput struct{ *pulumi.OutputState }

func (AclArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]*Acl)(nil)).Elem()
}

func (o AclArrayOutput) ToAclArrayOutput() AclArrayOutput {
	return o
}

func (o AclArrayOutput) ToAclArrayOutputWithContext(ctx context.Context) AclArrayOutput {
	return o
}

func (o AclArrayOutput) Index(i pulumi.IntInput) AclOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Acl {
		return vs[0].([]*Acl)[vs[1].(int)]
	}).(AclOutput)
}

type AclMapOutput struct{ *pulumi.OutputState }

func (AclMapOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string]*Acl)(nil)).Elem()
}

func (o AclMapOutput) ToAclMapOutput() AclMapOutput {
	return o
}

func (o AclMapOutput) ToAclMapOutputWithContext(ctx context.Context) AclMapOutput {
	return o
}

func (o AclMapOutput) MapIndex(k pulumi.StringInput) AclOutput {
	return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Acl {
		return vs[0].(map[string]*Acl)[vs[1].(string)]
	}).(AclOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*AclInput)(nil)).Elem(), &Acl{})
	pulumi.RegisterInputType(reflect.TypeOf((*AclArrayInput)(nil)).Elem(), AclArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*AclMapInput)(nil)).Elem(), AclMap{})
	pulumi.RegisterOutputType(AclOutput{})
	pulumi.RegisterOutputType(AclArrayOutput{})
	pulumi.RegisterOutputType(AclMapOutput{})
}