Golang EC2.DescribeNetworkInterfaces方法代码示例

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
}