unset GREP_OPTIONS

TOP_DIR=$(cd $(dirname "$0") && pwd)

source $TOP_DIR/functions

GetDistro

if [[ ! -r $TOP_DIR/stackrc ]]; then

log_error $LINENO "missing $TOP_DIR/stackrc - did you grab more than just stack.sh?"

source $TOP_DIR/stackrc

export_proxy_variables

DEST=${DEST:-/opt/stack}

if [[ -r $TOP_DIR/.stackenv ]]; then

rm $TOP_DIR/.stackenv

FILES=$TOP_DIR/files

if [ ! -d $FILES ]; then

log_error $LINENO "missing devstack/files"

if [ ! -d $TOP_DIR/lib ]; then

log_error $LINENO "missing devstack/lib"

source $TOP_DIR/lib/database

source $TOP_DIR/lib/rpc_backend

disable_negated_services

if [[ ! ${DISTRO} =~ (oneiric|precise|quantal|raring|saucy|7.0|wheezy|sid|testing|jessie|f16|f17|f18|f19|opensuse-12.2|rhel6) ]]; then

echo "WARNING: this script has not been tested on $DISTRO"

if [[ "$FORCE" != "yes" ]]; then

die $LINENO "If you wish to run this script anyway run with FORCE=yes"

fi

check_rpc_backend

if type -p screen >/dev/null && screen -ls | egrep -q "[0-9].$SCREEN_NAME"; then

echo "You are already running a stack.sh session."

echo "To rejoin this session type 'screen -x stack'."

echo "To destroy this session, type './unstack.sh'."

exit 1

VERBOSE=$(trueorfalse True $VERBOSE)

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

echo 'deb http://archive.gplhost.com/debian grizzly main' | sudo tee /etc/apt/sources.list.d/gplhost_wheezy-backports.list

echo 'deb http://archive.gplhost.com/debian grizzly-backports main' | sudo tee -a /etc/apt/sources.list.d/gplhost_wheezy-backports.list

apt_get update

apt_get install --force-yes gplhost-archive-keyring

if [[ is_fedora && $DISTRO =~ (rhel6) ]]; then

# Installing Open vSwitch on RHEL6 requires enabling the RDO repo.

RHEL6_RDO_REPO_RPM=${RHEL6_RDO_REPO_RPM:-"http://rdo.fedorapeople.org/openstack/openstack-grizzly/rdo-release-grizzly-3.noarch.rpm"}

RHEL6_RDO_REPO_ID=${RHEL6_RDO_REPO_ID:-"openstack-grizzly"}

if ! yum repolist enabled $RHEL6_RDO_REPO_ID | grep -q $RHEL6_RDO_REPO_ID; then

echo "RDO repo not detected; installing"

yum_install $RHEL6_RDO_REPO_RPM || \

die $LINENO "Error installing RDO repo, cannot continue"

fi

# RHEL6 requires EPEL for many Open Stack dependencies

RHEL6_EPEL_RPM=${RHEL6_EPEL_RPM:-"http://dl.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm"}

if ! yum repolist enabled epel | grep -q 'epel'; then

echo "EPEL not detected; installing"

yum_install ${RHEL6_EPEL_RPM} || \

die $LINENO "Error installing EPEL repo, cannot continue"

fi

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

ROOTSLEEP=${ROOTSLEEP:-10}

echo "You are running this script as root."

echo "In $ROOTSLEEP seconds, we will create a user '$STACK_USER' and run as that user"

sleep $ROOTSLEEP

# Give the non-root user the ability to run as **root** via ``sudo``

is_package_installed sudo || install_package sudo

if ! getent group $STACK_USER >/dev/null; then

echo "Creating a group called $STACK_USER"

groupadd $STACK_USER

fi

if ! getent passwd $STACK_USER >/dev/null; then

echo "Creating a user called $STACK_USER"

useradd -g $STACK_USER -s /bin/bash -d $DEST -m $STACK_USER

fi

echo "Giving stack user passwordless sudo privileges"

# UEC images ``/etc/sudoers`` does not have a ``#includedir``, add one

grep -q "^#includedir.*/etc/sudoers.d" /etc/sudoers ||

echo "#includedir /etc/sudoers.d" >> /etc/sudoers

