# functions-common - Common functions used by DevStack components

#

# The canonical copy of this file is maintained in the DevStack repo.

# All modifications should be made there and then sync'ed to other repos

# as required.

#

# This file is sorted alphabetically within the function groups.

#

# - Config Functions

# - Control Functions

# - Distro Functions

# - Git Functions

# - OpenStack Functions

# - Package Functions

# - Process Functions

# - Python Functions

# - Service Functions

# - System Functions

#

# The following variables are assumed to be defined by certain functions:

#

# - ``GIT_DEPTH``

# - ``ENABLED_SERVICES``

# - ``ERROR_ON_CLONE``

# - ``FILES``

# - ``OFFLINE``

# - ``PIP_DOWNLOAD_CACHE``

# - ``RECLONE``

# - ``REQUIREMENTS_DIR``

# - ``STACK_USER``

# - ``TRACK_DEPENDS``

# - ``UNDO_REQUIREMENTS``

# - ``http_proxy``, ``https_proxy``, ``no_proxy``

#

# Save trace setting

XTRACE=$(set +o | grep xtrace)

set +o xtrace

# Global Config Variables

declare -A GITREPO

declare -A GITBRANCH

declare -A GITDIR

# Config Functions

# ================

# Append a new option in an ini file without replacing the old value

# iniadd config-file section option value1 value2 value3 ...

function iniadd {

local xtrace=$(set +o | grep xtrace)

set +o xtrace

local file=$1

local section=$2

local option=$3

shift 3

local values="$(iniget_multiline $file $section $option) $@"

iniset_multiline $file $section $option $values

$xtrace

}

# Comment an option in an INI file

# inicomment config-file section option

function inicomment {

local xtrace=$(set +o | grep xtrace)

set +o xtrace

local file=$1

local section=$2

local option=$3

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

$xtrace

}

# Get an option from an INI file

# iniget config-file section option

