XTRACE=$(set +o | grep xtrace)

set +o xtrace

function address_in_net() {

python -c "

}

function apt_get() {

[[ "$OFFLINE" = "True" || -z "$@" ]] && return

local sudo="sudo"

[[ "$(id -u)" = "0" ]] && sudo="env"

$sudo DEBIAN_FRONTEND=noninteractive \

http_proxy=$http_proxy https_proxy=$https_proxy \

no_proxy=$no_proxy \

apt-get --option "Dpkg::Options::=--force-confold" --assume-yes "$@"

}

function cp_it {

if [ -e $1 ] || [ -d $1 ]; then

cp -pRL $1 $2

fi

}

function die() {

local exitcode=$?

set +o xtrace

echo $@

exit $exitcode

}

function die_if_not_set() {

(

local exitcode=$?

set +o xtrace

local evar=$1; shift

if ! is_set $evar || [ $exitcode != 0 ]; then

echo $@

exit -1

fi

)

}

function get_field() {

while read data; do

if [ "$1" -lt 0 ]; then

field="(\$(NF$1))"

else

field="\$$(($1 + 1))"

fi

echo "$data" | awk -F'[ \t]*\\|[ \t]*' "{print $field}"

done

}

function get_packages() {

local package_dir=$1

local file_to_parse

local service

if [[ -z "$package_dir" ]]; then

echo "No package directory supplied"

return 1

fi

if [[ -z "$DISTRO" ]]; then

GetDistro

fi

for service in general ${ENABLED_SERVICES//,/ }; do

# Allow individual services to specify dependencies

if [[ -e ${package_dir}/${service} ]]; then

file_to_parse="${file_to_parse} $service"

fi

# NOTE(sdague) n-api needs glance for now because that's where

# glance client is

if [[ $service == n-api ]]; then

if [[ ! $file_to_parse =~ nova ]]; then

file_to_parse="${file_to_parse} nova"

fi

if [[ ! $file_to_parse =~ glance ]]; then

file_to_parse="${file_to_parse} glance"

fi

elif [[ $service == c-* ]]; then

if [[ ! $file_to_parse =~ cinder ]]; then

file_to_parse="${file_to_parse} cinder"

fi

elif [[ $service == ceilometer-* ]]; then

if [[ ! $file_to_parse =~ ceilometer ]]; then

file_to_parse="${file_to_parse} ceilometer"

fi

elif [[ $service == n-* ]]; then

if [[ ! $file_to_parse =~ nova ]]; then

file_to_parse="${file_to_parse} nova"

fi

elif [[ $service == g-* ]]; then

if [[ ! $file_to_parse =~ glance ]]; then

file_to_parse="${file_to_parse} glance"

fi

elif [[ $service == key* ]]; then

if [[ ! $file_to_parse =~ keystone ]]; then

file_to_parse="${file_to_parse} keystone"

fi

elif [[ $service == q-* ]]; then

if [[ ! $file_to_parse =~ quantum ]]; then

file_to_parse="${file_to_parse} quantum"

fi

fi

done

for file in ${file_to_parse}; do

local fname=${package_dir}/${file}

local OIFS line package distros distro

[[ -e $fname ]] || continue

OIFS=$IFS

IFS=$'\n'

for line in $(<${fname}); do

if [[ $line =~ "NOPRIME" ]]; then

continue

fi

if [[ $line =~ (.*)#.*dist:([^ ]*) ]]; then

# We are using BASH regexp matching feature.

package=${BASH_REMATCH[1]}

distros=${BASH_REMATCH[2]}

# In bash ${VAR,,} will lowecase VAR

[[ ${distros,,} =~ ${DISTRO,,} ]] && echo $package

continue

fi

echo ${line%#*}

done

IFS=$OIFS

done

}

GetOSVersion() {

# Figure out which vendor we are

if [[ -n "`which sw_vers 2>/dev/null`" ]]; then

# OS/X

os_VENDOR=`sw_vers -productName`

os_RELEASE=`sw_vers -productVersion`

os_UPDATE=${os_RELEASE##*.}

os_RELEASE=${os_RELEASE%.*}

os_PACKAGE=""

if [[ "$os_RELEASE" =~ "10.7" ]]; then

os_CODENAME="lion"

elif [[ "$os_RELEASE" =~ "10.6" ]]; then

os_CODENAME="snow leopard"

elif [[ "$os_RELEASE" =~ "10.5" ]]; then

os_CODENAME="leopard"

elif [[ "$os_RELEASE" =~ "10.4" ]]; then

os_CODENAME="tiger"

elif [[ "$os_RELEASE" =~ "10.3" ]]; then

os_CODENAME="panther"

else

os_CODENAME=""

fi

elif [[ -x $(which lsb_release 2>/dev/null) ]]; then

os_VENDOR=$(lsb_release -i -s)

os_RELEASE=$(lsb_release -r -s)

os_UPDATE=""

os_PACKAGE="rpm"

if [[ "Debian,Ubuntu" =~ $os_VENDOR ]]; then

os_PACKAGE="deb"

elif [[ "SUSE LINUX" =~ $os_VENDOR ]]; then

lsb_release -d -s | grep -q openSUSE

if [[ $? -eq 0 ]]; then

os_VENDOR="openSUSE"

fi

elif [[ $os_VENDOR =~ Red.*Hat ]]; then

os_VENDOR="Red Hat"

fi

os_CODENAME=$(lsb_release -c -s)

elif [[ -r /etc/redhat-release ]]; then

# Red Hat Enterprise Linux Server release 5.5 (Tikanga)

# CentOS release 5.5 (Final)

# CentOS Linux release 6.0 (Final)

# Fedora release 16 (Verne)

os_CODENAME=""

for r in "Red Hat" CentOS Fedora; do

os_VENDOR=$r

if [[ -n "`grep \"$r\" /etc/redhat-release`" ]]; then

ver=`sed -e 's/^.* \(.*\) (\(.*\)).*$/\1\|\2/' /etc/redhat-release`

os_CODENAME=${ver#*|}

os_RELEASE=${ver%|*}

os_UPDATE=${os_RELEASE##*.}

os_RELEASE=${os_RELEASE%.*}

break

fi

os_VENDOR=""

done

os_PACKAGE="rpm"

elif [[ -x $(which emerge 2>/dev/null) ]]; then

os_VENDOR="Gentoo"

os_RELEASE=$(eselect --brief --colour=no profile show)

os_PACKAGE="ebuild"

elif [[ -r /etc/SuSE-release ]]; then

for r in openSUSE "SUSE Linux"; do

if [[ "$r" = "SUSE Linux" ]]; then

os_VENDOR="SUSE LINUX"

else

os_VENDOR=$r

fi

if [[ -n "`grep \"$r\" /etc/SuSE-release`" ]]; then

os_CODENAME=`grep "CODENAME = " /etc/SuSE-release | sed 's:.* = ::g'`

os_RELEASE=`grep "VERSION = " /etc/SuSE-release | sed 's:.* = ::g'`

os_UPDATE=`grep "PATCHLEVEL = " /etc/SuSE-release | sed 's:.* = ::g'`

break

fi

os_VENDOR=""

done

os_PACKAGE="rpm"

fi

export os_VENDOR os_RELEASE os_UPDATE os_PACKAGE os_CODENAME

}

function git_update_branch() {

GIT_BRANCH=$1

git checkout -f origin/$GIT_BRANCH

# a local branch might not exist

git branch -D $GIT_BRANCH || true

git checkout -b $GIT_BRANCH

}

function git_update_tag() {

GIT_TAG=$1

git tag -d $GIT_TAG

# fetching given tag only

git fetch origin tag $GIT_TAG

git checkout -f $GIT_TAG

}

function git_update_remote_branch() {

GIT_BRANCH=$1

git checkout -b $GIT_BRANCH -t origin/$GIT_BRANCH

}

function GetDistro() {

GetOSVersion

if [[ "$os_VENDOR" =~ (Ubuntu) ]]; then

# 'Everyone' refers to Ubuntu releases by the code name adjective

DISTRO=$os_CODENAME

elif [[ "$os_VENDOR" =~ (Fedora) ]]; then

# For Fedora, just use 'f' and the release

DISTRO="f$os_RELEASE"

elif [[ "$os_VENDOR" =~ (Gentoo) ]]; then

DISTRO="gentoo"

elif [[ "$os_VENDOR" =~ (openSUSE) ]]; then

DISTRO="opensuse-$os_RELEASE"

elif [[ "$os_VENDOR" =~ (SUSE LINUX) ]]; then

# For SLE, also use the service pack

if [[ -z "$os_UPDATE" ]]; then

DISTRO="sle${os_RELEASE}"

else

DISTRO="sle${os_RELEASE}sp${os_UPDATE}"

fi

else

# Catch-all for now is Vendor + Release + Update

DISTRO="$os_VENDOR-$os_RELEASE.$os_UPDATE"

fi

export DISTRO

}

function is_ubuntu {

if [[ -z "$os_PACKAGE" ]]; then

GetOSVersion

fi

[ "$os_PACKAGE" = "deb" ]

}

function is_fedora {

if [[ -z "$os_VENDOR" ]]; then

GetOSVersion

fi

[ "$os_VENDOR" = "Fedora" ] || [ "$os_VENDOR" = "Red Hat" ] || [ "$os_VENDOR" = "CentOS" ]

}

function is_suse {

if [[ -z "$os_VENDOR" ]]; then

GetOSVersion

fi

[ "$os_VENDOR" = "openSUSE" ] || [ "$os_VENDOR" = "SUSE LINUX" ]

}

function is_gentoo {

if [[ -z "$os_VENDOR" ]]; then

GetOSVersion

fi

[ "$os_VENDOR" = "Gentoo" ]

}

function exit_distro_not_supported {

if [[ -z "$DISTRO" ]]; then

GetDistro

fi

if [ $# -gt 0 ]; then

echo "Support for $DISTRO is incomplete: no support for $@"

else

echo "Support for $DISTRO is incomplete."

fi

exit 1

}

function git_clone {

[[ "$OFFLINE" = "True" ]] && return

GIT_REMOTE=$1

GIT_DEST=$2

GIT_REF=$3

if echo $GIT_REF | egrep -q "^refs"; then

# If our branch name is a gerrit style refs/changes/...

if [[ ! -d $GIT_DEST ]]; then

[[ "$ERROR_ON_CLONE" = "True" ]] && exit 1

git clone $GIT_REMOTE $GIT_DEST

fi

cd $GIT_DEST

git fetch $GIT_REMOTE $GIT_REF && git checkout FETCH_HEAD

else

# do a full clone only if the directory doesn't exist

if [[ ! -d $GIT_DEST ]]; then

[[ "$ERROR_ON_CLONE" = "True" ]] && exit 1

git clone $GIT_REMOTE $GIT_DEST

cd $GIT_DEST

# This checkout syntax works for both branches and tags

git checkout $GIT_REF

elif [[ "$RECLONE" == "yes" ]]; then

# if it does exist then simulate what clone does if asked to RECLONE

cd $GIT_DEST

# set the url to pull from and fetch

git remote set-url origin $GIT_REMOTE

git fetch origin

# remove the existing ignored files (like pyc) as they cause breakage

# (due to the py files having older timestamps than our pyc, so python

# thinks the pyc files are correct using them)

find $GIT_DEST -name '*.pyc' -delete

# handle GIT_REF accordingly to type (tag, branch)

if [[ -n "`git show-ref refs/tags/$GIT_REF`" ]]; then

git_update_tag $GIT_REF

elif [[ -n "`git show-ref refs/heads/$GIT_REF`" ]]; then

git_update_branch $GIT_REF

elif [[ -n "`git show-ref refs/remotes/origin/$GIT_REF`" ]]; then

git_update_remote_branch $GIT_REF

else

echo $GIT_REF is neither branch nor tag

exit 1

fi

fi

fi

}

function inicomment() {

local file=$1

local section=$2

local option=$3

sed -i -e "/^\[$section\]/,/^\[.*\]/ s|^\($option[ \t]*=.*$\)|#\1|" "$file"

}

function iniuncomment() {

local file=$1

local section=$2

local option=$3

sed -i -e "/^\[$section\]/,/^\[.*\]/ s|[^ \t]*#[ \t]*\($option[ \t]*=.*$\)|\1|" "$file"

}

function iniget() {

local file=$1

local section=$2

local option=$3

local line

line=$(sed -ne "/^\[$section\]/,/^\[.*\]/ { /^$option[ \t]*=/ p; }" "$file")

echo ${line#*=}

}

function ini_has_option() {

local file=$1

local section=$2

local option=$3

local line

line=$(sed -ne "/^\[$section\]/,/^\[.*\]/ { /^$option[ \t]*=/ p; }" "$file")

[ -n "$line" ]

}

function iniset() {

local file=$1

local section=$2

local option=$3

local value=$4

if ! grep -q "^\[$section\]" "$file"; then

# Add section at the end

echo -e "\n[$section]" >>"$file"

fi

if ! ini_has_option "$file" "$section" "$option"; then

# Add it

sed -i -e "/^\[$section\]/ a\\

" "$file"

else

# Replace it

sed -i -e "/^\[$section\]/,/^\[.*\]/ s|^\($option[ \t]*=[ \t]*\).*$|\1$value|" "$file"

fi

}

function is_service_enabled() {

services=$@

for service in ${services}; do

[[ ,${ENABLED_SERVICES}, =~ ,${service}, ]] && return 0

[[ ${service} == "nova" && ${ENABLED_SERVICES} =~ "n-" ]] && return 0

[[ ${service} == "cinder" && ${ENABLED_SERVICES} =~ "c-" ]] && return 0

[[ ${service} == "ceilometer" && ${ENABLED_SERVICES} =~ "ceilometer-" ]] && return 0

[[ ${service} == "glance" && ${ENABLED_SERVICES} =~ "g-" ]] && return 0

[[ ${service} == "quantum" && ${ENABLED_SERVICES} =~ "q-" ]] && return 0

done

return 1

}

function _cleanup_service_list () {

echo "$1" | sed -e '

}

function enable_service() {

local tmpsvcs="${ENABLED_SERVICES}"

for service in $@; do

if ! is_service_enabled $service; then

tmpsvcs+=",$service"

fi

done

ENABLED_SERVICES=$(_cleanup_service_list "$tmpsvcs")

disable_negated_services

}

function disable_service() {

local tmpsvcs=",${ENABLED_SERVICES},"

local service

for service in $@; do

if is_service_enabled $service; then

tmpsvcs=${tmpsvcs//,$service,/,}

fi

done

ENABLED_SERVICES=$(_cleanup_service_list "$tmpsvcs")

}

function disable_all_services() {

ENABLED_SERVICES=""

}

function disable_negated_services() {

local tmpsvcs="${ENABLED_SERVICES}"

local service

for service in ${tmpsvcs//,/ }; do

if [[ ${service} == -* ]]; then

tmpsvcs=$(echo ${tmpsvcs}|sed -r "s/(,)?(-)?${service#-}(,)?/,/g")

fi

done

ENABLED_SERVICES=$(_cleanup_service_list "$tmpsvcs")

}

function install_package() {

if is_ubuntu; then

[[ "$NO_UPDATE_REPOS" = "True" ]] || apt_get update

NO_UPDATE_REPOS=True

apt_get install "$@"

elif [[ "$os_PACKAGE" = "ebuild" ]]; then

emerge_ebuild "$@"

elif is_fedora; then

yum_install "$@"

elif is_suse; then

zypper_install "$@"

else

exit_distro_not_supported "installing packages"

fi

}

function is_package_installed() {

if [[ -z "$@" ]]; then

return 1

fi

if [[ -z "$os_PACKAGE" ]]; then

GetOSVersion

fi

if [[ "$os_PACKAGE" = "deb" ]]; then

dpkg -l "$@" > /dev/null

return $?

elif [[ "$os_PACKAGE" = "rpm" ]]; then

rpm --quiet -q "$@"

return $?

elif [[ "$os_PACKAGE" = "ebuild" ]]; then

emerge -qCp "$@" > /dev/null

return $?

else

exit_distro_not_supported "finding if a package is installed"

fi

}

function is_set() {

local var=\$"$1"

eval "[ -n \"$var\" ]" # For ex.: sh -c "[ -n \"$var\" ]" would be better, but several exercises depends on this

}

function pip_install {

[[ "$OFFLINE" = "True" || -z "$@" ]] && return

if [[ -z "$os_PACKAGE" ]]; then

GetOSVersion

fi

if [[ $TRACK_DEPENDS = True ]] ; then

source $DEST/.venv/bin/activate

CMD_PIP=$DEST/.venv/bin/pip

SUDO_PIP="env"

else

SUDO_PIP="sudo"

CMD_PIP=$(get_pip_command)

fi

if [[ "$PIP_USE_MIRRORS" != "False" ]]; then

PIP_MIRROR_OPT="--use-mirrors"

fi

$SUDO_PIP PIP_DOWNLOAD_CACHE=${PIP_DOWNLOAD_CACHE:-/var/cache/pip} \

HTTP_PROXY=$http_proxy \

HTTPS_PROXY=$https_proxy \

NO_PROXY=$no_proxy \

$CMD_PIP install $PIP_MIRROR_OPT $@

}

function restart_service() {

if is_ubuntu; then

sudo /usr/sbin/service $1 restart

elif [[ "$os_PACKAGE" = "rpm" ]]; then

sudo /sbin/service $1 restart

elif [[ "$os_PACKAGE" = "ebuild" ]]; then

sudo /sbin/rc-service $1 restart

fi

}

function screen_it {

NL=`echo -ne '\015'`

SCREEN_NAME=${SCREEN_NAME:-stack}

SERVICE_DIR=${SERVICE_DIR:-${DEST}/status}

if is_service_enabled $1; then

# Append the service to the screen rc file

screen_rc "$1" "$2"

screen -S $SCREEN_NAME -X screen -t $1

# sleep to allow bash to be ready to be send the command - we are

# creating a new window in screen and then sends characters, so if

# bash isn't running by the time we send the command, nothing happens

sleep 1.5

if [[ -n ${SCREEN_LOGDIR} ]]; then

screen -S $SCREEN_NAME -p $1 -X logfile ${SCREEN_LOGDIR}/screen-${1}.${CURRENT_LOG_TIME}.log

screen -S $SCREEN_NAME -p $1 -X log on

ln -sf ${SCREEN_LOGDIR}/screen-${1}.${CURRENT_LOG_TIME}.log ${SCREEN_LOGDIR}/screen-${1}.log

fi

screen -S $SCREEN_NAME -p $1 -X stuff "$2 || touch \"$SERVICE_DIR/$SCREEN_NAME/$1.failure\"$NL"

fi

}

function screen_rc {

SCREEN_NAME=${SCREEN_NAME:-stack}

SCREENRC=$TOP_DIR/$SCREEN_NAME-screenrc

if [[ ! -e $SCREENRC ]]; then

# Name the screen session

echo "sessionname $SCREEN_NAME" > $SCREENRC

# Set a reasonable statusbar

echo "hardstatus alwayslastline '$SCREEN_HARDSTATUS'" >> $SCREENRC

echo "screen -t shell bash" >> $SCREENRC

fi

# If this service doesn't already exist in the screenrc file

if ! grep $1 $SCREENRC 2>&1 > /dev/null; then

NL=`echo -ne '\015'`

echo "screen -t $1 bash" >> $SCREENRC

echo "stuff \"$2$NL\"" >> $SCREENRC

fi

}

function init_service_check() {

SCREEN_NAME=${SCREEN_NAME:-stack}

SERVICE_DIR=${SERVICE_DIR:-${DEST}/status}

if [[ ! -d "$SERVICE_DIR/$SCREEN_NAME" ]]; then

mkdir -p "$SERVICE_DIR/$SCREEN_NAME"

fi

rm -f "$SERVICE_DIR/$SCREEN_NAME"/*.failure

}

function service_check() {

local service

local failures

SCREEN_NAME=${SCREEN_NAME:-stack}

SERVICE_DIR=${SERVICE_DIR:-${DEST}/status}

if [[ ! -d "$SERVICE_DIR/$SCREEN_NAME" ]]; then

echo "No service status directory found"

return

fi

# Check if there is any falure flag file under $SERVICE_DIR/$SCREEN_NAME

failures=`ls "$SERVICE_DIR/$SCREEN_NAME"/*.failure 2>/dev/null`

for service in $failures; do

service=`basename $service`

service=${service::-8}

echo "Error: Service $service is not running"

done

if [ -n "$failures" ]; then

echo "More details about the above errors can be found with screen, with ./rejoin-stack.sh"

fi

}

function setup_develop() {

if [[ $TRACK_DEPENDS = True ]] ; then

SUDO_CMD="env"

else

SUDO_CMD="sudo"

fi

(cd $1; \

python setup.py egg_info; \

raw_links=$(awk '/^.+/ {print "-f " $1}' *.egg-info/dependency_links.txt); \

depend_links=$(echo $raw_links | xargs); \

require_file=$([ ! -r *-info/requires.txt ] || echo "-r *-info/requires.txt"); \

pip_install $require_file $depend_links; \

$SUDO_CMD \

HTTP_PROXY=$http_proxy \

HTTPS_PROXY=$https_proxy \

NO_PROXY=$no_proxy \

python setup.py develop \

)

}

function start_service() {

if is_ubuntu; then

sudo /usr/sbin/service $1 start

elif [[ "$os_PACKAGE" = "rpm" ]]; then

sudo /sbin/service $1 start

elif [[ "$os_PACKAGE" = "ebuild" ]]; then

sudo /sbin/rc-service $1 start

fi

}

function stop_service() {

if is_ubuntu; then

sudo /usr/sbin/service $1 stop

elif [[ "$os_PACKAGE" = "rpm" ]]; then

sudo /sbin/service $1 stop

elif [[ "$os_PACKAGE" = "ebuild" ]]; then

sudo /sbin/rc-service $1 stop

fi

}

function trueorfalse() {

local default=$1

local testval=$2

[[ -z "$testval" ]] && { echo "$default"; return; }

[[ "0 no false False FALSE" =~ "$testval" ]] && { echo "False"; return; }

[[ "1 yes true True TRUE" =~ "$testval" ]] && { echo "True"; return; }

echo "$default"

}

function upload_image() {

local image_url=$1

local token=$2

# Create a directory for the downloaded image tarballs.

mkdir -p $FILES/images

# Downloads the image (uec ami+aki style), then extracts it.

IMAGE_FNAME=`basename "$image_url"`

if [[ ! -f $FILES/$IMAGE_FNAME || "$(stat -c "%s" $FILES/$IMAGE_FNAME)" = "0" ]]; then

wget -c $image_url -O $FILES/$IMAGE_FNAME

if [[ $? -ne 0 ]]; then

echo "Not found: $image_url"

return

fi

fi

# OpenVZ-format images are provided as .tar.gz, but not decompressed prior to loading

if [[ "$image_url" =~ 'openvz' ]]; then

IMAGE="$FILES/${IMAGE_FNAME}"

IMAGE_NAME="${IMAGE_FNAME%.tar.gz}"

glance --os-auth-token $token --os-image-url http://$GLANCE_HOSTPORT image-create --name "$IMAGE_NAME" --is-public=True --container-format ami --disk-format ami < "${IMAGE}"

return

fi

KERNEL=""

RAMDISK=""

DISK_FORMAT=""

CONTAINER_FORMAT=""

UNPACK=""

# FIXME: Maybe check it with file instead of basing on filename?

case "$IMAGE_FNAME" in

*.tar.gz|*.tgz)

# Extract ami and aki files

[ "${IMAGE_FNAME%.tar.gz}" != "$IMAGE_FNAME" ] &&

IMAGE_NAME="${IMAGE_FNAME%.tar.gz}" ||

IMAGE_NAME="${IMAGE_FNAME%.tgz}"

xdir="$FILES/images/$IMAGE_NAME"

rm -Rf "$xdir";

mkdir "$xdir"

tar -zxf $FILES/$IMAGE_FNAME -C "$xdir"

KERNEL=$(for f in "$xdir/"*-vmlinuz* "$xdir/"aki-*/image; do

RAMDISK=$(for f in "$xdir/"*-initrd* "$xdir/"ari-*/image; do

IMAGE=$(for f in "$xdir/"*.img "$xdir/"ami-*/image; do

if [[ -z "$IMAGE_NAME" ]]; then

IMAGE_NAME=$(basename "$IMAGE" ".img")

fi

;;

*.img)

IMAGE="$FILES/$IMAGE_FNAME";

IMAGE_NAME=$(basename "$IMAGE" ".img")

format=$(qemu-img info ${IMAGE} | awk '/^file format/ { print $3; exit }')

if [[ ",qcow2,raw,vdi,vmdk,vpc," =~ ",$format," ]]; then

DISK_FORMAT=$format

else

DISK_FORMAT=raw

fi

CONTAINER_FORMAT=bare

;;

*.img.gz)

IMAGE="$FILES/${IMAGE_FNAME}"

IMAGE_NAME=$(basename "$IMAGE" ".img.gz")

DISK_FORMAT=raw

CONTAINER_FORMAT=bare

UNPACK=zcat

;;

*.qcow2)

IMAGE="$FILES/${IMAGE_FNAME}"

IMAGE_NAME=$(basename "$IMAGE" ".qcow2")

DISK_FORMAT=qcow2

CONTAINER_FORMAT=bare

;;

*) echo "Do not know what to do with $IMAGE_FNAME"; false;;

esac

if [ "$CONTAINER_FORMAT" = "bare" ]; then

if [ "$UNPACK" = "zcat" ]; then

glance --os-auth-token $token --os-image-url http://$GLANCE_HOSTPORT image-create --name "$IMAGE_NAME" --public --container-format=$CONTAINER_FORMAT --disk-format $DISK_FORMAT < <(zcat --force "${IMAGE}")

else

glance --os-auth-token $token --os-image-url http://$GLANCE_HOSTPORT image-create --name "$IMAGE_NAME" --public --container-format=$CONTAINER_FORMAT --disk-format $DISK_FORMAT < "${IMAGE}"

fi

else

# Use glance client to add the kernel the root filesystem.

# We parse the results of the first upload to get the glance ID of the

# kernel for use when uploading the root filesystem.

KERNEL_ID=""; RAMDISK_ID="";

if [ -n "$KERNEL" ]; then

KERNEL_ID=$(glance --os-auth-token $token --os-image-url http://$GLANCE_HOSTPORT image-create --name "$IMAGE_NAME-kernel" --public --container-format aki --disk-format aki < "$KERNEL" | grep ' id ' | get_field 2)

fi

if [ -n "$RAMDISK" ]; then

RAMDISK_ID=$(glance --os-auth-token $token --os-image-url http://$GLANCE_HOSTPORT image-create --name "$IMAGE_NAME-ramdisk" --public --container-format ari --disk-format ari < "$RAMDISK" | grep ' id ' | get_field 2)

fi

glance --os-auth-token $token --os-image-url http://$GLANCE_HOSTPORT image-create --name "${IMAGE_NAME%.img}" --public --container-format ami --disk-format ami ${KERNEL_ID:+--property kernel_id=$KERNEL_ID} ${RAMDISK_ID:+--property ramdisk_id=$RAMDISK_ID} < "${IMAGE}"

fi