unset GREP_OPTIONS

unset LANG

unset LANGUAGE

LC_ALL=C

export LC_ALL

umask 022

PATH=$PATH:/usr/local/sbin:/usr/sbin:/sbin

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

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

rm $TOP_DIR/.stackenv

FILES=$TOP_DIR/files

if [ ! -d $FILES ]; then

die $LINENO "missing devstack/files"

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

die $LINENO "missing devstack/lib"

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

echo "You are running this script as root."

echo "Cut it out."

echo "Really."

echo "If you need an account to run DevStack, do this (as root, heh) to create a non-root account:"

echo "$TOP_DIR/tools/create-stack-user.sh"

exit 1

source $TOP_DIR/functions

source $TOP_DIR/lib/config

GetDistro

rm -f $TOP_DIR/.localrc.auto

if [[ -r $TOP_DIR/local.conf ]]; then

LRC=$(get_meta_section_files $TOP_DIR/local.conf local)

for lfile in $LRC; do

if [[ "$lfile" == "localrc" ]]; then

if [[ -r $TOP_DIR/localrc ]]; then

warn $LINENO "localrc and local.conf:[[local]] both exist, using localrc"

else

echo "# Generated file, do not edit" >$TOP_DIR/.localrc.auto

get_meta_section $TOP_DIR/local.conf local $lfile >>$TOP_DIR/.localrc.auto

fi

fi

done

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

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

source $TOP_DIR/stackrc

if [[ ! ${DISTRO} =~ (precise|trusty|7.0|wheezy|sid|testing|jessie|f20|f21|rhel6|rhel7) ]]; 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

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

export_proxy_variables

disable_negated_services

if [[ ,${ENABLED_SERVICES}, =~ ,"swift", ]]; then

echo "FATAL: 'swift' is not supported as a service name"

echo "FATAL: Use the actual swift service names to enable them as required:"

echo "FATAL: s-proxy s-object s-container s-account"

exit 1

is_package_installed sudo || install_package sudo

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

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

TEMPFILE=`mktemp`

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

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

echo "Defaults:$STACK_USER !requiretty" >> $TEMPFILE

chmod 0440 $TEMPFILE

sudo chown root:root $TEMPFILE

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

if is_ubuntu; then

echo 'APT::Acquire::Retries "20";' | sudo tee /etc/apt/apt.conf.d/80retry >/dev/null

if is_fedora && [[ $DISTRO == "rhel6" || $DISTRO == "rhel7" ]]; then

# RHEL requires EPEL for many Open Stack dependencies

# note we always remove and install latest -- some environments

# use snapshot images, and if EPEL version updates they break

# unless we update them to latest version.

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

uninstall_package epel-release || true

fi

# This trick installs the latest epel-release from a bootstrap

# repo, then removes itself (as epel-release installed the

# "real" repo).

#

# you would think that rather than this, you could use

# $releasever directly in .repo file we create below. However

# RHEL gives a $releasever of "6Server" which breaks the path;

# see https://bugzilla.redhat.com/show_bug.cgi?id=1150759

if [[ $DISTRO == "rhel7" ]]; then

epel_ver="7"

elif [[ $DISTRO == "rhel6" ]]; then

epel_ver="6"

fi

cat <<EOF | sudo tee /etc/yum.repos.d/epel-bootstrap.repo

# bare yum call due to --enablerepo

sudo yum --enablerepo=epel-bootstrap -y install epel-release || \

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

# epel rpm has installed it's version

sudo rm -f /etc/yum.repos.d/epel-bootstrap.repo

# ... and also optional to be enabled

is_package_installed yum-utils || install_package yum-utils

if [[ $DISTRO == "rhel7" ]]; then

OPTIONAL_REPO=rhel-7-server-optional-rpms

elif [[ $DISTRO == "rhel6" ]]; then

OPTIONAL_REPO=rhel-6-server-optional-rpms

fi

sudo yum-config-manager --enable ${OPTIONAL_REPO}

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

# Note no juno packages for rhel6

if [[ $DISTRO == "rhel6" ]]; then

RHEL_RDO_REPO_RPM=${RHEL6_RDO_REPO_RPM:-"https://repos.fedorapeople.org/repos/openstack/openstack-icehouse/rdo-release-icehouse-4.noarch.rpm"}

RHEL_RDO_REPO_ID=${RHEL6_RDO_REPO_ID:-"openstack-icehouse"}

elif [[ $DISTRO == "rhel7" ]]; then

RHEL_RDO_REPO_RPM=${RHEL7_RDO_REPO_RPM:-"https://repos.fedorapeople.org/repos/openstack/openstack-juno/rdo-release-juno-1.noarch.rpm"}

RHEL_RDO_REPO_ID=${RHEL7_RDO_REPO_ID:-"openstack-juno"}

fi

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

echo "RDO repo not detected; installing"

yum_install $RHEL_RDO_REPO_RPM || \

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

fi

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

sudo mkdir -p $DEST

safe_chown -R $STACK_USER $DEST

safe_chmod 0755 $DEST

check_path_perm_sanity ${DEST}

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

sudo mkdir -p $DATA_DIR

safe_chown -R $STACK_USER $DATA_DIR

LOCAL_HOSTNAME=`hostname -s`

if [ -z "`grep ^127.0.0.1 /etc/hosts | grep $LOCAL_HOSTNAME`" ]; then

sudo sed -i "s/\(^127.0.0.1.*\)/\1 $LOCAL_HOSTNAME/" /etc/hosts

VERBOSE=$(trueorfalse True $VERBOSE)

function spinner {

}

function kill_spinner {

}

function echo_summary {

}

function echo_nolog {

echo $@ >&3

}

if is_fedora && [ $DISTRO == "rhel6" ]; then

