# functions - Common functions used by DevStack components

#

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

# ``ENABLED_SERVICES``

# ``EROR_ON_CLONE``

# ``FILES``

# ``GLANCE_HOSTPORT``

# ``OFFLINE``

# ``PIP_DOWNLOAD_CACHE``

# ``PIP_USE_MIRRORS``

# ``RECLONE``

# ``TRACK_DEPENDS``

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

# Save trace setting

XTRACE=$(set +o | grep xtrace)

set +o xtrace

# Exit 0 if address is in network or 1 if address is not in

# network or netaddr library is not installed.

# address_in_net ip-address ip-range

function address_in_net() {

python -c "

import netaddr

import sys

sys.exit(netaddr.IPAddress('$1') not in netaddr.IPNetwork('$2'))

"

}

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

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

# apt_get operation package [package ...]

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

}

# Gracefully cp only if source file/dir exists

# cp_it source destination

function cp_it {

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

cp -pRL $1 $2

fi

}

# 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

err $line "$*"

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=$?

FXTRACE=$(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

$FXTRACE

}

# Prints line number and "message" in error format

# err $LINENO "message"

function err() {

local exitcode=$?

errXTRACE=$(set +o | grep xtrace)

set +o xtrace

local msg="[ERROR] $0:$1 $2"

echo $msg 1>&2;

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

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

fi

$errXTRACE

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=$?

errinsXTRACE=$(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

$errinsXTRACE

return $exitcode

}

# HTTP and HTTPS proxy servers are supported via the usual environment variables [1]

# ``http_proxy``, ``https_proxy`` and ``no_proxy``. They can be set in

# ``localrc`` or on the command line if necessary::

#

# [1] http://www.w3.org/Daemon/User/Proxies/ProxyClients.html

#

# http_proxy=http://proxy.example.com:3128/ no_proxy=repo.example.net ./stack.sh

function export_proxy_variables() {

if [[ -n "$http_proxy" ]]; then

export http_proxy=$http_proxy

fi

if [[ -n "$https_proxy" ]]; then

export https_proxy=$https_proxy

fi

if [[ -n "$no_proxy" ]]; then

export no_proxy=$no_proxy

fi

}

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

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

}

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

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

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

}

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"

}

# 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 services=$1

local package_dir=$(_get_package_dir)

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 ${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 == s-* ]]; then

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

file_to_parse="${file_to_parse} swift"

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 =~ neutron ]]; then

file_to_parse="${file_to_parse} neutron"

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

}

# Determine OS Vendor, Release and Update

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

# Returns results in global variables:

# os_VENDOR - vendor name

# os_RELEASE - release

# os_UPDATE - update

# os_PACKAGE - package type

# os_CODENAME - vendor's codename for release

# GetOSVersion

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

# 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 [[ -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 ``DISTRO`` from the ``os_*`` values

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) ]]; then

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

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

else

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

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

fi

export DISTRO

}

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

}

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

}

# 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

}

# Utility function for checking machine architecture

# is_arch arch-type

function is_arch {

ARCH_TYPE=$1

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

}

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

# Uses global ``OFFLINE``

# git_clone remote dest-dir branch

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

}

# git update using reference as a branch.

# git_update_branch ref

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

}

# git update using reference as a branch.

# git_update_remote_branch ref

function git_update_remote_branch() {

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() {

GIT_TAG=$1

git tag -d $GIT_TAG

# fetching given tag only

git fetch origin tag $GIT_TAG

git checkout -f $GIT_TAG

}

# Comment an option in an INI file

# inicomment config-file section option

function inicomment() {

local file=$1

local section=$2

local option=$3

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

}

# Uncomment an option in an INI file

# iniuncomment config-file section option

function iniuncomment() {

local file=$1

local section=$2

local option=$3

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

}

# Get an option from an INI file

# iniget config-file section option

function iniget() {

local file=$1

local section=$2

local option=$3

local line

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

echo ${line#*=}

}

# Determinate is the given option present in the INI file

# ini_has_option config-file section option

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

}

# Set an option in an INI file

# iniset config-file section option value

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\\

$option = $value

" "$file"

else

# Replace it

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

fi

}

# Get a multiple line option from an INI file

# iniget_multiline config-file section option

function iniget_multiline() {

local file=$1

local section=$2

local option=$3

local values

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

echo ${values}

}

# Set a multiple line option in an INI file

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

function iniset_multiline() {

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

}

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

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

function iniadd() {

local file=$1

local section=$2

local option=$3

shift 3

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

iniset_multiline $file $section $option $values

}

# Find out if a process exists by partial name.

# is_running name

function is_running() {

local name=$1

ps auxw | grep -v grep | grep ${name} > /dev/null

RC=$?

# some times I really hate bash reverse binary logic

return $RC

}

# is_service_enabled() checks if the service(s) specified as arguments are

# enabled by the user in ``ENABLED_SERVICES``.

#

# Multiple services specified as arguments are ``OR``'ed together; the test

# is a short-circuit boolean, i.e it returns on the first match.

#

# There are special cases for some 'catch-all' services::

# **nova** returns true if any service enabled start with **n-**

# **cinder** returns true if any service enabled start with **c-**

# **ceilometer** returns true if any service enabled start with **ceilometer**

# **glance** returns true if any service enabled start with **g-**

# **neutron** returns true if any service enabled start with **q-**

# **swift** returns true if any service enabled start with **s-**

# For backward compatibility if we have **swift** in ENABLED_SERVICES all the

# **s-** services will be enabled. This will be deprecated in the future.

#

# Uses global ``ENABLED_SERVICES``