( umask 226 && echo "$STACK_USER ALL=(ALL) NOPASSWD:ALL" \

> /etc/sudoers.d/50_stack_sh )

echo "Copying files to $STACK_USER user"

STACK_DIR="$DEST/${TOP_DIR##*/}"

cp -r -f -T "$TOP_DIR" "$STACK_DIR"

chown -R $STACK_USER "$STACK_DIR"

cd "$STACK_DIR"

if [[ "$SHELL_AFTER_RUN" != "no" ]]; then

exec sudo -u $STACK_USER bash -l -c "set -e; bash stack.sh; bash"

else

exec sudo -u $STACK_USER bash -l -c "set -e; source stack.sh"

fi

exit 1

# We're not **root**, make sure ``sudo`` is available

is_package_installed sudo || die "Sudo is required. Re-run stack.sh as root ONE TIME ONLY to set up sudo."

# UEC images ``/etc/sudoers`` does not have a ``#includedir``, add one

sudo grep -q "^#includedir.*/etc/sudoers.d" /etc/sudoers ||

echo "#includedir /etc/sudoers.d" | sudo tee -a /etc/sudoers

# Set up devstack sudoers

TEMPFILE=`mktemp`

echo "$STACK_USER ALL=(root) NOPASSWD:ALL" >$TEMPFILE

# Some binaries might be under /sbin or /usr/sbin, so make sure sudo will

# see them by forcing PATH

echo "Defaults:$STACK_USER secure_path=/sbin:/usr/sbin:/usr/bin:/bin:/usr/local/sbin:/usr/local/bin" >> $TEMPFILE

chmod 0440 $TEMPFILE

sudo chown root:root $TEMPFILE

sudo mv $TEMPFILE /etc/sudoers.d/50_stack_sh

# Remove old file

sudo rm -f /etc/sudoers.d/stack_sh_nova

sudo mkdir -p $DEST

sudo chown -R $STACK_USER $DEST

check_path_perm_sanity ${DEST}

OFFLINE=`trueorfalse False $OFFLINE`

ERROR_ON_CLONE=`trueorfalse False $ERROR_ON_CLONE`

DATA_DIR=${DATA_DIR:-${DEST}/data}

sudo mkdir -p $DATA_DIR

sudo chown -R $STACK_USER $DATA_DIR

FLOATING_RANGE=${FLOATING_RANGE:-172.24.4.224/28}

FIXED_RANGE=${FIXED_RANGE:-10.0.0.0/24}

FIXED_NETWORK_SIZE=${FIXED_NETWORK_SIZE:-256}

HOST_IP=$(get_default_host_ip $FIXED_RANGE $FLOATING_RANGE "$HOST_IP_IFACE" "$HOST_IP")

if [ "$HOST_IP" == "" ]; then

die $LINENO "Could not determine host ip address. Either localrc specified dhcp on ${HOST_IP_IFACE} or defaulted"

SERVICE_HOST=${SERVICE_HOST:-$HOST_IP}

SERVICE_PROTOCOL=${SERVICE_PROTOCOL:-http}

SYSLOG=`trueorfalse False $SYSLOG`

SYSLOG_HOST=${SYSLOG_HOST:-$HOST_IP}

SYSLOG_PORT=${SYSLOG_PORT:-516}

SYSSTAT_FILE=${SYSSTAT_FILE:-"sysstat.dat"}

SYSSTAT_INTERVAL=${SYSSTAT_INTERVAL:-"1"}

LOG_COLOR=`trueorfalse True $LOG_COLOR`

SERVICE_TIMEOUT=${SERVICE_TIMEOUT:-60}

source $TOP_DIR/lib/tls

source $TOP_DIR/lib/infra

source $TOP_DIR/lib/oslo

source $TOP_DIR/lib/horizon

source $TOP_DIR/lib/keystone

source $TOP_DIR/lib/glance

source $TOP_DIR/lib/nova

source $TOP_DIR/lib/cinder

source $TOP_DIR/lib/swift

source $TOP_DIR/lib/ceilometer

source $TOP_DIR/lib/heat

source $TOP_DIR/lib/neutron

source $TOP_DIR/lib/baremetal

source $TOP_DIR/lib/ldap

OPENSTACKCLIENT_DIR=$DEST/python-openstackclient

