github.com/cloud-foundations/dominator@v0.0.0-20221004181915-6e4fee580046/imagepublishers/amipublisher/libAws.go

package amipublisher

import (
	"errors"
	"fmt"
	"path"
	"strings"
	"time"

	"github.com/Cloud-Foundations/Dominator/lib/awsutil"
	"github.com/Cloud-Foundations/Dominator/lib/log"
	libtags "github.com/Cloud-Foundations/Dominator/lib/tags"
	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/service/ec2"
	"github.com/aws/aws-sdk-go/service/s3"
)

const (
	creationTimeFormat = "2006-01-02T15:04:05.000Z"
	rootDevName        = "/dev/sda1"
)

var (
	amiNameReplacer = strings.NewReplacer(
		"@", "@@",
		"~", "@tilde@",
		"!", "@bang@",
		"#", "@hash@",
		"$", "@dollar@",
		"%", "@percent@",
		"^", "@caret@",
		"&", "@ampersand@",
		"*", "@asterix@", // the gaul.
		"=", "@equal@",
		"+", "@plus@",
		":", ".",
	)
)

func attachVolume(awsService *ec2.EC2, instance *ec2.Instance, volumeId string,
	logger log.Logger) error {
	usedBlockDevices := make(map[string]struct{})
	for _, device := range instance.BlockDeviceMappings {
		usedBlockDevices[aws.StringValue(device.DeviceName)] = struct{}{}
	}
	blockDeviceName := getFreeVolumeName(usedBlockDevices)
	if blockDeviceName == "" {
		return errors.New("no space for new block device")
	}
	_, err := awsService.AttachVolume(&ec2.AttachVolumeInput{
		Device:     aws.String(blockDeviceName),
		InstanceId: instance.InstanceId,
		VolumeId:   aws.String(volumeId),
	})
	if err != nil {
		return fmt.Errorf("ec2.AttachVolume: %s", err)
	}
	blockDevMappings := make([]*ec2.InstanceBlockDeviceMappingSpecification, 1)
	blockDevMappings[0] = &ec2.InstanceBlockDeviceMappingSpecification{
		DeviceName: aws.String(blockDeviceName),
		Ebs: &ec2.EbsInstanceBlockDeviceSpecification{
			DeleteOnTermination: aws.Bool(true),
			VolumeId:            aws.String(volumeId),
		},
	}
	_, err = awsService.ModifyInstanceAttribute(
		&ec2.ModifyInstanceAttributeInput{
			BlockDeviceMappings: blockDevMappings,
			InstanceId:          instance.InstanceId,
		})
	if err != nil {
		return fmt.Errorf("ec2.ModifyInstanceAttribute: %s", err)
	}
	logger.Printf("requested attach(%s): %s on %s, waiting...\n",
		aws.StringValue(instance.InstanceId), volumeId, blockDeviceName)
	dvi := &ec2.DescribeVolumesInput{
		VolumeIds: aws.StringSlice([]string{volumeId}),
	}
	if err := awsService.WaitUntilVolumeInUse(dvi); err != nil {
		return fmt.Errorf("ec2.WaitUntilVolumeInUse: %s", err)
	}
	for ; true; time.Sleep(time.Second) {
		desc, err := awsService.DescribeVolumes(dvi)
		if err != nil {
			return fmt.Errorf("ec2.DescribeVolumes: %s", err)
		}
		if len(desc.Volumes[0].Attachments) < 1 {
			logger.Printf("attachments: %d\n",
				len(desc.Volumes[0].Attachments))
			continue
		}
		state := *desc.Volumes[0].Attachments[0].State
		logger.Printf("state: \"%s\"\n", state)
		if state == ec2.VolumeAttachmentStateAttached {
			break
		}
	}
	logger.Printf("attached: %s\n", volumeId)
	return nil
}

// computeImageConsumption returns the size in GiB.
func computeImageConsumption(image *ec2.Image) int64 {
	var sizeGiB int64
	for _, bdMapping := range image.BlockDeviceMappings {
		// TODO(rgooch): Should use the snapshot size instead.
		if ebs := bdMapping.Ebs; ebs != nil {
			sizeGiB += aws.Int64Value(ebs.VolumeSize)
		}
	}
	// TODO(rgooch): Should query the S3 folder instead.
	if sizeGiB < 1 {
		sizeGiB = 1
	}
	return sizeGiB
}

