provider/aws: Support suspending auto scaling group processes

builtin/providers/aws/resource_aws_autoscaling_group.go

@@ -109,6 +109,13 @@ func resourceAwsAutoscalingGroup() *schema.Resource {
 				Set:      schema.HashString,
 			},
 
+			"suspended_processes": &schema.Schema{
+				Type:     schema.TypeSet,
+				Optional: true,
+				Elem:     &schema.Schema{Type: schema.TypeString},
+				Set:      schema.HashString,
+			},
+
 			"vpc_zone_identifier": &schema.Schema{
 				Type:     schema.TypeSet,
 				Optional: true,
@@ -232,10 +239,15 @@ func resourceAwsAutoscalingGroupCreate(d *schema.ResourceData, meta interface{})
 		return fmt.Errorf("Error creating Autoscaling Group: %s", err)
 	}
 
+	if err := updateSuspendedProcesses(d, meta); err != nil {
+		return err
+	}
+
 	d.SetId(d.Get("name").(string))
+
 	log.Printf("[INFO] AutoScaling Group ID: %s", d.Id())
 
-	if err := waitForASGCapacity(d, meta, capacitySatifiedCreate); err != nil {
+	if err := waitForASGCapacity(d, meta); err != nil {
 		return err
 	}
 
@@ -273,6 +285,7 @@ func resourceAwsAutoscalingGroupRead(d *schema.ResourceData, meta interface{}) e
 	d.Set("max_size", g.MaxSize)
 	d.Set("placement_group", g.PlacementGroup)
 	d.Set("name", g.AutoScalingGroupName)
+	d.Set("suspended_processes", flattenSuspendedProcesses(g.SuspendedProcesses))
 	d.Set("tag", g.Tags)
 	d.Set("vpc_zone_identifier", strings.Split(*g.VPCZoneIdentifier, ","))
 
@@ -298,7 +311,6 @@ func resourceAwsAutoscalingGroupRead(d *schema.ResourceData, meta interface{}) e
 
 func resourceAwsAutoscalingGroupUpdate(d *schema.ResourceData, meta interface{}) error {
 	conn := meta.(*AWSClient).autoscalingconn
-	shouldWaitForCapacity := false
 
 	opts := autoscaling.UpdateAutoScalingGroupInput{
 		AutoScalingGroupName: aws.String(d.Id()),
@@ -310,7 +322,6 @@ func resourceAwsAutoscalingGroupUpdate(d *schema.ResourceData, meta interface{})
 
 	if d.HasChange("desired_capacity") {
 		opts.DesiredCapacity = aws.Int64(int64(d.Get("desired_capacity").(int)))
-		shouldWaitForCapacity = true
 	}
 
 	if d.HasChange("launch_configuration") {
@@ -319,7 +330,6 @@ func resourceAwsAutoscalingGroupUpdate(d *schema.ResourceData, meta interface{})
 
 	if d.HasChange("min_size") {
 		opts.MinSize = aws.Int64(int64(d.Get("min_size").(int)))
-		shouldWaitForCapacity = true
 	}
 
 	if d.HasChange("max_size") {
@@ -360,12 +370,16 @@ func resourceAwsAutoscalingGroupUpdate(d *schema.ResourceData, meta interface{})
 		}
 	}
 
+	if err := updateSuspendedProcesses(d, meta); err != nil {
+		return err
+	}
+
 	if err := setAutoscalingTags(conn, d); err != nil {
 		return err
-	} else {
-		d.SetPartial("tag")
 	}
 
+	d.SetPartial("tag")
+
 	log.Printf("[DEBUG] AutoScaling Group update configuration: %#v", opts)
 	_, err := conn.UpdateAutoScalingGroup(&opts)
 	if err != nil {
@@ -409,8 +423,8 @@ func resourceAwsAutoscalingGroupUpdate(d *schema.ResourceData, meta interface{})
 		}
 	}
 
-	if shouldWaitForCapacity {
-		waitForASGCapacity(d, meta, capacitySatifiedUpdate)
+	if err := waitForASGCapacity(d, meta); err != nil {
+		return err
 	}
 
 	if d.HasChange("enabled_metrics") {
@@ -643,3 +657,46 @@ func expandVpcZoneIdentifiers(list []interface{}) *string {
 	}
 	return aws.String(strings.Join(strs, ","))
 }
+
+func flattenSuspendedProcesses(procs []*autoscaling.SuspendedProcess) []string {
+	names := make([]string, len(procs))
+	for i, p := range procs {
+		names[i] = *p.ProcessName
+	}
+	return names
+}
+
+func updateSuspendedProcesses(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).autoscalingconn
+
+	if d.HasChange("suspended_processes") {
+		old, new := d.GetChange("suspended_processes")
+		oldSet := old.(*schema.Set)
+		newSet := new.(*schema.Set)
+
+		added := newSet.Difference(oldSet).List()
+		if len(added) > 0 {
+			_, err := conn.SuspendProcesses(&autoscaling.ScalingProcessQuery{
+				AutoScalingGroupName: aws.String(d.Get("name").(string)),
+				ScalingProcesses:     expandStringList(added),
+			})
+			if err != nil {
+				return fmt.Errorf("Failure suspending scaling processes: %s", err)
+			}
+		}
+
+		removed := oldSet.Difference(newSet).List()
+		if len(removed) > 0 {
+			_, err := conn.ResumeProcesses(&autoscaling.ScalingProcessQuery{
+				AutoScalingGroupName: aws.String(d.Get("name").(string)),
+				ScalingProcesses:     expandStringList(removed),
+			})
+			if err != nil {
+				return fmt.Errorf("Failure resuming scaling processes: %s", err)
+			}
+		}
+		d.SetPartial("suspended_processes")
+	}
+
+	return nil
+}

builtin/providers/aws/resource_aws_autoscaling_group_test.go

@@ -136,6 +136,41 @@ func TestAccAWSAutoScalingGroup_terminationPolicies(t *testing.T) {
 	})
 }
 