function read_password {

}

initialize_database_backends && echo "Using $DATABASE_TYPE database backend" || echo "No database enabled"

if is_service_enabled rabbit; then

RABBIT_HOST=${RABBIT_HOST:-localhost}

read_password RABBIT_PASSWORD "ENTER A PASSWORD TO USE FOR RABBIT."

if is_service_enabled key; then

# The ``SERVICE_TOKEN`` is used to bootstrap the Keystone database. It is

# just a string and is not a 'real' Keystone token.

read_password SERVICE_TOKEN "ENTER A SERVICE_TOKEN TO USE FOR THE SERVICE ADMIN TOKEN."

# Services authenticate to Identity with servicename/``SERVICE_PASSWORD``

read_password SERVICE_PASSWORD "ENTER A SERVICE_PASSWORD TO USE FOR THE SERVICE AUTHENTICATION."

# Horizon currently truncates usernames and passwords at 20 characters

read_password ADMIN_PASSWORD "ENTER A PASSWORD TO USE FOR HORIZON AND KEYSTONE (20 CHARS OR LESS)."

# Keystone can now optionally install OpenLDAP by enabling the ``ldap``

# service in ``localrc`` (e.g. ``enable_service ldap``).

# To clean out the Keystone contents in OpenLDAP set ``KEYSTONE_CLEAR_LDAP``

# to ``yes`` (e.g. ``KEYSTONE_CLEAR_LDAP=yes``) in ``localrc``. To enable the

# Keystone Identity Driver (``keystone.identity.backends.ldap.Identity``)

# set ``KEYSTONE_IDENTITY_BACKEND`` to ``ldap`` (e.g.

# ``KEYSTONE_IDENTITY_BACKEND=ldap``) in ``localrc``.

# only request ldap password if the service is enabled

if is_service_enabled ldap; then

read_password LDAP_PASSWORD "ENTER A PASSWORD TO USE FOR LDAP"

fi

if is_service_enabled s-proxy; then

# We only ask for Swift Hash if we have enabled swift service.

# ``SWIFT_HASH`` is a random unique string for a swift cluster that

# can never change.

read_password SWIFT_HASH "ENTER A RANDOM SWIFT HASH."

function spinner() {

}

function echo_summary() {

}

function echo_nolog() {

echo $@ >&3

}

TIMESTAMP_FORMAT=${TIMESTAMP_FORMAT:-"%F-%H%M%S"}

if [[ -n "$LOGFILE" || -n "$SCREEN_LOGDIR" ]]; then

LOGDAYS=${LOGDAYS:-7}

CURRENT_LOG_TIME=$(date "+$TIMESTAMP_FORMAT")

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

# First clean up old log files. Use the user-specified ``LOGFILE``

# as the template to search for, appending '.*' to match the date

# we added on earlier runs.

LOGDIR=$(dirname "$LOGFILE")

LOGFILENAME=$(basename "$LOGFILE")

mkdir -p $LOGDIR

find $LOGDIR -maxdepth 1 -name $LOGFILENAME.\* -mtime +$LOGDAYS -exec rm {} \;

LOGFILE=$LOGFILE.${CURRENT_LOG_TIME}

SUMFILE=$LOGFILE.${CURRENT_LOG_TIME}.summary

# Redirect output according to config

# Copy stdout to fd 3

exec 3>&1

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

# Redirect stdout/stderr to tee to write the log file

exec 1> >( awk '

}' | tee "${LOGFILE}" ) 2>&1

# Set up a second fd for output

exec 6> >( tee "${SUMFILE}" )

else

# Set fd 1 and 2 to primary logfile

exec 1> "${LOGFILE}" 2>&1

# Set fd 6 to summary logfile and stdout

exec 6> >( tee "${SUMFILE}" /dev/fd/3 )

fi

echo_summary "stack.sh log $LOGFILE"

# Specified logfile name always links to the most recent log

ln -sf $LOGFILE $LOGDIR/$LOGFILENAME

ln -sf $SUMFILE $LOGDIR/$LOGFILENAME.summary

# Set up output redirection without log files

# Copy stdout to fd 3

exec 3>&1

if [[ "$VERBOSE" != "True" ]]; then

# Throw away stdout and stderr

exec 1>/dev/null 2>&1

fi

