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  }