func processNetInterfaces(svc *ec2.EC2, pageSize int64, apply func([]*string)) {
networkInterfaces, err := svc.DescribeNetworkInterfaces(&ec2.DescribeNetworkInterfacesInput{})
kingpin.FatalIfError(err, "Could not retrieve EC2 network interfaces")
var niIds []*string
for _, ni := range networkInterfaces.NetworkInterfaces {
niIds = append(niIds, ni.NetworkInterfaceId)
}
apply(niIds)
}
func networkInterfaceAttachmentRefreshFunc(conn *ec2.EC2, id string) resource.StateRefreshFunc {
return func() (interface{}, string, error) {
describe_network_interfaces_request := &ec2.DescribeNetworkInterfacesInput{
NetworkInterfaceIds: []*string{aws.String(id)},
}
describeResp, err := conn.DescribeNetworkInterfaces(describe_network_interfaces_request)
if err != nil {
log.Printf("[ERROR] Could not find network interface %s. %s", id, err)
return nil, "", err
}
eni := describeResp.NetworkInterfaces[0]
hasAttachment := strconv.FormatBool(eni.Attachment != nil)
log.Printf("[DEBUG] ENI %s has attachment state %s", id, hasAttachment)
return eni, hasAttachment, nil
}
}
func waitForNoUsedIPS(svc *ec2.EC2, vpcid string) error {
filters := make([]*ec2.Filter, 0)
keyname := "vpc-id"
filter := ec2.Filter{
Name: &keyname, Values: []*string{&vpcid}}
filters = append(filters, &filter)
dnii := &ec2.DescribeNetworkInterfacesInput{Filters: filters}
dnio, err := svc.DescribeNetworkInterfaces(dnii)
if err != nil {
fmt.Println("Failed to describe network interfaces:", err)
return err
}
//for i := range dnio.NetworkInterfaces {
// fmt.Println(dnio.NetworkInterfaces[i])
//}
count := 0
for {
dnio, err = svc.DescribeNetworkInterfaces(dnii)
if len(dnio.NetworkInterfaces) == 0 {
return nil
}
//for i := range dnio.NetworkInterfaces {
// fmt.Println(dnio.NetworkInterfaces[i])
//}
if count > 60 {
break
}
time.Sleep(2 * time.Second)
count++
}
return errors.New("Waited too long for IPs to disappear...")
}
func getLambdaENIs(conn *ec2.EC2, d *schema.ResourceData) []ec2.NetworkInterface {
filter := &ec2.Filter{
Name: aws.String("group-id"),
Values: []*string{aws.String(d.Id())},
}
params := &ec2.DescribeNetworkInterfacesInput{
Filters: []*ec2.Filter{filter},
}
networkInterfaceResp, err := conn.DescribeNetworkInterfaces(params)
lambdaENIs := make([]ec2.NetworkInterface, 0)
if err != nil {
log.Printf("[WARN] Unable to fetch ENIs: %s", err)
return lambdaENIs
}
v := networkInterfaceResp.NetworkInterfaces
for _, eni := range v {
if strings.Contains(*eni.Description, "AWS Lambda VPC ENI") {
lambdaENIs = append(lambdaENIs, *eni)
}
}
return lambdaENIs
}
// The AWS Lambda service creates ENIs behind the scenes and keeps these around for a while
// which would prevent SGs attached to such ENIs from being destroyed
func deleteLingeringLambdaENIs(conn *ec2.EC2, d *schema.ResourceData) error {
// Here we carefully find the offenders
params := &ec2.DescribeNetworkInterfacesInput{
Filters: []*ec2.Filter{
&ec2.Filter{
Name: aws.String("group-id"),
Values: []*string{aws.String(d.Id())},
},
&ec2.Filter{
Name: aws.String("description"),
Values: []*string{aws.String("AWS Lambda VPC ENI: *")},
},
&ec2.Filter{
Name: aws.String("requester-id"),
Values: []*string{aws.String("*:awslambda_*")},
},
},
}
networkInterfaceResp, err := conn.DescribeNetworkInterfaces(params)
if err != nil {
return err
}
// Then we detach and finally delete those
v := networkInterfaceResp.NetworkInterfaces
for _, eni := range v {
if eni.Attachment != nil {
detachNetworkInterfaceParams := &ec2.DetachNetworkInterfaceInput{
AttachmentId: eni.Attachment.AttachmentId,
}
_, detachNetworkInterfaceErr := conn.DetachNetworkInterface(detachNetworkInterfaceParams)
if detachNetworkInterfaceErr != nil {
return detachNetworkInterfaceErr
}
log.Printf("[DEBUG] Waiting for ENI (%s) to become detached", *eni.NetworkInterfaceId)
stateConf := &resource.StateChangeConf{
Pending: []string{"true"},
Target: []string{"false"},
Refresh: networkInterfaceAttachedRefreshFunc(conn, *eni.NetworkInterfaceId),
Timeout: 10 * time.Minute,
}
if _, err := stateConf.WaitForState(); err != nil {
return fmt.Errorf(
"Error waiting for ENI (%s) to become detached: %s", *eni.NetworkInterfaceId, err)
}
}
deleteNetworkInterfaceParams := &ec2.DeleteNetworkInterfaceInput{
NetworkInterfaceId: eni.NetworkInterfaceId,
}
_, deleteNetworkInterfaceErr := conn.DeleteNetworkInterface(deleteNetworkInterfaceParams)
if deleteNetworkInterfaceErr != nil {
return deleteNetworkInterfaceErr
}
}
return nil
}