# poor old python2.6 doesn't have argparse by default, which

# outfilter.py uses

is_package_installed python-argparse || install_package python-argparse

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

# Set fd 3 to a copy of stdout. So we can set fd 1 without losing

# stdout later.

exec 3>&1

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

# Set fd 1 and 2 to write the log file

exec 1> >( $TOP_DIR/tools/outfilter.py -v -o "${LOGFILE}" ) 2>&1

# Set fd 6 to summary log file

exec 6> >( $TOP_DIR/tools/outfilter.py -o "${SUMFILE}" )

else

# Set fd 1 and 2 to primary logfile

exec 1> >( $TOP_DIR/tools/outfilter.py -o "${LOGFILE}" ) 2>&1

# Set fd 6 to summary logfile and stdout

exec 6> >( $TOP_DIR/tools/outfilter.py -v -o "${SUMFILE}" >&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

# Set fd 3 to a copy of stdout. So we can set fd 1 without losing

# stdout later.

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> >( $TOP_DIR/tools/outfilter.py -v >&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 exit_trap EXIT

function exit_trap {

}

trap err_trap ERR

function err_trap {

}

set -o errexit

set -o xtrace

OFFLINE=`trueorfalse False $OFFLINE`

ERROR_ON_CLONE=`trueorfalse False $ERROR_ON_CLONE`

ENABLE_DEBUG_LOG_LEVEL=`trueorfalse True $ENABLE_DEBUG_LOG_LEVEL`

FLOATING_RANGE=${FLOATING_RANGE:-172.24.4.0/24}

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. See local.conf for suggestions on setting HOST_IP."

SERVICE_HOST=${SERVICE_HOST:-$HOST_IP}

SYSLOG=`trueorfalse False $SYSLOG`

SYSLOG_HOST=${SYSLOG_HOST:-$HOST_IP}

SYSLOG_PORT=${SYSLOG_PORT:-516}

LOG_COLOR=`trueorfalse True $LOG_COLOR`

SSL_BUNDLE_FILE="$DATA_DIR/ca-bundle.pem"

rm -f $SSL_BUNDLE_FILE

source $TOP_DIR/lib/database

source $TOP_DIR/lib/rpc_backend

check_rpc_backend

USE_SSL=$(trueorfalse False $USE_SSL)

SSL_ENABLED_SERVICES="key,nova,cinder,glance,s-proxy,neutron"

if is_service_enabled tls-proxy && [ "$USE_SSL" == "True" ]; then

die $LINENO "tls-proxy and SSL are mutually exclusive"

source $TOP_DIR/lib/apache

source $TOP_DIR/lib/tls

source $TOP_DIR/lib/infra

source $TOP_DIR/lib/oslo

source $TOP_DIR/lib/stackforge

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/ldap

source $TOP_DIR/lib/dstat

fetch_plugins

run_phase source

function read_password {

}

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

RABBIT_USERID=${RABBIT_USERID:-stackrabbit}

if is_service_enabled rabbit; then

RABBIT_HOST=${RABBIT_HOST:-$SERVICE_HOST}

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

if [[ -z "$SWIFT_TEMPURL_KEY" ]] && [[ "$SWIFT_ENABLE_TEMPURLS" == "True" ]]; then

read_password SWIFT_TEMPURL_KEY "ENTER A KEY FOR SWIFT TEMPURLS."

fi

echo_summary "Installing package prerequisites"

source $TOP_DIR/tools/install_prereqs.sh

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

PYPI_ALTERNATIVE_URL=$PYPI_ALTERNATIVE_URL $TOP_DIR/tools/install_pip.sh

TRACK_DEPENDS=${TRACK_DEPENDS:-False}

if [[ $TRACK_DEPENDS = True ]]; then

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

pip_install -U 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

source $TOP_DIR/tools/fixup_stuff.sh

run_phase stack pre-install

install_rpc_backend

if is_service_enabled $DATABASE_BACKENDS; then

install_database

if is_service_enabled neutron; then

install_neutron_agent_packages

echo_summary "Installing OpenStack project source"

install_infra

install_oslo

if is_service_enabled stackforge_libs; then

install_stackforge

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

install_keystonemiddleware

if use_library_from_git "python-openstackclient"; then

git_clone_by_name "python-openstackclient"

setup_dev_lib "python-openstackclient"

pip_install 'python-openstackclient>=1.0.0'

if is_service_enabled key; then

if [ "$KEYSTONE_AUTH_HOST" == "$SERVICE_HOST" ]; then

install_keystone

configure_keystone

fi

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 horizon; then

# django openstack_auth

install_django_openstack_auth

# dashboard

install_horizon

configure_horizon

if is_service_enabled ceilometer; then

install_ceilometerclient

install_ceilometer

echo_summary "Configuring Ceilometer"

configure_ceilometer

if is_service_enabled heat; then

install_heat

install_heat_other

cleanup_heat

configure_heat

if is_service_enabled tls-proxy || [ "$USE_SSL" == "True" ]; then

configure_CA

init_CA

init_cert

# Add name to /etc/hosts

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

run_phase stack install

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

echo "Detect some changes for installed packages of pip, in depend tracking mode"

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 [ -f $SSL_BUNDLE_FILE ]; then

export OS_CACERT=$SSL_BUNDLE_FILE

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

start_dstat

if is_service_enabled key; then

echo_summary "Starting Keystone"

if [ "$KEYSTONE_AUTH_HOST" == "$SERVICE_HOST" ]; then

init_keystone

start_keystone

fi

# Set up a temporary admin URI for Keystone

SERVICE_ENDPOINT=$KEYSTONE_AUTH_URI/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

# Setup OpenStackclient token-flow auth

export OS_TOKEN=$SERVICE_TOKEN