~ubuntu-on-ec2/ubuntu-on-ec2/ec2-publishing-scripts

#!/bin/bash

# vi: ts=4 noexpandtab

TEMP_D=""

VOLUME_ID=""

VOLUME_ATTACHED=0

SNAPSHOT_ID=""

SSH_USER=${SSH_USER:-ubuntu}

REGARGS=( )

IID=""

SSH=${SSH:-"ssh"}

error() { echo ${PREFIX:+"${PREFIX}"} "$@" 1>&2; }

fail() {

	isfalse ${SNAPSHOT_ID} || delete_snapshot "${SNAPSHOT_ID}"

	[ $# -eq 0 ] || error "$@";

	local out=""

	[ -z "$IID" ] || out=$(xc2 info-instances "${REGARGS[@]}" "${IID}")

	[ -n "$out" ] || error "$out"

	exit 1;

}

debug() {

	local level=${1}

	shift;

	[ "${level}" -gt "${VERBOSITY}" ] && return

	echo "$(date): ${@}" 1>&2

}

get_volstate() {

	local vol="$1" tmp=""

	tmp=$(mktemp "$TEMP_D/describe_vol_out.$vol.XXXXXX") ||

		return 1

	if xc2 describe-volumes "${REGARGS[@]}" "$vol" > "$tmp"; then

		_RET=$(awk '-F\t' '$1 == "VOLUME" { print $6 }' "$tmp")

		rm -f "$tmp"

		return 0

	fi

	error "ec2-describe-volumes $vol failed"

	rm -f "$tmp"

	_RET=""

}

detach_vol() {

	local vol="${1}" log=${2:-/dev/null} max=${3:-20} state="" i=0 ret=1;

	debug 2 "detaching ${vol}"

	until [ "${i}" -gt "${max}" -o "$state" = "available" ]; do

		i=$(($i + 1))

		retry 3 30 get_volstate "$vol" && state="${_RET}"

		debug 2 "volume state after pass $i/$max, state=$state"

		case "${state}" in

			available) debug 2 "${vol} is available, returning 0"; ret=0;;

			in-use)	   debug 2 "${vol} is attached calling for detach";

					   retry 3 30 xc2 detach-volume "${REGARGS[@]}" "${vol}" > ${log};

					   sleep 60;;

		esac

	done

	error "after $i waits, $vol, state=$state"

	return $ret

}

delete_vol() {

	local vol=${1}

	debug 2 "deleting ${vol}"

	xc2 delete-volume "${REGARGS[@]}" "${vol}" > ${2:-/dev/null} ||

		{ error "failed to delete ${vol}"; return 1; }

}

delete_snapshot() {

	local snap_id=${1}

	debug 2 "deleting ${snap_id}"

	xc2 delete-snapshot "${REGARGS[@]}" "${snap_id}" > ${2:-/dev/null} ||

		{ error "failed to delete ${snap_id}"; return 1; }

}

istrue() {

	[ -n "$1" -a "$1" != "0" ]

}

isfalse() {

	[ -z "$1" -o "$1" = "0" ]

}

cleanup() {

	isfalse ${VOLUME_ATTACHED} || detach_vol "${VOLUME_ID}"

	[ -z "${VOLUME_ID}" ] || retry 3 30 delete_vol "${VOLUME_ID}"

	[ -z "${TEMP_D}" ] || rm -Rf "${TEMP_D}"

}

killed() {

	error "${0##*/} killed"

	exit 143 # 143 is exit code of: bash -c 'sleep 3& kill $$'; echo $?

}