func createSnapshot(awsService *ec2.EC2, volumeId string, description string,
	tags libtags.Tags, logger log.Logger) (
	string, error) {
	snapshot, err := awsService.CreateSnapshot(&ec2.CreateSnapshotInput{
		VolumeId:    aws.String(volumeId),
		Description: aws.String(description),
	})
	if err != nil {
		return "", fmt.Errorf("ec2.CreateSnapshot: %s", err)
	}
	snapshotIds := make([]string, 1)
	snapshotIds[0] = *snapshot.SnapshotId
	logger.Printf("Created: %s\n", *snapshot.SnapshotId)
	tags = tags.Copy()
	tags["Name"] = description
	if err := createTags(awsService, *snapshot.SnapshotId, tags); err != nil {
		return "", err
	}
	logger.Printf("Tagged: %s, waiting...\n", *snapshot.SnapshotId)
	err = awsService.WaitUntilSnapshotCompleted(&ec2.DescribeSnapshotsInput{
		SnapshotIds: aws.StringSlice(snapshotIds),
	})
	if err != nil {
		return "", fmt.Errorf("ec2.WaitUntilSnapshotCompleted: %s", err)
	}
	return *snapshot.SnapshotId, nil
}

func createTags(awsService *ec2.EC2, resourceId string,
	tags map[string]string) error {
	resourceIds := make([]string, 1)
	resourceIds[0] = resourceId
	awsTags := make([]*ec2.Tag, 0, len(tags))
	for key, value := range tags {
		awsTags = append(awsTags,
			&ec2.Tag{Key: aws.String(key), Value: aws.String(value)})
	}
	_, err := awsService.CreateTags(&ec2.CreateTagsInput{
		Resources: aws.StringSlice(resourceIds),
		Tags:      awsTags,
	})
	if err != nil {
		return fmt.Errorf("ec2.CreateTags: %s", err)
	}
	return nil
}

func createTagSpecification(resourceType string,
	tags libtags.Tags) *ec2.TagSpecification {
	if tags == nil {
		return nil
	}
	awsTags := make([]*ec2.Tag, 0, len(tags))
	for key, value := range tags {
		awsTags = append(awsTags,
			&ec2.Tag{Key: aws.String(key), Value: aws.String(value)})
	}
	return &ec2.TagSpecification{
		ResourceType: aws.String(resourceType),
		Tags:         awsTags,
	}
}

func createVolume(awsService *ec2.EC2, availabilityZone *string, size uint64,
	tags libtags.Tags, logger log.Logger) (string, error) {
	tags = tags.Copy()
	delete(tags, "ExpiresAt")
	tags["Name"] = "image unpacker"
	sizeInGiB := int64(size) >> 30
	if sizeInGiB<<30 < int64(size) {
		sizeInGiB++
	}
	volume, err := awsService.CreateVolume(&ec2.CreateVolumeInput{
		AvailabilityZone: availabilityZone,
		Encrypted:        aws.Bool(true),
		Size:             aws.Int64(sizeInGiB),
		TagSpecifications: []*ec2.TagSpecification{
			createTagSpecification(ec2.ResourceTypeVolume, tags),
		},
		VolumeType: aws.String("gp2"),
	})
	if err != nil {
		return "", fmt.Errorf("ec2.CreateVolume: %s", err)
	}
	volumeIds := make([]string, 1)
	volumeIds[0] = *volume.VolumeId
	logger.Printf("Created: %s, waiting...\n", *volume.VolumeId)
	err = awsService.WaitUntilVolumeAvailable(&ec2.DescribeVolumesInput{
		VolumeIds: aws.StringSlice(volumeIds),
	})
	if err != nil {
		return "", fmt.Errorf("ec2.WaitUntilVolumeAvailable: %s", err)
	}
	return *volume.VolumeId, nil
}

