cbdocker

#!/bin/bash

if [ $0 != "-bash" ] ; then
    pushd `dirname "$0"` 2>&1 > /dev/null
fi
CB_BASE_DIR=$(pwd)
if [ $0 != "-bash" ] ; then
    popd 2>&1 > /dev/null
fi
    
if [[ -e /.dockerenv ]]
then
    echo "It appears that we are already running inside a docker. The executable $0 was designed to be used outside of a Docker container"
    exit -1
fi

CB_MULTIARCH=0
CB_USER=${CB_USER:-$HOME}
CB_DOCKER_USER=${CB_DOCKER_USER:-cbuser}
CB_DOCKER_NETHOST=0
CB_DOCKER_REPO=${CB_DOCKER_REPO:-ibmcb}
CB_DOCKER_IMAGE=${CB_DOCKER_IMAGE:-ubuntu_cb_orchestrator}
CB_DOCKER_TAG=${CB_DOCKER_TAG:-master}
CB_DOCKER_DEBUG=0
CB_KILL_DOCKER=0
CB_PRIVATE_CONFIG=0
CB_PRIVATE_DATA=0
CB_PRIVATE_CREDENTIALS=0
CB_DRY_RUN=0
CB_DOCKER_PRECOMMAND=/bin/true
CB_DOCKER_UPDATE=0
CB_DOCKER_COMMAND="auto"
CB_MANAGER_IP=${CB_MANAGER_IP:-"auto"}
CB_DOCKER_EXTRA_OPTS=${CB_DOCKER_EXTRA_OPTS:-""}
CB_DOCKER_IN_CLI=${CB_DOCKER_IN_CLI:-1}
CB_EXECUTABLE_PARMS=" "
CB_DOCKER_ADDITIONAL_VOLUMES="none"
CB_DOCKER_ADDITIONAL_ENVARS="none"
CB_DOCKER_HOST_ENTRY="none"
CB_EXECUTABLE_NAME=cbtool
CB_OBJECTSTORE_PORT=${CB_OBJECTSTORE_PORT:-40000}
CB_OBJECTSTORE_USAGE=${CB_OBJECTSTORE_USAGE:-private}
CB_LOGSTORE_PORT=${CB_LOGSTORE_PORT:-40001}
CB_LOGSTORE_USAGE=${CB_LOGSTORE_USAGE:-private}
CB_METRICSTORE_PORT=${CB_METRICSTORE_PORT:-40002}
CB_METRICSTORE_USAGE=${CB_METRICSTORE_USAGE:-private}
CB_FILESTORE_PORT=${CB_FILESTORE_PORT:-40003}
CB_API_DEFAULTS_PORT=${CB_API_DEFAULTS_PORT:-40004}
CB_GUI_DEFAULTS_PORT=${CB_GUI_DEFAULTS_PORT:-40005}
CB_VPN_SERVER_PORT=${CB_VPN_SERVER_PORT:-1194}
CB_CREATE_ONLY=0

CB_USAGE="Usage: $0 [-r/--repo <repository>] [-i/--image image name] [-b/--branch branch] [-c/--config config] [-D/--pexec command] [-e/--execute command] [-v/--volumes] [-g/--envars] [-a/--add-host] [-m/--cloudrename] [-t/--trace tracefile] [-u/--update] [-p/--private] [-z/--nethost] [-d/--debug] [--reset] [-f/--soft_reset] [-x/--hard_reset] [-k/--kill] [-n/--dryrun] [-y/--createonly] [--multiarch]"