di_field() {

	local field=$1 f=""

	local fields=( itype iid ami host host_int state

		key_name ami_launch_index product_codes

		instance_type launch_time placement kernel

		ramdisk )

	for((i=0;i<${#fields[@]};i++)); do

		[ "${fields[$i]}" = "${field}" ] && { f=$(($i+1)) ; break; }

	done

	[ -n "$f" ] || return 1

	local cmd='$1 == "INSTANCE" { print $'$f' }'

	_RET=$(awk '-F\t' "$cmd")

}

xssh() {

    local host="$1"

	shift;

	debug 2 "${SSH} ${SSH_OPTS} ${SSH_USER:+${SSH_USER}@}$host $*"

	${SSH} ${SSH_OPTS} ${SSH_USER:+${SSH_USER}@}$host "$@"

}

# retry(max,sleeptime, cmd)

# retry cmd up to max times until it suceeds, sleeping sleeptime in between

retry() {

    local max=$1 sleep=$2 i=0 ret=0;

    shift 2 || { debug 1 "bad input to retry"; return 1; }

    while :; do

        i=$(($i+1))

        "$@" ; ret=$?

        [ $ret -eq 0 ] && break

        [ $i -eq 1 ] && debug 1 "cmd failed [$i/$max]: $*" ||

            debug 2 "cmd failed [$i/$max]: $*"

        [ $i -lt $max ] || break

        sleep "$sleep"

    done

    if [ $ret -eq 0 ]; then

        [ $i -ne 1 ] && debug 1 "cmd passed [$i/$max]: $*"

        return 0

    fi

    return $ret

}

write_discard() {

cat <<"EOF"

discard() {

	local mnt="${1}"

	sudo sed -i -e 's|defaults|defaults,discard|g' "${mnt}/etc/fstab"

}

EOF

}

write_hvmify() {

cat <<"EOF"

hvmify() {

	local mnt="${1}" vol="${2}"

	error "hvmify on ${mnt} for vol=${vol}"

	sudo sed -i \

		-e 's,^#GRUB_TERMINAL=console,GRUB_TERMINAL=console,' \

		"${mnt}/etc/default/grub"

	if [ -f "${mnt}/etc/default/grub.d/50-cloudimg-settings.cfg" ] ; then

		echo GRUB_HIDDEN_TIMEOUT=0.1 | \

			sudo tee --append \

				"${mnt}/etc/default/grub.d/50-cloudimg-settings.cfg" > /dev/null

	fi

	for m in sys proc dev; do sudo mount --bind "/${m}" "${mnt}/${m}"; done

	sudo chroot "${mnt}" update-grub

	sudo chroot "${mnt}" grub-install "${vol}"

	sync

	for m in sys proc dev; do sudo umount -f "${mnt}/${m}"; done;

	if [ -f "$mnt/etc/init/tty1.conf" ]; then

		# no upstart in vivid means no upstart jobs

		sudo cp "${mnt}/etc/init/tty1.conf" "${mnt}/etc/init/ttyS0.conf"

		sudo sed -i 's,tty1,ttyS0,' "${mnt}/etc/init/ttyS0.conf"

	fi

    # from xenial boot 25s earlier removing unneeded xen-fbfront driver

    SUITE=$(sudo chroot "$mnt" lsb_release -sc)

    case "${SUITE}" in

    "precise" | "trusty")

        ;; # nothing to do here

    "xenial" | "yakkety" | *)

        BLACKLIST_FILE="${mnt}/etc/modprobe.d/blacklist-xen-fbfront.conf"

        sudo rm -f "${BLACKLIST_FILE}"

        sudo touch "${BLACKLIST_FILE}"

        echo "# xenial+ boots 25s earlier removing unneeded xen-fbfront" | \

            sudo tee --append "${BLACKLIST_FILE}" > /dev/null

        echo | sudo tee --append "${BLACKLIST_FILE}" > /dev/null

        echo "blacklist xen-fbfront" | \

            sudo tee --append "${BLACKLIST_FILE}" > /dev/null

        ;;

    esac

    # from xenial boot 1s earlier overriding cdrom udev rule

    SUITE=$(sudo chroot "${mnt}" lsb_release -sc)

    case "${SUITE}" in

    "precise" | "trusty")

        ;; # Nothing to do here

    "xenial" | "yakkety" | *)

        sudo ln -s /dev/null "${mnt}/etc/udev/rules.d/60-cdrom_id.rules"

        ;;

    esac

}

EOF

}