function iniget {

local xtrace=$(set +o | grep xtrace)

set +o xtrace

local file=$1

local section=$2

local option=$3

local line

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

echo ${line#*=}

$xtrace

}

# Get a multiple line option from an INI file

# iniget_multiline config-file section option

function iniget_multiline {

local xtrace=$(set +o | grep xtrace)

set +o xtrace

local file=$1

local section=$2

local option=$3

local values

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

echo ${values}

$xtrace

}

# Determinate is the given option present in the INI file

# ini_has_option config-file section option

function ini_has_option {

local xtrace=$(set +o | grep xtrace)

set +o xtrace

local file=$1

local section=$2

local option=$3

local line

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

$xtrace

[ -n "$line" ]

}

# Add another config line for a multi-line option.

# It's normally called after iniset of the same option and assumes

# that the section already exists.

#

# Note that iniset_multiline requires all the 'lines' to be supplied

# in the argument list. Doing that will cause incorrect configuration

# if spaces are used in the config values.

#

# iniadd_literal config-file section option value

function iniadd_literal {

local xtrace=$(set +o | grep xtrace)

set +o xtrace

local file=$1

local section=$2

local option=$3

local value=$4

[[ -z $section || -z $option ]] && return

# Add it

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

$option = $value

" "$file"

$xtrace

}

# Set an option in an INI file

# iniset config-file section option value

function iniset {

local xtrace=$(set +o | grep xtrace)

set +o xtrace

local file=$1

local section=$2

local option=$3

local value=$4

[[ -z $section || -z $option ]] && return

if ! grep -q "^\[$section\]" "$file" 2>/dev/null; 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\\

$option = $value

" "$file"

else

local sep=$(echo -ne "\x01")

# Replace it

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

fi

$xtrace

}

# Set a multiple line option in an INI file

# iniset_multiline config-file section option value1 value2 valu3 ...

function iniset_multiline {

local xtrace=$(set +o | grep xtrace)

set +o xtrace

local file=$1

local section=$2

local option=$3

shift 3

local values

for v in $@; do

# The later sed command inserts each new value in the line next to

# the section identifier, which causes the values to be inserted in

# the reverse order. Do a reverse here to keep the original order.

values="$v ${values}"

done

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

# Add section at the end

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

else

# Remove old values

sed -i -e "/^\[$section\]/,/^\[.*\]/ { /^$option[ \t]*=/ d; }" "$file"

fi

# Add new ones

for v in $values; do

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

$option = $v

" "$file"

done

$xtrace

}

# Uncomment an option in an INI file

# iniuncomment config-file section option

function iniuncomment {

local xtrace=$(set +o | grep xtrace)

set +o xtrace

local file=$1

local section=$2

local option=$3

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

$xtrace

}

# Normalize config values to True or False

# Accepts as False: 0 no No NO false False FALSE

# Accepts as True: 1 yes Yes YES true True TRUE

# VAR=$(trueorfalse default-value test-value)

function trueorfalse {

local xtrace=$(set +o | grep xtrace)

set +o xtrace

local default=$1

local testval=$2

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

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

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

echo "$default"

$xtrace

}

# Control Functions

# =================

# Prints backtrace info

# filename:lineno:function

# backtrace level

function backtrace {

local level=$1

local deep=$((${#BASH_SOURCE[@]} - 1))

echo "[Call Trace]"

while [ $level -le $deep ]; do

echo "${BASH_SOURCE[$deep]}:${BASH_LINENO[$deep-1]}:${FUNCNAME[$deep-1]}"

deep=$((deep - 1))

done

}

# Prints line number and "message" then exits

# die $LINENO "message"

function die {

local exitcode=$?

set +o xtrace

local line=$1; shift

if [ $exitcode == 0 ]; then

exitcode=1

fi

backtrace 2

err $line "$*"

# Give buffers a second to flush

sleep 1

exit $exitcode

}

# Checks an environment variable is not set or has length 0 OR if the

# exit code is non-zero and prints "message" and exits

# NOTE: env-var is the variable name without a '$'

# die_if_not_set $LINENO env-var "message"

function die_if_not_set {

local exitcode=$?

local xtrace=$(set +o | grep xtrace)

set +o xtrace

local line=$1; shift

local evar=$1; shift

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

die $line "$*"

fi

$xtrace

}

# Prints line number and "message" in error format

# err $LINENO "message"

function err {

local exitcode=$?

local xtrace=$(set +o | grep xtrace)

set +o xtrace

local msg="[ERROR] ${BASH_SOURCE[2]}:$1 $2"

echo $msg 1>&2;

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

echo $msg >> "${SCREEN_LOGDIR}/error.log"

fi

$xtrace

return $exitcode

}

# Checks an environment variable is not set or has length 0 OR if the

# exit code is non-zero and prints "message"

# NOTE: env-var is the variable name without a '$'

# err_if_not_set $LINENO env-var "message"

function err_if_not_set {

local exitcode=$?

local xtrace=$(set +o | grep xtrace)

set +o xtrace

local line=$1; shift

local evar=$1; shift

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

err $line "$*"

fi

$xtrace

return $exitcode

}

# Exit after outputting a message about the distribution not being supported.

# exit_distro_not_supported [optional-string-telling-what-is-missing]

function exit_distro_not_supported {

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

GetDistro

fi

if [ $# -gt 0 ]; then

die $LINENO "Support for $DISTRO is incomplete: no support for $@"

else

die $LINENO "Support for $DISTRO is incomplete."

fi

}

# Test if the named environment variable is set and not zero length

# is_set env-var

function is_set {

local var=\$"$1"

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

}

# Prints line number and "message" in warning format

# warn $LINENO "message"

function warn {

local exitcode=$?

local xtrace=$(set +o | grep xtrace)

set +o xtrace

local msg="[WARNING] ${BASH_SOURCE[2]}:$1 $2"

echo $msg 1>&2;

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

echo $msg >> "${SCREEN_LOGDIR}/error.log"

fi

$xtrace

return $exitcode

}

# Distro Functions

# ================

# Determine OS Vendor, Release and Update

# Tested with OS/X, Ubuntu, RedHat, CentOS, Fedora

# Returns results in global variables:

# ``os_VENDOR`` - vendor name: ``Ubuntu``, ``Fedora``, etc

# ``os_RELEASE`` - major release: ``14.04`` (Ubuntu), ``20`` (Fedora)

# ``os_UPDATE`` - update: ex. the ``5`` in ``RHEL6.5``

# ``os_PACKAGE`` - package type: ``deb`` or ``rpm``

# ``os_CODENAME`` - vendor's codename for release: ``snow leopard``, ``trusty``

declare os_VENDOR os_RELEASE os_UPDATE os_PACKAGE os_CODENAME

# GetOSVersion

function GetOSVersion {

# Figure out which vendor we are

if [[ -x "`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,LinuxMint" =~ $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 == "openSUSE project" ]]; then

os_VENDOR="openSUSE"

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)

# Red Hat Enterprise Linux Server release 7.0 Beta (Maipo)

# CentOS release 5.5 (Final)

# CentOS Linux release 6.0 (Final)

# Fedora release 16 (Verne)

# XenServer release 6.2.0-70446c (xenenterprise)

os_CODENAME=""

for r in "Red Hat" CentOS Fedora XenServer; do

os_VENDOR=$r

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

ver=`sed -e 's/^.* \([0-9].*\) (\(.*\)).*$/\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 [[ -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"

# If lsb_release is not installed, we should be able to detect Debian OS

elif [[ -f /etc/debian_version ]] && [[ $(cat /proc/version) =~ "Debian" ]]; then

os_VENDOR="Debian"

os_PACKAGE="deb"

os_CODENAME=$(awk '/VERSION=/' /etc/os-release | sed 's/VERSION=//' | sed -r 's/\"|\(|\)//g' | awk '{print $2}')

os_RELEASE=$(awk '/VERSION_ID=/' /etc/os-release | sed 's/VERSION_ID=//' | sed 's/\"//g')

fi

export os_VENDOR os_RELEASE os_UPDATE os_PACKAGE os_CODENAME

}

# Translate the OS version values into common nomenclature

# Sets global ``DISTRO`` from the ``os_*`` values

declare DISTRO

function GetDistro {

GetOSVersion

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

# 'Everyone' refers to Ubuntu / Debian 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" =~ (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

elif [[ "$os_VENDOR" =~ (Red Hat) || \

"$os_VENDOR" =~ (CentOS) || \

"$os_VENDOR" =~ (OracleServer) ]]; then

# Drop the . release as we assume it's compatible

DISTRO="rhel${os_RELEASE::1}"

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

DISTRO="xs$os_RELEASE"

else

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

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

fi

export DISTRO

}

# Utility function for checking machine architecture

# is_arch arch-type

function is_arch {

[[ "$(uname -m)" == "$1" ]]

}

# Quick check for a rackspace host; n.b. rackspace provided images

# have these Xen tools installed but a custom image may not.

function is_rackspace {

[ -f /usr/bin/xenstore-ls ] && \

sudo /usr/bin/xenstore-ls vm-data | grep -q "Rackspace"

}

# Determine if current distribution is a Fedora-based distribution

# (Fedora, RHEL, CentOS, etc).

# is_fedora

function is_fedora {

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

GetOSVersion

fi

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

[ "$os_VENDOR" = "CentOS" ] || [ "$os_VENDOR" = "OracleServer" ]

}

# Determine if current distribution is a SUSE-based distribution

# (openSUSE, SLE).

# is_suse

function is_suse {

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

GetOSVersion

fi

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

}

# Determine if current distribution is an Ubuntu-based distribution

# It will also detect non-Ubuntu but Debian-based distros

# is_ubuntu

function is_ubuntu {

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

GetOSVersion

fi

[ "$os_PACKAGE" = "deb" ]

}

# Git Functions

# =============

# Returns openstack release name for a given branch name

# ``get_release_name_from_branch branch-name``

function get_release_name_from_branch {

local branch=$1

if [[ $branch =~ "stable/" || $branch =~ "proposed/" ]]; then

echo ${branch#*/}

else

echo "master"

fi

}

# git clone only if directory doesn't exist already. Since ``DEST`` might not

# be owned by the installation user, we create the directory and change the

# ownership to the proper user.

# Set global ``RECLONE=yes`` to simulate a clone when dest-dir exists

# Set global ``ERROR_ON_CLONE=True`` to abort execution with an error if the git repo

# does not exist (default is False, meaning the repo will be cloned).

# Set global ``GIT_DEPTH=<number>`` to limit the history depth of the git clone

# Uses globals ``ERROR_ON_CLONE``, ``OFFLINE``, ``RECLONE``, ``GIT_DEPTH``

# git_clone remote dest-dir branch

function git_clone {

local git_remote=$1

local git_dest=$2

local git_ref=$3

local orig_dir=$(pwd)

local git_clone_flags=""

RECLONE=$(trueorfalse False $RECLONE)

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

git_clone_flags="$git_clone_flags --depth $GIT_DEPTH"

fi

if [[ "$OFFLINE" = "True" ]]; then

echo "Running in offline mode, clones already exist"

# print out the results so we know what change was used in the logs

cd $git_dest

git show --oneline | head -1

cd $orig_dir

return

fi

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" ]] && \

die $LINENO "Cloning not allowed in this configuration"

git_timed clone $git_clone_flags $git_remote $git_dest

fi

cd $git_dest

git_timed 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" ]] && \

die $LINENO "Cloning not allowed in this configuration"

git_timed clone $git_clone_flags $git_remote $git_dest

cd $git_dest

# This checkout syntax works for both branches and tags

git checkout $git_ref

elif [[ "$RECLONE" = "True" ]]; 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_timed 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

die $LINENO "$git_ref is neither branch nor tag"

fi

fi

fi

# print out the results so we know what change was used in the logs

cd $git_dest

git show --oneline | head -1

cd $orig_dir

}

# A variation on git clone that lets us specify a project by it's

# actual name, like oslo.config. This is exceptionally useful in the

# library installation case

function git_clone_by_name {

local name=$1

local repo=${GITREPO[$name]}

local dir=${GITDIR[$name]}

local branch=${GITBRANCH[$name]}

git_clone $repo $dir $branch

}

# git can sometimes get itself infinitely stuck with transient network

# errors or other issues with the remote end. This wraps git in a

# timeout/retry loop and is intended to watch over non-local git

# processes that might hang. GIT_TIMEOUT, if set, is passed directly

# to timeout(1); otherwise the default value of 0 maintains the status

# quo of waiting forever.

# usage: git_timed <git-command>

function git_timed {

local count=0

local timeout=0

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

timeout=${GIT_TIMEOUT}

fi

until timeout -s SIGINT ${timeout} git "$@"; do

# 124 is timeout(1)'s special return code when it reached the

# timeout; otherwise assume fatal failure

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

die $LINENO "git call failed: [git $@]"

fi

count=$(($count + 1))

warn "timeout ${count} for git call: [git $@]"

if [ $count -eq 3 ]; then

die $LINENO "Maximum of 3 git retries reached"

fi

sleep 5

done

}

# git update using reference as a branch.

# git_update_branch ref

function git_update_branch {

local 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

}

# git update using reference as a branch.

# git_update_remote_branch ref

function git_update_remote_branch {

local git_branch=$1

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

}

# git update using reference as a tag. Be careful editing source at that repo

# as working copy will be in a detached mode

# git_update_tag ref

function git_update_tag {

local git_tag=$1

git tag -d $git_tag

# fetching given tag only

git_timed fetch origin tag $git_tag

git checkout -f $git_tag

}

# OpenStack Functions

# ===================

# Get the default value for HOST_IP

# get_default_host_ip fixed_range floating_range host_ip_iface host_ip

function get_default_host_ip {

local fixed_range=$1

local floating_range=$2

local host_ip_iface=$3

local host_ip=$4

# Find the interface used for the default route

host_ip_iface=${host_ip_iface:-$(ip route | sed -n '/^default/{ s/.*dev \(\w\+\)\s\+.*/\1/; p; }' | head -1)}

# Search for an IP unless an explicit is set by ``HOST_IP`` environment variable

if [ -z "$host_ip" -o "$host_ip" == "dhcp" ]; then

host_ip=""

local host_ips=$(LC_ALL=C ip -f inet addr show ${host_ip_iface} | awk '/inet/ {split($2,parts,"/"); print parts[1]}')

local ip

for ip in $host_ips; do

# Attempt to filter out IP addresses that are part of the fixed and

# floating range. Note that this method only works if the ``netaddr``

# python library is installed. If it is not installed, an error

# will be printed and the first IP from the interface will be used.

# If that is not correct set ``HOST_IP`` in ``localrc`` to the correct

# address.

if ! (address_in_net $ip $fixed_range || address_in_net $ip $floating_range); then

host_ip=$ip

break;

fi

done

fi

echo $host_ip

}

# Generates hex string from ``size`` byte of pseudo random data

# generate_hex_string size

function generate_hex_string {

local size=$1

hexdump -n "$size" -v -e '/1 "%02x"' /dev/urandom

}

# Grab a numbered field from python prettytable output

# Fields are numbered starting with 1

# Reverse syntax is supported: -1 is the last field, -2 is second to last, etc.

# get_field field-number

function get_field {

local data 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

}

# Add a policy to a policy.json file

# Do nothing if the policy already exists

# ``policy_add policy_file policy_name policy_permissions``

function policy_add {

local policy_file=$1

local policy_name=$2

local policy_perm=$3

if grep -q ${policy_name} ${policy_file}; then

echo "Policy ${policy_name} already exists in ${policy_file}"

return

fi

# Add a terminating comma to policy lines without one

# Remove the closing '}' and all lines following to the end-of-file

local tmpfile=$(mktemp)

uniq ${policy_file} | sed -e '

s/]$/],/

/^[}]/,$d

' > ${tmpfile}

# Append policy and closing brace

echo " \"${policy_name}\": ${policy_perm}" >>${tmpfile}

echo "}" >>${tmpfile}

mv ${tmpfile} ${policy_file}

}

# Gets or creates a domain

# Usage: get_or_create_domain <name> <description>

function get_or_create_domain {

local os_url="$KEYSTONE_SERVICE_URI/v3"

# Gets domain id

local domain_id=$(

# Gets domain id

openstack --os-token=$OS_TOKEN --os-url=$os_url \

--os-identity-api-version=3 domain show $1 \

-f value -c id 2>/dev/null ||

# Creates new domain

openstack --os-token=$OS_TOKEN --os-url=$os_url \

--os-identity-api-version=3 domain create $1 \

--description "$2" \

-f value -c id

)

echo $domain_id

}

# Gets or creates user

# Usage: get_or_create_user <username> <password> <project> [<email> [<domain>]]

function get_or_create_user {

if [[ ! -z "$4" ]]; then

local email="--email=$4"

else

local email=""

fi

local os_cmd="openstack"

local domain=""

if [[ ! -z "$5" ]]; then

domain="--domain=$5"

os_cmd="$os_cmd --os-url=$KEYSTONE_SERVICE_URI/v3 --os-identity-api-version=3"

fi

# Gets user id

local user_id=$(

# Gets user id

$os_cmd user show $1 $domain -f value -c id 2>/dev/null ||

# Creates new user

$os_cmd user create \

$1 \

--password "$2" \

--project $3 \

$email \

$domain \

-f value -c id

)

echo $user_id

}

# Gets or creates project

# Usage: get_or_create_project <name> [<domain>]

function get_or_create_project {

# Gets project id

local os_cmd="openstack"

local domain=""

if [[ ! -z "$2" ]]; then

domain="--domain=$2"

os_cmd="$os_cmd --os-url=$KEYSTONE_SERVICE_URI/v3 --os-identity-api-version=3"

fi

local project_id=$(

# Gets project id

$os_cmd project show $1 $domain -f value -c id 2>/dev/null ||

# Creates new project if not exists

$os_cmd project create $1 $domain -f value -c id

)

echo $project_id

}

# Gets or creates role

# Usage: get_or_create_role <name>

function get_or_create_role {

local role_id=$(

# Gets role id

openstack role show $1 -f value -c id 2>/dev/null ||

# Creates role if not exists

openstack role create $1 -f value -c id

)

echo $role_id

}

# Gets or adds user role

# Usage: get_or_add_user_role <role> <user> <project>

function get_or_add_user_role {

# Gets user role id

local user_role_id=$(openstack user role list \

$2 \

--project $3 \

--column "ID" \

--column "Name" \

| grep " $1 " | get_field 1)

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

# Adds role to user

user_role_id=$(openstack role add \

$1 \

--user $2 \

--project $3 \

| grep " id " | get_field 2)

fi

echo $user_role_id

}

# Gets or creates service

# Usage: get_or_create_service <name> <type> <description>

function get_or_create_service {

# Gets service id

local service_id=$(

# Gets service id

openstack service show $1 -f value -c id 2>/dev/null ||

# Creates new service if not exists

openstack service create \

$1 \

--type=$2 \

--description="$3" \

-f value -c id

)

echo $service_id

}

# Gets or creates endpoint

# Usage: get_or_create_endpoint <service> <region> <publicurl> <adminurl> <internalurl>

function get_or_create_endpoint {

# Gets endpoint id

local endpoint_id=$(openstack endpoint list \

--column "ID" \

--column "Region" \

--column "Service Name" \

| grep " $2 " \

| grep " $1 " | get_field 1)

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

# Creates new endpoint

endpoint_id=$(openstack endpoint create \

$1 \

--region $2 \

--publicurl $3 \

--adminurl $4 \

--internalurl $5 \

| grep " id " | get_field 2)

fi

echo $endpoint_id

}

# Package Functions

# =================

# _get_package_dir

function _get_package_dir {

local pkg_dir

if is_ubuntu; then

pkg_dir=$FILES/apts

elif is_fedora; then

pkg_dir=$FILES/rpms

elif is_suse; then

pkg_dir=$FILES/rpms-suse

else

exit_distro_not_supported "list of packages"

fi

echo "$pkg_dir"

}

# Wrapper for ``apt-get`` to set cache and proxy environment variables

# Uses globals ``OFFLINE``, ``*_proxy``

# apt_get operation package [package ...]

function apt_get {

local xtrace=$(set +o | grep xtrace)

set +o xtrace

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

local sudo="sudo"

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

$xtrace

$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 "$@"

}

# get_packages() collects a list of package names of any type from the

# prerequisite files in ``files/{apts|rpms}``. The list is intended

# to be passed to a package installer such as apt or yum.

#

# Only packages required for the services in 1st argument will be

# included. Two bits of metadata are recognized in the prerequisite files:

#

# - ``# NOPRIME`` defers installation to be performed later in `stack.sh`

# - ``# dist:DISTRO`` or ``dist:DISTRO1,DISTRO2`` limits the selection

# of the package to the distros listed. The distro names are case insensitive.

function get_packages {

local xtrace=$(set +o | grep xtrace)

set +o xtrace

local services=$@

local package_dir=$(_get_package_dir)

local file_to_parse

local service

INSTALL_TESTONLY_PACKAGES=$(trueorfalse False $INSTALL_TESTONLY_PACKAGES)

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

echo "No package directory supplied"

return 1

fi