while [[ $# -gt 0 ]]
do
    key="$1"

    case $key in
        -r|--repo)
        CB_DOCKER_REPO="$2"
        shift
        ;;
        -r=*|--repo=*)
        CB_DOCKER_REPO=$(echo $key | cut -d '=' -f 2)
        shift
        ;;
        -i|--image)
        CB_DOCKER_IMAGE="$2"
        shift
        ;;
        -i=*|--image=*)
        CB_DOCKER_IMAGE=$(echo $key | cut -d '=' -f 2)
        shift
        ;;
        -b|--branch)
        CB_DOCKER_TAG="$2"
        shift
        ;;
        -b=*|--branch=*)
        CB_DOCKER_TAG=$(echo $key | cut -d '=' -f 2)
        shift
        ;;
        -c|--config)
        CB_EXECUTABLE_PARMS=${CB_EXECUTABLE_PARMS}" --config $2 "
        shift
        ;;
        -c=*|--config=*)
        CB_EXECUTABLE_PARMS=${CB_EXECUTABLE_PARMS}" --config $(echo $key | cut -d '=' -f 2)"
        shift
        ;;
        -v|--volumes)
        CB_DOCKER_ADDITIONAL_VOLUMES="$2"
        shift
        ;;
        -v=*|--volumes=*)
        CB_DOCKER_ADDITIONAL_VOLUMES=$(echo $key | cut -d '=' -f 2)
        shift
        ;;
        -g|--envars)
        CB_DOCKER_ADDITIONAL_ENVARS="$2"
        shift
        ;;
        -g=*|--envars=*)
        CB_DOCKER_ADDITIONAL_ENVARS=$(echo $key | cut -d '=' -f 2)
        shift
        ;;        
        -m|--cloudrename)
        CB_CLOUD_RENAME="$2"
        shift
        ;;
        -m=*|--cloudrename=*)
        CB_CLOUD_RENAME=$(echo $key | cut -d '=' -f 2)
        shift
        ;;
        -a|--add-host)
        CB_DOCKER_HOST_ENTRY="$2"
        shift
        ;;
        -a=*|--add-host=*)
        CB_DOCKER_HOST_ENTRY=$(echo $key | cut -d '=' -f 2)
        shift
        ;;
        -t|--trace)
        CB_EXECUTABLE_PARMS=${CB_EXECUTABLE_PARMS}" --trace $2 "
        shift
        ;;
        -t=*|--trace=*)
        CB_EXECUTABLE_PARMS=${CB_EXECUTABLE_PARMS}" --trace $(echo $key | cut -d '=' -f 2)"
        shift
        ;;
        -e|--execute)
        CB_DOCKER_COMMAND="$2"
        shift
        ;;
        -e=*|--execute=*)
        CB_DOCKER_COMMAND=$(echo $key | cut -d '=' -f 2)
        shift
        ;;
        -D|--pexec)
        CB_DOCKER_PRECOMMAND="$2"
        shift
        ;;
        -D=*|--pexec=*)
        CB_DOCKER_PRECOMMAND=$(echo $key | cut -d '=' -f 2)
        shift        
        ;;                
        -p|--private)
        CB_PRIVATE_CONFIG=1
        CB_PRIVATE_DATA=1
        CB_PRIVATE_CREDENTIALS=1
        ;;
        -z|--nethost)
        CB_DOCKER_NETHOST=1
        ;;
        -y|--createonly)
        CB_CREATE_ONLY=1
        ;;
        -d|--debug)
        CB_DOCKER_DEBUG=1
        ;;
        --reset)
        CB_EXECUTABLE_PARMS=${CB_EXECUTABLE_PARMS}" --soft_reset "
        CB_KILL_DOCKER=2
        ;;
        -f|--soft_reset)
        CB_EXECUTABLE_PARMS=${CB_EXECUTABLE_PARMS}" --soft_reset "
        CB_KILL_DOCKER=2
        ;;
        -x|--hard_reset)
        CB_EXECUTABLE_PARMS=${CB_EXECUTABLE_PARMS}" --hard_reset "
        CB_KILL_DOCKER=2
        ;;
        -u|--update)
        CB_DOCKER_UPDATE=1
        ;;        
        -k|--kill)
        CB_KILL_DOCKER=1
        ;;
        -n|--dryrun)
        CB_DRY_RUN=1
        ;;
        -m|--multiarch)
        CB_MULTIARCH=1    
        ;;    
        -h|--help)
        echo $CB_USAGE
        shift
        exit 0
        ;;        
        *)
        # unknown option
        ;;
        esac
        shift