Usage() {

	cat <<EOF

Usage: ${0##*/} [ options ] instance-id arch imgurl register-name

   Utilize 'instance-id' to

     - download 'imgurl',

     - populate a ebs snapshot with its content.

     - register an ebs boot instance for 'arch' as 'register-name'

   options:

       --region r        use '--region r' in ec2 commands

       --description d   register image with description 'd'

       --snapshot-desc d create snapshot with description 'd'

       --kernel aki      register image with kernel 'aki'

       --ramdisk ari     register image with ramdisk 'ari'

       --size s          create volume of size 's' (in Gig)

       --fstype f        put filesystem of type 'f' on volume

       --etype  t        "ebs type" type (hvm or ebs)

       --address         address instance by 'address' rather than looking up

    -v|--verbose         increase verbosity

       --prefix P        prefix output messages with 'P'

       --sriov			 register with 'sriov=simple' for HVM

EOF

}

bad_Usage() { Usage 1>&2; [ $# -eq 0 ] || error "$@"; exit 1; }

short_opts="hv"

long_opts="etype:,address:,description:,help,fstype:,image-md5:,kernel:,prefix:,ramdisk:,region:,snapshot-desc:,size:,ssh-id:,verbose,sriov"

getopt_out=$(getopt --name "${0##*/}" \

	--options "${short_opts}" --long "${long_opts}" -- "$@") &&

	eval set -- "${getopt_out}" ||

	bad_Usage

address=""

description=""

etype="ebs"

fstype=""

# if fslabel is set to an empty string, then the filesystem label will be

# copied from the image.  If non-empty, this label will be used.

# if set to 'none' no label will be written

fslabel=""

kernel=""

ramdisk=""

region=""

ssh_id=""

size="15"

snapshot_desc=""

image_md5=""

sriov=0

VERBOSITY=0

PREFIX=""

while [ $# -ne 0 ]; do

	cur=${1}; next=${2};

	case "$cur" in

		-h|--help) Usage; exit 0;;

		   --address) address=${next}; shift;;

		   --etype) etype=${next}; shift;;

		   --description) description=${next}; shift;;

		   --image-md5) image_md5=${next}; shift;;

		   --kernel) kernel=${next}; shift;;

		   --ramdisk) ramdisk=${next}; shift;;

		   --size) size=${next}; shift;;

		   --fstype) fstype=${next}; shift;;

		   --sriov) sriov=1;;

		-v|--verbose)

			VERBOSITY=$((${VERBOSITY}+1));;

		   --region)

			region=${next}; shift;;

		   --ssh-id)

			ssh_id="${next}"; shift;;

		   --snapshot-desc)

			snapshot_desc=${next}; shift;;

		   --prefix)

			PREFIX="${next}"; shift;;

		--) shift; break;;

	esac

	shift;

done

[ $# -eq 4 ] ||

	bad_Usage "must provide instance-id arch imgurl register-name"

REGARGS=( );

[ -n "${region}" ] && REGARGS=( "--region" "$region" )

iid=${1}

IID=$iid

arch=${2}

imgurl=${3}

register_name=${4}

[ -z "${snapshot_desc}" ] && snapshot_desc="${register_name}"

case "${arch}" in

	i386) ec2_arch=$arch;;

	amd64|x86_64) ec2_arch=x86_64;;

	*) fail "arch ${arch} not supported (i386 or x86_64)";;

esac

[ "${arch}" = "amd64" ] && arch=x86_64 && debarch=amd64 || debarch=${arch}

