~philroche/ubuntu-on-ec2/ec2-publishing-scripts-kernel-panic-revert

#!/bin/bash
# vi: ts=4 noexpandtab

TMPD=""
VERBOSITY=0
error() { echo "$@" 1>&2; }
errorp() { printf "$@" 1>&2; }
fail() { [ $# -eq 0 ] || error "$@"; exit 1; }
failp() { [ $# -eq 0 ] || errorp "$@"; exit 1; }
debug() {
	local level=${1}
	shift;
	[ "${level}" -gt "${VERBOSITY}" ] && return
	echo "$(date): ${@}" 1>&2
}
get_img_entry() {
	# get all entries correlating to ami from describe-images output in input
	# given valid input, this is the same as 'describe-images ami-id'
	local ami="$1"
	awk '-F\t' '{
		if ($1 == "IMAGE") { if ($2 == ami) cur=1; else cur=0; };
		if ( cur == 1 ) print $0 }' "ami=$ami"
}

Usage() {
	cat <<EOF
Usage: ${0##*/} [ options ] region image-id

   remove 'image-id' from 'region' on ec2.

   This includes both unregistering and deleting.
   Both operations are permenant, so be careful!

   If image-id is kernel or ramdisk, check for other references, failing
   if there are any.

   -f | --follow            if image-id is a machine image, remove
                            the associated kernel and ramdisk
   -n | --dry-run           only report what would be done
   -s | --skip-referenced   if image-id is a kernel or ramdisk and is
                            referenced by other images, silently continue
   -v | --verbose           increase verbosity
   Example:
   ${0##*/} us-east-1 ami-abcdef

EOF
}

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

cleanup() {
	[ -n "${TMPD}" -a -d "${TMPD}" ] && rm -Rf "${TMPD}"
	return 0
}
remove_image() {

	local short_opts="fhnsv"
	local long_opts="cache:,dry-run,follow,following:,help,skip-referenced,unpub-path-fmt:,verbose"
	getopt_out=$(getopt --name "${0##*/}" \
		--options "${short_opts}" --long "${long_opts}" -- "$@") &&
		eval set -- "${getopt_out}" || { bad_Usage; return 1; }

	local oifs=${IFS};
	local region="" id="" img_info="" x=""
	local id_info="" manif="" nmanif="" acl="" itype="" kernel="" ramdisk=""
	local dry_run=0 follow=0 skip=0 cur="" next="" followed=""
	local VERBOSITY=0 # verbosity is local, but read by debug
	local unpub_path_fmt="" unpub_path=""

	local pt; pt=( );   # remove_image pass through
	local rpt; rpt=( ); # remove manifest pass through

	while [ $# -ne 0 ]; do
		cur=${1}; next=${2};
		case "$cur" in
			--) shift; break;;
			-f|--follow) follow=1; pt[${#pt[@]}]=${cur};;
			   --following) followed=${next}; shift;;
			-h|--help) Usage; return 0;;
			-n|--dry-run)
				dry_run=1; 
				pt[${#pt[@]}]=${cur};
				rpt[${#rpt[@]}]=${cur};;
			-s|--skip-referenced) skip=1; pt[${#pt[@]}]=${cur};;
			   --unpub-path-fmt)
				unpub_path_fmt=${next}; 
				pt[${#pt[@]}]="--unpub-path-fmt=${next}";
				shift;;
			-v|--verbose)
				pt[${#pt[@]}]=${cur};
				rpt[${#rpt[@]}]=${cur};
				VERBOSITY=$((${VERBOSITY}+1));;
			-*) bad_Usage "confused by ${cur}"; return 1;;
		esac
		shift;
	done

	region=${1}
	id=${2}

	[ $# -gt 2 ] && { bad_Usage "to many arguments given"; return 1; }
	[ $# -lt 2 ] && { bad_Usage "must provide region and image-id"; return 1; }

	if [ -z "${TMPD}" ]; then
		TMPD=$(mktemp -d ${TMPDIR:-/tmp}/${0##*/}.XXXXXX) ||
			{ error "failed to make temp dir"; return 1; }
		trap cleanup EXIT
	fi

	img_info=${TMPD}/img_info.txt;
	xc2 ximages describe-images "--region=$region" --all > "$img_info" ||
		fail "failed to describe-images --region=$region --all"

	# get manifest, public/private, type, kernel,ramdisk
	id_info=$(awk '-F\t' '$2 == id { print $3,$6,$13,$9,$10,$11 }' \
	          "id=${id}" "OFS=|" "${img_info}" ) &&
		{ IFS="|"; set -- ${id_info}; IFS=${oifs}; } ||
		error "failed to parse images info"

	# ramdisk and kernel can be empty, in which case the 'set based split'
	# above will result in 4 items in the list
	[ $# -eq 5 -o $# -eq 6 ] ||
		{ error "${id} not found in ${region}"; return 1; }

	nmanif=${1}; acl=${2}; st_type=${3}; itype=${4}; kernel=${5}; ramdisk=${6};

	local snapshots=""
	manif=""
	if [ "${st_type}" = "ebs" ]; then
		local my_snaps="" snap="" others=""
		get_img_entry "$id" < "$img_info" > "$TMPD/tmp.out" &&
			my_snaps=$(awk '-F\t' '$1 == "BLOCKDEVICEMAPPING" &&
				$5 ~ /snap-/ { printf("%s ",$5) }' < "${TMPD}/tmp.out") &&
				[ -n "$my_snaps" ] ||
			{ error "failed to get snapshot info for ${id}"; return 1; }

		# filter out snapshots that are used by other (more than 1) builds
		# this occurs when a daily build has been promoted as the promoted
		# name re-uses the snapshot
		snapshots=""
		for snap in $my_snaps; do
			others=$(awk '-F\t' '
				$1 == "IMAGE" { curami=$2; curname=$3 };
				$1 == "BLOCKDEVICEMAPPING" && $5 == snap && curami != ami \
					{ printf("%s:%s ",curami,curname); }' \
					"snap=$snap" ami="$id" "$img_info") || {
						error "failed check for other snaps for $id/$snap";
						return 1;
					}
			if [ -n "$others" ]; then
				error "Warn: not deleting $id/$snap. used by others: $others"
			else
				snapshots="$snapshots $snap"
			fi
		done
		snapshots=${snapshots# }
	elif [ "${st_type}" = "instance-store" ]; then
		# due to 'ec2-register --name', manifest path isn't in describe-images
		# output. need to get it elsewhere
		manif=$(xc2 get-manifest-path "${id}" "${region}")
	fi

	if [ -n "${unpub_path_fmt}" ]; then
		unpub_path=${unpub_path_fmt//%r/${region}}
		unpub_path=${unpub_path//%i/${id}}
	fi

	# check if this manifest is registered more than once
	local other=""

	## TODO: THIS IS BROKEN.  To check if manifest path is registered
	## more than once, you have to get the manifest path. but
	## will not have that, only name
	other=$(awk '-F\t' '$3 == manif && $2 != id { print $2 }' \
	        "manif=${nmanif}" "id=${id}" "${img_info}") ||
		{ error "failed to check for multi-registered manifest"; return 1; }
	[ -z "${other}" ] ||
		{ error "${id}:${nmanif} is multi-registered: ${other}"; return 1; }

	# if its a kernel or ramdisk, check public images
	if [ "${itype}" = "kernel" -o "${itype}" = "ramdisk" ]; then
		local used_by=""
		# have to check that the image we find isn't the one followed
		local cond='( $10 == id || $11 == id )'
		local action='{ printf("\t%s %s\n",$2,$3); }'
		[ -z "${followed}" ] || cond="${cond} && \$2 != \"${followed}\""

		used_by=$(awk '-F\t' "${cond} ${action}" "id=${id}" "${img_info}" ) ||
			{ error "failed to parse image info for ${id}"; return 1; }
		if [ -n "${used_by}" ]; then
			
			debugp 2 "%s used by:\n%s\n" "${id}" "${used_by}"

			if [ ${skip} -eq 0 ]; then
				errorp "%s referenced by public images%s\n" \
					"${id}" "${followed:+ [followed from ${followed}]}"
				errorp "\t%s\n" " use --skip-referenced to skip"
				return 1;
			fi

			# skip was set, just ignore
			debugp 1 "skipping %s %s\n" "${id}" "${nmanif}"
			return 0
		fi
	# if its a machine and follow was given, then follow
	elif [ "${itype}" = "machine" ]; then
		if [ ${follow} -ne 0 ]; then
			for x in "${kernel}" "${ramdisk}"; do
				[ -n "${x}" ] || continue;
				remove_image "${pt[@]}" --following=${id} "${region}" "${x}" ||
					return 1;
			done
		fi
	else
		error "bad type: ${itype} for ${id} [${nmanif}]"
		return 1
	fi

	# its safe to delete it now
	local out=""
	if [ ${dry_run} -eq 0 ]; then
		out=$(xc2 ximages deregister --region "${region}" "${id}" ) || {
			error "failed to unregister ${id}";
			return 1;
		}
		local snap
		for snap in ${snapshots}; do
			out=$(xc2 delete-snapshot --region "${region}" "${snap}" ) || {
				error "Warn: failed to delete snapshot ${snap}: ${out}"
				return 1;
			}
		done
	fi

	if [ "${st_type}" = "instance-store" ]; then
		remove-manifest --message-label "$id" \
			${unpub_path:+--unpub-path=${unpub_path}} \
			"${rpt[@]}" "${manif}" ||
			{ error "failed to remove manifest ${manif}"; return 1; }
	else
		local xinfo="$id ${nmanif}${snapshots:+ [${snapshots}]}"
	    [ $dry_run -eq 0 ] && echo "deleted $xinfo" || error "delete $xinfo"
	fi

}

remove_image "$@"