unset GREP_OPTIONS

unset LANG

unset LANGUAGE

LC_ALL=C

export LC_ALL

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

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

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} =~ (precise|raring|saucy|trusty|7.0|wheezy|sid|testing|jessie|f18|f19|f20|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-havana/rdo-release-havana.rpm"}

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

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

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 $STACK_USER:"

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

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

chmod 0440 $TEMPFILE

sudo chown root:root $TEMPFILE

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

sudo mkdir -p $DEST

safe_chown -R $STACK_USER $DEST

safe_chmod 0755 $DEST

check_path_perm_sanity ${DEST}

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

OFFLINE=`trueorfalse False $OFFLINE`

ERROR_ON_CLONE=`trueorfalse False $ERROR_ON_CLONE`

ENABLE_DEBUG_LOG_LEVEL=`trueorfalse True $ENABLE_DEBUG_LOG_LEVEL`

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

sudo mkdir -p $DATA_DIR

safe_chown -R $STACK_USER $DATA_DIR

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

DSTAT_FILE=${DSTAT_FILE:-"dstat.txt"}

PIDSTAT_FILE=${PIDSTAT_FILE:-"pidstat.txt"}

PIDSTAT_INTERVAL=${PIDSTAT_INTERVAL:-"5"}

LOG_COLOR=`trueorfalse True $LOG_COLOR`

SERVICE_TIMEOUT=${SERVICE_TIMEOUT:-60}

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

rm -f $SSL_BUNDLE_FILE

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

source $TOP_DIR/lib/ldap

if [[ -d $TOP_DIR/extras.d ]]; then

for i in $TOP_DIR/extras.d/*.sh; do

[[ -r $i ]] && source $i source

done

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}" >&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

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

$TOP_DIR/tools/install_pip.sh

$TOP_DIR/tools/fixup_stuff.sh

install_rpc_backend

if is_service_enabled $DATABASE_BACKENDS; then

install_database

if is_service_enabled neutron; then

install_neutron_agent_packages

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

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

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 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 [[ -d $TOP_DIR/extras.d ]]; then

for i in $TOP_DIR/extras.d/*.sh; do

[[ -r $i ]] && source $i stack install

done

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

if is_service_enabled sysstat; then

# what we want to measure

# -u : cpu statitics

# -q : load

# -b : io load rates

# -w : process creation and context switch rates

SYSSTAT_OPTS="-u -q -b -w"

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

screen_it sysstat "cd $TOP_DIR; ./tools/sar_filter.py $SYSSTAT_OPTS -o $SCREEN_LOGDIR/$SYSSTAT_FILE $SYSSTAT_INTERVAL"

else

screen_it sysstat "./tools/sar_filter.py $SYSSTAT_OPTS $SYSSTAT_INTERVAL"

fi

if is_service_enabled dstat; then

# Per-process stats

DSTAT_OPTS="-tcndylp --top-cpu-adv"

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

screen_it dstat "cd $TOP_DIR; dstat $DSTAT_OPTS | tee $SCREEN_LOGDIR/$DSTAT_FILE"

else

screen_it dstat "dstat $DSTAT_OPTS"

fi

if is_service_enabled pidstat; then

# Per-process stats

PIDSTAT_OPTS="-l -p ALL -T ALL"

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

screen_it pidstat "cd $TOP_DIR; pidstat $PIDSTAT_OPTS $PIDSTAT_INTERVAL > $SCREEN_LOGDIR/$PIDSTAT_FILE"

else

screen_it pidstat "pidstat $PIDSTAT_OPTS $PIDSTAT_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

# Add temporarily to make openstackclient work

export OS_TOKEN=$SERVICE_TOKEN

export OS_URL=$SERVICE_ENDPOINT

create_keystone_accounts

create_nova_accounts

create_cinder_accounts

create_neutron_accounts

if is_service_enabled ceilometer; then

create_ceilometer_accounts

fi

if is_service_enabled swift || is_service_enabled s-proxy; then

create_swift_accounts

fi

if is_service_enabled heat; then

create_heat_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

unset OS_TOKEN OS_URL

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

# Run init_neutron only on the node hosting the neutron API server

if is_service_enabled $DATABASE_BACKENDS && is_service_enabled q-svc; then

init_neutron

fi