# is_service_enabled service [service ...]

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} == "neutron" && ${ENABLED_SERVICES} =~ "q-" ]] && return 0

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

[[ ${service} == s-* && ${ENABLED_SERVICES} =~ "swift" ]] && return 0

done

return 1

}

# remove extra commas from the input string (i.e. ``ENABLED_SERVICES``)

# _cleanup_service_list service-list

function _cleanup_service_list () {

echo "$1" | sed -e '

s/,,/,/g;

s/^,//;

s/,$//

'

}

# enable_service() adds the services passed as argument to the

# ``ENABLED_SERVICES`` list, if they are not already present.

#

# For example:

# enable_service qpid

#

# This function does not know about the special cases

# for nova, glance, and neutron built into is_service_enabled().

# Uses global ``ENABLED_SERVICES``

# enable_service service [service ...]

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

}

# disable_service() removes the services passed as argument to the

# ``ENABLED_SERVICES`` list, if they are present.

#

# For example:

# disable_service rabbit

#

# This function does not know about the special cases

# for nova, glance, and neutron built into is_service_enabled().

# Uses global ``ENABLED_SERVICES``

# disable_service service [service ...]

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

}

# disable_all_services() removes all current services

# from ``ENABLED_SERVICES`` to reset the configuration

# before a minimal installation

# Uses global ``ENABLED_SERVICES``

# disable_all_services

function disable_all_services() {

ENABLED_SERVICES=""

}

# Remove all services starting with '-'. For example, to install all default

# services except rabbit (rabbit) set in ``localrc``:

# ENABLED_SERVICES+=",-rabbit"

# Uses global ``ENABLED_SERVICES``

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

}

# Distro-agnostic package installer

# install_package package [package ...]

function install_package() {

if is_ubuntu; then

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

NO_UPDATE_REPOS=True

apt_get install "$@"

elif is_fedora; then

yum_install "$@"

elif is_suse; then

zypper_install "$@"

else

exit_distro_not_supported "installing packages"

fi

}

# Distro-agnostic package uninstaller

# uninstall_package package [package ...]

function uninstall_package() {

if is_ubuntu; then

apt_get purge "$@"

elif is_fedora; then

sudo yum remove -y "$@"

elif is_suse; then

sudo rpm -e "$@"

else

exit_distro_not_supported "uninstalling packages"

fi

}

# Distro-agnostic function to tell if a package is installed

# is_package_installed package [package ...]

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

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

rpm --quiet -q "$@"

else

exit_distro_not_supported "finding if a package is installed"

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

}

# Wrapper for ``pip install`` to set cache and proxy environment variables

# Uses globals ``OFFLINE``, ``PIP_DOWNLOAD_CACHE``, ``PIP_USE_MIRRORS``,

# ``TRACK_DEPENDS``, ``*_proxy`

# pip_install package [package ...]

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 [[ is_fedora && $DISTRO =~ (rhel6) ]]; then

# RHEL6 pip by default doesn't have this (was introduced

# around 0.8.1 or so)

PIP_USE_MIRRORS=${PIP_USE_MIRRORS:-False}

else

PIP_USE_MIRRORS=${PIP_USE_MIRRORS:-True}

fi

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

PIP_MIRROR_OPT="--use-mirrors"

fi

# pip < 1.4 has a bug where it will use an already existing build

# directory unconditionally. Say an earlier component installs

# foo v1.1; pip will have built foo's source in

# /tmp/$USER-pip-build. Even if a later component specifies foo <

# 1.1, the existing extracted build will be used and cause

# confusing errors. By creating unique build directories we avoid

# this problem. See

# https://github.com/pypa/pip/issues/709

local pip_build_tmp=$(mktemp --tmpdir -d pip-build.XXXXX)

$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 --build=${pip_build_tmp} \

$PIP_MIRROR_OPT $@ \

&& $SUDO_PIP rm -rf ${pip_build_tmp}

}

# Cleanup anything from /tmp on unstack

# clean_tmp

function cleanup_tmp {

local tmp_dir=${TMPDIR:-/tmp}

# see comments in pip_install

sudo rm -rf ${tmp_dir}/pip-build.*

}

# Service wrapper to restart services

# restart_service service-name

function restart_service() {

if is_ubuntu; then

sudo /usr/sbin/service $1 restart

else

sudo /sbin/service $1 restart

fi

}

# _run_process() is designed to be backgrounded by run_process() to simulate a

# fork. It includes the dirty work of closing extra filehandles and preparing log

# files to produce the same logs as screen_it(). The log filename is derived

# from the service name and global-and-now-misnamed SCREEN_LOGDIR

# _run_process service "command-line"

function _run_process() {

local service=$1

local command="$2"

# Undo logging redirections and close the extra descriptors

exec 1>&3

exec 2>&3

exec 3>&-

exec 6>&-

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

exec 1>&${SCREEN_LOGDIR}/screen-${1}.${CURRENT_LOG_TIME}.log 2>&1

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

# TODO(dtroyer): Hack to get stdout from the Python interpreter for the logs.

export PYTHONUNBUFFERED=1

fi

exec /bin/bash -c "$command"

die "$service exec failure: $command"

}

# run_process() launches a child process that closes all file descriptors and

# then exec's the passed in command. This is meant to duplicate the semantics

# of screen_it() without screen. PIDs are written to

# $SERVICE_DIR/$SCREEN_NAME/$service.pid

# run_process service "command-line"

function run_process() {

local service=$1

local command="$2"

# Spawn the child process

_run_process "$service" "$command" &

echo $!

}

# Helper to launch a service in a named screen

# screen_it service "command-line"