func deleteImage(cs *awsutil.CredentialsStore, accountName, region string,
	image *ec2.Image) error {
	ec2Service := cs.GetEC2Service(accountName, region)
	s3Service := s3.New(cs.GetSessionForAccount(accountName),
		&aws.Config{Region: aws.String(region)})
	imageId := aws.StringValue(image.ImageId)
	if err := deregisterAmi(ec2Service, imageId); err != nil {
		return errors.New(imageId + ": " + err.Error())
	}
	switch rootDevType := aws.StringValue(image.RootDeviceType); rootDevType {
	case "ebs":
		var firstError error
		for _, bdMapping := range image.BlockDeviceMappings {
			if bdMapping.Ebs == nil {
				return nil
			}
			snapshotId := aws.StringValue(bdMapping.Ebs.SnapshotId)
			if err := deleteSnapshot(ec2Service, snapshotId); err != nil {
				if firstError == nil {
					firstError = errors.New(snapshotId + ": " + err.Error())
				}
			}
		}
		if firstError != nil {
			return firstError
		}
	case "instance-store":
		splitPath := strings.Split(aws.StringValue(image.ImageLocation), "/")
		bucket := splitPath[0]
		folder := strings.Join(splitPath[1:len(splitPath)-1], "/")
		return deleteS3Directory(s3Service, bucket, folder)
	default:
		return errors.New("unsupported root device type: " + rootDevType +
			" for: " + imageId)
	}
	return nil
}

func deleteS3Directory(awsService *s3.S3, bucket, dir string) error {
	out, err := awsService.ListObjects(&s3.ListObjectsInput{
		Bucket: aws.String(bucket),
		Prefix: aws.String(dir),
	})
	if err != nil {
		fmt.Printf("error listing: %s: %s\n", dir, err)
		return fmt.Errorf("s3.ListObjects: %s", err)
	}
	if len(out.Contents) < 1 {
		return nil
	}
	objectIds := make([]*s3.ObjectIdentifier, 0, len(out.Contents))
	for _, obj := range out.Contents {
		objectIds = append(objectIds,
			&s3.ObjectIdentifier{Key: obj.Key})
	}
	_, err = awsService.DeleteObjects(&s3.DeleteObjectsInput{
		Bucket: aws.String(bucket),
		Delete: &s3.Delete{Objects: objectIds},
	})
	if err != nil {
		fmt.Printf("error deleting objects: %s\n", err)
	}
	return nil
}

func deleteSnapshot(awsService *ec2.EC2, snapshotId string) error {
	var err error
	for i := 0; i < 60; i++ {
		_, err = awsService.DeleteSnapshot(&ec2.DeleteSnapshotInput{
			SnapshotId: aws.String(snapshotId),
		})
		if err == nil {
			return nil
		}
		if !strings.Contains(err.Error(), "in use by ami") &&
			!strings.Contains(err.Error(), "RequestLimitExceeded") {
			return err
		}
		time.Sleep(time.Second)
	}
	if strings.Contains(err.Error(), "in use by ami") {
		return errors.New("timed out waiting for delete: " + snapshotId)
	}
	return err
}

func deleteTagsFromResources(awsService *ec2.EC2, tagKeys []string,
	resourceId ...string) error {
	if len(tagKeys) < 1 {
		return nil
	}
	resourceIds := make([]string, 0)
	for _, id := range resourceId {
		if id != "" {
			resourceIds = append(resourceIds, id)
		}
	}
	if len(resourceIds) < 1 {
		return nil
	}
	tags := make([]*ec2.Tag, 0, len(tagKeys))
	for _, tagKey := range tagKeys {
		tags = append(tags, &ec2.Tag{Key: aws.String(tagKey)})
	}
	_, err := awsService.DeleteTags(&ec2.DeleteTagsInput{
		Resources: aws.StringSlice(resourceIds),
		Tags:      tags,
	})
	if err != nil {
		return fmt.Errorf("ec2.DeleteTags: %s", err)
	}
	return nil
}

func deleteVolume(awsService *ec2.EC2, volumeId string) error {
	_, err := awsService.DeleteVolume(&ec2.DeleteVolumeInput{
		VolumeId: aws.String(volumeId),
	})
	if err != nil {
		return fmt.Errorf("ec2.DeleteVolume: %s", err)
	}
	return nil
}

func detachVolume(awsService *ec2.EC2, instanceId, volumeId string) error {
	_, err := awsService.DetachVolume(&ec2.DetachVolumeInput{
		InstanceId: aws.String(instanceId),
		VolumeId:   aws.String(volumeId),
	})
	if err != nil {
		return fmt.Errorf("ec2.DetachVolume: %s", err)
	}
	err = awsService.WaitUntilVolumeAvailable(&ec2.DescribeVolumesInput{
		VolumeIds: aws.StringSlice([]string{volumeId}),
	})
	if err != nil {
		return fmt.Errorf("ec2.WaitUntilVolumeAvailable: %s", err)
	}
	return nil
}

