mkcbundle

#!/bin/bash

set -e
set -u

NOCLEAN=0

function on_exit() {
    [ -e ${TEMPDIR} ] && rm -rf ${TEMPDIR}
}

function usage() {
    echo "mkcbundle [args]"
    echo
    echo "Valid args:"
    echo " -p <profile>    use a specific profile directory"
    echo " -v <version>    use a specific version (default to date)"
    echo " -b <dir>        use a specific build directory (default: mktemp)"
    echo " -n              don't clean the build dir"
    echo
}

function get_sha_for_checkout() {
    # $1 - repo
    # $2 - branch

    local repo=$1
    local branch=$2

    if [ ${#branch} -eq 40 ]; then
        echo ${branch}
        return
    fi

    declare -a sha_info
    sha_info=( $(git ls-remote ${repo} | egrep "refs/[^/]*/${branch}$") )
    sha=${sha_info[0]}
    echo ${sha}
}


PROFILE=""
BUILD_NUMBER=$(date +%Y%m%d%H%M)

while getopts "p:v:nb:" OPTION; do
    case ${OPTION} in
        p)
            PROFILE=${OPTARG}
            ;;
        v)
            BUILD_NUMBER=${OPTARG}
            ;;
        n)
            NOCLEAN=1
            ;;
        b)
            TEMPDIR=${OPTARG}
            ;;
        ?)
            usage
            exit 1
    esac
done

if [ "${PROFILE}" = "" ]; then
    usage
    exit 1
fi

if [ ! -f ${PROFILE}/manifest.txt ]; then
    echo "Cannot find profile: (${PROFILE}/manifest.txt missing)"
    exit 1
fi

TEMPDIR=${TEMPDIR:-$(mktemp -d --tmpdir bundler-XXXXXXXXXXX)}
if [ "${NOCLEAN}" -eq 0 ]; then
    trap on_exit exit
fi

mkdir -p .cache
CACHE_ROOT=$(readlink -f .cache)

DESTDIR=${TEMPDIR}/${PROFILE}-${BUILD_NUMBER}
REAL_DESTDIR=${DESTDIR}
mkdir -p ${DESTDIR}
OLD_PKG_CONFIG_PATH=${PKG_CONFIG_PATH:-}
export PKG_CONFIG_PATH=${DESTDIR}/lib/pkgconfig:${OLD_PKG_CONFIG_PATH}
PATH=${DESTDIR}/bin:${PATH}
export LD_LIBRARY_PATH=${DESTDIR}/lib

exec 3>&1
exec > >(tee -a ${DESTDIR}/build.log)

while read repo branch; do
    if [[ "$repo" =~ "git+" ]]; then
        repo_type=GIT
        project=$(basename ${repo})
        repo=${repo#git+}
    else
        repo_type=TAR
        project=$(basename ${repo})
        project=${project%-*}
        project_version=${branch}
    fi

    echo -e "\n######################################################"
    echo "Building ${project}"
    echo -e "######################################################\n"

    CACHEDIR=${CACHE_ROOT}/${project}
    cached_project_version=0

    if [ -e ${CACHEDIR}/${project}-version.txt ]; then
        cached_project_version=$(cat ${CACHEDIR}/${project}-version.txt)
    fi

    if [ "${repo_type}" == "GIT" ]; then
        project_version=$(get_sha_for_checkout "${repo}" "${branch}")

        if [ "${project_version}" == "" ]; then
            echo "can't get sha for ${repo}@${branch}"
            exit 1
        fi
    fi

    if [ "${project_version}" != "${cached_project_version}" ]; then
        rm -rf ${CACHEDIR}
        mkdir -p ${CACHEDIR}

        build_script=''
        if [ -f ${PROFILE}/build/${project}.build ]; then
            build_script=$(readlink -f ${PROFILE}/build/${project}.build)
        fi

        install_script=''
        if [ -f ${PROFILE}/build/${project}.install ]; then
            install_script=$(readlink -f ${PROFILE}/build/${project}.install)
        fi


        # checkout
        if [ "${repo_type}" == "TAR" ]; then
            wget -O ${TEMPDIR}/${project}.tar.gz ${repo}
            mkdir -p ${TEMPDIR}/${project}
            tar -C ${TEMPDIR}/${project} --strip-components=1 -xzvf ${TEMPDIR}/${project}.tar.gz
            pushd ${TEMPDIR}/${project}
        elif [ "${repo_type}" == "GIT" ]; then
            if [ -d ${TEMPDIR}/${project} ]; then
                pushd ${TEMPDIR}/${project}
                git reset --hard
                git checkout master
                git pull
            else
                git clone ${repo} ${TEMPDIR}/${project}
                pushd ${TEMPDIR}/${project}
            fi
            git checkout ${project_version}
        fi

        # build and stage into cache dir
        if [ "${build_script}" != "" ]; then
            echo "### Building using supplied build script"
            source "${build_script}"
        else
            echo "### Building using existing autoconf framework"
            if [ ! -x configure ]; then
                if [ -x autogen.sh ]; then
                    ./autogen.sh
                else
                    autoreconf -fi
                fi
            fi

            ./configure CFLAGS=-I${DESTDIR}/include LDFLAGS=-L${DESTDIR}/lib --prefix=''
            make V=1
            # make check
        fi

        if [ "${install_script}" != "" ]; then
            DESTDIR=${DESTDIR}
            source "${install_script}"
            DESTDIR=${CACHEDIR}
            source "${install_script}"
            echo ${project_version} > ${CACHEDIR}/${project}-version.txt
        elif [ "${build_script}" == "" ]; then
            make DESTDIR=${DESTDIR} install
            make DESTDIR=${CACHEDIR} install
            echo ${project_version} > ${CACHEDIR}/${project}-version.txt
        fi

        DESTDIR=${REAL_DESTDIR}

        # otherwise, the build script did an install and we won't do caches
        popd
    else
        # have a cached copy...
        cp -a "${CACHEDIR}"/* "${DESTDIR}"
    fi

    echo "${project} ${repo}@${branch} (${project_version})" >> ${DESTDIR}/versions.txt

    # whack the .la files
    find ${DESTDIR} -name "*la" -exec rm {} \;
done < <( grep -v "^#" ${PROFILE}/manifest.txt )

rm -rf "${DESTDIR}/etc"
rm -rf "${DESTDIR}/init"
rm -f "${DESTDIR}/binfiles"

[ -d "${PROFILE}/etc" ] && cp -a "${PROFILE}/etc" "${DESTDIR}"
[ -d "${PROFILE}/init" ] && cp -a "${PROFILE}/init" "${DESTDIR}"
[ -e "${PROFILE}/binfiles" ] && cp "${PROFILE}/binfiles" "${DESTDIR}"

exec 1>&3
exec 3>&-

tar -C ${TEMPDIR} -czf ${PROFILE}-${BUILD_NUMBER}.tar.gz ${PROFILE}-${BUILD_NUMBER}