Spotfleet Launch Template and On-Demand Capacity Support

aws/resource_aws_spot_fleet_request.go

@@ -5,11 +5,13 @@ import (
 	"fmt"
 	"log"
 	"strconv"
+	"strings"
 	"time"
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/hashicorp/terraform/helper/customdiff"
 	"github.com/hashicorp/terraform/helper/hashcode"
 	"github.com/hashicorp/terraform/helper/resource"
 	"github.com/hashicorp/terraform/helper/schema"
@@ -53,9 +55,10 @@ func resourceAwsSpotFleetRequest() *schema.Resource {
 			// http://docs.aws.amazon.com/sdk-for-go/api/service/ec2.html#type-SpotFleetLaunchSpecification
 			// http://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_SpotFleetLaunchSpecification.html
 			"launch_specification": {
-				Type:     schema.TypeSet,
-				Required: true,
-				ForceNew: true,
+				Type:          schema.TypeSet,
+				Optional:      true,
+				ConflictsWith: []string{"launch_template_configs"},
+				ForceNew:      true,
 				Elem: &schema.Resource{
 					Schema: map[string]*schema.Schema{
 						"vpc_security_group_ids": {
@@ -273,7 +276,88 @@ func resourceAwsSpotFleetRequest() *schema.Resource {
 				},
 				Set: hashLaunchSpecification,
 			},
-			// Everything on a spot fleet is ForceNew except target_capacity
+			"launch_template_configs": {
+				Type:          schema.TypeSet,
+				Optional:      true,
+				ForceNew:      true,
+				ConflictsWith: []string{"launch_specification"},
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"launch_template_specification": {
+							Type:     schema.TypeList,
+							Required: true,
+							MaxItems: 1,
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"id": {
+										Type:          schema.TypeString,
+										Optional:      true,
+										Computed:      true,
+										ForceNew:      true,
+										ConflictsWith: []string{"launch_template_configs.0.launch_template_specification.0.name"},
+										ValidateFunc:  validateLaunchTemplateId,
+									},
+									"name": {
+										Type:          schema.TypeString,
+										Optional:      true,
+										Computed:      true,
+										ForceNew:      true,
+										ConflictsWith: []string{"launch_template_configs.0.launch_template_specification.0.id"},
+										ValidateFunc:  validateLaunchTemplateName,
+									},
+									"version": {
+										Type:         schema.TypeString,
+										Optional:     true,
+										Computed:     true,
+										ForceNew:     true,
+										ValidateFunc: validation.StringLenBetween(1, 255),
+									},
+								},
+							},
+						},
+						"overrides": {
+							Type:     schema.TypeSet,
+							Optional: true,
+							ForceNew: true,
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"availability_zone": {
+										Type:     schema.TypeString,
+										Optional: true,
+										ForceNew: true,
+									},
+									"instance_type": {
+										Type:     schema.TypeString,
+										Optional: true,
+										ForceNew: true,
+									},
+									"spot_price": {
+										Type:     schema.TypeString,
+										Optional: true,
+										Computed: true,
+										ForceNew: true,
+									},
+									"subnet_id": {
+										Type:     schema.TypeString,
+										Optional: true,
+										Computed: true,
+										ForceNew: true,
+									},
+									"weighted_capacity": {
+										Type:     schema.TypeFloat,
+										Optional: true,
+										Computed: true,
+										ForceNew: true,
+									},
+								},
+							},
+							Set: hashLaunchTemplateOverrides,
+						},
+					},
+				},
+			},
+			// Everything on a spot fleet is ForceNew except target_capacity and excess_capacity_termination_policy,
+			// see https://docs.aws.amazon.com/sdk-for-go/api/service/ec2/#ModifySpotFleetRequestInput
 			"target_capacity": {
 				Type:     schema.TypeInt,
 				Required: true,
@@ -360,6 +444,17 @@ func resourceAwsSpotFleetRequest() *schema.Resource {
 				Set:      schema.HashString,
 			},
 		},
+		// A launch template can be created with an id or a name, but once created will have both even though we specify only one.
+		// If either changes, this makes sure the other (which was specified) will register as changed in order to correctly determine diffs.
+		// This was taken from the original implementation of launch templates in resource_aws_autoscaling_group.go
+		CustomizeDiff: customdiff.Sequence(
+			customdiff.ComputedIf("launch_template_configs.0.launch_template_specification.0.id", func(diff *schema.ResourceDiff, meta interface{}) bool {
+				return diff.HasChange("launch_template_configs.0.launch_template_specification.0.name")
+			}),
+			customdiff.ComputedIf("launch_template_configs.0.launch_template_specification.0.name", func(diff *schema.ResourceDiff, meta interface{}) bool {
+				return diff.HasChange("launch_template_configs.0.launch_template_specification.0.id")
+			}),
+		),
 	}
 }
 
@@ -598,19 +693,93 @@ func buildAwsSpotFleetLaunchSpecifications(
 	return specs, nil
 }
 