done

CB_DOCKER_NAME=$(echo ${CB_USER}_cbon | rev | cut -d '/' -f 1 | rev)

CB_DOCKER_VOL_CMDLINE=""

#
#
#
#

if [[ $(sudo docker ps | grep -c $CB_DOCKER_NAME) -eq 0 ]]
then
    echo -n "Docker \"$CB_DOCKER_NAME\" not running."
    if [[ $CB_KILL_DOCKER -eq 0 ]]
    then
        echo " Will start a new one."
        CB_KILL_DOCKER=2
    else 
        echo " "
    fi
elif [[ $(sudo docker ps | grep -c $CB_DOCKER_NAME) -gt 0 ]]
then
    echo -n "Docker \"$CB_DOCKER_NAME\" is already running."
    if [[ $CB_KILL_DOCKER -ne 0 ]]
    then
        echo " One of the following options \"--reset, -f/--soft_reset, -x/--hard_reset, -k/--kill\" was set. Container will be recreated"
    else 
        echo " "
    fi    
else
    if [[ $(sudo docker ps -a | grep -c $CB_DOCKER_NAME) -eq 1 ]]
    then
        if [[ $CB_KILL_DOCKER -eq 0 ]]
        then
            echo "Docker \"$CB_DOCKER_NAME\" exists, but is not running. Will remove and recreate."        
            CB_KILL_DOCKER=2
        fi
    fi
fi

if [[ $CB_DOCKER_COMMAND == "auto" ]]
then
    if [[ $CB_KILL_DOCKER -gt 0  ]]
    then
        sudo docker kill $CB_DOCKER_NAME >/dev/null 2>&1
        sudo docker rm $CB_DOCKER_NAME >/dev/null 2>&1

        if [[ $CB_KILL_DOCKER -gt 1  ]]
        then
            if [[ $(echo $CB_EXECUTABLE_PARMS | grep -c reset) -eq 0 ]]
            then
                CB_EXECUTABLE_PARMS=${CB_EXECUTABLE_PARMS}" --soft_reset "
            fi
            
            if [[ ${CB_DOCKER_IN_CLI} -eq 0 ]]
            then
                CB_EXECUTABLE_PARMS=${CB_EXECUTABLE_PARMS}" vmclist; bash"
            fi

#
#
#
#
            CB_DOCKER_COMMAND="/home/$CB_DOCKER_USER/${CB_EXECUTABLE_NAME}/private_configs/build_cloud_config_file_from_env.sh $CB_DOCKER_USER /home/$CB_DOCKER_USER/${CB_EXECUTABLE_NAME}; /home/$CB_DOCKER_USER/${CB_EXECUTABLE_NAME}/cb $CB_EXECUTABLE_PARMS; touch cbstarted"
#
        fi
    else
        CB_DOCKER_COMMAND="/home/$CB_DOCKER_USER/${CB_EXECUTABLE_NAME}/cb"
    fi
else 
    if [[ $CB_KILL_DOCKER -gt 0  ]]
    then
        sudo docker kill $CB_DOCKER_NAME >/dev/null 2>&1
        sudo docker rm $CB_DOCKER_NAME >/dev/null 2>&1
    fi
fi

CB_DOCKER_COMMAND=$CB_DOCKER_PRECOMMAND" && "$CB_DOCKER_COMMAND

if [[ $CB_DOCKER_DEBUG -eq 1 ]]
then
    CB_DOCKER_BASE_CMDLINE="run -it "
else
    CB_DOCKER_BASE_CMDLINE="run -itd "
fi