# Always send summary fd to original stdout

exec 6>&3

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

# We make sure the directory is created.

if [[ -d "$SCREEN_LOGDIR" ]]; then

# We cleanup the old logs

find $SCREEN_LOGDIR -maxdepth 1 -name screen-\*.log -mtime +$LOGDAYS -exec rm {} \;

else

mkdir -p $SCREEN_LOGDIR

fi

trap clean EXIT

clean() {

}

trap failed ERR

failed() {

}

set -o xtrace

echo_summary "Installing package prerequisites"

source $TOP_DIR/tools/install_prereqs.sh

install_rpc_backend

if is_service_enabled $DATABASE_BACKENDS; then

install_database

if is_service_enabled neutron; then

install_neutron_agent_packages

unfubar_setuptools

if [[ is_fedora && $DISTRO =~ (rhel6) ]]; then

# Disable selinux to avoid configuring to allow Apache access

# to Horizon files or run nodejs (LP#1175444)

if selinuxenabled; then

sudo setenforce 0

fi

# An old version of ``python-crypto`` (2.0.1) may be installed on a

# fresh system via Anaconda and the dependency chain

# ``cas`` -> ``python-paramiko`` -> ``python-crypto``.

# ``pip uninstall pycrypto`` will remove the packaged ``.egg-info`` file

# but leave most of the actual library files behind in ``/usr/lib64/python2.6/Crypto``.

# Later ``pip install pycrypto`` will install over the packaged files resulting

# in a useless mess of old, rpm-packaged files and pip-installed files.

# Remove the package so that ``pip install python-crypto`` installs cleanly.

# Note: other RPM packages may require ``python-crypto`` as well. For example,

# RHEL6 does not install ``python-paramiko packages``.

uninstall_package python-crypto

# A similar situation occurs with ``python-lxml``, which is required by

# ``ipa-client``, an auditing package we don't care about. The

# build-dependencies needed for ``pip install lxml`` (``gcc``,

# ``libxml2-dev`` and ``libxslt-dev``) are present in ``files/rpms/general``.

uninstall_package python-lxml

# If the ``dbus`` package was installed by DevStack dependencies the

# uuid may not be generated because the service was never started (PR#598200),

# causing Nova to stop later on complaining that ``/var/lib/dbus/machine-id``

# does not exist.

sudo service messagebus restart

# ``setup.py`` contains a ``setup_requires`` package that is supposed

# to be transient. However, RHEL6 distribute has a bug where

# ``setup_requires`` registers entry points that are not cleaned

# out properly after the setup-phase resulting in installation failures

# (bz#924038). Pre-install the problem package so the ``setup_requires``

# dependency is satisfied and it will not be installed transiently.

# Note we do this before the track-depends below.

pip_install hgtools

# RHEL6's version of ``python-nose`` is incompatible with Tempest.

# Install nose 1.1 (Tempest-compatible) from EPEL

install_package python-nose1.1

# Add a symlink for the new nosetests to allow tox for Tempest to

# work unmolested.

sudo ln -sf /usr/bin/nosetests1.1 /usr/local/bin/nosetests

TRACK_DEPENDS=${TRACK_DEPENDS:-False}

if [[ $TRACK_DEPENDS = True ]]; then

echo_summary "Installing Python packages into a virtualenv $DEST/.venv"

install_package python-virtualenv

rm -rf $DEST/.venv

virtualenv --system-site-packages $DEST/.venv

source $DEST/.venv/bin/activate

$DEST/.venv/bin/pip freeze > $DEST/requires-pre-pip

echo_summary "Installing OpenStack project source"

install_infra

install_oslo

install_keystoneclient

install_glanceclient

install_cinderclient

install_novaclient

if is_service_enabled swift glance horizon; then

install_swiftclient

if is_service_enabled neutron nova horizon; then

install_neutronclient

if is_service_enabled heat horizon; then

install_heatclient

git_clone $OPENSTACKCLIENT_REPO $OPENSTACKCLIENT_DIR $OPENSTACKCLIENT_BRANCH

setup_develop $OPENSTACKCLIENT_DIR

if is_service_enabled key; then

install_keystone

configure_keystone

if is_service_enabled s-proxy; then

install_swift

configure_swift

# swift3 middleware to provide S3 emulation to Swift