TEMP_D=$(mktemp -d ${TMPDIR:-/tmp}/${0##*/}.XXXXXX) ||

	fail "failed to make tmp dir"

trap cleanup EXIT

trap killed SIGINT SIGTERM

export XC2_XIMAGES_CACHE_D=${XC2_XIMAGES_CACHE_D:-"$TEMP_D/ximgcache"}

rem_workd="/mnt/${0##*/}/${register_name##*/}.${arch}.${etype}"

rem_src_mnt="${rem_workd}/src_d"

rem_trg_mnt="${rem_workd}/trg_d"

rem_dl_d="${rem_workd}/dl"

rem_funcs="${rem_workd}/sh_funcs"

desc_instance="${TEMP_D}/instance.info"

vol_info="${TEMP_D}/volume.info"

vol_attach_info="${TEMP_D}/vol_attach.info"

vol_detach_info="${TEMP_D}/vol_detach.info"

vol_delete_info="${TEMP_D}/vol_delete.info"

create_snapshot_info="${TEMP_D}/create_snapshot.info"

desc_snapshot_poll="${TEMP_D}/desc_snapshot.poll"

register_info="${TEMP_D}/register.info"

vol_attach_dev=/dev/sdi

alt_attach_dev=/dev/xvdi

retry 3 5 xc2 info-instances "${REGARGS[@]}" "${iid}" > "${desc_instance}" ||

	fail "failed to get information about instance $iid"

if [ -z "$address" ]; then

	di_field host < "${desc_instance}" && remaddr=${_RET} &&

		[ -n "${remaddr}" ] || fail "failed to read hostname for ${iid}"

else

	remaddr="$address"

fi

di_field placement < "${desc_instance}" && placement=${_RET} &&

	[ -n "${placement}" ] || fail "unable to determine availability zone"

debug 2 "${iid} is at ${remaddr} in zone ${placement}"

debug 1 "verifying connection to ${remaddr}"

retry 15 30s xssh "${remaddr}" /bin/true ||

	fail "failed to verify connection to ${remaddr}"

# [host] attach a volume to the instance, wait for it to become available

retry 3 5 xc2 create-volume "${REGARGS[@]}" --size "$size" \

	--availability-zone "${placement}" > "${vol_info}" &&

	vol_id=$(awk '-F\t' '{print $2}' < "${vol_info}") && [ -n "${vol_id}" ] ||

	fail "failed to create a volume"

VOLUME_ID=${vol_id}

debug 2 "created volume ${vol_id}"

retry 15 30 xc2 attach-volume "${REGARGS[@]}" --device "${vol_attach_dev}" \

	--instance "${iid}" "${vol_id}" > "${vol_attach_info}" &&

	VOLUME_ATTACHED=1 ||

	(cat ${vol_attach_info} &&

	 get_volstate "$vol" &&

	 error "volume state is $_RET" &&

	 fail "failed to attach volume to ${vol_attach_dev}")

debug 2 "volume ${vol_id} attached to ${iid} at ${vol_attach_dev}"

# [instance] download the published tarfile from http://cloud-images.ubuntu.com

# [instance] extract image, mount loopback

getter="lftp"

debug 2 "obtaining image on ${remaddr}"

xssh "${remaddr}" bash -e <<EOF || fail "failed to download/setup image"

exec 1>&2

[ -e "${rem_workd}" ] && sudo rm -rf "${rem_workd}"

[ -e "${rem_dl_d}" ] && sudo rm -rf "${rem_dl_d}"

sudo mkdir -p "${rem_src_mnt}" "${rem_trg_mnt}" "${rem_dl_d}"

sudo chown -R \$(id -u) "${rem_workd}"

cat > "${rem_funcs}" <<"END"

error() { echo "$PREFIX\$@" 1>&2; }

fail() { [ \$# -eq 0 ] || error "\$@" 1>&2; exit 1; }

[ ${VERBOSITY:-0} -ge 2 ] || exec 2>/dev/null

[ ${VERBOSITY:-0} -ge 3 ] && set -x

exec 1>&2

END

. ${rem_funcs}

out="${rem_dl_d}/img.tar.gz"

if [ ! -f "\${out}" ]; then

	start=\${SECONDS}

	case "$getter" in

		lftp)

			dpkg-query --show lftp >/dev/null 2>&1 ||

				sudo env DEBIAN_FRONTEND=noninteractive \

					apt-get install lftp -qq >/dev/null

			imgurl="${imgurl}"

			proto=\${imgurl%%://*}

			site=\${imgurl#\${proto}://}; site=\${site%%/*};

			path=\${imgurl#\${proto}://\${site}/}

			lftp -c "open \${proto}://\${site}/ && pget \${path} -o \${out}" </dev/null

			;;

		*)

			wget "${imgurl}" --progress=dot:mega -O "\${out}"

			;;

	esac

	elapsed=\$((\${SECONDS}-\${start}))

	[ "\${elapsed}" = "0" ] && elapsed=1

	size=\$(stat --format "%s" "\${out}")

	rate=\$(((\${size}/1024)/\${elapsed}))

	error "got \${size} bytes in \${elapsed} seconds. \${rate} kB/s"

fi

if [ -n "${image_md5}" ]; then

	printf "%s  %s" "${image_md5}" "img.tar.gz" > "${rem_dl_d}/MD5SUMS"

	( cd "${rem_dl_d}" && md5sum --check MD5SUMS ) >/dev/null

fi

tar -C "${rem_dl_d}" -Sxzf "${rem_dl_d}/img.tar.gz"

sudo rm "${rem_dl_d}/img.tar.gz"

imgfile=""

for f in "${rem_dl_d}/"*; do

	case \$f in

		*.img) imgfile=\$f; break;;

	esac

done

[ -n "\$imgfile" ] || fail "failed to find *.img in tarball"

img_label=\$(e2label "\${imgfile}")

echo "img_label=\"\${img_label}\"" >> "${rem_funcs}"

sudo mount -o loop \${imgfile} "${rem_src_mnt}"

img_fstype=\$(awk '\$2 == "${rem_src_mnt}" { val=\$3 }; END { print val }' < /proc/mounts)

echo "img_fstype=\"\${img_fstype}\"" >> "${rem_funcs}"

EOF

# [instance] mkfs on attached volume

# [instance] copy data from loopbacked image to ebs volume, sync

if [[ "${etype}" =~ ssd ]]; then

	debug 2 "writing discard to rem_funcs ${rem_funcs}"

	write_discard | xssh "$remaddr" sh -c "cat >> ${rem_funcs}"

fi

if [[ "${etype}" =~ hvm ]]; then

	debug 2 "writing hvmify to rem_funcs ${rem_funcs}"

	write_hvmify | xssh "$remaddr" sh -c "cat >> ${rem_funcs}"

fi

debug 2 "copying data on ${remaddr}"

xssh "$remaddr" bash -e <<EOF || fail "failed to copy data to volume"

. ${rem_funcs}

i=0;

vol_attach_dev=${vol_attach_dev};

alt_attach_dev="${alt_attach_dev}";

while [ \$i -lt 180 ]; do

	[ -e "${vol_attach_dev}" ] && break ||

		{ [ -e "\${alt_attach_dev}" ] &&

			vol_attach_dev=\${alt_attach_dev} && break; } ||

		sleep 2

	i=\$((\$i+1))

done

[ -e "\${vol_attach_dev}" ] || {

	error "\${vol_attach_dev} doesn't exist, showing /proc/partitions"

	cat /proc/partitions 1>&2

	fail "\${vol_attach_dev} does not exist"

}

fsdev="\${vol_attach_dev}"

if [[ "${etype}" =~ hvm ]]; then

	echo "1,,L,*" | sudo sfdisk "\${vol_attach_dev}" ||

		fail "failed to partition \${vol_attach_dev}"

	fsdev="\${vol_attach_dev}1"

fi

label=\${img_label}

if [ -n "${fslabel}" ]; then

   [ "${fslabel}" = "none" ] && fslabel=""

   label="${fslabel}"

fi

xtype=\${img_fstype}

if [ -n "${fstype}" ]; then

   xtype="${fstype}"

fi

mkfs_args="-t \${xtype}"

case "\${xtype}" in

	ext*) mkfs_args="\${mkfs_args} -F";;

esac

error "creating fs: \$mkfs_args label=\${label} on \$fsdev"

sudo mkfs \${mkfs_args} \${label:+-L "\${label}"} "\${fsdev}" >/dev/null

sudo mount "\${fsdev}" "${rem_trg_mnt}"

sudo rsync -aXHAS "${rem_src_mnt}/" "${rem_trg_mnt}"

suite=\$(sudo chroot ${rem_trg_mnt} lsb_release --codename --short)

if [[ ! "\${suite}" =~ (lucid|10.04) ]]; then

	# Only enable discard for Lucid and later

	if [[ "${etype}" =~ ssd ]]; then

		discard "${rem_trg_mnt}"

	fi

	if [[ "${etype}" =~ hvm ]]; then

		hvmify "${rem_trg_mnt}" "\${vol_attach_dev}"

	fi

fi

sudo umount -f "${rem_trg_mnt}"

sudo umount -f "${rem_src_mnt}"

sync

sudo rm -rf "${rem_src_mnt}"

sudo rm -rf "${rem_workd}"

error "copied data to \${vol_attach_dev}"

EOF

# [host] detach volume, create-snapshot, delete-volume

detach_vol "${vol_id}" "${vol_detach_info}" ||

	(get_volstate "$vol" &&

	 error "volume state is $_RET" &&

 	 fail "failed to detach volume")

VOLUME_ATTACHED=0

debug 2 "creating snapshot of ${vol_id}"

snap_start=${SECONDS}

retry 10 60 xc2 create-snapshot "${REGARGS[@]}" \

	"--description=${snapshot_desc}" \

	"${vol_id}" > "${create_snapshot_info}" &&

	snapshot_id=$(awk '-F\t' 'END{print $2}' < "${create_snapshot_info}") &&

	[ -n "${snapshot_id}" ] ||

	fail "failed to create snapshot of ${vol_id}"

SNAPSHOT_ID=${snapshot_id}

retry 5 60 delete_vol "${vol_id}" "${vol_delete_info}" ||

	fail "failed to delete volume ${vol_id}"

VOLUME_ID=""

failed_last=0

debug 2 "waiting for ${snapshot_id} to become complete"

# [host] wait for snapshot to leave pending

for((i=0;i<90;i++)); do

	retry 3 10 xc2 info-snapshots "${REGARGS[@]}" "${snapshot_id}" \

		> "${desc_snapshot_poll}" && failed_last=0 ||

		failed_last=$((${failed_last}+1))

	[ "${failed_last}" -lt 30 ] ||

		fail "describe-snapshots failed ${failed_last} times in a row"

	if [ ${failed_last} -eq 0 ]; then

		state=$(awk '-F\t' '{print $4}' < "${desc_snapshot_poll}")

		case "${state}" in

			pending) :;;

			completed) break;;

			error) fail "snapshot ${snapshot_id} is in state 'errror'";;

			*) error "WARNING: unknown snapshot state \"${state}\"";;

		esac

		debug 2 "snapshot state is $state after $((${SECONDS}-${snap_start}))s"

	fi

	sleep 15