if [[ $CB_KILL_DOCKER -eq 2 ]]
then

    CB_DOCKER_CMDLINE_NAME="--name ${CB_DOCKER_NAME} "
    CB_DOCKER_SEC_CMDLINE="--cap-add=SYS_PTRACE --cap-add=NET_ADMIN --privileged=true"
    if [[ $CB_DOCKER_NETHOST -eq 1 ]]
    then
        CB_DOCKER_NET_CMDLINE=" --net=host "
    else 
        CB_DOCKER_NET_CMDLINE=" -p ${CB_OBJECTSTORE_PORT}:${CB_OBJECTSTORE_PORT} -p ${CB_LOGSTORE_PORT}:${CB_LOGSTORE_PORT} -p ${CB_METRICSTORE_PORT}:${CB_METRICSTORE_PORT} -p ${CB_FILESTORE_PORT}:${CB_FILESTORE_PORT} -p ${CB_API_DEFAULTS_PORT}:${CB_API_DEFAULTS_PORT} -p ${CB_GUI_DEFAULTS_PORT}:${CB_GUI_DEFAULTS_PORT} -p ${CB_VPN_SERVER_PORT}"
    fi

    if [[ $CB_PRIVATE_CONFIG -eq 0 ]]
    then
        if [[ $(sudo docker volume ls | grep -c ${USER}_cbon_configs) -eq 0 ]]
        then
            sudo docker volume create ${USER}_cbon_configs
        fi
        #CB_DOCKER_VOL_CMDLINE=${CB_DOCKER_VOL_CMDLINE}" -v $CB_BASE_DIR/configs:/home/$CB_DOCKER_USER/${CB_EXECUTABLE_NAME}/configs:rw "
        CB_DOCKER_VOL_CMDLINE=${CB_DOCKER_VOL_CMDLINE}" -v ${USER}_cbon_configs:/home/$CB_DOCKER_USER/${CB_EXECUTABLE_NAME}/configs "
    fi

    if [[ $CB_PRIVATE_CREDENTIALS -eq 0 ]]
    then
        if [[ $(sudo docker volume ls | grep -c ${USER}_cbon_credentials) -eq 0 ]]
        then
            sudo docker volume create ${USER}_cbon_credentials
        fi
        #CB_DOCKER_VOL_CMDLINE=${CB_DOCKER_VOL_CMDLINE}" -v $CB_BASE_DIR/credentials:/home/$CB_DOCKER_USER/${CB_EXECUTABLE_NAME}/credentials:rw "
        CB_DOCKER_VOL_CMDLINE=${CB_DOCKER_VOL_CMDLINE}" -v ${USER}_cbon_credentials:/home/$CB_DOCKER_USER/${CB_EXECUTABLE_NAME}/credentials "
    fi
    
    if [[ $CB_PRIVATE_DATA -eq 0 ]]
    then
        if [[ $(sudo docker volume ls | grep -c ${USER}_cbon_data) -eq 0 ]]
        then
            sudo docker volume create ${USER}_cbon_data
        fi
        #CB_DOCKER_VOL_CMDLINE=${CB_DOCKER_VOL_CMDLINE}" -v $CB_BASE_DIR/data:/home/$CB_DOCKER_USER/${CB_EXECUTABLE_NAME}/data "
        CB_DOCKER_VOL_CMDLINE=${CB_DOCKER_VOL_CMDLINE}" -v ${USER}_cbon_data:/home/$CB_DOCKER_USER/${CB_EXECUTABLE_NAME}/data "
    fi
 
    if [[ $CB_DOCKER_ADDITIONAL_VOLUMES != "none" ]]
    then
        for CB_VOL_ENTRY in $(echo $CB_DOCKER_ADDITIONAL_VOLUMES | sed 's/,/ /g')
        do
            CB_DOCKER_VOL_CMDLINE=${CB_DOCKER_VOL_CMDLINE}" -v "$(echo $CB_VOL_ENTRY | sed "s^~^$HOME^g")" "
        done
    fi

    if [[ $CB_MANAGER_IP != "auto" ]]
    then
        CB_DOCKER_ENV_CMDLINE=$CB_DOCKER_ENV_CMDLINE" -e CB_MANAGER_IP=${CB_MANAGER_IP} "    
    fi

    CB_DOCKER_ENV_CMDLINE=$CB_DOCKER_ENV_CMDLINE" -e CB_API_DEFAULTS_PORT=${CB_API_DEFAULTS_PORT} -e CB_GUI_DEFAULTS_PORT=${CB_GUI_DEFAULTS_PORT} "
            
    CB_DOCKER_HOST_CMDLINE=''
    if [[ $CB_DOCKER_HOST_ENTRY != "none" ]]
    then
        CB_DOCKER_HOST_CMDLINE=" --add-host $CB_DOCKER_HOST_ENTRY"
    fi

    CB_DOCKER_ENV_CMDLINE=$CB_DOCKER_ENV_CMDLINE" -e CB_PRIVATE_CONFIG=$CB_PRIVATE_CONFIG -e CB_PRIVATE_DATA=$CB_PRIVATE_DATA "
   
    CB_STARTUP_CLOUD=${CB_STARTUP_CLOUD:-MYSIM}
    if [[ $CB_STARTUP_CLOUD != "NONE" ]]
    then
        CB_DOCKER_ENV_CMDLINE=$CB_DOCKER_ENV_CMDLINE" -e CB_STARTUP_CLOUD=$CB_STARTUP_CLOUD"
        CB_CFGVAR_CLOUD_LIST=$(echo $CB_STARTUP_CLOUD | sed 's/MY//g')
    fi
 
    for store in OBJECTSTORE LOGSTORE METRICSTORE FILESTORE
    do
        for param in HOST PORT USAGE DBIB VERBOSITY DATABASE
        do
            cb_env_var_name=CB_${store}_${param}
            cb_env_var_value=$(echo ${!cb_env_var_name})
            if [[ ! -z ${!cb_env_var_name} ]]
            then
                CB_DOCKER_ENV_CMDLINE=$CB_DOCKER_ENV_CMDLINE" -e ${cb_env_var_name}=${!cb_env_var_name} "
            fi
        done
    done
    
    for cmodel in $CB_CFGVAR_CLOUD_LIST
    do
        for param in ACCESS CREDENTIALS SECURITY_GROUPS INITIAL_VMCS SSH_KEY_NAME KEY_NAME NETNAME POOLNAME NETNAME LOGIN
        do
            cb_env_var_name=CB_${cmodel}_${param}
            cb_env_var_value=$(echo ${!cb_env_var_name})
            if [[ ! -z ${!cb_env_var_name} ]]
            then
                CB_DOCKER_ENV_CMDLINE=$CB_DOCKER_ENV_CMDLINE" -e ${cb_env_var_name}=${!cb_env_var_name} "
                if [[ $param == "ACCESS" || $param == "CREDENTIALS" ]]
                then
                    cbcf=${!cb_env_var_name}
                    eval cbcf=${cbcf}
                    cbcf=$(echo $cbcf | cut -d ':' -f 2)
                    if [[ -f $cbcf ]]
                    then
                        CB_DOCKER_VOL_CMDLINE=${CB_DOCKER_VOL_CMDLINE}" -v ${cbcf}:${cbcf} "
                    fi 
                fi
            fi
        done
    done

    for obj in $(cat $CB_BASE_DIR/configs/templates/internal_options.txt | grep "^\[" | grep -v USER-DEFINED | sed 's/\[//g' | sed 's/\]//g')
    do
        for cmodel in EMPTY $CB_CFGVAR_CLOUD_LIST
        do
            section_exists=0
            for param in $(cat $CB_BASE_DIR/configs/build_cloud_config_file_attributes.txt)
            do
                cb_env_var_name=CB_${obj}_${cmodel}_${param}
                cb_env_var_name=$(echo $cb_env_var_name | sed 's/_EMPTY//g')
                if [[ ! -z ${!cb_env_var_name} ]]
                then
                    CB_DOCKER_ENV_CMDLINE=$CB_DOCKER_ENV_CMDLINE" -e ${cb_env_var_name}=${!cb_env_var_name} "
                fi
            done
        done
    done