if is_service_enabled swift3; then

# replace the nova-objectstore port by the swift port

S3_SERVICE_PORT=8080

git_clone $SWIFT3_REPO $SWIFT3_DIR $SWIFT3_BRANCH

setup_develop $SWIFT3_DIR

fi

if is_service_enabled g-api n-api; then

# image catalog service

install_glance

configure_glance

if is_service_enabled cinder; then

install_cinder

configure_cinder

if is_service_enabled neutron; then

install_neutron

install_neutron_third_party

if is_service_enabled nova; then

# compute service

install_nova

cleanup_nova

configure_nova

if is_service_enabled n-novnc; then

# a websockets/html5 or flash powered VNC console for vm instances

git_clone $NOVNC_REPO $NOVNC_DIR $NOVNC_BRANCH

if is_service_enabled n-spice; then

# a websockets/html5 or flash powered SPICE console for vm instances

git_clone $SPICE_REPO $SPICE_DIR $SPICE_BRANCH

if is_service_enabled horizon; then

# dashboard

install_horizon

configure_horizon

if is_service_enabled ceilometer; then

install_ceilometerclient

install_ceilometer

echo_summary "Configuring Ceilometer"

configure_ceilometer

configure_ceilometerclient

if is_service_enabled heat; then

install_heat

cleanup_heat

configure_heat

if is_service_enabled tls-proxy; then

configure_CA

init_CA

init_cert

# Add name to /etc/hosts

# don't be naive and add to existing line!

if [[ $TRACK_DEPENDS = True ]]; then

$DEST/.venv/bin/pip freeze > $DEST/requires-post-pip

if ! diff -Nru $DEST/requires-pre-pip $DEST/requires-post-pip > $DEST/requires.diff; then

cat $DEST/requires.diff

fi

echo "Ran stack.sh in depend tracking mode, bailing out now"

exit 0

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

if [[ "$SYSLOG_HOST" = "$HOST_IP" ]]; then

# Configure the master host to receive

cat <<EOF >/tmp/90-stack-m.conf

sudo mv /tmp/90-stack-m.conf /etc/rsyslog.d

else

# Set rsyslog to send to remote host

cat <<EOF >/tmp/90-stack-s.conf

sudo mv /tmp/90-stack-s.conf /etc/rsyslog.d

fi

RSYSLOGCONF="/etc/rsyslog.conf"

if [ -f $RSYSLOGCONF ]; then

sudo cp -b $RSYSLOGCONF $RSYSLOGCONF.bak

if [[ $(grep '$SystemLogRateLimitBurst' $RSYSLOGCONF) ]]; then

sudo sed -i 's/$SystemLogRateLimitBurst\ .*/$SystemLogRateLimitBurst\ 0/' $RSYSLOGCONF

else

sudo sed -i '$ i $SystemLogRateLimitBurst\ 0' $RSYSLOGCONF

fi

if [[ $(grep '$SystemLogRateLimitInterval' $RSYSLOGCONF) ]]; then

sudo sed -i 's/$SystemLogRateLimitInterval\ .*/$SystemLogRateLimitInterval\ 0/' $RSYSLOGCONF

else

sudo sed -i '$ i $SystemLogRateLimitInterval\ 0' $RSYSLOGCONF

fi

fi

echo_summary "Starting rsyslog"

restart_service rsyslog

restart_rpc_backend

if is_service_enabled $DATABASE_BACKENDS; then

configure_database

USE_SCREEN=$(trueorfalse True $USE_SCREEN)

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

# Create a new named screen to run processes in

screen -d -m -S $SCREEN_NAME -t shell -s /bin/bash

sleep 1

# Set a reasonable status bar

if [ -z "$SCREEN_HARDSTATUS" ]; then

SCREEN_HARDSTATUS='%{= .} %-Lw%{= .}%> %n%f %t*%{= .}%+Lw%< %-=%{g}(%{d}%H/%l%{g})'

fi

screen -r $SCREEN_NAME -X hardstatus alwayslastline "$SCREEN_HARDSTATUS"

screen -r $SCREEN_NAME -X setenv PROMPT_COMMAND /bin/true

SCREENRC=$TOP_DIR/$SCREEN_NAME-screenrc

if [[ -e $SCREENRC ]]; then

