local tag=${1:-""}

# Save some values we generated for later use

time_stamp=$(date "+$TIMESTAMP_FORMAT")

echo "# $time_stamp $tag" >$TOP_DIR/.stackenv

for i in $STACK_ENV_VARS; do

echo $i=${!i} >>$TOP_DIR/.stackenv

done

local clouds_yaml

sudo mkdir -p /etc/openstack

sudo chown -R $STACK_USER /etc/openstack

# XXX: to be removed, see https://review.openstack.org/237149/

# careful not to sudo this, incase ~ is NFS mounted

mkdir -p ~/.config/openstack

for clouds_path in /etc/openstack ~/.config/openstack ; do

clouds_yaml=$clouds_path/clouds.yaml

CA_CERT_ARG=''

if [ -f "$SSL_BUNDLE_FILE" ]; then

CA_CERT_ARG="--os-cacert $SSL_BUNDLE_FILE"

fi

$TOP_DIR/tools/update_clouds_yaml.py \

--file $clouds_yaml \

--os-cloud devstack \

--os-region-name $REGION_NAME \

--os-identity-api-version 3 \

$CA_CERT_ARG \

--os-auth-url $KEYSTONE_AUTH_URI \

--os-username demo \

--os-password $ADMIN_PASSWORD \

--os-project-name demo

$TOP_DIR/tools/update_clouds_yaml.py \

--file $clouds_yaml \

--os-cloud devstack-admin \

--os-region-name $REGION_NAME \

--os-identity-api-version 3 \

$CA_CERT_ARG \

--os-auth-url $KEYSTONE_AUTH_URI \

--os-username admin \

--os-password $ADMIN_PASSWORD \

--os-project-name admin

done

local xtrace

xtrace=$(set +o | grep xtrace)

set +o xtrace

local default=$1

if [ -z $2 ]; then

die $LINENO "variable to normalize required"

fi

local testval=${!2:-}

case "$testval" in

"1" | [yY]es | "YES" | [tT]rue | "TRUE" ) echo "True" ;;

"0" | [nN]o | "NO" | [fF]alse | "FALSE" ) echo "False" ;;

* ) echo "$default" ;;

esac

$xtrace

local level=$1

local deep

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

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

local exitcode=$?

local xtrace

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

local text=$1

DEPRECATED_TEXT+="\n$text"

echo "WARNING: $text"

local exitcode=$?

local xtrace

xtrace=$(set +o | grep xtrace)

set +o xtrace

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

echo $msg 1>&2;

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

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

fi

$xtrace

return $exitcode

local exitcode=$?

local xtrace

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

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

local exitcode=$?

local xtrace

xtrace=$(set +o | grep xtrace)

set +o xtrace

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

echo $msg

$xtrace

return $exitcode

# 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)

# Oracle Linux release 7

# CloudLinux release 7.1

os_CODENAME=""

for r in "Red Hat" CentOS Fedora XenServer CloudLinux; 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

if [ "$os_VENDOR" = "Red Hat" ] && [[ -r /etc/oracle-release ]]; then

os_VENDOR=OracleLinux

fi

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

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" =~ (OracleLinux) ]]; 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

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

GetOSVersion

fi

[ "$os_VENDOR" = "OracleLinux" ]

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

GetOSVersion

fi

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

[ "$os_VENDOR" = "CentOS" ] || [ "$os_VENDOR" = "OracleLinux" ] || \

[ "$os_VENDOR" = "CloudLinux" ]

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

GetOSVersion

fi

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

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

GetOSVersion

fi

[ "$os_PACKAGE" = "deb" ]

local branch=$1

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