#
#
#
#

    if [[ $CB_DOCKER_ADDITIONAL_ENVARS != "none" ]]
    then
        for CB_ENVAR_ENTRY in $(echo $CB_DOCKER_ADDITIONAL_ENVARS | sed 's/,/ /g')
        do
            CB_DOCKER_ENV_CMDLINE=${CB_DOCKER_ENV_CMDLINE}" -e "$(echo $CB_ENVAR_ENTRY | sed "s^~^$HOME^g" | sed "s/comma/,/g")" "
        done
    fi

    if [[ ! -z $CB_CLOUD_RENAME ]]
    then
        CB_DOCKER_ENV_CMDLINE=$CB_DOCKER_ENV_CMDLINE" -e CB_CLOUD_RENAME=${CB_CLOUD_RENAME} "
        
        if [[ $CB_CLOUD_RENAME == "AUTO" ]]
        then
            CB_DOCKER_VOL_CMDLINE=${CB_DOCKER_VOL_CMDLINE}" -v $(whoami)gucn:/home/$CB_DOCKER_USER/.gucn "
        fi
    fi
    
    if [[ $CB_CREATE_ONLY -eq 1 ]]
    then
        CB_DOCKER_ENV_CMDLINE=$CB_DOCKER_ENV_CMDLINE" -e CB_VM_DEFAULTS_CHECK_BOOT_COMPLETE=wait_for_0 -e CB_VM_DEFAULTS_TRANSFER_FILES=false -e CB_VM_DEFAULTS_RUN_GENERIC_SCRIPTS=false -e CB_VM_DEFAULTS_CHECK_SSH=false -e CB_VM_DEFAULTS_UPDATE_FREQUENCY=1 -e CB_AI_DEFAULTS_RUN_APPLICATION_SCRIPTS=false -e CB_AI_DEFAULTS_DONT_START_LOAD_MANAGER=true"
    fi

    if [[ $CB_MULTIARCH -eq 1 ]]
    then
        CB_DOCKER_IMAGE=${CB_DOCKER_IMAGE}-$(dpkg --print-architecture | sed s'/ppc64el/ppc64le/g')
    fi

    if [[ $CB_DOCKER_REPO == "local" ]]
    then
        CB_DOCKER_IMAGE_CMDLINE=${CB_DOCKER_IMAGE}":"${CB_DOCKER_TAG}
    else
        CB_DOCKER_IMAGE_CMDLINE=" "${CB_DOCKER_REPO}${CB_DOCKER_IMAGE}":"${CB_DOCKER_TAG}
    fi
    
    docker pull $CB_DOCKER_IMAGE_CMDLINE
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#

    CB_DOCKER_AUX_CMDLINE=${CB_DOCKER_BASE_CMDLINE}${CB_DOCKER_CMDLINE_NAME}${CB_DOCKER_SEC_CMDLINE}${CB_DOCKER_NET_CMDLINE}${CB_DOCKER_VOL_CMDLINE}${CB_DOCKER_HOST_CMDLINE}${CB_DOCKER_ENV_CMDLINE}${CB_DOCKER_EXTRA_OPTS}${CB_DOCKER_IMAGE_CMDLINE}    
    CB_DOCKER_CMDLINE=${CB_DOCKER_BASE_CMDLINE}${CB_DOCKER_CMDLINE_NAME}${CB_DOCKER_SEC_CMDLINE}${CB_DOCKER_NET_CMDLINE}${CB_DOCKER_VOL_CMDLINE}${CB_DOCKER_HOST_CMDLINE}${CB_DOCKER_ENV_CMDLINE}${CB_DOCKER_EXTRA_OPTS}${CB_DOCKER_IMAGE_CMDLINE}${CB_DOCKER_EXE_CMDLINE}
    
    echo "Creating docker with the command: \"docker $CB_DOCKER_CMDLINE\""
    if [[ $CB_DRY_RUN -eq 0 ]]
    then
        sudo docker $CB_DOCKER_AUX_CMDLINE bash -c "$CB_DOCKER_COMMAND"
    fi
fi

if [[ $CB_KILL_DOCKER -eq 0 ]]
then
    if [[ $CB_DRY_RUN -eq 0 ]]
    then
        sudo docker exec -it $CB_DOCKER_NAME bash -c "$CB_DOCKER_COMMAND"
    fi
fi

exit $?