rm -f $SCREENRC

init_service_check

if is_service_enabled sysstat;then

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

screen_it sysstat "sar -o $SCREEN_LOGDIR/$SYSSTAT_FILE $SYSSTAT_INTERVAL"

else

screen_it sysstat "sar $SYSSTAT_INTERVAL"

fi

if is_service_enabled key; then

echo_summary "Starting Keystone"

init_keystone

start_keystone

# Set up a temporary admin URI for Keystone

SERVICE_ENDPOINT=$KEYSTONE_SERVICE_PROTOCOL://$KEYSTONE_AUTH_HOST:$KEYSTONE_AUTH_PORT/v2.0

if is_service_enabled tls-proxy; then

export OS_CACERT=$INT_CA_DIR/ca-chain.pem

# Until the client support is fixed, just use the internal endpoint

SERVICE_ENDPOINT=http://$KEYSTONE_AUTH_HOST:$KEYSTONE_AUTH_PORT_INT/v2.0

fi

# Do the keystone-specific bits from keystone_data.sh

export OS_SERVICE_TOKEN=$SERVICE_TOKEN

export OS_SERVICE_ENDPOINT=$SERVICE_ENDPOINT

create_keystone_accounts

create_nova_accounts

create_cinder_accounts

create_neutron_accounts

if is_service_enabled swift || is_service_enabled s-proxy; then

create_swift_accounts

fi

# ``keystone_data.sh`` creates services, admin and demo users, and roles.

ADMIN_PASSWORD=$ADMIN_PASSWORD SERVICE_TENANT_NAME=$SERVICE_TENANT_NAME SERVICE_PASSWORD=$SERVICE_PASSWORD \

SERVICE_TOKEN=$SERVICE_TOKEN SERVICE_ENDPOINT=$SERVICE_ENDPOINT SERVICE_HOST=$SERVICE_HOST \

S3_SERVICE_PORT=$S3_SERVICE_PORT KEYSTONE_CATALOG_BACKEND=$KEYSTONE_CATALOG_BACKEND \

DEVSTACK_DIR=$TOP_DIR ENABLED_SERVICES=$ENABLED_SERVICES HEAT_API_CFN_PORT=$HEAT_API_CFN_PORT \

HEAT_API_PORT=$HEAT_API_PORT \

bash -x $FILES/keystone_data.sh

# Set up auth creds now that keystone is bootstrapped

export OS_AUTH_URL=$SERVICE_ENDPOINT

export OS_TENANT_NAME=admin

export OS_USERNAME=admin

export OS_PASSWORD=$ADMIN_PASSWORD

unset OS_SERVICE_TOKEN OS_SERVICE_ENDPOINT

if is_service_enabled horizon; then

echo_summary "Configuring and starting Horizon"

init_horizon

start_horizon

if is_service_enabled g-reg; then

echo_summary "Configuring Glance"

init_glance

if is_service_enabled neutron; then

echo_summary "Configuring Neutron"

configure_neutron

init_neutron

if is_service_enabled neutron; then

configure_neutron_third_party

init_neutron_third_party

start_neutron_third_party

if is_service_enabled nova; then

echo_summary "Configuring Nova"

configure_nova

if is_service_enabled n-net q-dhcp; then

# Delete traces of nova networks from prior runs

# Do not kill any dnsmasq instance spawned by NetworkManager

netman_pid=$(pidof NetworkManager || true)

if [ -z "$netman_pid" ]; then

sudo killall dnsmasq || true

else

sudo ps h -o pid,ppid -C dnsmasq | grep -v $netman_pid | awk '{print $1}' | sudo xargs kill || true

fi

clean_iptables

rm -rf ${NOVA_STATE_PATH}/networks

sudo mkdir -p ${NOVA_STATE_PATH}/networks

sudo chown -R ${USER} ${NOVA_STATE_PATH}/networks

# Force IP forwarding on, just in case

sudo sysctl -w net.ipv4.ip_forward=1

if is_service_enabled s-proxy; then

echo_summary "Configuring Swift"

init_swift

if is_service_enabled cinder; then

echo_summary "Configuring Cinder"

init_cinder

if is_service_enabled nova; then

echo_summary "Configuring Nova"

# Rebuild the config file from scratch

create_nova_conf