+func TestAccAWSAutoScalingGroup_suspendedProcceses(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckAWSAutoScalingGroupDestroy,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccAWSAutoScalingGroupConfig_suspendedProcessesNone,
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr(
+						"aws_autoscaling_group.bar", "suspended_processes.#", "0"),
+				),
+			},
+			resource.TestStep{
+				Config: testAccAWSAutoScalingGroupConfig_suspendedProcessesUpdate,
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr(
+						"aws_autoscaling_group.bar", "suspended_processes.#", "2"),
+					resource.TestCheckResourceAttr(
+						"aws_autoscaling_group.bar", "suspended_processes.997436260", "HealthCheck"),
+					resource.TestCheckResourceAttr(
+						"aws_autoscaling_group.bar", "suspended_processes.2282213524", "ScheduledActions"),
+				),
+			},
+			resource.TestStep{
+				Config: testAccAWSAutoScalingGroupConfig_suspendedProcessesNone,
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr(
+						"aws_autoscaling_group.bar", "suspended_processes.#", "0"),
+				),
+			},
+		},
+	})
+}
+
 func TestAccAWSAutoScalingGroup_tags(t *testing.T) {
 	var group autoscaling.Group
 
@@ -539,6 +574,41 @@ resource "aws_autoscaling_group" "bar" {
 }
 `
 
+const testAccAWSAutoScalingGroupConfig_suspendedProcessesNone = `
+resource "aws_launch_configuration" "foobar" {
+  image_id = "ami-21f78e11"
+  instance_type = "t1.micro"
+}
+
+resource "aws_autoscaling_group" "bar" {
+  availability_zones = ["us-west-2a"]
+  desired_capacity = 0
+  max_size = 0
+  min_size = 0
+  launch_configuration = "${aws_launch_configuration.foobar.name}"
+}
+`
+
+const testAccAWSAutoScalingGroupConfig_suspendedProcessesUpdate = `
+resource "aws_launch_configuration" "foobar" {
+  image_id = "ami-21f78e11"
+  instance_type = "t1.micro"
+}
+
+resource "aws_autoscaling_group" "bar" {
+  availability_zones = ["us-west-2a"]
+  desired_capacity = 0
+  max_size = 0
+  min_size = 0
+  launch_configuration = "${aws_launch_configuration.foobar.name}"
+
+  suspended_processes = [
+    "HealthCheck",
+    "ScheduledActions",
+  ]
+}
+`
+
 const testAccAWSAutoScalingGroupConfig = `
 resource "aws_launch_configuration" "foobar" {
   image_id = "ami-21f78e11"

builtin/providers/aws/resource_aws_autoscaling_group_waiting.go

@@ -16,10 +16,7 @@ import (
 // the capacitySatisfiedFunc returns true.
 //
 // See "Waiting for Capacity" in docs for more discussion of the feature.
-func waitForASGCapacity(
-	d *schema.ResourceData,
-	meta interface{},
-	satisfiedFunc capacitySatisfiedFunc) error {
+func waitForASGCapacity(d *schema.ResourceData, meta interface{}) error {
 	wait, err := time.ParseDuration(d.Get("wait_for_capacity_timeout").(string))
 	if err != nil {
 		return err
@@ -77,7 +74,7 @@ func waitForASGCapacity(
 			}
 		}
 
-		satisfied, reason := satisfiedFunc(d, haveASG, haveELB)
+		satisfied, reason := checkCapacitySatisfied(d, haveASG, haveELB)
 
 		log.Printf("[DEBUG] %q Capacity: %d ASG, %d ELB, satisfied: %t, reason: %q",
 			d.Id(), haveASG, haveELB, satisfied, reason)
@@ -91,42 +88,55 @@ func waitForASGCapacity(
 	})
 }
 
-type capacitySatisfiedFunc func(*schema.ResourceData, int, int) (bool, string)
+// checkCapacitySatisfied determines if required ASG and ELB targets are met.
+func checkCapacitySatisfied(d *schema.ResourceData, haveASG, haveELB int) (bool, string) {
+	isLaunchSuspended := false
+	isTerminateSuspended := false
+	if procs, ok := d.GetOk("suspended_processes"); ok {
+		for _, p := range procs.(*schema.Set).List() {
+			switch p.(string) {
+			case "Launch":
+				isLaunchSuspended = true
+			case "Terminate":
+				isTerminateSuspended = true
+			}
+		}
+	}
 
-// capacitySatifiedCreate treats all targets as minimums
-func capacitySatifiedCreate(d *schema.ResourceData, haveASG, haveELB int) (bool, string) {
-	minASG := d.Get("min_size").(int)
-	if wantASG := d.Get("desired_capacity").(int); wantASG > 0 {
-		minASG = wantASG
+	if desiredASG, ok := d.GetOk("desired_capacity"); ok && desiredASG.(int) > haveASG && !isLaunchSuspended {
+		return false, fmt.Sprintf(
+			"Need exactly %d healthy instances in ASG, have %d", desiredASG.(int), haveASG)
 	}
-	if haveASG < minASG {
+
+	if desiredASG, ok := d.GetOk("desired_capacity"); ok && desiredASG.(int) < haveASG && !isTerminateSuspended {
 		return false, fmt.Sprintf(
-			"Need at least %d healthy instances in ASG, have %d", minASG, haveASG)
+			"Need exactly %d healthy instances in ASG, have %d", desiredASG.(int), haveASG)
 	}
-	minELB := d.Get("min_elb_capacity").(int)
-	if wantELB := d.Get("wait_for_elb_capacity").(int); wantELB > 0 {
-		minELB = wantELB
+
+	if minASG, ok := d.GetOk("min_size"); ok && minASG.(int) > haveASG && !isLaunchSuspended {
+		return false, fmt.Sprintf(
+			"Need at least %d healthy instances in ASG, have %d", minASG.(int), haveASG)
 	}
-	if haveELB < minELB {
+
+	if maxASG, ok := d.GetOk("max_size"); ok && maxASG.(int) < haveASG && !isTerminateSuspended {
 		return false, fmt.Sprintf(
-			"Need at least %d healthy instances in ELB, have %d", minELB, haveELB)
+			"Need at most %d healthy instances in ASG, have %d", maxASG.(int), haveASG)
 	}
-	return true, ""
-}
 
-// capacitySatifiedUpdate only cares about specific targets
-func capacitySatifiedUpdate(d *schema.ResourceData, haveASG, haveELB int) (bool, string) {
-	if wantASG := d.Get("desired_capacity").(int); wantASG > 0 {
-		if haveASG != wantASG {
-			return false, fmt.Sprintf(
-				"Need exactly %d healthy instances in ASG, have %d", wantASG, haveASG)
-		}
+	if desiredELB, ok := d.GetOk("wait_for_elb_capacity"); ok && desiredELB.(int) > haveELB && !isLaunchSuspended {
+		return false, fmt.Sprintf(
+			"Need exactly %d healthy instances in ELB, have %d", desiredELB.(int), haveELB)
 	}
-	if wantELB := d.Get("wait_for_elb_capacity").(int); wantELB > 0 {
-		if haveELB != wantELB {
-			return false, fmt.Sprintf(
-				"Need exactly %d healthy instances in ELB, have %d", wantELB, haveELB)
-		}
+
+	if desiredELB, ok := d.GetOk("wait_for_elb_capacity"); ok && desiredELB.(int) < haveELB && !isTerminateSuspended {
+		return false, fmt.Sprintf(
+			"Need exactly %d healthy instances in ELB, have %d", desiredELB.(int), haveELB)
 	}
+
+	if minELB, ok := d.GetOk("min_elb_capacity"); ok && minELB.(int) > haveELB && !isLaunchSuspended {
+		return false, fmt.Sprintf(
+			"Need at least %d healthy instances in ELB, have %d", minELB.(int), haveELB)
+	}
+
 	return true, ""
 }