echo ${branch#*/}

else

echo "master"

fi

local git_remote=$1

local git_dest=$2

local git_ref=$3

local orig_dir

orig_dir=$(pwd)

local git_clone_flags=""

RECLONE=$(trueorfalse False RECLONE)

if [[ "${GIT_DEPTH}" -gt 0 ]]; 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

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

echo "The $git_dest project was not found; if this is a gate job, add"

echo "the project to the \$PROJECTS variable in the job definition."

die $LINENO "Cloning not allowed in this configuration"

fi

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

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

echo "The $git_dest project was not found; if this is a gate job, add"

echo "the project to the \$PROJECTS variable in the job definition."

die $LINENO "Cloning not allowed in this configuration"

fi

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

local name=$1

local repo=${GITREPO[$name]}

local dir=${GITDIR[$name]}

local branch=${GITBRANCH[$name]}

git_clone $repo $dir $branch

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 $LINENO "timeout ${count} for git call: [git $@]"

if [ $count -eq 3 ]; then

die $LINENO "Maximum of 3 git retries reached"

fi

sleep 5

done

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

local git_branch=$1

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

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

local fixed_range=$1

local floating_range=$2

local host_ip_iface=$3

local host_ip=$4

local af=$5

# 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=""

# Find the interface used for the default route

host_ip_iface=${host_ip_iface:-$(ip -f $af route | awk '/default/ {print $5}' | head -1)}

local host_ips

host_ips=$(LC_ALL=C ip -f $af addr show ${host_ip_iface} | sed /temporary/d |awk /$af'/ {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 [[ "$af" == "inet6" ]]; then

host_ip=$ip

break;

fi

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

host_ip=$ip

break;

fi

done

fi

echo $host_ip

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

local project=$1

local project_uc

project_uc=$(echo $1|tr a-z A-Z)

local conf_dir="${project_uc}_CONF_DIR"

# eval conf dir to get the variable

conf_dir="${!conf_dir}"

local project_dir="${project_uc}_DIR"

# eval project dir to get the variable

project_dir="${!project_dir}"

local sample_conf_dir="${project_dir}/etc/${project}"

local sample_policy_dir="${project_dir}/etc/${project}/policy.d"

# first copy any policy.json

cp -p $sample_conf_dir/policy.json $conf_dir

# then optionally copy over policy.d

if [[ -d $sample_policy_dir ]]; then

cp -r $sample_policy_dir $conf_dir/policy.d

fi

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

tmpfile=$(mktemp)

uniq ${policy_file} | sed -e '

' > ${tmpfile}

# Append policy and closing brace

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

echo "}" >>${tmpfile}

mv ${tmpfile} ${policy_file}

local domain_id

# Gets domain id

domain_id=$(

echo $domain_id

local desc="${3:-}"

local group_id

# Gets group id

group_id=$(

echo $group_id

local user_id

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

local email="--email=$4"

else

local email=""

fi

# Gets user id

user_id=$(

echo $user_id

local project_id

project_id=$(

echo $project_id

local role_id

role_id=$(

echo $role_id

local user_role_id

# Gets user role id

user_role_id=$(openstack role list \

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

# Adds role to user and get it

openstack role add $1 \

--user $2 \

--project $3

user_role_id=$(openstack role list \

fi

echo $user_role_id

local group_role_id

# Gets group role id

group_role_id=$(openstack role list \

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

# Adds role to group and get it

openstack role add $1 \

--group $2 \

--project $3

group_role_id=$(openstack role list \

fi

echo $group_role_id

local service_id

# Gets service id

service_id=$(

echo $service_id

local endpoint_id

# TODO(dgonzalez): The check of the region name, as done in the grep

# statement below, exists only because keystone does currently

# not allow filtering the region name when listing endpoints. If keystone

# gets support for this, the check for the region name can be removed.

# Related bug in keystone: https://bugs.launchpad.net/keystone/+bug/1482772

endpoint_id=$(openstack endpoint list \

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

# Creates new endpoint

endpoint_id=$(openstack endpoint create \

fi

echo $endpoint_id

# NOTE(jamielennnox): when converting to v3 endpoint creation we go from

# creating one endpoint with multiple urls to multiple endpoints each with

# a different interface. To maintain the existing function interface we

# create 3 endpoints and return the id of the public one. In reality

# returning the public id will not make a lot of difference as there are no

# scenarios currently that use the returned id. Ideally this behaviour

# should be pushed out to the service setups and let them create the

# endpoints they need.

local public_id

public_id=$(_get_or_create_endpoint_with_interface $1 public $3 $2)

_get_or_create_endpoint_with_interface $1 admin $4 $2

_get_or_create_endpoint_with_interface $1 internal $5 $2

# return the public id to indicate success, and this is the endpoint most likely wanted

echo $public_id

echo $(openstack endpoint list \

local base_dir=$1

local pkg_dir

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

base_dir=$FILES

fi

if is_ubuntu; then

pkg_dir=$base_dir/debs

elif is_fedora; then

pkg_dir=$base_dir/rpms

elif is_suse; then

pkg_dir=$base_dir/rpms-suse

else

exit_distro_not_supported "list of packages"

fi

echo "$pkg_dir"

local xtrace

xtrace=$(set +o | grep xtrace)

set +o xtrace

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

local sudo="sudo"

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