func deregisterAmi(awsService *ec2.EC2, amiId string) error {
	var err error
	for i := 0; i < 6; i++ {
		_, err = awsService.DeregisterImage(&ec2.DeregisterImageInput{
			ImageId: aws.String(amiId),
		})
		if err == nil {
			break
		}
		if !strings.Contains(err.Error(), "RequestLimitExceeded") {
			return err
		}
		time.Sleep(time.Second * 11)
	}
	if err != nil {
		return errors.New("timed out waiting for delete: " + amiId)
	}
	imageIds := make([]*string, 1)
	imageIds[0] = aws.String(amiId)
	for i := 0; i < 60; i++ {
		out, err := awsService.DescribeImages(&ec2.DescribeImagesInput{
			ImageIds: imageIds,
		})
		if err != nil {
			return fmt.Errorf("ec2.DescribeImages: %s", err)
		}
		if len(out.Images) < 1 {
			return nil
		}
		time.Sleep(time.Second)
	}
	return errors.New("timed out waiting for deregister: " + amiId)
}

func describeInstances(awsService *ec2.EC2, input *ec2.DescribeInstancesInput) (
	[]*ec2.Instance, error) {
	if input == nil {
		input = &ec2.DescribeInstancesInput{}
	}
	inp := *input
	inp.NextToken = nil
	instances := make([]*ec2.Instance, 0)
	for {
		out, err := awsService.DescribeInstances(&inp)
		if err != nil {
			return nil, fmt.Errorf("ec2.DescribeInstances: %s", err)
		}
		for _, reservation := range out.Reservations {
			for _, instance := range reservation.Instances {
				instances = append(instances, instance)
			}
		}
		if out.NextToken == nil {
			break
		}
		inp.NextToken = out.NextToken
	}
	return instances, nil
}

func findImage(awsService *ec2.EC2, tags libtags.Tags) (*ec2.Image, error) {
	images, err := getImages(awsService, "", tags)
	if err != nil {
		return nil, err
	}
	return findLatestImage(images)
}

func findMarketplaceImage(awsService *ec2.EC2, productCode string) (
	*ec2.Image, error) {
	out, err := awsService.DescribeImages(
		&ec2.DescribeImagesInput{
			Filters: []*ec2.Filter{
				{
					Name:   aws.String("product-code"),
					Values: aws.StringSlice([]string{productCode}),
				},
				{
					Name:   aws.String("product-code.type"),
					Values: aws.StringSlice([]string{"marketplace"}),
				},
			},
		})
	if err != nil {
		return nil, fmt.Errorf("ec2.DescribeImages: %s", err)
	}
	return findLatestImage(out.Images)
}

func findLatestImage(images []*ec2.Image) (*ec2.Image, error) {
	var youngestImage *ec2.Image
	var youngestTime time.Time
	for _, image := range images {
		creationTime, err := time.Parse(creationTimeFormat,
			aws.StringValue(image.CreationDate))
		if err != nil {
			return nil, err
		}
		if creationTime.After(youngestTime) {
			youngestImage = image
			youngestTime = creationTime
		}
	}
	return youngestImage, nil
}

func getAccountId(awsService *ec2.EC2) (string, error) {
	// TODO(rgooch): This relies on at least one instance existing. This doesn't
	//               work in a fresh account. Figure out a better way.
	out, err := awsService.DescribeInstances(&ec2.DescribeInstancesInput{
		MaxResults: aws.Int64(5),
	})
	if err != nil {
		return "", fmt.Errorf("ec2.DescribeInstances: %s", err)
	}
	if len(out.Reservations) < 1 {
		return "", errors.New("no instances found")
	}
	return aws.StringValue(out.Reservations[0].OwnerId), nil
}

