github.com/nicgrayson/terraform@v0.4.3-0.20150415203910-c4de50829380/builtin/providers/aws/resource_aws_network_interface.go (about) 1 package aws 2 3 import ( 4 "bytes" 5 "fmt" 6 "log" 7 "strconv" 8 "time" 9 10 "github.com/awslabs/aws-sdk-go/aws" 11 "github.com/awslabs/aws-sdk-go/service/ec2" 12 "github.com/hashicorp/terraform/helper/hashcode" 13 "github.com/hashicorp/terraform/helper/resource" 14 "github.com/hashicorp/terraform/helper/schema" 15 ) 16 17 func resourceAwsNetworkInterface() *schema.Resource { 18 return &schema.Resource{ 19 Create: resourceAwsNetworkInterfaceCreate, 20 Read: resourceAwsNetworkInterfaceRead, 21 Update: resourceAwsNetworkInterfaceUpdate, 22 Delete: resourceAwsNetworkInterfaceDelete, 23 24 Schema: map[string]*schema.Schema{ 25 26 "subnet_id": &schema.Schema{ 27 Type: schema.TypeString, 28 Required: true, 29 ForceNew: true, 30 }, 31 32 "private_ips": &schema.Schema{ 33 Type: schema.TypeSet, 34 Optional: true, 35 ForceNew: true, 36 Elem: &schema.Schema{Type: schema.TypeString}, 37 Set: func(v interface{}) int { 38 return hashcode.String(v.(string)) 39 }, 40 }, 41 42 "security_groups": &schema.Schema{ 43 Type: schema.TypeSet, 44 Optional: true, 45 Computed: true, 46 Elem: &schema.Schema{Type: schema.TypeString}, 47 Set: func(v interface{}) int { 48 return hashcode.String(v.(string)) 49 }, 50 }, 51 52 "attachment": &schema.Schema{ 53 Type: schema.TypeSet, 54 Optional: true, 55 Elem: &schema.Resource{ 56 Schema: map[string]*schema.Schema{ 57 "instance": &schema.Schema{ 58 Type: schema.TypeString, 59 Required: true, 60 }, 61 "device_index": &schema.Schema{ 62 Type: schema.TypeInt, 63 Required: true, 64 }, 65 "attachment_id": &schema.Schema{ 66 Type: schema.TypeString, 67 Computed: true, 68 }, 69 }, 70 }, 71 Set: resourceAwsEniAttachmentHash, 72 }, 73 74 "tags": tagsSchema(), 75 }, 76 } 77 } 78 79 func resourceAwsNetworkInterfaceCreate(d *schema.ResourceData, meta interface{}) error { 80 81 conn := meta.(*AWSClient).ec2SDKconn 82 83 request := &ec2.CreateNetworkInterfaceInput{ 84 Groups: expandStringListSDK(d.Get("security_groups").(*schema.Set).List()), 85 SubnetID: aws.String(d.Get("subnet_id").(string)), 86 PrivateIPAddresses: expandPrivateIPAddessesSDK(d.Get("private_ips").(*schema.Set).List()), 87 } 88 89 log.Printf("[DEBUG] Creating network interface") 90 resp, err := conn.CreateNetworkInterface(request) 91 if err != nil { 92 return fmt.Errorf("Error creating ENI: %s", err) 93 } 94 95 d.SetId(*resp.NetworkInterface.NetworkInterfaceID) 96 log.Printf("[INFO] ENI ID: %s", d.Id()) 97 return resourceAwsNetworkInterfaceUpdate(d, meta) 98 } 99 100 func resourceAwsNetworkInterfaceRead(d *schema.ResourceData, meta interface{}) error { 101 102 conn := meta.(*AWSClient).ec2SDKconn 103 describe_network_interfaces_request := &ec2.DescribeNetworkInterfacesInput{ 104 NetworkInterfaceIDs: []*string{aws.String(d.Id())}, 105 } 106 describeResp, err := conn.DescribeNetworkInterfaces(describe_network_interfaces_request) 107 108 if err != nil { 109 if ec2err, ok := err.(aws.APIError); ok && ec2err.Code == "InvalidNetworkInterfaceID.NotFound" { 110 // The ENI is gone now, so just remove it from the state 111 d.SetId("") 112 return nil 113 } 114 115 return fmt.Errorf("Error retrieving ENI: %s", err) 116 } 117 if len(describeResp.NetworkInterfaces) != 1 { 118 return fmt.Errorf("Unable to find ENI: %#v", describeResp.NetworkInterfaces) 119 } 120 121 eni := describeResp.NetworkInterfaces[0] 122 d.Set("subnet_id", eni.SubnetID) 123 d.Set("private_ips", flattenNetworkInterfacesPrivateIPAddessesSDK(eni.PrivateIPAddresses)) 124 d.Set("security_groups", flattenGroupIdentifiersSDK(eni.Groups)) 125 126 // Tags 127 d.Set("tags", tagsToMapSDK(eni.TagSet)) 128 129 if eni.Attachment != nil { 130 attachment := []map[string]interface{}{flattenAttachmentSDK(eni.Attachment)} 131 d.Set("attachment", attachment) 132 } else { 133 d.Set("attachment", nil) 134 } 135 136 return nil 137 } 138 139 func networkInterfaceAttachmentRefreshFunc(conn *ec2.EC2, id string) resource.StateRefreshFunc { 140 return func() (interface{}, string, error) { 141 142 describe_network_interfaces_request := &ec2.DescribeNetworkInterfacesInput{ 143 NetworkInterfaceIDs: []*string{aws.String(id)}, 144 } 145 describeResp, err := conn.DescribeNetworkInterfaces(describe_network_interfaces_request) 146 147 if err != nil { 148 log.Printf("[ERROR] Could not find network interface %s. %s", id, err) 149 return nil, "", err 150 } 151 152 eni := describeResp.NetworkInterfaces[0] 153 hasAttachment := strconv.FormatBool(eni.Attachment != nil) 154 log.Printf("[DEBUG] ENI %s has attachment state %s", id, hasAttachment) 155 return eni, hasAttachment, nil 156 } 157 } 158 159 func resourceAwsNetworkInterfaceDetach(oa *schema.Set, meta interface{}, eniId string) error { 160 // if there was an old attachment, remove it 161 if oa != nil && len(oa.List()) > 0 { 162 old_attachment := oa.List()[0].(map[string]interface{}) 163 detach_request := &ec2.DetachNetworkInterfaceInput{ 164 AttachmentID: aws.String(old_attachment["attachment_id"].(string)), 165 Force: aws.Boolean(true), 166 } 167 conn := meta.(*AWSClient).ec2SDKconn 168 _, detach_err := conn.DetachNetworkInterface(detach_request) 169 if detach_err != nil { 170 return fmt.Errorf("Error detaching ENI: %s", detach_err) 171 } 172 173 log.Printf("[DEBUG] Waiting for ENI (%s) to become dettached", eniId) 174 stateConf := &resource.StateChangeConf{ 175 Pending: []string{"true"}, 176 Target: "false", 177 Refresh: networkInterfaceAttachmentRefreshFunc(conn, eniId), 178 Timeout: 10 * time.Minute, 179 } 180 if _, err := stateConf.WaitForState(); err != nil { 181 return fmt.Errorf( 182 "Error waiting for ENI (%s) to become dettached: %s", eniId, err) 183 } 184 } 185 186 return nil 187 } 188 189 func resourceAwsNetworkInterfaceUpdate(d *schema.ResourceData, meta interface{}) error { 190 conn := meta.(*AWSClient).ec2SDKconn 191 d.Partial(true) 192 193 if d.HasChange("attachment") { 194 oa, na := d.GetChange("attachment") 195 196 detach_err := resourceAwsNetworkInterfaceDetach(oa.(*schema.Set), meta, d.Id()) 197 if detach_err != nil { 198 return detach_err 199 } 200 201 // if there is a new attachment, attach it 202 if na != nil && len(na.(*schema.Set).List()) > 0 { 203 new_attachment := na.(*schema.Set).List()[0].(map[string]interface{}) 204 di := new_attachment["device_index"].(int) 205 attach_request := &ec2.AttachNetworkInterfaceInput{ 206 DeviceIndex: aws.Long(int64(di)), 207 InstanceID: aws.String(new_attachment["instance"].(string)), 208 NetworkInterfaceID: aws.String(d.Id()), 209 } 210 _, attach_err := conn.AttachNetworkInterface(attach_request) 211 if attach_err != nil { 212 return fmt.Errorf("Error attaching ENI: %s", attach_err) 213 } 214 } 215 216 d.SetPartial("attachment") 217 } 218 219 if d.HasChange("security_groups") { 220 request := &ec2.ModifyNetworkInterfaceAttributeInput{ 221 NetworkInterfaceID: aws.String(d.Id()), 222 Groups: expandStringListSDK(d.Get("security_groups").(*schema.Set).List()), 223 } 224 225 _, err := conn.ModifyNetworkInterfaceAttribute(request) 226 if err != nil { 227 return fmt.Errorf("Failure updating ENI: %s", err) 228 } 229 230 d.SetPartial("security_groups") 231 } 232 233 if err := setTagsSDK(conn, d); err != nil { 234 return err 235 } else { 236 d.SetPartial("tags") 237 } 238 239 d.Partial(false) 240 241 return resourceAwsNetworkInterfaceRead(d, meta) 242 } 243 244 func resourceAwsNetworkInterfaceDelete(d *schema.ResourceData, meta interface{}) error { 245 conn := meta.(*AWSClient).ec2SDKconn 246 247 log.Printf("[INFO] Deleting ENI: %s", d.Id()) 248 249 detach_err := resourceAwsNetworkInterfaceDetach(d.Get("attachment").(*schema.Set), meta, d.Id()) 250 if detach_err != nil { 251 return detach_err 252 } 253 254 deleteEniOpts := ec2.DeleteNetworkInterfaceInput{ 255 NetworkInterfaceID: aws.String(d.Id()), 256 } 257 if _, err := conn.DeleteNetworkInterface(&deleteEniOpts); err != nil { 258 return fmt.Errorf("Error deleting ENI: %s", err) 259 } 260 261 return nil 262 } 263 264 func resourceAwsEniAttachmentHash(v interface{}) int { 265 var buf bytes.Buffer 266 m := v.(map[string]interface{}) 267 buf.WriteString(fmt.Sprintf("%s-", m["instance"].(string))) 268 buf.WriteString(fmt.Sprintf("%d-", m["device_index"].(int))) 269 return hashcode.String(buf.String()) 270 }