+func buildLaunchTemplateConfigs(d *schema.ResourceData) ([]*ec2.LaunchTemplateConfig, error) {
+	launch_template_cfgs := d.Get("launch_template_configs").(*schema.Set).List()
+	cfgs := make([]*ec2.LaunchTemplateConfig, len(launch_template_cfgs))
+
+	for _, launch_template_cfg := range launch_template_cfgs {
+
+		ltc := &ec2.LaunchTemplateConfig{}
+
+		ltc_map := launch_template_cfg.(map[string]interface{})
+
+		//launch template spec
+		if v, ok := ltc_map["launch_template_specification"]; ok {
+			vL := v.([]interface{})
+			lts := vL[0].(map[string]interface{})
+
+			flts := &ec2.FleetLaunchTemplateSpecification{}
+
+			if v, ok := lts["id"].(string); ok && v != "" {
+				flts.LaunchTemplateId = aws.String(v)
+			}
+
+			if v, ok := lts["name"].(string); ok && v != "" {
+				flts.LaunchTemplateName = aws.String(v)
+			}
+
+			if v, ok := lts["version"].(string); ok && v != "" {
+				flts.Version = aws.String(v)
+			}
+
+			ltc.LaunchTemplateSpecification = flts
+
+		}
+
+		overrides := make([]*ec2.LaunchTemplateOverrides, 0)
+
+		if v, ok := ltc_map["overrides"]; ok {
+			vL := v.(*schema.Set).List()
+			for _, v := range vL {
+				ors := v.(map[string]interface{})
+				lto := &ec2.LaunchTemplateOverrides{}
+
+				if v, ok := ors["availability_zone"].(string); ok && v != "" {
+					lto.AvailabilityZone = aws.String(v)
+				}
+
+				if v, ok := ors["instance_type"].(string); ok && v != "" {
+					lto.InstanceType = aws.String(v)
+				}
+
+				if v, ok := ors["spot_price"].(string); ok && v != "" {
+					lto.SpotPrice = aws.String(v)
+				}
+
+				if v, ok := ors["subnet_id"].(string); ok && v != "" {
+					lto.SubnetId = aws.String(v)
+				}
+
+				if v, ok := ors["weighted_capacity"].(float64); ok && v > 0 {
+					lto.WeightedCapacity = aws.Float64(v)
+				}
+
+				overrides = append(overrides, lto)
+
+			}
+		}
+		ltc.Overrides = overrides
+
+		cfgs = append(cfgs, ltc)
+	}
+
+	return cfgs, nil
+}
+
 func resourceAwsSpotFleetRequestCreate(d *schema.ResourceData, meta interface{}) error {
 	// http://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RequestSpotFleet.html
 	conn := meta.(*AWSClient).ec2conn
 
-	launch_specs, err := buildAwsSpotFleetLaunchSpecifications(d, meta)
-	if err != nil {
-		return err
+	_, launchSpecificationOk := d.GetOk("launch_specification")
+	_, launchTemplateConfigsOk := d.GetOk("launch_template_configs")
+
+	if !launchSpecificationOk && !launchTemplateConfigsOk {
+		return fmt.Errorf("One of `launch_specification` or `launch_template` must be set for a fleet request")
 	}
 
 	// http://docs.aws.amazon.com/sdk-for-go/api/service/ec2.html#type-SpotFleetRequestConfigData
 	spotFleetConfig := &ec2.SpotFleetRequestConfigData{
 		IamFleetRole:                     aws.String(d.Get("iam_fleet_role").(string)),
-		LaunchSpecifications:             launch_specs,
 		TargetCapacity:                   aws.Int64(int64(d.Get("target_capacity").(int))),
 		ClientToken:                      aws.String(resource.UniqueId()),
 		TerminateInstancesWithExpiration: aws.Bool(d.Get("terminate_instances_with_expiration").(bool)),
@@ -619,6 +788,24 @@ func resourceAwsSpotFleetRequestCreate(d *schema.ResourceData, meta interface{})
 		Type:                             aws.String(d.Get("fleet_type").(string)),
 	}
 
+	var err error
+
+	if launchSpecificationOk {
+		launch_specs, err := buildAwsSpotFleetLaunchSpecifications(d, meta)
+		if err != nil {
+			return err
+		}
+		spotFleetConfig.LaunchSpecifications = launch_specs
+	}
+
+	if launchTemplateConfigsOk {
+		launch_templates, err := buildLaunchTemplateConfigs(d)
+		if err != nil {
+			return err
+		}
+		spotFleetConfig.LaunchTemplateConfigs = launch_templates
+	}
+
 	if v, ok := d.GetOk("excess_capacity_termination_policy"); ok {
 		spotFleetConfig.ExcessCapacityTerminationPolicy = aws.String(v.(string))
 	}
@@ -703,10 +890,20 @@ func resourceAwsSpotFleetRequestCreate(d *schema.ResourceData, meta interface{})
 
 		if err != nil {
 			if awsErr, ok := err.(awserr.Error); ok {
-				// IAM is eventually consistent :/
+
 				if awsErr.Code() == "InvalidSpotFleetRequestConfig" {
-					return resource.RetryableError(
-						fmt.Errorf("Error creating Spot fleet request, retrying: %s", err))
+					switch {
+					case strings.Contains(awsErr.Message(), "LaunchTemplateSpecification"):
+						// AWS is letting us know that the Launch Template has been specified in some invalid way.
+						// No point in retrying as the template needs to be corrected.
+						return resource.NonRetryableError(err)
+					case strings.Contains(awsErr.Message(), "IamFleetRole"):
+						// IAM is eventually consistent :/
+						return resource.RetryableError(
+							fmt.Errorf("[WARN] Error creating Spot fleet request, retrying: %s", err))
+					default:
+						return resource.NonRetryableError(err)
+					}
 				}
 			}
 			return resource.NonRetryableError(err)
@@ -726,7 +923,7 @@ func resourceAwsSpotFleetRequestCreate(d *schema.ResourceData, meta interface{})
 		Pending:    []string{"submitted"},
 		Target:     []string{"active"},
 		Refresh:    resourceAwsSpotFleetRequestStateRefreshFunc(d, meta),
-		Timeout:    10 * time.Minute,
+		Timeout:    d.Timeout(schema.TimeoutCreate), //10 * time.Minute,
 		MinTimeout: 10 * time.Second,
 		Delay:      30 * time.Second,
 	}
@@ -934,9 +1131,49 @@ func resourceAwsSpotFleetRequestRead(d *schema.ResourceData, meta interface{}) e
 	d.Set("fleet_type", config.Type)
 	d.Set("launch_specification", launchSpecsToSet(config.LaunchSpecifications, conn))
 
+	if len(config.LaunchTemplateConfigs) > 0 {
+		d.Set("launch_template_configs.0.launch_template_specification.0", flattenFleetLaunchTemplateSpecification(config.LaunchTemplateConfigs[0].LaunchTemplateSpecification))
+		d.Set("launch_template_configs.0.overrides", setLaunchTemplateOverrides(config.LaunchTemplateConfigs[0].Overrides))
+	} else {
+		d.Set("launch_template_configs.0.launch_template_specification.0", nil)
+	}
+
 	return nil
 }
 
+func setLaunchTemplateOverrides(overrides []*ec2.LaunchTemplateOverrides) *schema.Set {
+	overrideSet := &schema.Set{F: hashLaunchTemplateOverrides}
+	for _, override := range overrides {
+		overrideSet.Add(flattenSpotFleetRequestLaunchTemplateOverrides(override))
+	}
+	return overrideSet
+}
+
+func flattenSpotFleetRequestLaunchTemplateOverrides(override *ec2.LaunchTemplateOverrides) map[string]interface{} {
+	m := make(map[string]interface{})
+
+	if override.AvailabilityZone != nil {
+		m["availability_zone"] = aws.StringValue(override.AvailabilityZone)
+	}
+	if override.InstanceType != nil {
+		m["instance_type"] = aws.StringValue(override.InstanceType)
+	}
+
+	if override.SpotPrice != nil {
+		m["spot_price"] = aws.StringValue(override.SpotPrice)
+	}
+
+	if override.SubnetId != nil {
+		m["subnet_id"] = aws.StringValue(override.SubnetId)
+	}
+
+	if override.WeightedCapacity != nil {
+		m["weighted_capacity"] = aws.Float64Value(override.WeightedCapacity)
+	}
+
+	return m
+}
+
 func launchSpecsToSet(launchSpecs []*ec2.SpotFleetLaunchSpecification, conn *ec2.EC2) *schema.Set {
 	specSet := &schema.Set{F: hashLaunchSpecification}
 	for _, spec := range launchSpecs {
@@ -1235,6 +1472,27 @@ func hashLaunchSpecification(v interface{}) int {
 	return hashcode.String(buf.String())
 }
 
+func hashLaunchTemplateOverrides(v interface{}) int {
+	var buf bytes.Buffer
+	m := v.(map[string]interface{})
+	if m["availability_zone"] != nil {
+		buf.WriteString(fmt.Sprintf("%s-", m["availability_zone"].(string)))
+	}
+	if m["subnet_id"] != nil {
+		buf.WriteString(fmt.Sprintf("%s-", m["subnet_id"].(string)))
+	}
+	if m["spot_price"] != nil {
+		buf.WriteString(fmt.Sprintf("%s-", m["spot_price"].(string)))
+	}
+	if m["instance_type"] != nil {
+		buf.WriteString(fmt.Sprintf("%s-", m["instance_type"].(string)))
+	}
+	if m["weighted_capacity"] != nil {
+		buf.WriteString(fmt.Sprintf("%f-", m["weighted_capacity"].(float64)))
+	}
+	return hashcode.String(buf.String())
+}
+
 func hashEbsBlockDevice(v interface{}) int {
 	var buf bytes.Buffer
 	m := v.(map[string]interface{})