func getFreeVolumeName(usedBlockDevices map[string]struct{}) string {
	// First try the "/dev/sdb" through "/dev/sdz" range.
	for c := 'b'; c <= 'z'; c++ {
		name := "/dev/sd" + string(c)
		if _, ok := usedBlockDevices[name]; !ok {
			return name
		}
	}
	// Now try the "/dev/xvdba" through "/dev/xvdzz" range. Note that the entire
	// range may not be supported.
	var dev [2]byte
	dev[0] = 'b'
	dev[1] = 'a'
	for {
		name := "/dev/xvd" + string(dev[:])
		if _, ok := usedBlockDevices[name]; !ok {
			return name
		}
		dev[1]++
		if dev[1] > 'z' {
			dev[1] = 'a'
			dev[0]++
			if dev[0] > 'z' {
				return ""
			}
		}
	}
}

func getImages(awsService *ec2.EC2, accountId string, tags libtags.Tags) (
	[]*ec2.Image, error) {
	filters := awsutil.MakeFiltersFromTags(tags)
	if accountId != "" {
		filters = append(filters, &ec2.Filter{
			Name:   aws.String("owner-id"),
			Values: aws.StringSlice([]string{accountId}),
		})
	}
	filters = append(filters, &ec2.Filter{
		Name:   aws.String("is-public"),
		Values: aws.StringSlice([]string{"false"}),
	})
	out, err := awsService.DescribeImages(
		&ec2.DescribeImagesInput{Filters: filters})
	if err != nil {
		return nil, fmt.Errorf("ec2.DescribeImages: %s", err)
	}
	return out.Images, nil
}

func getInstances(awsService *ec2.EC2, nameTag string) (
	[]*ec2.Instance, error) {
	if nameTag == "" {
		return nil, errors.New("no name given")
	}
	states := []string{
		ec2.InstanceStateNamePending,
		ec2.InstanceStateNameRunning,
		ec2.InstanceStateNameStopping,
		ec2.InstanceStateNameStopped,
	}
	instances, err := describeInstances(awsService, &ec2.DescribeInstancesInput{
		Filters: []*ec2.Filter{
			{
				Name:   aws.String("tag:Name"),
				Values: aws.StringSlice([]string{nameTag}),
			},
			{
				Name:   aws.String("instance-state-name"),
				Values: aws.StringSlice(states),
			},
		},
	})
	return instances, err
}

func getInstanceIds(instances []*ec2.Instance) []string {
	instanceIds := make([]string, 0, len(instances))
	for _, instance := range instances {
		instanceIds = append(instanceIds, aws.StringValue(instance.InstanceId))
	}
	return instanceIds
}

func getRunningInstance(awsService *ec2.EC2, instances []*ec2.Instance,
	logger log.Logger) (*ec2.Instance, error) {
	for _, instance := range instances {
		if aws.StringValue(instance.State.Name) ==
			ec2.InstanceStateNameRunning {
			return instance, nil
		}
	}
	var stoppedInstance *ec2.Instance
	isStopped := false
	for _, instance := range instances {
		if stoppedInstance != nil {
			break
		}
		switch aws.StringValue(instance.State.Name) {
		case ec2.InstanceStateNameStopped:
			stoppedInstance = instance
			isStopped = true
		case ec2.InstanceStateNamePending:
			stoppedInstance = instance
		}
	}
	if stoppedInstance == nil {
		return nil, nil
	}
	instanceIds := make([]*string, 1)
	instanceIds[0] = stoppedInstance.InstanceId
	if isStopped {
		logger.Printf("starting instance: %s\n",
			aws.StringValue(instanceIds[0]))
		_, err := awsService.StartInstances(&ec2.StartInstancesInput{
			InstanceIds: instanceIds,
		})
		if err != nil {
			return nil, fmt.Errorf("ec2.StartInstances: %s", err)
		}
		stoppedInstance.LaunchTime = aws.Time(time.Now())
	}
	logger.Printf("waiting for pending instance: %s\n",
		aws.StringValue(instanceIds[0]))
	err := awsService.WaitUntilInstanceRunning(&ec2.DescribeInstancesInput{
		InstanceIds: instanceIds,
	})
	if err != nil {
		return nil, fmt.Errorf("ec2.WaitUntilInstanceRunning: %s", err)
	}
	return stoppedInstance, nil
}

