using Pulumi;
using AliCloud = Pulumi.AliCloud;

class MyStack : Stack
{
    public MyStack()
    {
        var config = new Config();
        var name = config.Get("name") ?? "tf-testAccEssNotification-%d";
        var defaultRegions = Output.Create(AliCloud.GetRegions.InvokeAsync(new AliCloud.GetRegionsArgs
        {
            Current = true,
        }));
        var defaultAccount = Output.Create(AliCloud.GetAccount.InvokeAsync());
        var defaultZones = Output.Create(AliCloud.GetZones.InvokeAsync(new AliCloud.GetZonesArgs
        {
            AvailableDiskCategory = "cloud_efficiency",
            AvailableResourceCreation = "VSwitch",
        }));
        var defaultNetwork = new AliCloud.Vpc.Network("defaultNetwork", new AliCloud.Vpc.NetworkArgs
        {
            VpcName = name,
            CidrBlock = "172.16.0.0/16",
        });
        var defaultSwitch = new AliCloud.Vpc.Switch("defaultSwitch", new AliCloud.Vpc.SwitchArgs
        {
            VpcId = defaultNetwork.Id,
            CidrBlock = "172.16.0.0/24",
            ZoneId = defaultZones.Apply(defaultZones => defaultZones.Zones?[0]?.Id),
            VswitchName = name,
        });
        var defaultScalingGroup = new AliCloud.Ess.ScalingGroup("defaultScalingGroup", new AliCloud.Ess.ScalingGroupArgs
        {
            MinSize = 1,
            MaxSize = 1,
            ScalingGroupName = name,
            RemovalPolicies = 
            {
                "OldestInstance",
                "NewestInstance",
            },
            VswitchIds = 
            {
                defaultSwitch.Id,
            },
        });
        var defaultQueue = new AliCloud.Mns.Queue("defaultQueue", new AliCloud.Mns.QueueArgs
        {
        });
        var defaultNotification = new AliCloud.Ess.Notification("defaultNotification", new AliCloud.Ess.NotificationArgs
        {
            ScalingGroupId = defaultScalingGroup.Id,
            NotificationTypes = 
            {
                "AUTOSCALING:SCALE_OUT_SUCCESS",
                "AUTOSCALING:SCALE_OUT_ERROR",
            },
            NotificationArn = Output.Tuple(defaultRegions, defaultAccount, defaultQueue.Name).Apply(values =>
            {
                var defaultRegions = values.Item1;
                var defaultAccount = values.Item2;
                var name = values.Item3;
                return $"acs:ess:{defaultRegions.Regions?[0]?.Id}:{defaultAccount.Id}:queue/{name}";
            }),
        });
    }

}

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/ess"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/mns"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/vpc"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		name := fmt.Sprintf("%v%v%v", "tf-testAccEssNotification-", "%", "d")
		if param := cfg.Get("name"); param != "" {
			name = param
		}
		defaultRegions, err := alicloud.GetRegions(ctx, &GetRegionsArgs{
			Current: pulumi.BoolRef(true),
		}, nil)
		if err != nil {
			return err
		}
		defaultAccount, err := alicloud.GetAccount(ctx, nil, nil)
		if err != nil {
			return err
		}
		defaultZones, err := alicloud.GetZones(ctx, &GetZonesArgs{
			AvailableDiskCategory:     pulumi.StringRef("cloud_efficiency"),
			AvailableResourceCreation: pulumi.StringRef("VSwitch"),
		}, nil)
		if err != nil {
			return err
		}
		defaultNetwork, err := vpc.NewNetwork(ctx, "defaultNetwork", &vpc.NetworkArgs{
			VpcName:   pulumi.String(name),
			CidrBlock: pulumi.String("172.16.0.0/16"),
		})
		if err != nil {
			return err
		}
		defaultSwitch, err := vpc.NewSwitch(ctx, "defaultSwitch", &vpc.SwitchArgs{
			VpcId:       defaultNetwork.ID(),
			CidrBlock:   pulumi.String("172.16.0.0/24"),
			ZoneId:      pulumi.String(defaultZones.Zones[0].Id),
			VswitchName: pulumi.String(name),
		})
		if err != nil {
			return err
		}
		defaultScalingGroup, err := ess.NewScalingGroup(ctx, "defaultScalingGroup", &ess.ScalingGroupArgs{
			MinSize:          pulumi.Int(1),
			MaxSize:          pulumi.Int(1),
			ScalingGroupName: pulumi.String(name),
			RemovalPolicies: pulumi.StringArray{
				pulumi.String("OldestInstance"),
				pulumi.String("NewestInstance"),
			},
			VswitchIds: pulumi.StringArray{
				defaultSwitch.ID(),
			},
		})
		if err != nil {
			return err
		}
		defaultQueue, err := mns.NewQueue(ctx, "defaultQueue", nil)
		if err != nil {
			return err
		}
		_, err = ess.NewNotification(ctx, "defaultNotification", &ess.NotificationArgs{
			ScalingGroupId: defaultScalingGroup.ID(),
			NotificationTypes: pulumi.StringArray{
				pulumi.String("AUTOSCALING:SCALE_OUT_SUCCESS"),
				pulumi.String("AUTOSCALING:SCALE_OUT_ERROR"),
			},
			NotificationArn: defaultQueue.Name.ApplyT(func(name string) (string, error) {
				return fmt.Sprintf("%v%v%v%v%v%v", "acs:ess:", defaultRegions.Regions[0].Id, ":", defaultAccount.Id, ":queue/", name), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

import pulumi
import pulumi_alicloud as alicloud

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "tf-testAccEssNotification-%d"
default_regions = alicloud.get_regions(current=True)
default_account = alicloud.get_account()
default_zones = alicloud.get_zones(available_disk_category="cloud_efficiency",
    available_resource_creation="VSwitch")
default_network = alicloud.vpc.Network("defaultNetwork",
    vpc_name=name,
    cidr_block="172.16.0.0/16")
default_switch = alicloud.vpc.Switch("defaultSwitch",
    vpc_id=default_network.id,
    cidr_block="172.16.0.0/24",
    zone_id=default_zones.zones[0].id,
    vswitch_name=name)
default_scaling_group = alicloud.ess.ScalingGroup("defaultScalingGroup",
    min_size=1,
    max_size=1,
    scaling_group_name=name,
    removal_policies=[
        "OldestInstance",
        "NewestInstance",
    ],
    vswitch_ids=[default_switch.id])
default_queue = alicloud.mns.Queue("defaultQueue")
default_notification = alicloud.ess.Notification("defaultNotification",
    scaling_group_id=default_scaling_group.id,
    notification_types=[
        "AUTOSCALING:SCALE_OUT_SUCCESS",
        "AUTOSCALING:SCALE_OUT_ERROR",
    ],
    notification_arn=default_queue.name.apply(lambda name: f"acs:ess:{default_regions.regions[0].id}:{default_account.id}:queue/{name}"))

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

const config = new pulumi.Config();
const name = config.get("name") || `tf-testAccEssNotification-%d`;
const defaultRegions = alicloud.getRegions({
    current: true,
});
const defaultAccount = alicloud.getAccount({});
const defaultZones = alicloud.getZones({
    availableDiskCategory: "cloud_efficiency",
    availableResourceCreation: "VSwitch",
});
const defaultNetwork = new alicloud.vpc.Network("defaultNetwork", {
    vpcName: name,
    cidrBlock: "172.16.0.0/16",
});
const defaultSwitch = new alicloud.vpc.Switch("defaultSwitch", {
    vpcId: defaultNetwork.id,
    cidrBlock: "172.16.0.0/24",
    zoneId: defaultZones.then(defaultZones => defaultZones.zones?[0]?.id),
    vswitchName: name,
});
const defaultScalingGroup = new alicloud.ess.ScalingGroup("defaultScalingGroup", {
    minSize: 1,
    maxSize: 1,
    scalingGroupName: name,
    removalPolicies: [
        "OldestInstance",
        "NewestInstance",
    ],
    vswitchIds: [defaultSwitch.id],
});
const defaultQueue = new alicloud.mns.Queue("defaultQueue", {});
const defaultNotification = new alicloud.ess.Notification("defaultNotification", {
    scalingGroupId: defaultScalingGroup.id,
    notificationTypes: [
        "AUTOSCALING:SCALE_OUT_SUCCESS",
        "AUTOSCALING:SCALE_OUT_ERROR",
    ],
    notificationArn: pulumi.all([defaultRegions, defaultAccount, defaultQueue.name]).apply(([defaultRegions, defaultAccount, name]) => `acs:ess:${defaultRegions.regions?[0]?.id}:${defaultAccount.id}:queue/${name}`),
});