done

debug 1 "snapshot complete after $((${SECONDS}-${snap_start})) seconds"

# [host] register

args=( "${REGARGS[@]}" "--architecture=${ec2_arch}" "--name=${register_name}" )

[ -n "${description}" ] && args[${#args[@]}]="--description=${description}"

[ -n "${kernel}" ]      && args[${#args[@]}]="--kernel=${kernel}"

[ -n "${ramdisk}" ]     && args[${#args[@]}]="--ramdisk=${ramdisk}"

# Note (2010-08-31):

#  passing --block-device-mapping as shown here does get block devices

#  mapped for the 2 explicit cases.  Other block devices will not be

#  present by default, though.  ie, on an m1.large, which should have 2

#  ephemeral block devices, you will get only 1.

#

#  if you do not pass *any* --block-device-mapping, you will get no

#  ephemeral block devices.

#

#  if you pass a long list:

#    --block-device-mapping sdb=ephemeral0

#    --block-device-mapping sdc=ephemeral1

#    --block-device-mapping sdd=ephemeral2

#    --block-device-mapping sde=ephemeral3

#

#  then you will get that all appropriate block devices for the given size

#  when you run it (ie, m1.large will have sdb and sdc), but the

#  metadata will also have entries for sdd and sde.  That fact will *not*

#  prevent you from attaching a volume as '--device /dev/sde'

#

#  the end result of all of this is that almost all ubuntu EBS instances

#  will only have a single ephemeral device node unless the user

#  changes arguments at launch time.

case "${ec2_arch}:${etype}" in

	x86_64:ebs*)

		args[${#args[@]}]="--block-device-mapping"

 		args[${#args[@]}]="/dev/sdb=ephemeral0"

		;;

	i386:ebs*)

		args[${#args[@]}]="--block-device-mapping"

 		args[${#args[@]}]="/dev/sda2=ephemeral0"

		;;

	x86_64:hvm*)

		args[${#args[@]}]="--block-device-mapping"

 		args[${#args[@]}]="/dev/sdb=ephemeral0"

		args[${#args[@]}]="--block-device-mapping"

 		args[${#args[@]}]="/dev/sdc=ephemeral1"

		[ "${sriov:-0}" -eq 1 ] &&

			 args[${#args[@]}]="--sriov=simple"

		;;

esac

# Handle the specific mappings

debug 1 "ec2-images2ebs: etype is ${etype}"

case "${etype}" in

	*ssd)

		# SSDs use the gp2 disk type

		args[${#args[@]}]="--block-device-mapping"

		args[${#args[@]}]="/dev/sda1=${snapshot_id}::true:gp2"

		;;

	*io1)

		# Provisioned IOPs use io1

		args[${#args[@]}]="--block-device-mapping"

		args[${#args[@]}]="/dev/sda1=${snapshot_id}::true:io1:200"

		;;

	*)

		args[${#args[@]}]="--snapshot"

		args[${#args[@]}]="${snapshot_id}"

		;;

esac

[[ "${etype}" =~ hvm ]] && args[${#args[@]}]="--virtualization-type=hvm"

# If the storage type contains the string hvm then this is of virtualization type hvm

# As such we will use cloud-image-manager to register the image and set AMI

# attributes during registration that can not be set using the old way

# to register images.

if [[ "${etype}" =~ hvm ]]

then

	# Map ebs volume type to the terms used by cloud-image-manager

	ebs_storage_type='ebs'

	if [[ "${etype}" =~ ssd ]]; then

		ebs_storage_type='ebs-ssd'

	fi

	if [[ "${etype}" =~ io1 ]]; then

		ebs_storage_type='ebs-io1'

	fi

	query_data_directory="${SUITE}/$SERIAL/${RELEASE_LABEL}/ec2-query-data/${debarch}/hvm/ebs/${ebs_storage_type}"

	mkdir -p "${query_data_directory}"

	if [ ${RELEASE_LABEL} = 'release' ]; then

		query_data_file=${query_data_directory}/released.txt

	else

		query_data_file=${query_data_directory}/${RELEASE_LABEL}.txt

	fi

	debug 1  "Running cloud-image-manager register_image_from_snapshot ..."

	set -x

	${VENV_BIN}/cloud-image-manager \

			--debug-log debug.log \

			--log-to-console \

		aws \

			--partition "${AWS_DEFAULT_PARTITION:-aws}" \

			--profile "${AWS_DEFAULT_PROFILE:-alan}" \

		register_image_from_snapshot \

			"${SUITE}" \

			"${SERIAL}" \

			"${RELEASE_LABEL}" \

			--arch=${debarch} \

			--virt="hvm" \

			--snapshot_id=${SNAPSHOT_ID} \

			--ebs_storage_type=${ebs_storage_type} \

			--region ${region} \

			--query-data-directory=${query_data_directory} \

			--force-querydata \

			--no-debug

	set +x

	# read the img_id from the generated query data

	read junk junk junk junk junk junk junk new_ami junk < ${query_data_file}

	echo "${new_ami}" > "${register_info}"

else

	debug 1 "registering: register ${args[*]}"

	retry 15 30 xc2 ximages register "${args[@]}" > "${register_info}" &&

	new_ami=$(awk '-F\t' 'END{print $2}' < "${register_info}") &&

	[ -n "${new_ami}" ] && SNAPSHOT_ID="" ||

	fail "failed to register: xc2 register ${args[*]}"

fi

debug 1 "published ${register_name} as ${new_ami}"

echo "${new_ami}"

exit 0