func getSecurityGroup(awsService *ec2.EC2, vpcId string, tags libtags.Tags) (
	*ec2.SecurityGroup, error) {
	filters := awsutil.MakeFiltersFromTags(tags)
	filters = append(filters, &ec2.Filter{
		Name:   aws.String("vpc-id"),
		Values: aws.StringSlice([]string{vpcId}),
	})
	out, err := awsService.DescribeSecurityGroups(
		&ec2.DescribeSecurityGroupsInput{Filters: filters})
	if err != nil {
		return nil, fmt.Errorf("ec2.DescribeSecurityGroups: %s", err)
	}
	if len(out.SecurityGroups) < 1 {
		return nil, errors.New("no security group found")
	}
	if len(out.SecurityGroups) > 1 {
		return nil, errors.New("too many security groups found")
	}
	return out.SecurityGroups[0], nil
}

func getSubnet(awsService *ec2.EC2, vpcId string, tags libtags.Tags) (
	*ec2.Subnet, error) {
	filters := awsutil.MakeFiltersFromTags(tags)
	filters = append(filters, &ec2.Filter{
		Name:   aws.String("vpc-id"),
		Values: aws.StringSlice([]string{vpcId}),
	})
	out, err := awsService.DescribeSubnets(
		&ec2.DescribeSubnetsInput{Filters: filters})
	if err != nil {
		return nil, fmt.Errorf("ec2.DescribeSubnets: %s", err)
	}
	if len(out.Subnets) < 1 {
		return nil, errors.New("no subnets found")
	}
	for _, subnet := range out.Subnets {
		if aws.Int64Value(subnet.AvailableIpAddressCount) > 0 {
			return subnet, nil
		}
	}
	return nil, errors.New("no subnets with available IPs found")
}

func getVpc(awsService *ec2.EC2, tags libtags.Tags) (*ec2.Vpc, error) {
	out, err := awsService.DescribeVpcs(
		&ec2.DescribeVpcsInput{Filters: awsutil.MakeFiltersFromTags(tags)})
	if err != nil {
		return nil, fmt.Errorf("ec2.DescribeVpcs: %s", err)
	}
	if len(out.Vpcs) < 1 {
		return nil, errors.New("no VPC found")
	}
	if len(out.Vpcs) > 1 {
		return nil, errors.New("too many VPCs found")
	}
	return out.Vpcs[0], nil
}

func launchInstance(awsService *ec2.EC2, image *ec2.Image, rootVolumeSize uint,
	tags libtags.Tags, vpcSearchTags, subnetSearchTags,
	securityGroupSearchTags libtags.Tags, instanceType string,
	sshKeyName string) (*ec2.Instance, error) {
	vpc, err := getVpc(awsService, vpcSearchTags)
	if err != nil {
		return nil, err
	}
	subnet, err := getSubnet(awsService, aws.StringValue(vpc.VpcId),
		subnetSearchTags)
	if err != nil {
		return nil, err
	}
	sg, err := getSecurityGroup(awsService, aws.StringValue(vpc.VpcId),
		securityGroupSearchTags)
	if err != nil {
		return nil, err
	}
	var blockDeviceMappings []*ec2.BlockDeviceMapping
	if rootVolumeSize != 0 {
		blockDeviceMappings = []*ec2.BlockDeviceMapping{{
			DeviceName: aws.String(rootDevName),
			Ebs: &ec2.EbsBlockDevice{
				DeleteOnTermination: aws.Bool(true),
				VolumeSize:          aws.Int64(int64(rootVolumeSize)),
			}},
		}
	}
	reservation, err := awsService.RunInstances(&ec2.RunInstancesInput{
		BlockDeviceMappings: blockDeviceMappings,
		ImageId:             image.ImageId,
		InstanceType:        aws.String(instanceType),
		KeyName:             aws.String(sshKeyName),
		MaxCount:            aws.Int64(1),
		MinCount:            aws.Int64(1),
		SecurityGroupIds:    []*string{sg.GroupId},
		SubnetId:            subnet.SubnetId,
		TagSpecifications: []*ec2.TagSpecification{
			createTagSpecification(ec2.ResourceTypeInstance, tags),
			createTagSpecification(ec2.ResourceTypeVolume, tags),
		},
	})
	if err != nil {
		return nil, fmt.Errorf("ec2.RunInstances: %s", err)
	}
	instance := reservation.Instances[0]
	err = awsService.WaitUntilInstanceExists(&ec2.DescribeInstancesInput{
		InstanceIds: []*string{instance.InstanceId},
	})
	if err != nil {
		return nil, fmt.Errorf("ec2.WaitUntilInstanceExists: %s", err)
	}
	return instance, nil
}

