run

#!/bin/bash

# sourcing configuration file.
. conf

# Almost nothing happens here. Functionality is defined in ./functions.
CWD="$(pwd)"
echo "Adding functions."
for file in ./functions/*.sh
do
    . "$file"
done

# Setting and recreating the work folder.
if [ ! -d "$WORK_DIR" ]
then
    mkdir -p "$WORK_DIR"
fi
cd "$WORK_DIR" || exit 1
echo "Work dir: $(pwd)"

START=$(date +%s)
export LIBGUESTFS_BACKEND=direct

# This is where functions are executed.
LOG_FILE="${BASE_LOG_FILE}_$1.log"
run ()
{
    echo "[$(date +%T)] Running $1 $2" | tee -a "$LOG_FILE"
    SECONDS=0
    $1
    echo "$1 finished with no errors and ran for $(time_diff $SECONDS)" | \
        tee -a "$LOG_FILE"
}

# Installation step names
STEP_NAME=(clean host uc-prep uc-inst uc-post oc-prep oc-depl oc-post)
LAST_STEP=${#STEP_NAME[@]}

# Special commands
SPECIAL=(tests once until bnr full func-ls)

STEP=$(echo ${STEP_NAME[@]} | tr " " "\n" | grep -n $1 2> /dev/null | cut -d ":" -f 1)
SPECIAL=$(echo ${SPECIAL[@]} | tr " " "\n" | grep -n $1 2> /dev/null | cut -d ":" -f 1)

# If step was not found in any of the arrays, print help and exit.
if [ -z "$STEP" ] && [ -z "$SPECIAL" ] 
then
    echo -ne "$HELP"
    exit 1
fi

# Building STEP_RUN and setting it to false
declare INSTALLATION_STEP
for i in $(seq 1 $LAST_STEP)
do
    INSTALLATION_STEP[$(( i - 1 ))]=false
done

# If its an installation step, enable only it.
if [ ! -z "$STEP" ]
then
    INSTALLATION_STEP[$(( STEP - 1 ))]=true 
fi



host_clean ()
{
    run clean
    run clean_vms                                                             
    run clean_vnets                                                           
    run clean_pool
    run clean_vbmc
}

host_preprerations ()
{
    # Editing the host prior to do anything else.
    run install_host_packages "$LONG"
    run install_extra_packages
    run discover_puddle_version
    run set_puddle_params
    run update_os "$LONG"
    run host_tweaks
    run fix_host_ssh
    run fix_virt_access
    run fix_host_kvm
    echo -e "Host prepared in $(time_diff $(( $(date +%s) - START)))\n"
}

virt_setup ()
{
    # Re-creating virtual resources.
    run restart_libvirt
    run create_vnet
    echo -e "Cleaned old resources in $(time_diff $(( $(date +%s) - START)))\n"
}

create_installation_images ()
{
    # If no installation images are available, create them for the requested version.
    if $CREATE_IMAGES
    then
        run get_ntpd_settings
        run proto_create
        run proto_prerun
        run proto_firstrun
        run proto_start "$LONG"
        run proto_clean
        run "clean_vms proto"
        run package_puddle_image
        run upload_puddle_image
        echo -e "Created installation images in $(time_diff $(( $(date +%s) - START)))\n"
    fi
}

create_virtual_environment ()
{
    # Creating the virtual environment as set in conf.
    run get_undercloud_image
    run create_node_images
    run define_nodes
    run "fetch_vbmc ${NODES[0]}-0"
    run vbmc_add
    run "vbmc_stat down"
    run vbmc_start
    run "vbmc_stat running"
    run "undercloud_firstboot ${NODES[0]}-0"
    echo -e "Created virtual environment in $(time_diff $(( $(date +%s) - START)))\n"
}

prepare_main_undercloud ()
{
    # Preparing the main Undercloud machine.
    run "vm_power ${NODES[0]}-0 start" "$LONG"
    run "undercloud_wait ${NODES[0]}-0" "$LONG"
    run "undercloud_ssh_access ${NODES[0]}-0 root $ROOT_PASS"
    run "undercloud_ssh_access ${NODES[0]}-0 stack stack"
    run "pre_uc_install_wa ${NODES[0]}-0"
    if [ $OS_VER -gt 11 ]
    then
        run "undercloud_container ${NODES[0]}-0"
    fi
    run "undercloud_gen_conf ${NODES[0]}-0"
    echo -e "Undercloud preparations finished in $(time_diff $(( $(date +%s) - START)))\n"
}

install_main_undercloud ()
{
    # Installing the main Undercloud machine.
    run "undercloud_install ${NODES[0]}-0" "This should take 40-50 minutes."
    echo -e "Undercloud installed in $(time_diff $(( $(date +%s) - START)))\n"
}

post_install_main_undercloud ()
{
    # Installing the main Undercloud machine.
    run "post_uc_install_wa ${NODES[0]}-0"
    run "post_uc_install_tweaks ${NODES[0]}-0"
    echo -e "Undercloud post installation tasks finished in $(time_diff $(( $(date +%s) - START)))\n"
}

predeploy_overcloud ()
{
    # Running steps prior to deploying the Overcloud.
    run "define_flavors ${NODES[0]}-0"
    run "add_templates ${NODES[0]}-0"
    run "prepare_director_images ${NODES[0]}-0" "$LONG"
    run "create_json ${NODES[0]}-0"
    run "overcloud_predeploy ${NODES[0]}-0" "$LONG"
    echo -e "Finished deployment preperations in $(time_diff $(( $(date +%s) - START)))\n"
}

deploy_overcloud ()
{
    # Running overcloud deploy and waiting for deployment to finish.
    run "pre_oc_deploy_wa ${NODES[0]}-0"
    run "overcloud_deploy ${NODES[0]}-0" "This takes about 60-80 minutes."
    echo -e "Overcloud deployed in $(time_diff $(( $(date +%s) - START)))\n"
}

post_deploy_overcloud ()
{
    # Running post deploy tasks.
    run "post_oc_deploy_wa ${NODES[0]}-0"
    run "populate_hosts ${NODES[0]}-0"
    run "post_oc_deploy_int_net ${NODES[0]}-0"
    run "post_oc_deploy_ext_net ${NODES[0]}-0"
    run "post_oc_deploy_repos ${NODES[0]}-0"
    echo -e "Overcloud post deploy tasks finished in $(time_diff $(( $(date +%s) - START)))\n"
}

undercloud_backup ()
{
    # Backup the main Undercloud machine.
    run "backup_undercloud ${NODES[0]}-0"
    run "vm_power ${NODES[0]}-0 stop"
    echo -e "Undercloud backed up in $(time_diff $(( $(date +%s) - START)))\n"
}

undercloud_restore ()
{
    # Restoring the old Undercloud data onto a new Undercloud machine.
    run "upload_backup ${NODES[0]}-1"
    run "undercloud_firstboot ${NODES[0]}-1"
    run "vm_power ${NODES[0]}-1 start" "$LONG"
    run "undercloud_wait ${NODES[0]}-1" "$LONG"
    run "undercloud_ssh_access ${NODES[0]}-1 root $ROOT_PASS"
    run "undercloud_ssh_access ${NODES[0]}-1 stack stack"
    run "restore_undercloud ${NODES[0]}-1"
    run "undercloud_install ${NODES[0]}-1" "$LONG"
    run "populate_hosts ${NODES[0]}-1"
    echo -e "Undercloud restored in $(time_diff $(( $(date +%s) - START)))\n"
}

run_automation ()
{
    # Run automation tests
    run "run_tests $1 stack overcloud"
}

# Handeling non-installation-steps arguments.
if [ ! -z "$SPECIAL" ]
then
    case $SPECIAL in 
        1) run_automation "${NODES[0]}-0" ;;
        2) 
            if [ ! -z "$2" ]
            then
                run $2 $3 $4 $5
            fi
        ;;
        3)
            if [ -z "$2" ]
            then
                echo -ne "$HELP"
                exit 1
            fi
            STEP_2=$(echo ${STEP_NAME[@]} | tr " " "\n" | grep -n $2 2> /dev/null | cut -d ":" -f 1)
            for i in $(seq 1 $STEP_2 )
            do
                INSTALLATION_STEP[$(( i - 1 ))]=true
            done
        ;;
        4)
            undercloud_backup
            undercloud_restore
        ;;
        5) 
            for i in $(seq 1 $LAST_STEP)
            do
                INSTALLATION_STEP[$(( i - 1 ))]=true
            done
        ;;
        6) head -qn 1 $CWD/functions/*.sh ;;
    esac
fi
# Step 0 - clean.
if ${INSTALLATION_STEP[0]}; then host_clean; fi

# Step 1 - host and puddle preparation.
if ${INSTALLATION_STEP[1]}
then
    host_preprerations
    virt_setup
    create_installation_images
    create_virtual_environment
fi

# Step 2 - preparing the undercloud machine.
if ${INSTALLATION_STEP[2]}; then prepare_main_undercloud; fi

# Step 3 - installing the undercloud.
if ${INSTALLATION_STEP[3]}; then install_main_undercloud; fi

# Step 4 - post installation tweaks.
if ${INSTALLATION_STEP[4]} ; then post_install_main_undercloud; fi

# Step 5 - predeploy tasks.
if ${INSTALLATION_STEP[5]}; then predeploy_overcloud; fi

# Step 6 - overcloud deploy.
if ${INSTALLATION_STEP[6]}; then deploy_overcloud; fi

# Step 7 - post deploy tweaks.
if ${INSTALLATION_STEP[7]}; then post_deploy_overcloud; fi

echo "ALL DONE in $(time_diff $(( $(date +%s) - START)))"