terraform/builtin/providers/spotinst/resource_spotinst_aws_group.go

2335 lines
67 KiB
Go
Raw Normal View History

New Provider: Spotinst (#5001) * providers/spotinst: Add support for Spotinst resources * providers/spotinst: Fix merge conflict - layouts/docs.erb * docs/providers/spotinst: Fix the resource description field * providers/spotinst: Fix the acceptance tests * providers/spotinst: Mark the device_index as a required field * providers/spotinst: Change the associate_public_ip_address field to TypeBool * docs/providers/spotinst: Update the description of the adjustment field * providers/spotinst: Rename IamRole to IamInstanceProfile to make it more compatible with the AWS provider * docs/providers/spotinst: Rename iam_role to iam_instance_profile * providers/spotinst: Deprecate the iam_role attribute * providers/spotinst: Fix a misspelled var (IamRole) * providers/spotinst: Fix possible null pointer exception related to "iam_instance_profile" * docs/providers/spotinst: Add "load_balancer_names" missing description * providers/spotinst: New resource "spotinst_subscription" added * providers/spotinst: Eliminate a possible null pointer exception in "spotinst_aws_group" * providers/spotinst: Eliminate a possible null pointer exception in "spotinst_subscription" * providers/spotinst: Mark spotinst_subscription as deleted in destroy * providers/spotinst: Add support for custom event format in spotinst_subscription * providers/spotinst: Disable the destroy step of spotinst_subscription * providers/spotinst: Add support for update subscriptions * providers/spotinst: Merge fixed conflict - layouts/docs.erb * providers/spotinst: Vendor dependencies * providers/spotinst: Return a detailed error message * provider/spotinst: Update the plugin list * providers/spotinst: Vendor dependencies using govendor * providers/spotinst: New resource "spotinst_healthcheck" added * providers/spotinst: Update the Spotinst SDK * providers/spotinst: Comment out unnecessary log.Printf * providers/spotinst: Fix the acceptance tests * providers/spotinst: Gofmt fixes * providers/spotinst: Use multiple functions to expand each block * providers/spotinst: Allow ondemand_count to be zero * providers/spotinst: Change security_group_ids from TypeSet to TypeList * providers/spotinst: Remove unnecessary `ForceNew` fields * providers/spotinst: Update the Spotinst SDK * providers/spotinst: Add support for capacity unit * providers/spotinst: Add support for EBS volume pool * providers/spotinst: Delete health check * providers/spotinst: Allow to set multiple availability zones * providers/spotinst: Gofmt * providers/spotinst: Omit empty strings from the load_balancer_names field * providers/spotinst: Update the Spotinst SDK to v1.1.9 * providers/spotinst: Add support for new strategy parameters * providers/spotinst: Update the Spotinst SDK to v1.2.0 * providers/spotinst: Add support for Kubernetes integration * providers/spotinst: Fix merge conflict - vendor/vendor.json * providers/spotinst: Update the Spotinst SDK to v1.2.1 * providers/spotinst: Add support for Application Load Balancers * providers/spotinst: Do not allow to set ondemand_count to 0 * providers/spotinst: Update the Spotinst SDK to v1.2.2 * providers/spotinst: Add support for scaling policy operators * providers/spotinst: Add dimensions to spotinst_aws_group tests * providers/spotinst: Allow both ARN and name for IAM instance profiles * providers/spotinst: Allow ondemand_count=0 * providers/spotinst: Split out the set funcs into flatten style funcs * providers/spotinst: Update the Spotinst SDK to v1.2.3 * providers/spotinst: Add support for EBS optimized flag * providers/spotinst: Update the Spotinst SDK to v2.0.0 * providers/spotinst: Use stringutil.Stringify for debugging * providers/spotinst: Update the Spotinst SDK to v2.0.1 * providers/spotinst: Key pair is now optional * providers/spotinst: Make sure we do not nullify signals on strategy update * providers/spotinst: Hash both Strategy and EBS Block Device * providers/spotinst: Hash AWS load balancer * providers/spotinst: Update the Spotinst SDK to v2.0.2 * providers/spotinst: Verify namespace exists before appending policy * providers/spotinst: Image ID will be in a separate block from now on, so as to allow ignoring changes only on the image ID. This change is backwards compatible. * providers/spotinst: user data decoded when returned from spotinst api, so that TF compares the two states properly, and does not update without cause.
2017-02-22 21:57:16 +01:00
package spotinst
import (
"bytes"
"crypto/sha1"
"encoding/base64"
"encoding/hex"
"fmt"
"log"
"regexp"
"strings"
"github.com/hashicorp/terraform/helper/hashcode"
"github.com/hashicorp/terraform/helper/schema"
"github.com/spotinst/spotinst-sdk-go/spotinst"
"github.com/spotinst/spotinst-sdk-go/spotinst/util/stringutil"
)
func resourceSpotinstAwsGroup() *schema.Resource {
return &schema.Resource{
Create: resourceSpotinstAwsGroupCreate,
Read: resourceSpotinstAwsGroupRead,
Update: resourceSpotinstAwsGroupUpdate,
Delete: resourceSpotinstAwsGroupDelete,
Schema: map[string]*schema.Schema{
"name": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
"description": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
"capacity": &schema.Schema{
Type: schema.TypeSet,
Required: true,
MaxItems: 1,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"target": &schema.Schema{
Type: schema.TypeInt,
Required: true,
},
"minimum": &schema.Schema{
Type: schema.TypeInt,
Optional: true,
Computed: true,
},
"maximum": &schema.Schema{
Type: schema.TypeInt,
Optional: true,
Computed: true,
},
"unit": &schema.Schema{
Type: schema.TypeString,
Optional: true,
Computed: true,
},
},
},
Set: hashAwsGroupCapacity,
},
"strategy": &schema.Schema{
Type: schema.TypeSet,
Required: true,
MaxItems: 1,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"risk": &schema.Schema{
Type: schema.TypeFloat,
Optional: true,
},
"ondemand_count": &schema.Schema{
Type: schema.TypeInt,
Optional: true,
},
"availability_vs_cost": &schema.Schema{
Type: schema.TypeString,
Optional: true,
Computed: true,
},
"draining_timeout": &schema.Schema{
Type: schema.TypeInt,
Optional: true,
Computed: true,
},
"utilize_reserved_instances": &schema.Schema{
Type: schema.TypeBool,
Optional: true,
Computed: true,
},
"fallback_to_ondemand": &schema.Schema{
Type: schema.TypeBool,
Optional: true,
Computed: true,
},
},
},
Set: hashAwsGroupStrategy,
},
"scheduled_task": &schema.Schema{
Type: schema.TypeSet,
Optional: true,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"task_type": &schema.Schema{
Type: schema.TypeString,
Optional: true,
},
"frequency": &schema.Schema{
Type: schema.TypeString,
Optional: true,
},
"cron_expression": &schema.Schema{
Type: schema.TypeString,
Optional: true,
},
"scale_target_capacity": &schema.Schema{
Type: schema.TypeInt,
Optional: true,
},
"scale_min_capacity": &schema.Schema{
Type: schema.TypeInt,
Optional: true,
},
"scale_max_capacity": &schema.Schema{
Type: schema.TypeInt,
Optional: true,
},
},
},
},
"product": &schema.Schema{
Type: schema.TypeString,
Required: true,
ForceNew: true,
},
"instance_types": &schema.Schema{
Type: schema.TypeSet,
Required: true,
MaxItems: 1,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"ondemand": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
"spot": &schema.Schema{
Type: schema.TypeList,
Required: true,
Elem: &schema.Schema{Type: schema.TypeString},
},
},
},
},
"signal": &schema.Schema{
Type: schema.TypeSet,
Optional: true,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"name": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
},
},
},
"availability_zone": &schema.Schema{
Type: schema.TypeSet,
Optional: true,
ConflictsWith: []string{"availability_zones"},
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"name": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
"subnet_id": &schema.Schema{
Type: schema.TypeString,
Optional: true,
},
},
},
},
"availability_zones": &schema.Schema{
Type: schema.TypeList,
Optional: true,
Elem: &schema.Schema{Type: schema.TypeString},
ConflictsWith: []string{"availability_zone"},
},
"hot_ebs_volume": &schema.Schema{
Type: schema.TypeSet,
Optional: true,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"device_name": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
"volume_ids": &schema.Schema{
Type: schema.TypeList,
Required: true,
Elem: &schema.Schema{Type: schema.TypeString},
},
},
},
},
"load_balancer": &schema.Schema{
Type: schema.TypeSet,
Optional: true,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"name": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
"arn": &schema.Schema{
Type: schema.TypeString,
Optional: true,
},
"type": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
},
},
Set: hashAwsGroupLoadBalancer,
},
"launch_specification": &schema.Schema{
Type: schema.TypeSet,
Required: true,
MaxItems: 1,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"load_balancer_names": &schema.Schema{
Type: schema.TypeList,
Optional: true,
Elem: &schema.Schema{Type: schema.TypeString},
},
"monitoring": &schema.Schema{
Type: schema.TypeBool,
Optional: true,
Default: false,
},
"ebs_optimized": &schema.Schema{
Type: schema.TypeBool,
Optional: true,
Computed: true,
},
"image_id": &schema.Schema{
Type: schema.TypeString,
Optional: true,
ConflictsWith: []string{"image_id"},
},
"key_pair": &schema.Schema{
Type: schema.TypeString,
Optional: true,
},
"health_check_type": &schema.Schema{
Type: schema.TypeString,
Optional: true,
},
"health_check_grace_period": &schema.Schema{
Type: schema.TypeInt,
Optional: true,
},
"security_group_ids": &schema.Schema{
Type: schema.TypeList,
Required: true,
Elem: &schema.Schema{Type: schema.TypeString},
},
"user_data": &schema.Schema{
Type: schema.TypeString,
Optional: true,
StateFunc: func(v interface{}) string {
switch v.(type) {
case string:
hash := sha1.Sum([]byte(v.(string)))
return hex.EncodeToString(hash[:])
default:
return ""
}
},
},
"iam_role": &schema.Schema{
Type: schema.TypeString,
Optional: true,
Deprecated: "Attribute iam_role is deprecated. Use iam_instance_profile instead",
},
"iam_instance_profile": &schema.Schema{
Type: schema.TypeString,
Optional: true,
},
},
},
},
"image_id": &schema.Schema{
Type: schema.TypeString,
Optional: true,
},
"elastic_ips": &schema.Schema{
Type: schema.TypeList,
Optional: true,
Elem: &schema.Schema{Type: schema.TypeString},
},
"tags": &schema.Schema{
Type: schema.TypeMap,
Optional: true,
},
"ebs_block_device": &schema.Schema{
Type: schema.TypeSet,
Optional: true,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"delete_on_termination": &schema.Schema{
Type: schema.TypeBool,
Optional: true,
Computed: true,
},
"device_name": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
"encrypted": &schema.Schema{
Type: schema.TypeBool,
Optional: true,
Computed: true,
},
"iops": &schema.Schema{
Type: schema.TypeInt,
Optional: true,
},
"snapshot_id": &schema.Schema{
Type: schema.TypeString,
Optional: true,
},
"volume_size": &schema.Schema{
Type: schema.TypeInt,
Optional: true,
},
"volume_type": &schema.Schema{
Type: schema.TypeString,
Optional: true,
Computed: true,
},
},
},
Set: hashAwsGroupEBSBlockDevice,
},
"ephemeral_block_device": &schema.Schema{
Type: schema.TypeSet,
Optional: true,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"device_name": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
"virtual_name": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
},
},
},
"network_interface": &schema.Schema{
Type: schema.TypeSet,
Optional: true,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"description": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
"device_index": &schema.Schema{
Type: schema.TypeInt,
Required: true,
},
"secondary_private_ip_address_count": &schema.Schema{
Type: schema.TypeInt,
Optional: true,
},
"associate_public_ip_address": &schema.Schema{
Type: schema.TypeBool,
Optional: true,
},
"delete_on_termination": &schema.Schema{
Type: schema.TypeBool,
Optional: true,
Computed: true,
},
"security_group_ids": &schema.Schema{
Type: schema.TypeList,
Optional: true,
Elem: &schema.Schema{Type: schema.TypeString},
},
"network_interface_id": &schema.Schema{
Type: schema.TypeString,
Optional: true,
},
"private_ip_address": &schema.Schema{
Type: schema.TypeString,
Optional: true,
},
"subnet_id": &schema.Schema{
Type: schema.TypeString,
Optional: true,
},
},
},
},
"scaling_up_policy": scalingPolicySchema(),
"scaling_down_policy": scalingPolicySchema(),
"rancher_integration": &schema.Schema{
Type: schema.TypeSet,
Optional: true,
MaxItems: 1,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"master_host": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
"access_key": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
"secret_key": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
},
},
},
"elastic_beanstalk_integration": &schema.Schema{
Type: schema.TypeSet,
Optional: true,
MaxItems: 1,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"environment_id": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
},
},
},
"ec2_container_service_integration": &schema.Schema{
Type: schema.TypeSet,
Optional: true,
MaxItems: 1,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"cluster_name": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
},
},
},
"kubernetes_integration": &schema.Schema{
Type: schema.TypeSet,
Optional: true,
MaxItems: 1,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"api_server": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
"token": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
},
},
},
"mesosphere_integration": &schema.Schema{
Type: schema.TypeSet,
Optional: true,
MaxItems: 1,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"api_server": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
},
},
},
},
}
}
func scalingPolicySchema() *schema.Schema {
return &schema.Schema{
Type: schema.TypeSet,
Optional: true,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"policy_name": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
"metric_name": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
"statistic": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
"unit": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
"threshold": &schema.Schema{
Type: schema.TypeFloat,
Required: true,
},
"adjustment": &schema.Schema{
Type: schema.TypeInt,
Optional: true,
},
"min_target_capacity": &schema.Schema{
Type: schema.TypeInt,
Optional: true,
},
"max_target_capacity": &schema.Schema{
Type: schema.TypeInt,
Optional: true,
},
"namespace": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
"operator": &schema.Schema{
Type: schema.TypeString,
Optional: true,
Computed: true,
},
"evaluation_periods": &schema.Schema{
Type: schema.TypeInt,
Required: true,
},
"period": &schema.Schema{
Type: schema.TypeInt,
Required: true,
},
"cooldown": &schema.Schema{
Type: schema.TypeInt,
Required: true,
},
"dimensions": &schema.Schema{
Type: schema.TypeMap,
Optional: true,
},
},
},
Set: hashAwsGroupScalingPolicy,
}
}
func resourceSpotinstAwsGroupCreate(d *schema.ResourceData, meta interface{}) error {
client := meta.(*spotinst.Client)
newAwsGroup, err := buildAwsGroupOpts(d, meta)
if err != nil {
return err
}
log.Printf("[DEBUG] AwsGroup create configuration: %s\n", stringutil.Stringify(newAwsGroup))
input := &spotinst.CreateAwsGroupInput{Group: newAwsGroup}
resp, err := client.AwsGroupService.Create(input)
if err != nil {
return fmt.Errorf("Error creating group: %s", err)
}
d.SetId(spotinst.StringValue(resp.Group.ID))
log.Printf("[INFO] AwsGroup created successfully: %s\n", d.Id())
return resourceSpotinstAwsGroupRead(d, meta)
}
func resourceSpotinstAwsGroupRead(d *schema.ResourceData, meta interface{}) error {
client := meta.(*spotinst.Client)
input := &spotinst.ReadAwsGroupInput{ID: spotinst.String(d.Id())}
resp, err := client.AwsGroupService.Read(input)
if err != nil {
return fmt.Errorf("Error retrieving group: %s", err)
}
if g := resp.Group; g != nil {
d.Set("name", g.Name)
d.Set("description", g.Description)
d.Set("product", g.Compute.Product)
d.Set("tags", tagsToMap(g.Compute.LaunchSpecification.Tags))
d.Set("elastic_ips", g.Compute.ElasticIPs)
// Set capacity.
if g.Capacity != nil {
if err := d.Set("capacity", flattenAwsGroupCapacity(g.Capacity)); err != nil {
return fmt.Errorf("Error setting capacity onfiguration: %#v", err)
}
}
// Set strategy.
if g.Strategy != nil {
if err := d.Set("strategy", flattenAwsGroupStrategy(g.Strategy)); err != nil {
return fmt.Errorf("Error setting strategy configuration: %#v", err)
}
}
// Set signals.
if g.Strategy.Signals != nil {
if err := d.Set("signal", flattenAwsGroupSignals(g.Strategy.Signals)); err != nil {
return fmt.Errorf("Error setting signals configuration: %#v", err)
}
}
// Set scaling up policies.
if g.Scaling.Up != nil {
if err := d.Set("scaling_up_policy", flattenAwsGroupScalingPolicies(g.Scaling.Up)); err != nil {
return fmt.Errorf("Error setting scaling up policies configuration: %#v", err)
}
}
// Set scaling down policies.
if g.Scaling.Down != nil {
if err := d.Set("scaling_down_policy", flattenAwsGroupScalingPolicies(g.Scaling.Down)); err != nil {
return fmt.Errorf("Error setting scaling down policies configuration: %#v", err)
}
}
// Set scheduled tasks.
if g.Scheduling.Tasks != nil {
if err := d.Set("scheduled_task", flattenAwsGroupScheduledTasks(g.Scheduling.Tasks)); err != nil {
return fmt.Errorf("Error setting scheduled tasks configuration: %#v", err)
}
}
// Set launch specification.
if g.Compute.LaunchSpecification != nil {
imageIDSetInLaunchSpec := true
if v, ok := d.GetOk("image_id"); ok && v != "" {
imageIDSetInLaunchSpec = false
}
if err := d.Set("launch_specification", flattenAwsGroupLaunchSpecification(g.Compute.LaunchSpecification, imageIDSetInLaunchSpec)); err != nil {
return fmt.Errorf("Error setting launch specification configuration: %#v", err)
}
}
// Set image ID.
if g.Compute.LaunchSpecification.ImageID != nil {
if d.Get("image_id") != nil && d.Get("image_id") != "" {
d.Set("image_id", g.Compute.LaunchSpecification.ImageID)
}
}
// Set load balancers.
if g.Compute.LaunchSpecification.LoadBalancersConfig != nil {
if err := d.Set("load_balancer", flattenAwsGroupLoadBalancers(g.Compute.LaunchSpecification.LoadBalancersConfig.LoadBalancers)); err != nil {
return fmt.Errorf("Error setting load balancers configuration: %#v", err)
}
}
// Set EBS volume pool.
if g.Compute.EBSVolumePool != nil {
if err := d.Set("hot_ebs_volume", flattenAwsGroupEBSVolumePool(g.Compute.EBSVolumePool)); err != nil {
return fmt.Errorf("Error setting EBS volume pool configuration: %#v", err)
}
}
// Set network interfaces.
if g.Compute.LaunchSpecification.NetworkInterfaces != nil {
if err := d.Set("network_interface", flattenAwsGroupNetworkInterfaces(g.Compute.LaunchSpecification.NetworkInterfaces)); err != nil {
return fmt.Errorf("Error setting network interfaces configuration: %#v", err)
}
}
// Set block devices.
if g.Compute.LaunchSpecification.BlockDevices != nil {
if err := d.Set("ebs_block_device", flattenAwsGroupEBSBlockDevices(g.Compute.LaunchSpecification.BlockDevices)); err != nil {
return fmt.Errorf("Error setting EBS block devices configuration: %#v", err)
}
if err := d.Set("ephemeral_block_device", flattenAwsGroupEphemeralBlockDevices(g.Compute.LaunchSpecification.BlockDevices)); err != nil {
return fmt.Errorf("Error setting Ephemeral block devices configuration: %#v", err)
}
}
// Set Rancher integration.
if g.Integration.Rancher != nil {
if err := d.Set("rancher_integration", flattenAwsGroupRancherIntegration(g.Integration.Rancher)); err != nil {
return fmt.Errorf("Error setting Rancher configuration: %#v", err)
}
}
// Set Elastic Beanstalk integration.
if g.Integration.ElasticBeanstalk != nil {
if err := d.Set("elastic_beanstalk_integration", flattenAwsGroupElasticBeanstalkIntegration(g.Integration.ElasticBeanstalk)); err != nil {
return fmt.Errorf("Error setting Elastic Beanstalk configuration: %#v", err)
}
}
// Set EC2 Container Service integration.
if g.Integration.EC2ContainerService != nil {
if err := d.Set("ec2_container_service_integration", flattenAwsGroupEC2ContainerServiceIntegration(g.Integration.EC2ContainerService)); err != nil {
return fmt.Errorf("Error setting EC2 Container Service configuration: %#v", err)
}
}
// Set Kubernetes integration.
if g.Integration.Kubernetes != nil {
if err := d.Set("kubernetes_integration", flattenAwsGroupKubernetesIntegration(g.Integration.Kubernetes)); err != nil {
return fmt.Errorf("Error setting Kubernetes configuration: %#v", err)
}
}
// Set Mesosphere integration.
if g.Integration.Mesosphere != nil {
if err := d.Set("mesosphere_integration", flattenAwsGroupMesosphereIntegration(g.Integration.Mesosphere)); err != nil {
return fmt.Errorf("Error setting Mesosphere configuration: %#v", err)
}
}
} else {
d.SetId("")
}
return nil
}
func resourceSpotinstAwsGroupUpdate(d *schema.ResourceData, meta interface{}) error {
client := meta.(*spotinst.Client)
group := &spotinst.AwsGroup{ID: spotinst.String(d.Id())}
update := false
if d.HasChange("name") {
group.Name = spotinst.String(d.Get("name").(string))
update = true
}
if d.HasChange("description") {
group.Description = spotinst.String(d.Get("description").(string))
update = true
}
if d.HasChange("capacity") {
if v, ok := d.GetOk("capacity"); ok {
if capacity, err := expandAwsGroupCapacity(v); err != nil {
return err
} else {
group.Capacity = capacity
update = true
}
}
}
if d.HasChange("strategy") {
if v, ok := d.GetOk("strategy"); ok {
if strategy, err := expandAwsGroupStrategy(v); err != nil {
return err
} else {
group.Strategy = strategy
if v, ok := d.GetOk("signal"); ok {
if signals, err := expandAwsGroupSignals(v); err != nil {
return err
} else {
group.Strategy.Signals = signals
}
}
update = true
}
}
}
if d.HasChange("launch_specification") {
if v, ok := d.GetOk("launch_specification"); ok {
lc, err := expandAwsGroupLaunchSpecification(v)
if err != nil {
return err
}
if group.Compute == nil {
group.Compute = &spotinst.AwsGroupCompute{}
}
group.Compute.LaunchSpecification = lc
update = true
}
}
if d.HasChange("image_id") {
if d.Get("image_id") != nil && d.Get("image_id") != "" {
if group.Compute == nil {
group.Compute = &spotinst.AwsGroupCompute{}
}
if group.Compute.LaunchSpecification == nil {
group.Compute.LaunchSpecification = &spotinst.AwsGroupComputeLaunchSpecification{}
}
group.Compute.LaunchSpecification.ImageID = spotinst.String(d.Get("image_id").(string))
update = true
}
}
if d.HasChange("load_balancer") {
if v, ok := d.GetOk("load_balancer"); ok {
if lbs, err := expandAwsGroupLoadBalancer(v); err != nil {
return err
} else {
if group.Compute == nil {
group.Compute = &spotinst.AwsGroupCompute{}
}
if group.Compute.LaunchSpecification == nil {
group.Compute.LaunchSpecification = &spotinst.AwsGroupComputeLaunchSpecification{}
}
if group.Compute.LaunchSpecification.LoadBalancersConfig == nil {
group.Compute.LaunchSpecification.LoadBalancersConfig = &spotinst.AwsGroupComputeLoadBalancersConfig{}
group.Compute.LaunchSpecification.LoadBalancersConfig.LoadBalancers = lbs
update = true
}
}
}
}
var blockDevicesExpanded bool
if d.HasChange("ebs_block_device") {
if v, ok := d.GetOk("ebs_block_device"); ok {
if devices, err := expandAwsGroupEBSBlockDevices(v); err != nil {
return err
} else {
if group.Compute == nil {
group.Compute = &spotinst.AwsGroupCompute{}
}
if group.Compute.LaunchSpecification == nil {
group.Compute.LaunchSpecification = &spotinst.AwsGroupComputeLaunchSpecification{}
}
if len(group.Compute.LaunchSpecification.BlockDevices) > 0 {
group.Compute.LaunchSpecification.BlockDevices = append(group.Compute.LaunchSpecification.BlockDevices, devices...)
} else {
if v, ok := d.GetOk("ephemeral_block_device"); ok {
if ephemeral, err := expandAwsGroupEphemeralBlockDevices(v); err != nil {
return err
} else {
devices = append(devices, ephemeral...)
blockDevicesExpanded = true
}
}
group.Compute.LaunchSpecification.BlockDevices = devices
}
update = true
}
}
}
if d.HasChange("ephemeral_block_device") && !blockDevicesExpanded {
if v, ok := d.GetOk("ephemeral_block_device"); ok {
if devices, err := expandAwsGroupEphemeralBlockDevices(v); err != nil {
return err
} else {
if group.Compute == nil {
group.Compute = &spotinst.AwsGroupCompute{}
}
if group.Compute.LaunchSpecification == nil {
group.Compute.LaunchSpecification = &spotinst.AwsGroupComputeLaunchSpecification{}
}
if len(group.Compute.LaunchSpecification.BlockDevices) > 0 {
group.Compute.LaunchSpecification.BlockDevices = append(group.Compute.LaunchSpecification.BlockDevices, devices...)
} else {
if v, ok := d.GetOk("ebs_block_device"); ok {
if ebs, err := expandAwsGroupEBSBlockDevices(v); err != nil {
return err
} else {
devices = append(devices, ebs...)
}
}
group.Compute.LaunchSpecification.BlockDevices = devices
}
update = true
}
}
}
if d.HasChange("network_interface") {
if v, ok := d.GetOk("network_interface"); ok {
if interfaces, err := expandAwsGroupNetworkInterfaces(v); err != nil {
return err
} else {
if group.Compute == nil {
group.Compute = &spotinst.AwsGroupCompute{}
}
if group.Compute.LaunchSpecification == nil {
group.Compute.LaunchSpecification = &spotinst.AwsGroupComputeLaunchSpecification{}
}
group.Compute.LaunchSpecification.NetworkInterfaces = interfaces
update = true
}
}
}
if d.HasChange("availability_zone") {
if v, ok := d.GetOk("availability_zone"); ok {
if zones, err := expandAwsGroupAvailabilityZones(v); err != nil {
return err
} else {
if group.Compute == nil {
group.Compute = &spotinst.AwsGroupCompute{}
}
group.Compute.AvailabilityZones = zones
update = true
}
}
}
if d.HasChange("availability_zones") {
if v, ok := d.GetOk("availability_zones"); ok {
if zones, err := expandAwsGroupAvailabilityZonesSlice(v); err != nil {
return err
} else {
if group.Compute == nil {
group.Compute = &spotinst.AwsGroupCompute{}
}
group.Compute.AvailabilityZones = zones
update = true
}
}
}
if d.HasChange("hot_ebs_volume") {
if v, ok := d.GetOk("hot_ebs_volume"); ok {
if ebsVolumePool, err := expandAwsGroupEBSVolumePool(v); err != nil {
return err
} else {
if group.Compute == nil {
group.Compute = &spotinst.AwsGroupCompute{}
}
group.Compute.EBSVolumePool = ebsVolumePool
update = true
}
}
}
if d.HasChange("signal") {
if v, ok := d.GetOk("signal"); ok {
if signals, err := expandAwsGroupSignals(v); err != nil {
return err
} else {
if group.Strategy == nil {
group.Strategy = &spotinst.AwsGroupStrategy{}
}
group.Strategy.Signals = signals
update = true
}
}
}
if d.HasChange("instance_types") {
if v, ok := d.GetOk("instance_types"); ok {
if types, err := expandAwsGroupInstanceTypes(v); err != nil {
return err
} else {
if group.Compute == nil {
group.Compute = &spotinst.AwsGroupCompute{}
}
group.Compute.InstanceTypes = types
update = true
}
}
}
if d.HasChange("tags") {
if v, ok := d.GetOk("tags"); ok {
if tags, err := expandAwsGroupTags(v); err != nil {
return err
} else {
if group.Compute == nil {
group.Compute = &spotinst.AwsGroupCompute{}
}
if group.Compute.LaunchSpecification == nil {
group.Compute.LaunchSpecification = &spotinst.AwsGroupComputeLaunchSpecification{}
}
group.Compute.LaunchSpecification.Tags = tags
update = true
}
}
}
if d.HasChange("elastic_ips") {
if v, ok := d.GetOk("elastic_ips"); ok {
if eips, err := expandAwsGroupElasticIPs(v); err != nil {
return err
} else {
if group.Compute == nil {
group.Compute = &spotinst.AwsGroupCompute{}
}
group.Compute.ElasticIPs = eips
update = true
}
}
}
if d.HasChange("scheduled_task") {
if v, ok := d.GetOk("scheduled_task"); ok {
if tasks, err := expandAwsGroupScheduledTasks(v); err != nil {
return err
} else {
if group.Scheduling == nil {
group.Scheduling = &spotinst.AwsGroupScheduling{}
}
group.Scheduling.Tasks = tasks
update = true
}
}
}
if d.HasChange("scaling_up_policy") {
if v, ok := d.GetOk("scaling_up_policy"); ok {
if policies, err := expandAwsGroupScalingPolicies(v); err != nil {
return err
} else {
if group.Scaling == nil {
group.Scaling = &spotinst.AwsGroupScaling{}
}
group.Scaling.Up = policies
update = true
}
}
}
if d.HasChange("scaling_down_policy") {
if v, ok := d.GetOk("scaling_down_policy"); ok {
if policies, err := expandAwsGroupScalingPolicies(v); err != nil {
return err
} else {
if group.Scaling == nil {
group.Scaling = &spotinst.AwsGroupScaling{}
}
group.Scaling.Down = policies
update = true
}
}
}
if d.HasChange("rancher_integration") {
if v, ok := d.GetOk("rancher_integration"); ok {
if integration, err := expandAwsGroupRancherIntegration(v); err != nil {
return err
} else {
if group.Integration == nil {
group.Integration = &spotinst.AwsGroupIntegration{}
}
group.Integration.Rancher = integration
update = true
}
}
}
if d.HasChange("elastic_eanstalk_integration") {
if v, ok := d.GetOk("elastic_beanstalk_integration"); ok {
if integration, err := expandAwsGroupElasticBeanstalkIntegration(v); err != nil {
return err
} else {
if group.Integration == nil {
group.Integration = &spotinst.AwsGroupIntegration{}
}
group.Integration.ElasticBeanstalk = integration
update = true
}
}
}
if d.HasChange("ec2_container_service_integration") {
if v, ok := d.GetOk("ec2_container_service_integration"); ok {
if integration, err := expandAwsGroupEC2ContainerServiceIntegration(v); err != nil {
return err
} else {
if group.Integration == nil {
group.Integration = &spotinst.AwsGroupIntegration{}
}
group.Integration.EC2ContainerService = integration
update = true
}
}
}
if d.HasChange("kubernetes_integration") {
if v, ok := d.GetOk("kubernetes_integration"); ok {
if integration, err := expandAwsGroupKubernetesIntegration(v); err != nil {
return err
} else {
if group.Integration == nil {
group.Integration = &spotinst.AwsGroupIntegration{}
}
group.Integration.Kubernetes = integration
update = true
}
}
}
if d.HasChange("mesosphere_integration") {
if v, ok := d.GetOk("mesosphere_integration"); ok {
if integration, err := expandAwsGroupMesosphereIntegration(v); err != nil {
return err
} else {
if group.Integration == nil {
group.Integration = &spotinst.AwsGroupIntegration{}
}
group.Integration.Mesosphere = integration
update = true
}
}
}
if update {
log.Printf("[DEBUG] AwsGroup update configuration: %s\n", stringutil.Stringify(group))
input := &spotinst.UpdateAwsGroupInput{Group: group}
if _, err := client.AwsGroupService.Update(input); err != nil {
return fmt.Errorf("Error updating group %s: %s", d.Id(), err)
}
}
return resourceSpotinstAwsGroupRead(d, meta)
}
func resourceSpotinstAwsGroupDelete(d *schema.ResourceData, meta interface{}) error {
client := meta.(*spotinst.Client)
log.Printf("[INFO] Deleting group: %s\n", d.Id())
input := &spotinst.DeleteAwsGroupInput{ID: spotinst.String(d.Id())}
if _, err := client.AwsGroupService.Delete(input); err != nil {
return fmt.Errorf("Error deleting group: %s", err)
}
d.SetId("")
return nil
}
func flattenAwsGroupCapacity(capacity *spotinst.AwsGroupCapacity) []interface{} {
result := make(map[string]interface{})
result["target"] = spotinst.IntValue(capacity.Target)
result["minimum"] = spotinst.IntValue(capacity.Minimum)
result["maximum"] = spotinst.IntValue(capacity.Maximum)
result["unit"] = spotinst.StringValue(capacity.Unit)
return []interface{}{result}
}
func flattenAwsGroupStrategy(strategy *spotinst.AwsGroupStrategy) []interface{} {
result := make(map[string]interface{})
result["risk"] = spotinst.Float64Value(strategy.Risk)
result["ondemand_count"] = spotinst.IntValue(strategy.OnDemandCount)
result["availability_vs_cost"] = spotinst.StringValue(strategy.AvailabilityVsCost)
result["draining_timeout"] = spotinst.IntValue(strategy.DrainingTimeout)
result["utilize_reserved_instances"] = spotinst.BoolValue(strategy.UtilizeReservedInstances)
result["fallback_to_ondemand"] = spotinst.BoolValue(strategy.FallbackToOnDemand)
return []interface{}{result}
}
func flattenAwsGroupLaunchSpecification(lspec *spotinst.AwsGroupComputeLaunchSpecification, includeImageID bool) []interface{} {
result := make(map[string]interface{})
result["health_check_grace_period"] = spotinst.IntValue(lspec.HealthCheckGracePeriod)
result["health_check_type"] = spotinst.StringValue(lspec.HealthCheckType)
if includeImageID {
result["image_id"] = spotinst.StringValue(lspec.ImageID)
}
result["key_pair"] = spotinst.StringValue(lspec.KeyPair)
if lspec.UserData != nil && spotinst.StringValue(lspec.UserData) != "" {
decodedUserData, _ := base64.StdEncoding.DecodeString(spotinst.StringValue(lspec.UserData))
result["user_data"] = string(decodedUserData)
} else {
result["user_data"] = ""
}
result["monitoring"] = spotinst.BoolValue(lspec.Monitoring)
result["ebs_optimized"] = spotinst.BoolValue(lspec.EBSOptimized)
result["load_balancer_names"] = lspec.LoadBalancerNames
result["security_group_ids"] = lspec.SecurityGroupIDs
if lspec.IamInstanceProfile != nil {
if lspec.IamInstanceProfile.Arn != nil {
result["iam_instance_profile"] = spotinst.StringValue(lspec.IamInstanceProfile.Arn)
} else {
result["iam_instance_profile"] = spotinst.StringValue(lspec.IamInstanceProfile.Name)
}
}
return []interface{}{result}
}
func flattenAwsGroupLoadBalancers(balancers []*spotinst.AwsGroupComputeLoadBalancer) []interface{} {
result := make([]interface{}, 0, len(balancers))
for _, b := range balancers {
m := make(map[string]interface{})
m["name"] = spotinst.StringValue(b.Name)
m["arn"] = spotinst.StringValue(b.Arn)
m["type"] = strings.ToLower(spotinst.StringValue(b.Type))
result = append(result, m)
}
return result
}
func flattenAwsGroupEBSVolumePool(volumes []*spotinst.AwsGroupComputeEBSVolume) []interface{} {
result := make([]interface{}, 0, len(volumes))
for _, v := range volumes {
m := make(map[string]interface{})
m["device_name"] = spotinst.StringValue(v.DeviceName)
m["volume_ids"] = v.VolumeIDs
result = append(result, m)
}
return result
}
func flattenAwsGroupSignals(signals []*spotinst.AwsGroupStrategySignal) []interface{} {
result := make([]interface{}, 0, len(signals))
for _, s := range signals {
m := make(map[string]interface{})
m["name"] = strings.ToLower(spotinst.StringValue(s.Name))
result = append(result, m)
}
return result
}
func flattenAwsGroupScheduledTasks(tasks []*spotinst.AwsGroupScheduledTask) []interface{} {
result := make([]interface{}, 0, len(tasks))
for _, t := range tasks {
m := make(map[string]interface{})
m["task_type"] = spotinst.StringValue(t.TaskType)
m["cron_expression"] = spotinst.StringValue(t.CronExpression)
m["frequency"] = spotinst.StringValue(t.Frequency)
m["scale_target_capacity"] = spotinst.IntValue(t.ScaleTargetCapacity)
m["scale_min_capacity"] = spotinst.IntValue(t.ScaleMinCapacity)
m["scale_max_capacity"] = spotinst.IntValue(t.ScaleMaxCapacity)
result = append(result, m)
}
return result
}
func flattenAwsGroupScalingPolicies(policies []*spotinst.AwsGroupScalingPolicy) []interface{} {
result := make([]interface{}, 0, len(policies))
for _, p := range policies {
m := make(map[string]interface{})
m["adjustment"] = spotinst.IntValue(p.Adjustment)
m["cooldown"] = spotinst.IntValue(p.Cooldown)
m["evaluation_periods"] = spotinst.IntValue(p.EvaluationPeriods)
m["min_target_capacity"] = spotinst.IntValue(p.MinTargetCapacity)
m["max_target_capacity"] = spotinst.IntValue(p.MaxTargetCapacity)
m["metric_name"] = spotinst.StringValue(p.MetricName)
m["namespace"] = spotinst.StringValue(p.Namespace)
m["operator"] = spotinst.StringValue(p.Operator)
m["period"] = spotinst.IntValue(p.Period)
m["policy_name"] = spotinst.StringValue(p.PolicyName)
m["statistic"] = spotinst.StringValue(p.Statistic)
m["threshold"] = spotinst.Float64Value(p.Threshold)
m["unit"] = spotinst.StringValue(p.Unit)
if len(p.Dimensions) > 0 {
flatDims := make(map[string]interface{})
for _, d := range p.Dimensions {
flatDims[spotinst.StringValue(d.Name)] = *d.Value
}
m["dimensions"] = flatDims
}
result = append(result, m)
}
return result
}
func flattenAwsGroupNetworkInterfaces(ifaces []*spotinst.AwsGroupComputeNetworkInterface) []interface{} {
result := make([]interface{}, 0, len(ifaces))
for _, iface := range ifaces {
m := make(map[string]interface{})
m["associate_public_ip_address"] = spotinst.BoolValue(iface.AssociatePublicIPAddress)
m["delete_on_termination"] = spotinst.BoolValue(iface.DeleteOnTermination)
m["description"] = spotinst.StringValue(iface.Description)
m["device_index"] = spotinst.IntValue(iface.DeviceIndex)
m["network_interface_id"] = spotinst.StringValue(iface.ID)
m["private_ip_address"] = spotinst.StringValue(iface.PrivateIPAddress)
m["secondary_private_ip_address_count"] = spotinst.IntValue(iface.SecondaryPrivateIPAddressCount)
m["subnet_id"] = spotinst.StringValue(iface.SubnetID)
m["security_group_ids"] = iface.SecurityGroupsIDs
result = append(result, m)
}
return result
}
func flattenAwsGroupEBSBlockDevices(devices []*spotinst.AwsGroupComputeBlockDevice) []interface{} {
result := make([]interface{}, 0, len(devices))
for _, dev := range devices {
if dev.EBS != nil {
m := make(map[string]interface{})
m["device_name"] = spotinst.StringValue(dev.DeviceName)
m["delete_on_termination"] = spotinst.BoolValue(dev.EBS.DeleteOnTermination)
m["encrypted"] = spotinst.BoolValue(dev.EBS.Encrypted)
m["iops"] = spotinst.IntValue(dev.EBS.IOPS)
m["snapshot_id"] = spotinst.StringValue(dev.EBS.SnapshotID)
m["volume_type"] = spotinst.StringValue(dev.EBS.VolumeType)
m["volume_size"] = spotinst.IntValue(dev.EBS.VolumeSize)
result = append(result, m)
}
}
return result
}
func flattenAwsGroupEphemeralBlockDevices(devices []*spotinst.AwsGroupComputeBlockDevice) []interface{} {
result := make([]interface{}, 0, len(devices))
for _, dev := range devices {
if dev.EBS == nil {
m := make(map[string]interface{})
m["device_name"] = spotinst.StringValue(dev.DeviceName)
m["virtual_name"] = spotinst.StringValue(dev.VirtualName)
result = append(result, m)
}
}
return result
}
func flattenAwsGroupRancherIntegration(integration *spotinst.AwsGroupRancherIntegration) []interface{} {
result := make(map[string]interface{})
result["master_host"] = spotinst.StringValue(integration.MasterHost)
result["access_key"] = spotinst.StringValue(integration.AccessKey)
result["secret_key"] = spotinst.StringValue(integration.SecretKey)
return []interface{}{result}
}
func flattenAwsGroupElasticBeanstalkIntegration(integration *spotinst.AwsGroupElasticBeanstalkIntegration) []interface{} {
result := make(map[string]interface{})
result["environment_id"] = spotinst.StringValue(integration.EnvironmentID)
return []interface{}{result}
}
func flattenAwsGroupEC2ContainerServiceIntegration(integration *spotinst.AwsGroupEC2ContainerServiceIntegration) []interface{} {
result := make(map[string]interface{})
result["cluster_name"] = spotinst.StringValue(integration.ClusterName)
return []interface{}{result}
}
func flattenAwsGroupKubernetesIntegration(integration *spotinst.AwsGroupKubernetesIntegration) []interface{} {
result := make(map[string]interface{})
result["api_server"] = spotinst.StringValue(integration.Server)
result["token"] = spotinst.StringValue(integration.Token)
return []interface{}{result}
}
func flattenAwsGroupMesosphereIntegration(integration *spotinst.AwsGroupMesosphereIntegration) []interface{} {
result := make(map[string]interface{})
result["api_server"] = spotinst.StringValue(integration.Server)
return []interface{}{result}
}
// buildAwsGroupOpts builds the Spotinst AWS Group options.
func buildAwsGroupOpts(d *schema.ResourceData, meta interface{}) (*spotinst.AwsGroup, error) {
group := &spotinst.AwsGroup{
Name: spotinst.String(d.Get("name").(string)),
Description: spotinst.String(d.Get("description").(string)),
Scaling: &spotinst.AwsGroupScaling{},
Scheduling: &spotinst.AwsGroupScheduling{},
Integration: &spotinst.AwsGroupIntegration{},
Compute: &spotinst.AwsGroupCompute{
Product: spotinst.String(d.Get("product").(string)),
LaunchSpecification: &spotinst.AwsGroupComputeLaunchSpecification{},
},
}
if v, ok := d.GetOk("capacity"); ok {
if capacity, err := expandAwsGroupCapacity(v); err != nil {
return nil, err
} else {
group.Capacity = capacity
}
}
if v, ok := d.GetOk("strategy"); ok {
if strategy, err := expandAwsGroupStrategy(v); err != nil {
return nil, err
} else {
group.Strategy = strategy
}
}
if v, ok := d.GetOk("scaling_up_policy"); ok {
if policies, err := expandAwsGroupScalingPolicies(v); err != nil {
return nil, err
} else {
group.Scaling.Up = policies
}
}
if v, ok := d.GetOk("scaling_down_policy"); ok {
if policies, err := expandAwsGroupScalingPolicies(v); err != nil {
return nil, err
} else {
group.Scaling.Down = policies
}
}
if v, ok := d.GetOk("scheduled_task"); ok {
if tasks, err := expandAwsGroupScheduledTasks(v); err != nil {
return nil, err
} else {
group.Scheduling.Tasks = tasks
}
}
if v, ok := d.GetOk("instance_types"); ok {
if types, err := expandAwsGroupInstanceTypes(v); err != nil {
return nil, err
} else {
group.Compute.InstanceTypes = types
}
}
if v, ok := d.GetOk("elastic_ips"); ok {
if eips, err := expandAwsGroupElasticIPs(v); err != nil {
return nil, err
} else {
group.Compute.ElasticIPs = eips
}
}
if v, ok := d.GetOk("availability_zone"); ok {
if zones, err := expandAwsGroupAvailabilityZones(v); err != nil {
return nil, err
} else {
group.Compute.AvailabilityZones = zones
}
}
if v, ok := d.GetOk("availability_zones"); ok {
if zones, err := expandAwsGroupAvailabilityZonesSlice(v); err != nil {
return nil, err
} else {
group.Compute.AvailabilityZones = zones
}
}
if v, ok := d.GetOk("hot_ebs_volume"); ok {
if ebsVolumePool, err := expandAwsGroupEBSVolumePool(v); err != nil {
return nil, err
} else {
group.Compute.EBSVolumePool = ebsVolumePool
}
}
if v, ok := d.GetOk("signal"); ok {
if signals, err := expandAwsGroupSignals(v); err != nil {
return nil, err
} else {
group.Strategy.Signals = signals
}
}
if v, ok := d.GetOk("launch_specification"); ok {
if lc, err := expandAwsGroupLaunchSpecification(v); err != nil {
return nil, err
} else {
group.Compute.LaunchSpecification = lc
}
}
if v, ok := d.GetOk("image_id"); ok {
group.Compute.LaunchSpecification.ImageID = spotinst.String(v.(string))
}
if v, ok := d.GetOk("load_balancer"); ok {
if lbs, err := expandAwsGroupLoadBalancer(v); err != nil {
return nil, err
} else {
if group.Compute.LaunchSpecification.LoadBalancersConfig == nil {
group.Compute.LaunchSpecification.LoadBalancersConfig = &spotinst.AwsGroupComputeLoadBalancersConfig{}
}
group.Compute.LaunchSpecification.LoadBalancersConfig.LoadBalancers = lbs
}
}
if v, ok := d.GetOk("tags"); ok {
if tags, err := expandAwsGroupTags(v); err != nil {
return nil, err
} else {
group.Compute.LaunchSpecification.Tags = tags
}
}
if v, ok := d.GetOk("network_interface"); ok {
if interfaces, err := expandAwsGroupNetworkInterfaces(v); err != nil {
return nil, err
} else {
group.Compute.LaunchSpecification.NetworkInterfaces = interfaces
}
}
if v, ok := d.GetOk("ebs_block_device"); ok {
if devices, err := expandAwsGroupEBSBlockDevices(v); err != nil {
return nil, err
} else {
group.Compute.LaunchSpecification.BlockDevices = devices
}
}
if v, ok := d.GetOk("ephemeral_block_device"); ok {
if devices, err := expandAwsGroupEphemeralBlockDevices(v); err != nil {
return nil, err
} else {
if len(group.Compute.LaunchSpecification.BlockDevices) > 0 {
group.Compute.LaunchSpecification.BlockDevices = append(group.Compute.LaunchSpecification.BlockDevices, devices...)
} else {
group.Compute.LaunchSpecification.BlockDevices = devices
}
}
}
if v, ok := d.GetOk("rancher_integration"); ok {
if integration, err := expandAwsGroupRancherIntegration(v); err != nil {
return nil, err
} else {
group.Integration.Rancher = integration
}
}
if v, ok := d.GetOk("elastic_beanstalk_integration"); ok {
if integration, err := expandAwsGroupElasticBeanstalkIntegration(v); err != nil {
return nil, err
} else {
group.Integration.ElasticBeanstalk = integration
}
}
if v, ok := d.GetOk("ec2_container_service_integration"); ok {
if integration, err := expandAwsGroupEC2ContainerServiceIntegration(v); err != nil {
return nil, err
} else {
group.Integration.EC2ContainerService = integration
}
}
if v, ok := d.GetOk("kubernetes_integration"); ok {
if integration, err := expandAwsGroupKubernetesIntegration(v); err != nil {
return nil, err
} else {
group.Integration.Kubernetes = integration
}
}
return group, nil
}
// expandAwsGroupCapacity expands the Capacity block.
func expandAwsGroupCapacity(data interface{}) (*spotinst.AwsGroupCapacity, error) {
list := data.(*schema.Set).List()
m := list[0].(map[string]interface{})
capacity := &spotinst.AwsGroupCapacity{}
if v, ok := m["minimum"].(int); ok && v >= 0 {
capacity.Minimum = spotinst.Int(v)
}
if v, ok := m["maximum"].(int); ok && v >= 0 {
capacity.Maximum = spotinst.Int(v)
}
if v, ok := m["target"].(int); ok && v >= 0 {
capacity.Target = spotinst.Int(v)
}
if v, ok := m["unit"].(string); ok && v != "" {
capacity.Unit = spotinst.String(v)
}
log.Printf("[DEBUG] AwsGroup capacity configuration: %s\n", stringutil.Stringify(capacity))
return capacity, nil
}
// expandAwsGroupStrategy expands the Strategy block.
func expandAwsGroupStrategy(data interface{}) (*spotinst.AwsGroupStrategy, error) {
list := data.(*schema.Set).List()
m := list[0].(map[string]interface{})
strategy := &spotinst.AwsGroupStrategy{}
if v, ok := m["risk"].(float64); ok && v >= 0 {
strategy.Risk = spotinst.Float64(v)
}
if v, ok := m["ondemand_count"].(int); ok && v >= 0 && spotinst.Float64Value(strategy.Risk) == 0 {
strategy.OnDemandCount = spotinst.Int(v)
strategy.Risk = nil
}
if v, ok := m["availability_vs_cost"].(string); ok && v != "" {
strategy.AvailabilityVsCost = spotinst.String(v)
}
if v, ok := m["draining_timeout"].(int); ok && v > 0 {
strategy.DrainingTimeout = spotinst.Int(v)
}
if v, ok := m["utilize_reserved_instances"].(bool); ok {
strategy.UtilizeReservedInstances = spotinst.Bool(v)
}
if v, ok := m["fallback_to_ondemand"].(bool); ok {
strategy.FallbackToOnDemand = spotinst.Bool(v)
}
log.Printf("[DEBUG] AwsGroup strategy configuration: %s\n", stringutil.Stringify(strategy))
return strategy, nil
}
// expandAwsGroupScalingPolicies expands the Scaling Policy block.
func expandAwsGroupScalingPolicies(data interface{}) ([]*spotinst.AwsGroupScalingPolicy, error) {
list := data.(*schema.Set).List()
policies := make([]*spotinst.AwsGroupScalingPolicy, 0, len(list))
for _, item := range list {
m := item.(map[string]interface{})
policy := &spotinst.AwsGroupScalingPolicy{}
if v, ok := m["policy_name"].(string); ok && v != "" {
policy.PolicyName = spotinst.String(v)
}
if v, ok := m["metric_name"].(string); ok && v != "" {
policy.MetricName = spotinst.String(v)
}
if v, ok := m["statistic"].(string); ok && v != "" {
policy.Statistic = spotinst.String(v)
}
if v, ok := m["unit"].(string); ok && v != "" {
policy.Unit = spotinst.String(v)
}
if v, ok := m["threshold"].(float64); ok && v > 0 {
policy.Threshold = spotinst.Float64(v)
}
if v, ok := m["adjustment"].(int); ok && v > 0 {
policy.Adjustment = spotinst.Int(v)
}
if v, ok := m["min_target_capacity"].(int); ok && v > 0 {
policy.MinTargetCapacity = spotinst.Int(v)
}
if v, ok := m["max_target_capacity"].(int); ok && v > 0 {
policy.MaxTargetCapacity = spotinst.Int(v)
}
if v, ok := m["namespace"].(string); ok && v != "" {
policy.Namespace = spotinst.String(v)
}
if v, ok := m["operator"].(string); ok && v != "" {
policy.Operator = spotinst.String(v)
}
if v, ok := m["period"].(int); ok && v > 0 {
policy.Period = spotinst.Int(v)
}
if v, ok := m["evaluation_periods"].(int); ok && v > 0 {
policy.EvaluationPeriods = spotinst.Int(v)
}
if v, ok := m["cooldown"].(int); ok && v > 0 {
policy.Cooldown = spotinst.Int(v)
}
if v, ok := m["dimensions"]; ok {
dimensions := expandAwsGroupScalingPolicyDimensions(v.(map[string]interface{}))
policy.Dimensions = dimensions
}
if v, ok := m["namespace"].(string); ok && v != "" {
log.Printf("[DEBUG] AwsGroup scaling policy configuration: %s\n", stringutil.Stringify(policy))
policies = append(policies, policy)
}
}
return policies, nil
}
func expandAwsGroupScalingPolicyDimensions(list map[string]interface{}) []*spotinst.AwsGroupScalingPolicyDimension {
dimensions := make([]*spotinst.AwsGroupScalingPolicyDimension, 0, len(list))
for name, val := range list {
dimension := &spotinst.AwsGroupScalingPolicyDimension{
Name: spotinst.String(name),
Value: spotinst.String(val.(string)),
}
log.Printf("[DEBUG] AwsGroup scaling policy dimension: %s\n", stringutil.Stringify(dimension))
dimensions = append(dimensions, dimension)
}
return dimensions
}
// expandAwsGroupScheduledTasks expands the Scheduled Task block.
func expandAwsGroupScheduledTasks(data interface{}) ([]*spotinst.AwsGroupScheduledTask, error) {
list := data.(*schema.Set).List()
tasks := make([]*spotinst.AwsGroupScheduledTask, 0, len(list))
for _, item := range list {
m := item.(map[string]interface{})
task := &spotinst.AwsGroupScheduledTask{}
if v, ok := m["task_type"].(string); ok && v != "" {
task.TaskType = spotinst.String(v)
}
if v, ok := m["frequency"].(string); ok && v != "" {
task.Frequency = spotinst.String(v)
}
if v, ok := m["cron_expression"].(string); ok && v != "" {
task.CronExpression = spotinst.String(v)
}
if v, ok := m["scale_target_capacity"].(int); ok && v > 0 {
task.ScaleTargetCapacity = spotinst.Int(v)
}
if v, ok := m["scale_min_capacity"].(int); ok && v > 0 {
task.ScaleMinCapacity = spotinst.Int(v)
}
if v, ok := m["scale_max_capacity"].(int); ok && v > 0 {
task.ScaleMaxCapacity = spotinst.Int(v)
}
log.Printf("[DEBUG] AwsGroup scheduled task configuration: %s\n", stringutil.Stringify(task))
tasks = append(tasks, task)
}
return tasks, nil
}
// expandAwsGroupAvailabilityZones expands the Availability Zone block.
func expandAwsGroupAvailabilityZones(data interface{}) ([]*spotinst.AwsGroupComputeAvailabilityZone, error) {
list := data.(*schema.Set).List()
zones := make([]*spotinst.AwsGroupComputeAvailabilityZone, 0, len(list))
for _, item := range list {
m := item.(map[string]interface{})
zone := &spotinst.AwsGroupComputeAvailabilityZone{}
if v, ok := m["name"].(string); ok && v != "" {
zone.Name = spotinst.String(v)
}
if v, ok := m["subnet_id"].(string); ok && v != "" {
zone.SubnetID = spotinst.String(v)
}
log.Printf("[DEBUG] AwsGroup availability zone configuration: %s\n", stringutil.Stringify(zone))
zones = append(zones, zone)
}
return zones, nil
}
// expandAwsGroupAvailabilityZonesSlice expands the Availability Zone block when provided as a slice.
func expandAwsGroupAvailabilityZonesSlice(data interface{}) ([]*spotinst.AwsGroupComputeAvailabilityZone, error) {
list := data.([]interface{})
zones := make([]*spotinst.AwsGroupComputeAvailabilityZone, 0, len(list))
for _, str := range list {
if s, ok := str.(string); ok {
parts := strings.Split(s, ":")
zone := &spotinst.AwsGroupComputeAvailabilityZone{}
if len(parts) >= 1 && parts[0] != "" {
zone.Name = spotinst.String(parts[0])
}
if len(parts) == 2 && parts[1] != "" {
zone.SubnetID = spotinst.String(parts[1])
}
log.Printf("[DEBUG] AwsGroup availability zone configuration: %s\n", stringutil.Stringify(zone))
zones = append(zones, zone)
}
}
return zones, nil
}
// expandAwsGroupEBSVolumePool expands the EBS Volume Pool block.
func expandAwsGroupEBSVolumePool(data interface{}) ([]*spotinst.AwsGroupComputeEBSVolume, error) {
list := data.(*schema.Set).List()
volumes := make([]*spotinst.AwsGroupComputeEBSVolume, 0, len(list))
for _, item := range list {
m := item.(map[string]interface{})
volume := &spotinst.AwsGroupComputeEBSVolume{}
if v, ok := m["device_name"].(string); ok && v != "" {
volume.DeviceName = spotinst.String(v)
}
if v, ok := m["volume_ids"].([]interface{}); ok {
ids := make([]string, len(v))
for i, j := range v {
ids[i] = j.(string)
}
volume.VolumeIDs = ids
}
log.Printf("[DEBUG] AwsGroup EBS volume (pool) configuration: %s\n", stringutil.Stringify(volume))
volumes = append(volumes, volume)
}
return volumes, nil
}
// expandAwsGroupSignals expands the Signal block.
func expandAwsGroupSignals(data interface{}) ([]*spotinst.AwsGroupStrategySignal, error) {
list := data.(*schema.Set).List()
signals := make([]*spotinst.AwsGroupStrategySignal, 0, len(list))
for _, item := range list {
m := item.(map[string]interface{})
signal := &spotinst.AwsGroupStrategySignal{}
if v, ok := m["name"].(string); ok && v != "" {
signal.Name = spotinst.String(strings.ToUpper(v))
}
log.Printf("[DEBUG] AwsGroup signal configuration: %s\n", stringutil.Stringify(signal))
signals = append(signals, signal)
}
return signals, nil
}
// expandAwsGroupInstanceTypes expands the Instance Types block.
func expandAwsGroupInstanceTypes(data interface{}) (*spotinst.AwsGroupComputeInstanceType, error) {
list := data.(*schema.Set).List()
m := list[0].(map[string]interface{})
types := &spotinst.AwsGroupComputeInstanceType{}
if v, ok := m["ondemand"].(string); ok && v != "" {
types.OnDemand = spotinst.String(v)
}
if v, ok := m["spot"].([]interface{}); ok {
it := make([]string, len(v))
for i, j := range v {
it[i] = j.(string)
}
types.Spot = it
}
log.Printf("[DEBUG] AwsGroup instance types configuration: %s\n", stringutil.Stringify(types))
return types, nil
}
// expandAwsGroupNetworkInterfaces expands the Elastic Network Interface block.
func expandAwsGroupNetworkInterfaces(data interface{}) ([]*spotinst.AwsGroupComputeNetworkInterface, error) {
list := data.(*schema.Set).List()
interfaces := make([]*spotinst.AwsGroupComputeNetworkInterface, 0, len(list))
for _, item := range list {
m := item.(map[string]interface{})
iface := &spotinst.AwsGroupComputeNetworkInterface{}
if v, ok := m["network_interface_id"].(string); ok && v != "" {
iface.ID = spotinst.String(v)
}
if v, ok := m["description"].(string); ok && v != "" {
iface.Description = spotinst.String(v)
}
if v, ok := m["device_index"].(int); ok && v >= 0 {
iface.DeviceIndex = spotinst.Int(v)
}
if v, ok := m["secondary_private_ip_address_count"].(int); ok && v > 0 {
iface.SecondaryPrivateIPAddressCount = spotinst.Int(v)
}
if v, ok := m["associate_public_ip_address"].(bool); ok {
iface.AssociatePublicIPAddress = spotinst.Bool(v)
}
if v, ok := m["delete_on_termination"].(bool); ok {
iface.DeleteOnTermination = spotinst.Bool(v)
}
if v, ok := m["private_ip_address"].(string); ok && v != "" {
iface.PrivateIPAddress = spotinst.String(v)
}
if v, ok := m["subnet_id"].(string); ok && v != "" {
iface.SubnetID = spotinst.String(v)
}
if v, ok := m["security_group_ids"].([]interface{}); ok {
ids := make([]string, len(v))
for i, j := range v {
ids[i] = j.(string)
}
iface.SecurityGroupsIDs = ids
}
log.Printf("[DEBUG] AwsGroup network interface configuration: %s\n", stringutil.Stringify(iface))
interfaces = append(interfaces, iface)
}
return interfaces, nil
}
// expandAwsGroupEphemeralBlockDevice expands the Ephemeral Block Device block.
func expandAwsGroupEphemeralBlockDevices(data interface{}) ([]*spotinst.AwsGroupComputeBlockDevice, error) {
list := data.(*schema.Set).List()
devices := make([]*spotinst.AwsGroupComputeBlockDevice, 0, len(list))
for _, item := range list {
m := item.(map[string]interface{})
device := &spotinst.AwsGroupComputeBlockDevice{}
if v, ok := m["device_name"].(string); ok && v != "" {
device.DeviceName = spotinst.String(v)
}
if v, ok := m["virtual_name"].(string); ok && v != "" {
device.VirtualName = spotinst.String(v)
}
log.Printf("[DEBUG] AwsGroup ephemeral block device configuration: %s\n", stringutil.Stringify(device))
devices = append(devices, device)
}
return devices, nil
}
// expandAwsGroupEBSBlockDevices expands the EBS Block Device block.
func expandAwsGroupEBSBlockDevices(data interface{}) ([]*spotinst.AwsGroupComputeBlockDevice, error) {
list := data.(*schema.Set).List()
devices := make([]*spotinst.AwsGroupComputeBlockDevice, 0, len(list))
for _, item := range list {
m := item.(map[string]interface{})
device := &spotinst.AwsGroupComputeBlockDevice{EBS: &spotinst.AwsGroupComputeEBS{}}
if v, ok := m["device_name"].(string); ok && v != "" {
device.DeviceName = spotinst.String(v)
}
if v, ok := m["delete_on_termination"].(bool); ok {
device.EBS.DeleteOnTermination = spotinst.Bool(v)
}
if v, ok := m["encrypted"].(bool); ok {
device.EBS.Encrypted = spotinst.Bool(v)
}
if v, ok := m["snapshot_id"].(string); ok && v != "" {
device.EBS.SnapshotID = spotinst.String(v)
}
if v, ok := m["volume_type"].(string); ok && v != "" {
device.EBS.VolumeType = spotinst.String(v)
}
if v, ok := m["volume_size"].(int); ok && v > 0 {
device.EBS.VolumeSize = spotinst.Int(v)
}
if v, ok := m["iops"].(int); ok && v > 0 {
device.EBS.IOPS = spotinst.Int(v)
}
log.Printf("[DEBUG] AwsGroup elastic block device configuration: %s\n", stringutil.Stringify(device))
devices = append(devices, device)
}
return devices, nil
}
// iprofArnRE is a regular expression for matching IAM instance profile ARNs.
var iprofArnRE = regexp.MustCompile(`arn:aws:iam::\d{12}:instance-profile/?[a-zA-Z_0-9+=,.@\-_/]+`)
// expandAwsGroupLaunchSpecification expands the launch Specification block.
func expandAwsGroupLaunchSpecification(data interface{}) (*spotinst.AwsGroupComputeLaunchSpecification, error) {
list := data.(*schema.Set).List()
m := list[0].(map[string]interface{})
lc := &spotinst.AwsGroupComputeLaunchSpecification{}
if v, ok := m["monitoring"].(bool); ok {
lc.Monitoring = spotinst.Bool(v)
}
if v, ok := m["ebs_optimized"].(bool); ok {
lc.EBSOptimized = spotinst.Bool(v)
}
if v, ok := m["image_id"].(string); ok && v != "" {
lc.ImageID = spotinst.String(v)
}
if v, ok := m["key_pair"].(string); ok && v != "" {
lc.KeyPair = spotinst.String(v)
}
if v, ok := m["health_check_type"].(string); ok && v != "" {
lc.HealthCheckType = spotinst.String(v)
}
if v, ok := m["health_check_grace_period"].(int); ok && v > 0 {
lc.HealthCheckGracePeriod = spotinst.Int(v)
}
if v, ok := m["iam_instance_profile"].(string); ok && v != "" {
iprof := &spotinst.AwsGroupComputeIamInstanceProfile{}
if iprofArnRE.MatchString(v) {
iprof.Arn = spotinst.String(v)
} else {
iprof.Name = spotinst.String(v)
}
lc.IamInstanceProfile = iprof
}
if v, ok := m["user_data"].(string); ok && v != "" {
lc.UserData = spotinst.String(base64.StdEncoding.EncodeToString([]byte(v)))
}
if v, ok := m["security_group_ids"].([]interface{}); ok {
ids := make([]string, len(v))
for i, j := range v {
ids[i] = j.(string)
}
lc.SecurityGroupIDs = ids
}
if v, ok := m["load_balancer_names"].([]interface{}); ok {
var names []string
for _, j := range v {
if name, ok := j.(string); ok && name != "" {
names = append(names, name)
}
}
lc.LoadBalancerNames = names
}
log.Printf("[DEBUG] AwsGroup launch specification configuration: %s\n", stringutil.Stringify(lc))
return lc, nil
}
// expandAwsGroupLoadBalancer expands the Load Balancer block.
func expandAwsGroupLoadBalancer(data interface{}) ([]*spotinst.AwsGroupComputeLoadBalancer, error) {
list := data.(*schema.Set).List()
lbs := make([]*spotinst.AwsGroupComputeLoadBalancer, 0, len(list))
for _, item := range list {
m := item.(map[string]interface{})
lb := &spotinst.AwsGroupComputeLoadBalancer{}
if v, ok := m["name"].(string); ok && v != "" {
lb.Name = spotinst.String(v)
}
if v, ok := m["arn"].(string); ok && v != "" {
lb.Arn = spotinst.String(v)
}
if v, ok := m["type"].(string); ok && v != "" {
lb.Type = spotinst.String(strings.ToUpper(v))
}
log.Printf("[DEBUG] AwsGroup load balancer configuration: %s\n", stringutil.Stringify(lb))
lbs = append(lbs, lb)
}
return lbs, nil
}
// expandAwsGroupRancherIntegration expands the Rancher Integration block.
func expandAwsGroupRancherIntegration(data interface{}) (*spotinst.AwsGroupRancherIntegration, error) {
list := data.(*schema.Set).List()
m := list[0].(map[string]interface{})
i := &spotinst.AwsGroupRancherIntegration{}
if v, ok := m["master_host"].(string); ok && v != "" {
i.MasterHost = spotinst.String(v)
}
if v, ok := m["access_key"].(string); ok && v != "" {
i.AccessKey = spotinst.String(v)
}
if v, ok := m["secret_key"].(string); ok && v != "" {
i.SecretKey = spotinst.String(v)
}
log.Printf("[DEBUG] AwsGroup Rancher integration configuration: %s\n", stringutil.Stringify(i))
return i, nil
}
// expandAwsGroupElasticBeanstalkIntegration expands the Elastic Beanstalk Integration block.
func expandAwsGroupElasticBeanstalkIntegration(data interface{}) (*spotinst.AwsGroupElasticBeanstalkIntegration, error) {
list := data.(*schema.Set).List()
m := list[0].(map[string]interface{})
i := &spotinst.AwsGroupElasticBeanstalkIntegration{}
if v, ok := m["environment_id"].(string); ok && v != "" {
i.EnvironmentID = spotinst.String(v)
}
log.Printf("[DEBUG] AwsGroup Elastic Beanstalk integration configuration: %s\n", stringutil.Stringify(i))
return i, nil
}
// expandAwsGroupEC2ContainerServiceIntegration expands the EC2 Container Service Integration block.
func expandAwsGroupEC2ContainerServiceIntegration(data interface{}) (*spotinst.AwsGroupEC2ContainerServiceIntegration, error) {
list := data.(*schema.Set).List()
m := list[0].(map[string]interface{})
i := &spotinst.AwsGroupEC2ContainerServiceIntegration{}
if v, ok := m["cluster_name"].(string); ok && v != "" {
i.ClusterName = spotinst.String(v)
}
log.Printf("[DEBUG] AwsGroup ECS integration configuration: %s\n", stringutil.Stringify(i))
return i, nil
}
// expandAwsGroupKubernetesIntegration expands the Kubernetes Integration block.
func expandAwsGroupKubernetesIntegration(data interface{}) (*spotinst.AwsGroupKubernetesIntegration, error) {
list := data.(*schema.Set).List()
m := list[0].(map[string]interface{})
i := &spotinst.AwsGroupKubernetesIntegration{}
if v, ok := m["api_server"].(string); ok && v != "" {
i.Server = spotinst.String(v)
}
if v, ok := m["token"].(string); ok && v != "" {
i.Token = spotinst.String(v)
}
log.Printf("[DEBUG] AwsGroup Kubernetes integration configuration: %s\n", stringutil.Stringify(i))
return i, nil
}
// expandAwsGroupMesosphereIntegration expands the Mesosphere Integration block.
func expandAwsGroupMesosphereIntegration(data interface{}) (*spotinst.AwsGroupMesosphereIntegration, error) {
list := data.(*schema.Set).List()
m := list[0].(map[string]interface{})
i := &spotinst.AwsGroupMesosphereIntegration{}
if v, ok := m["api_server"].(string); ok && v != "" {
i.Server = spotinst.String(v)
}
log.Printf("[DEBUG] AwsGroup Mesosphere integration configuration: %s\n", stringutil.Stringify(i))
return i, nil
}
// expandAwsGroupElasticIPs expands the Elastic IPs block.
func expandAwsGroupElasticIPs(data interface{}) ([]string, error) {
list := data.([]interface{})
eips := make([]string, 0, len(list))
for _, str := range list {
if eip, ok := str.(string); ok {
log.Printf("[DEBUG] AwsGroup elastic IP configuration: %s\n", stringutil.Stringify(eip))
eips = append(eips, eip)
}
}
return eips, nil
}
// expandAwsGroupTags expands the Tags block.
func expandAwsGroupTags(data interface{}) ([]*spotinst.AwsGroupComputeTag, error) {
list := data.(map[string]interface{})
tags := make([]*spotinst.AwsGroupComputeTag, 0, len(list))
for k, v := range list {
tag := &spotinst.AwsGroupComputeTag{
Key: spotinst.String(k),
Value: spotinst.String(v.(string)),
}
log.Printf("[DEBUG] AwsGroup tag configuration: %s\n", stringutil.Stringify(tag))
tags = append(tags, tag)
}
return tags, nil
}
func hashAwsGroupCapacity(v interface{}) int {
var buf bytes.Buffer
m := v.(map[string]interface{})
buf.WriteString(fmt.Sprintf("%d-", m["target"].(int)))
buf.WriteString(fmt.Sprintf("%d-", m["minimum"].(int)))
buf.WriteString(fmt.Sprintf("%d-", m["maximum"].(int)))
return hashcode.String(buf.String())
}
func hashAwsGroupStrategy(v interface{}) int {
var buf bytes.Buffer
m := v.(map[string]interface{})
buf.WriteString(fmt.Sprintf("%f-", m["risk"].(float64)))
buf.WriteString(fmt.Sprintf("%d-", m["ondemand_count"].(int)))
buf.WriteString(fmt.Sprintf("%t-", m["utilize_reserved_instances"].(bool)))
buf.WriteString(fmt.Sprintf("%t-", m["fallback_to_ondemand"].(bool)))
return hashcode.String(buf.String())
}
func hashAwsGroupLoadBalancer(v interface{}) int {
var buf bytes.Buffer
m := v.(map[string]interface{})
buf.WriteString(fmt.Sprintf("%s-", m["name"].(string)))
buf.WriteString(fmt.Sprintf("%s-", m["type"].(string)))
if v, ok := m["arn"].(string); ok && len(v) > 0 {
buf.WriteString(fmt.Sprintf("%s-", v))
}
return hashcode.String(buf.String())
}
func hashAwsGroupEBSBlockDevice(v interface{}) int {
var buf bytes.Buffer
m := v.(map[string]interface{})
buf.WriteString(fmt.Sprintf("%s-", m["device_name"].(string)))
buf.WriteString(fmt.Sprintf("%s-", m["snapshot_id"].(string)))
buf.WriteString(fmt.Sprintf("%d-", m["volume_size"].(int)))
buf.WriteString(fmt.Sprintf("%t-", m["delete_on_termination"].(bool)))
buf.WriteString(fmt.Sprintf("%t-", m["encrypted"].(bool)))
buf.WriteString(fmt.Sprintf("%d-", m["iops"].(int)))
return hashcode.String(buf.String())
}
func hashAwsGroupScalingPolicy(v interface{}) int {
var buf bytes.Buffer
m := v.(map[string]interface{})
buf.WriteString(fmt.Sprintf("%d-", m["adjustment"].(int)))
buf.WriteString(fmt.Sprintf("%d-", m["cooldown"].(int)))
buf.WriteString(fmt.Sprintf("%d-", m["evaluation_periods"].(int)))
buf.WriteString(fmt.Sprintf("%s-", m["metric_name"].(string)))
buf.WriteString(fmt.Sprintf("%s-", m["namespace"].(string)))
buf.WriteString(fmt.Sprintf("%d-", m["period"].(int)))
buf.WriteString(fmt.Sprintf("%s-", m["policy_name"].(string)))
buf.WriteString(fmt.Sprintf("%s-", m["statistic"].(string)))
buf.WriteString(fmt.Sprintf("%f-", m["threshold"].(float64)))
buf.WriteString(fmt.Sprintf("%s-", m["unit"].(string)))
buf.WriteString(fmt.Sprintf("%d-", m["min_target_capacity"].(int)))
buf.WriteString(fmt.Sprintf("%d-", m["max_target_capacity"].(int)))
// if v, ok := m["operator"].(string); ok && len(v) > 0 {
// buf.WriteString(fmt.Sprintf("%s-", v))
// }
if d, ok := m["dimensions"]; ok {
if len(d.(map[string]interface{})) > 0 {
e := d.(map[string]interface{})
for k, v := range e {
buf.WriteString(fmt.Sprintf("%s:%s-", k, v.(string)))
}
}
}
return hashcode.String(buf.String())
}
// tagsToMap turns the list of tags into a map.
func tagsToMap(ts []*spotinst.AwsGroupComputeTag) map[string]string {
result := make(map[string]string)
for _, t := range ts {
result[spotinst.StringValue(t.Key)] = spotinst.StringValue(t.Value)
}
return result
}