func registerAmi(awsService *ec2.EC2, snapshotId string, s3Manifest string,
	amiName string, imageName string, tags libtags.Tags, imageGiB uint64,
	publishOptions *PublishOptions, logger log.Logger) (string, error) {
	blkDevMaps := make([]*ec2.BlockDeviceMapping, 1)
	var volumeSize *int64
	if imageGiB > 0 {
		volumeSize = aws.Int64(int64(imageGiB))
	}
	blkDevMaps[0] = &ec2.BlockDeviceMapping{
		DeviceName: aws.String(rootDevName),
		Ebs: &ec2.EbsBlockDevice{
			DeleteOnTermination: aws.Bool(true),
			SnapshotId:          aws.String(snapshotId),
			VolumeSize:          volumeSize,
			VolumeType:          aws.String("gp2"),
		},
	}
	if amiName == "" {
		amiName = imageName
	}
	if publishOptions == nil {
		publishOptions = new(PublishOptions)
	}
	params := &ec2.RegisterImageInput{
		Architecture:       aws.String("x86_64"),
		Description:        aws.String(imageName),
		EnaSupport:         aws.Bool(publishOptions.EnaSupport),
		Name:               aws.String(amiNameReplacer.Replace(amiName)),
		RootDeviceName:     aws.String(rootDevName),
		SriovNetSupport:    aws.String("simple"),
		VirtualizationType: aws.String("hvm"),
	}
	if snapshotId != "" {
		params.BlockDeviceMappings = blkDevMaps
	}
	if s3Manifest != "" {
		params.ImageLocation = aws.String(s3Manifest)
	}
	ami, err := awsService.RegisterImage(params)
	if err != nil {
		return "", fmt.Errorf("ec2.RegisterImage: %s", err)
	}
	logger.Printf("Created: %s\n", *ami.ImageId)
	imageIds := []string{*ami.ImageId}
	err = awsService.WaitUntilImageExists(&ec2.DescribeImagesInput{
		ImageIds: aws.StringSlice(imageIds),
	})
	if err != nil {
		return "", fmt.Errorf("ec2.WaitUntilImageExists: %s", err)
	}
	tags = tags.Copy()
	tags["Name"] = path.Dir(imageName)
	if err := createTags(awsService, *ami.ImageId, tags); err != nil {
		return "", err
	}
	logger.Printf("Tagged: %s, waiting...\n", *ami.ImageId)
	err = awsService.WaitUntilImageAvailable(&ec2.DescribeImagesInput{
		ImageIds: aws.StringSlice(imageIds),
	})
	if err != nil {
		return "", fmt.Errorf("ec2.WaitUntilImageAvailable: %s", err)
	}
	logger.Printf("AMI: %s available\n", *ami.ImageId)
	return *ami.ImageId, nil
}

func libStartInstances(awsService *ec2.EC2, instanceIds ...string) error {
	_, err := awsService.StartInstances(&ec2.StartInstancesInput{
		InstanceIds: aws.StringSlice(instanceIds),
	})
	if err != nil {
		return fmt.Errorf("ec2.StartInstances: %s", err)
	}
	err = awsService.WaitUntilInstanceRunning(&ec2.DescribeInstancesInput{
		InstanceIds: aws.StringSlice(instanceIds),
	})
	if err != nil {
		return fmt.Errorf("ec2.WaitUntilInstanceRunning: %s", err)
	}
	return nil
}

func stopInstances(awsService *ec2.EC2, instanceIds ...string) error {
	_, err := awsService.StopInstances(&ec2.StopInstancesInput{
		InstanceIds: aws.StringSlice(instanceIds),
	})
	if err != nil {
		return fmt.Errorf("ec2.StopInstances: %s", err)
	}
	return nil
}

func libTerminateInstances(awsService *ec2.EC2, instanceIds ...string) error {
	_, err := awsService.TerminateInstances(&ec2.TerminateInstancesInput{
		InstanceIds: aws.StringSlice(instanceIds),
	})
	if err != nil {
		return fmt.Errorf("ec2.TerminateInstances: %s", err)
	}
	return nil
}