test-tutorial-framework/hack/bootstrap_tfw_dev.sh

#!/usr/bin/env bash
set -eu
set -o pipefail
set -o errtrace
shopt -s expand_aliases
[ "$(uname)" == "Darwin" ] && alias sed="gsed" || :

pushd() { command pushd "$@" > /dev/null; }
popd() { command popd "$@" > /dev/null; }

TFWDEV="${TFWDEV:-0}"
HTTPS_REMOTES="${HTTPS_REMOTES:-}"
TFW_POSTFIX=tutorial-framework
BASEDIR="$(pwd)"
BASEIMAGE=baseimage-${TFW_POSTFIX}
TEST=test-${TFW_POSTFIX}
FRONTEND=frontend-${TFW_POSTFIX}
LOGFILE=/tmp/bootstrap_tfw.log

remotebase="git@github.com:"

run()
{
    trap 'exit 1' INT
    trap handle_exit EXIT
    : > $LOGFILE

    check_dependencies
    clone_repos_ask_ssh_or_https
    install_frontend_deps
    if [ "$TFWDEV" == "0" ]; then
        LATESTTAG="$(fetch_latest_tag)"
        LATESTTAG=$LATESTTAG pin_latest_baseimage
        LATESTTAG=$LATESTTAG build_latest_baseimage
        cleanup_repos
        merge_repos
    fi

    echo 
    echo "You can build & start TFW by executing the command: ${TEST}/hack/tfw.sh start"
}

handle_exit()
{
    if [[ $? -ne 0 ]]; then
        err_cleanup
        showlog
    fi
    cleanlog
}

showlog() { echo && echo "Error! Showing logs:" && cat $LOGFILE; }
cleanlog() { rm $LOGFILE; }
err_cleanup() { cd "$BASEDIR" && rm -rf "$BASEIMAGE" "$FRONTEND" "$TEST"; }

check_dependencies()
{
    dependencies=("git" "docker" "yarn" "ng")
    missing="0"
    for dep in ${dependencies[@]}; do
        if ! type "$dep" > /dev/null 2>&1; then
            logged echo "Dependency '${dep}' not found!"
            missing="1"
        fi
    done
    if [ "$missing" == "1" ]; then
        logged echo "Please install the missing packages and retry!"
        exit 1
    fi

    if [ "$TFWDEV" == "0" ]; then
        if ! docker info > /dev/null 2>&1; then
            logged echo "The Docker daemon appears to be stopped. Please start it and try again!"
            exit 1
        fi
    fi
}

clone_repos_ask_ssh_or_https()
{
    if [[ -z "$HTTPS_REMOTES" ]]; then
        read -p "Repos are pulled over SSH by default. Should I use HTTPS instead? [y/N]" -r -t 5 || :
        echo
        if [[ $REPLY =~ ^(y|Y|yes|Yes|YES)$ ]]; then
            HTTPS_REMOTES=1 clone_repos
        else
            HTTPS_REMOTES=0 clone_repos
        fi
    else
        clone_repos
    fi
}

clone_repos()
{
    [[ "$HTTPS_REMOTES" == "1" ]] && remotebase="https://github.com/"

    echo -n "Cloning TFW repositories... "
    echo -n "baseimage... " && logged git clone ${remotebase}avatao-content/${BASEIMAGE}.git
    echo -n "frontend... " && logged git clone ${remotebase}avatao-content/${FRONTEND}.git
    echo -n "test... " && logged git clone ${remotebase}avatao-content/${TEST}.git
    echo "Done!"
}

install_frontend_deps()
{
    echo -n "Installing frontend dependencies... "
    pushd "$FRONTEND"
    spinned logged yarn install
    popd
    echo "Done!"
}

fetch_latest_tag()
{
    echo -n "$(git ls-remote --tags ${remotebase}avatao-content/${BASEIMAGE}.git   |
               cut -f2                                                             |
               grep -oP '(?<=refs/tags/)\w+-\d{8}$'                                |
               sort -t '-' -k2                                                     |
               tail -n 1)"
}

pin_latest_baseimage()
{
    echo -n "Pinning latest TFW baseimage version... "
    echo -n "which is ${LATESTTAG}... "
    sed -i "1 s/.*/&:${LATESTTAG}/" "${TEST}/solvable/Dockerfile"
    echo "Done!"
}

build_latest_baseimage()
{
    echo -n "Building baseimage at ${LATESTTAG}... "
    pushd "$BASEIMAGE"
    spinned logged git checkout "$LATESTTAG"
    popd
    TFWTAG=$LATESTTAG spinned logged ${TEST}/hack/tfw.sh buildtfw
    echo "Done!"
}

cleanup_repos()
{
    rm -rf "${BASEIMAGE}"
    rm -rf "${TEST}/.git"
    rm -rf "${FRONTEND}/.git"
}

merge_repos()
{
    echo -n "Merging repositories... "
    NESTED_FRONTEND="${TEST}/solvable/frontend"
    rm -rf $NESTED_FRONTEND
    mv "$FRONTEND" "$NESTED_FRONTEND"
    echo "Done!"
}

logged()
{
    "$@" >> $LOGFILE 2>&1
}

spinned()
{
    "$@" &
    pid=$!
    spin=("-" "\\" "|" "/")

    echo -n "${spin[0]}"
    while kill -0 $pid &> /dev/null; do
        for i in "${spin[@]}"; do
            echo -ne "\b$i"
            sleep 0.1
        done
    done
    echo -ne "\b"
    wait $pid
}

run