terraform/builtin/providers/aws/resource_aws_eip.go

213 lines
4.9 KiB
Go

package aws
import (
"fmt"
"log"
"github.com/hashicorp/terraform/helper/config"
"github.com/hashicorp/terraform/helper/diff"
"github.com/hashicorp/terraform/terraform"
"github.com/mitchellh/goamz/ec2"
)
func resource_aws_eip_create(
s *terraform.ResourceState,
d *terraform.ResourceDiff,
meta interface{}) (*terraform.ResourceState, error) {
p := meta.(*ResourceProvider)
ec2conn := p.ec2conn
// Merge the diff into the state so that we have all the attributes
// properly.
rs := s.MergeDiff(d)
// By default, we're not in a VPC
vpc := false
domainOpt := ""
if rs.Attributes["vpc"] == "true" {
vpc = true
domainOpt = "vpc"
}
allocOpts := ec2.AllocateAddress{
Domain: domainOpt,
}
log.Printf("[DEBUG] EIP create configuration: %#v", allocOpts)
allocResp, err := ec2conn.AllocateAddress(&allocOpts)
if err != nil {
return nil, fmt.Errorf("Error creating EIP: %s", err)
}
// Assign the eips (unique) allocation id for use later
// the EIP api has a conditional unique ID (really), so
// if we're in a VPC we need to save the ID as such, otherwise
// it defaults to using the public IP
if vpc {
rs.ID = allocResp.AllocationId
} else {
rs.ID = allocResp.PublicIp
}
log.Printf("[INFO] EIP ID: %s (vpc: %v)", rs.ID, vpc)
// If we have an instance to register, do it
instanceId := rs.Attributes["instance"]
// Only register with an instance if we have one
if instanceId != "" {
assocOpts := ec2.AssociateAddress{
InstanceId: instanceId,
PublicIp: rs.ID,
}
// more unique ID conditionals
if vpc {
assocOpts = ec2.AssociateAddress{
InstanceId: instanceId,
AllocationId: rs.ID,
}
}
log.Printf("[DEBUG] EIP associate configuration: %#v (vpc: %v)", assocOpts, vpc)
_, err := ec2conn.AssociateAddress(&assocOpts)
if err != nil {
return rs, fmt.Errorf("Failure associating instances: %s", err)
}
}
address, err := resource_aws_eip_retrieve_address(rs.ID, vpc, ec2conn)
if err != nil {
return rs, err
}
return resource_aws_eip_update_state(rs, address)
}
func resource_aws_eip_update(
s *terraform.ResourceState,
d *terraform.ResourceDiff,
meta interface{}) (*terraform.ResourceState, error) {
rs := s.MergeDiff(d)
log.Printf("ResourceDiff: %s", d)
log.Printf("ResourceState: %s", s)
log.Printf("Merged: %s", rs)
return nil, fmt.Errorf("Did not update")
}
func resource_aws_eip_destroy(
s *terraform.ResourceState,
meta interface{}) error {
p := meta.(*ResourceProvider)
ec2conn := p.ec2conn
var err error
if s.Attributes["vpc"] == "true" {
log.Printf("[DEBUG] EIP release (destroy) address allocation: %v", s.ID)
_, err = ec2conn.ReleaseAddress(s.ID)
return err
} else {
log.Printf("[DEBUG] EIP release (destroy) address: %v", s.ID)
_, err = ec2conn.ReleasePublicAddress(s.ID)
return err
}
return nil
}
func resource_aws_eip_refresh(
s *terraform.ResourceState,
meta interface{}) (*terraform.ResourceState, error) {
p := meta.(*ResourceProvider)
ec2conn := p.ec2conn
vpc := false
if s.Attributes["vpc"] == "true" {
vpc = true
}
address, err := resource_aws_eip_retrieve_address(s.ID, vpc, ec2conn)
if err != nil {
return s, err
}
return resource_aws_eip_update_state(s, address)
}
func resource_aws_eip_diff(
s *terraform.ResourceState,
c *terraform.ResourceConfig,
meta interface{}) (*terraform.ResourceDiff, error) {
b := &diff.ResourceBuilder{
Attrs: map[string]diff.AttrType{
"vpc": diff.AttrTypeCreate,
"instance": diff.AttrTypeUpdate,
},
ComputedAttrs: []string{
"public_ip",
"private_ip",
},
}
return b.Diff(s, c)
}
func resource_aws_eip_update_state(
s *terraform.ResourceState,
address *ec2.Address) (*terraform.ResourceState, error) {
s.Attributes["private_ip"] = address.PrivateIpAddress
s.Attributes["public_ip"] = address.PublicIp
s.Attributes["instance"] = address.InstanceId
return s, nil
}
// Returns a single address by it's ID
func resource_aws_eip_retrieve_address(id string, vpc bool, ec2conn *ec2.EC2) (*ec2.Address, error) {
// Get the full address description for saving to state for
// use in other resources
assocIds := []string{}
publicIps := []string{}
if vpc {
assocIds = []string{id}
} else {
publicIps = []string{id}
}
log.Printf("[DEBUG] EIP describe configuration: %#v, %#v (vpc: %v)", assocIds, publicIps, vpc)
describeAddresses, err := ec2conn.Addresses(publicIps, assocIds, nil)
if err != nil {
return nil, fmt.Errorf("Error retrieving EIP: %s", err)
}
// Verify AWS returned our EIP
if len(describeAddresses.Addresses) != 1 ||
describeAddresses.Addresses[0].AllocationId != id ||
describeAddresses.Addresses[0].PublicIp != id {
if err != nil {
return nil, fmt.Errorf("Unable to find EIP: %#v", describeAddresses.Addresses)
}
}
address := describeAddresses.Addresses[0]
return &address, nil
}
func resource_aws_eip_validation() *config.Validator {
return &config.Validator{
Optional: []string{
"vpc",
"instance",
},
}
}