terraform/builtin/providers/aws/resource_aws_elb.go

359 lines
9.6 KiB
Go
Raw Normal View History

package aws
import (
"fmt"
"log"
2014-07-30 13:46:51 +02:00
"strconv"
"github.com/hashicorp/terraform/flatmap"
"github.com/hashicorp/terraform/helper/config"
"github.com/hashicorp/terraform/helper/diff"
"github.com/hashicorp/terraform/terraform"
2014-06-27 18:55:24 +02:00
"github.com/mitchellh/goamz/elb"
)
func resource_aws_elb_create(
2014-09-17 02:44:42 +02:00
s *terraform.InstanceState,
2014-09-18 01:33:24 +02:00
d *terraform.InstanceDiff,
2014-09-17 02:44:42 +02:00
meta interface{}) (*terraform.InstanceState, error) {
p := meta.(*ResourceProvider)
elbconn := p.elbconn
// Merge the diff into the state so that we have all the attributes
// properly.
rs := s.MergeDiff(d)
// The name specified for the ELB. This is also our unique ID
// we save to state if the creation is successful (amazon verifies
// it is unique)
elbName := rs.Attributes["name"]
// Expand the "listener" array to goamz compat []elb.Listener
v := flatmap.Expand(rs.Attributes, "listener").([]interface{})
2014-07-25 00:50:18 +02:00
listeners, err := expandListeners(v)
if err != nil {
return nil, err
}
// Provision the elb
elbOpts := &elb.CreateLoadBalancer{
LoadBalancerName: elbName,
Listeners: listeners,
}
if _, ok := rs.Attributes["availability_zones.#"]; ok {
v = flatmap.Expand(rs.Attributes, "availability_zones").([]interface{})
elbOpts.AvailZone = expandStringList(v)
}
if _, ok := rs.Attributes["security_groups.#"]; ok {
v = flatmap.Expand(rs.Attributes, "security_groups").([]interface{})
elbOpts.SecurityGroups = expandStringList(v)
}
if _, ok := rs.Attributes["subnets.#"]; ok {
v = flatmap.Expand(rs.Attributes, "subnets").([]interface{})
elbOpts.Subnets = expandStringList(v)
}
2014-07-02 21:03:58 +02:00
log.Printf("[DEBUG] ELB create configuration: %#v", elbOpts)
2014-07-25 00:50:18 +02:00
_, err = elbconn.CreateLoadBalancer(elbOpts)
if err != nil {
return nil, fmt.Errorf("Error creating ELB: %s", err)
}
// Assign the elb's unique identifier for use later
rs.ID = elbName
log.Printf("[INFO] ELB ID: %s", elbName)
if _, ok := rs.Attributes["instances.#"]; ok {
// If we have any instances, we need to register them
v = flatmap.Expand(rs.Attributes, "instances").([]interface{})
instances := expandStringList(v)
if len(instances) > 0 {
registerInstancesOpts := elb.RegisterInstancesWithLoadBalancer{
LoadBalancerName: elbName,
Instances: instances,
}
_, err := elbconn.RegisterInstancesWithLoadBalancer(&registerInstancesOpts)
if err != nil {
return rs, fmt.Errorf("Failure registering instances: %s", err)
}
}
}
2014-07-30 13:46:51 +02:00
if _, ok := rs.Attributes["health_check.#"]; ok {
v := flatmap.Expand(rs.Attributes, "health_check").([]interface{})
health_check := v[0].(map[string]interface{})
healthyThreshold, err := strconv.ParseInt(health_check["healthy_threshold"].(string), 0, 0)
unhealthyThreshold, err := strconv.ParseInt(health_check["unhealthy_threshold"].(string), 0, 0)
interval, err := strconv.ParseInt(health_check["interval"].(string), 0, 0)
timeout, err := strconv.ParseInt(health_check["timeout"].(string), 0, 0)
if err != nil {
return nil, err
}
configureHealthCheckOpts := elb.ConfigureHealthCheck{
LoadBalancerName: elbName,
Check: elb.HealthCheck{
HealthyThreshold: healthyThreshold,
2014-07-30 13:46:51 +02:00
UnhealthyThreshold: unhealthyThreshold,
Interval: interval,
Target: health_check["target"].(string),
Timeout: timeout,
2014-07-30 13:46:51 +02:00
},
}
_, err = elbconn.ConfigureHealthCheck(&configureHealthCheckOpts)
if err != nil {
return rs, fmt.Errorf("Failure configuring health check: %s", err)
}
}
loadBalancer, err := resource_aws_elb_retrieve_balancer(rs.ID, elbconn)
if err != nil {
return rs, err
}
2014-07-03 07:40:55 +02:00
return resource_aws_elb_update_state(rs, loadBalancer)
}
2014-07-03 07:40:55 +02:00
func resource_aws_elb_update(
2014-09-17 02:44:42 +02:00
s *terraform.InstanceState,
2014-09-18 01:33:24 +02:00
d *terraform.InstanceDiff,
2014-09-17 02:44:42 +02:00
meta interface{}) (*terraform.InstanceState, error) {
2014-07-16 23:02:47 +02:00
p := meta.(*ResourceProvider)
elbconn := p.elbconn
2014-07-03 07:40:55 +02:00
2014-07-07 20:03:29 +02:00
rs := s.MergeDiff(d)
2014-07-16 23:02:47 +02:00
// If we currently have instances, or did have instances,
// we want to figure out what to add and remove from the load
// balancer
if attr, ok := d.Attributes["instances.#"]; ok && attr.Old != "" {
// The new state of instances merged with the diff
mergedInstances := expandStringList(flatmap.Expand(
rs.Attributes, "instances").([]interface{}))
// The state before the diff merge
previousInstances := expandStringList(flatmap.Expand(
s.Attributes, "instances").([]interface{}))
// keep track of what instances we are removing, and which
// we are adding
var toRemove []string
var toAdd []string
for _, instanceId := range mergedInstances {
for _, prevId := range previousInstances {
2014-07-16 23:02:47 +02:00
// If the merged instance ID existed
// previously, we don't have to do anything
if instanceId == prevId {
continue
// Otherwise, we need to add it to the load balancer
2014-07-16 23:02:47 +02:00
} else {
toAdd = append(toAdd, instanceId)
}
}
}
for i, instanceId := range toAdd {
for _, prevId := range previousInstances {
2014-07-16 23:02:47 +02:00
// If the instance ID we are adding existed
// previously, we want to not add it, but rather remove
// it
if instanceId == prevId {
toRemove = append(toRemove, instanceId)
toAdd = append(toAdd[:i], toAdd[i+1:]...)
// Otherwise, we continue adding it to the ELB
2014-07-16 23:02:47 +02:00
} else {
continue
}
}
}
2014-07-03 07:40:55 +02:00
2014-07-16 23:02:47 +02:00
if len(toAdd) > 0 {
registerInstancesOpts := elb.RegisterInstancesWithLoadBalancer{
LoadBalancerName: rs.ID,
Instances: toAdd,
}
2014-07-07 20:03:29 +02:00
2014-07-16 23:02:47 +02:00
_, err := elbconn.RegisterInstancesWithLoadBalancer(&registerInstancesOpts)
if err != nil {
return s, fmt.Errorf("Failure registering instances: %s", err)
}
}
if len(toRemove) > 0 {
deRegisterInstancesOpts := elb.DeregisterInstancesFromLoadBalancer{
LoadBalancerName: rs.ID,
Instances: toRemove,
}
_, err := elbconn.DeregisterInstancesFromLoadBalancer(&deRegisterInstancesOpts)
if err != nil {
return s, fmt.Errorf("Failure deregistering instances: %s", err)
}
}
}
loadBalancer, err := resource_aws_elb_retrieve_balancer(rs.ID, elbconn)
if err != nil {
return s, err
}
return resource_aws_elb_update_state(rs, loadBalancer)
2014-07-03 07:40:55 +02:00
}
func resource_aws_elb_destroy(
2014-09-17 02:44:42 +02:00
s *terraform.InstanceState,
meta interface{}) error {
2014-07-07 20:03:29 +02:00
p := meta.(*ResourceProvider)
elbconn := p.elbconn
log.Printf("[INFO] Deleting ELB: %s", s.ID)
// Destroy the load balancer
deleteElbOpts := elb.DeleteLoadBalancer{
LoadBalancerName: s.ID,
}
_, err := elbconn.DeleteLoadBalancer(&deleteElbOpts)
if err != nil {
return fmt.Errorf("Error deleting ELB: %s", err)
}
return nil
}
func resource_aws_elb_refresh(
2014-09-17 02:44:42 +02:00
s *terraform.InstanceState,
meta interface{}) (*terraform.InstanceState, error) {
p := meta.(*ResourceProvider)
elbconn := p.elbconn
loadBalancer, err := resource_aws_elb_retrieve_balancer(s.ID, elbconn)
if err != nil {
return nil, err
}
return resource_aws_elb_update_state(s, loadBalancer)
}
func resource_aws_elb_diff(
2014-09-17 02:44:42 +02:00
s *terraform.InstanceState,
c *terraform.ResourceConfig,
2014-09-18 01:33:24 +02:00
meta interface{}) (*terraform.InstanceDiff, error) {
b := &diff.ResourceBuilder{
Attrs: map[string]diff.AttrType{
2014-07-02 21:03:58 +02:00
"name": diff.AttrTypeCreate,
"availability_zone": diff.AttrTypeCreate,
"security_groups": diff.AttrTypeCreate, // TODO could be AttrTypeUpdate
"subnets": diff.AttrTypeCreate, // TODO could be AttrTypeUpdate
"listener": diff.AttrTypeCreate,
2014-07-03 07:40:55 +02:00
"instances": diff.AttrTypeUpdate,
2014-07-30 13:46:51 +02:00
"health_check": diff.AttrTypeCreate,
},
ComputedAttrs: []string{
"dns_name",
},
}
return b.Diff(s, c)
}
func resource_aws_elb_update_state(
2014-09-17 02:44:42 +02:00
s *terraform.InstanceState,
balancer *elb.LoadBalancer) (*terraform.InstanceState, error) {
2014-07-16 23:02:47 +02:00
s.Attributes["name"] = balancer.LoadBalancerName
s.Attributes["dns_name"] = balancer.DNSName
2014-07-16 23:02:47 +02:00
// Flatten our group values
toFlatten := make(map[string]interface{})
if len(balancer.Instances) > 0 && balancer.Instances[0].InstanceId != "" {
toFlatten["instances"] = flattenInstances(balancer.Instances)
}
if len(balancer.SecurityGroups) > 0 && balancer.SecurityGroups[0] != "" {
toFlatten["security_groups"] = balancer.SecurityGroups
}
if len(balancer.Subnets) > 0 && balancer.Subnets[0] != "" {
toFlatten["subnets"] = balancer.Subnets
}
// There's only one health check, so save that to state as we
// currently can
if balancer.HealthCheck.Target != "" {
toFlatten["health_check"] = flattenHealthCheck(balancer.HealthCheck)
}
for k, v := range flatmap.Flatten(toFlatten) {
s.Attributes[k] = v
2014-07-16 23:02:47 +02:00
}
return s, nil
}
// retrieves an ELB by its ID
func resource_aws_elb_retrieve_balancer(id string, elbconn *elb.ELB) (*elb.LoadBalancer, error) {
describeElbOpts := &elb.DescribeLoadBalancer{
Names: []string{id},
}
// Retrieve the ELB properties for updating the state
describeResp, err := elbconn.DescribeLoadBalancers(describeElbOpts)
if err != nil {
return nil, fmt.Errorf("Error retrieving ELB: %s", err)
}
loadBalancer := describeResp.LoadBalancers[0]
// Verify AWS returned our ELB
if len(describeResp.LoadBalancers) != 1 ||
describeResp.LoadBalancers[0].LoadBalancerName != id {
if err != nil {
return nil, fmt.Errorf("Unable to find ELB: %#v", describeResp.LoadBalancers)
}
}
return &loadBalancer, nil
}
func resource_aws_elb_validation() *config.Validator {
return &config.Validator{
Required: []string{
"name",
"listener.*",
"listener.*.instance_port",
"listener.*.instance_protocol",
"listener.*.lb_port",
"listener.*.lb_protocol",
},
Optional: []string{
"instances.*",
"availability_zones.*",
"security_groups.*",
"subnets.*",
2014-07-30 13:46:51 +02:00
"health_check.#",
"health_check.0.healthy_threshold",
"health_check.0.unhealthy_threshold",
"health_check.0.interval",
"health_check.0.target",
"health_check.0.timeout",
},
}
}