vbootstrap/vbuilder.sh.in

#!/bin/bash
# -*- coding: utf-8-unix -*-

Usage_C(){
    cat<<EOF
Usage:	$(basename $0) {--version [version]} {--arch [arch]} {--dist-upgrade} {--target [target]} {--with-compat32} {--build|--clean|--build-rpm [src.rpm]|--install-rpm [arch.rpm|package]|--remove-rpm [package]}

Options:
	--version:		set [version] (default: ${DEFAULT_VERSION})
	--arch:			set [arch] (default: $(uname -i))
	--dist-upgrade:		build VineSeed bootstrap via ${STABLE_VERSION}
	--target:		build rpms with [target]
	--with-compat32:	build rpms with compat32 on boostrap

Actions:
	--clean:		clean boostrap of [version]
	--build:		build boostrap of [version]
	--build-rpm:		build [src.rpm] on boostrap
	--install-rpm:		install [arch.rpm|package] on boostrap
	--remove-rpm:		remove [package] on boostrap

For example, 
* make a clean/plain build environment on the current archtecture:
$(basename $0) --clean --build
* build a source rpm:
$(basename $0) --build-rpm [src.rpm]
* make a plain build environment for Vine Linux 4.2:
$(basename $0) --version 4.2 --clean --build
* make a i386 chroot on x86_64:
$(basename $0) --arch i386 --clean --build
* build a kernel package with target i686
$(basename $0) --target i686 --build-rpm [kernel src.rpm]
* build a compat32 package:
$(basename $0) --arch i386 --with-compat32 --build-rpm [src.rpm]
$(/usr/sbin/vbootstrap | sed -e s/^Usage:.*// -e s/^E:.*//)
EOF
}

Usage_ja(){
    Usage_C
}

Msg_MissingParameter_C(){
    while read para; do
	cat<<EOF
E: Missing some parameter before ${para}
EOF
    done
}

Msg_MissingParameter_ja(){
    Msg_MissingParameter_C
}

Msg_NoSupportVARCH_C(){
    cat<<EOF
E: arch ${VARCH} is NO support on $(uname -i)
EOF
}

Msg_NoSupportVARCH_ja(){
    Msg_NoSupportVARCH_C
}

Msg_NoSupportVERSION_C(){
    cat<<EOF
E: version ${VERSION} is NO support
EOF
}

Msg_NoSupportVERSION_ja(){
    Msg_NoSupportVERSION_C
}

Msg_NoSupportDistUpgradeVERSION_C(){
    cat<<EOF
E: version ${VERSION} does not support --dist-upgrade option
EOF
}

Msg_NoSupportDistUpgradeVERSION_ja(){
    Msg_NoSupportDistUpgradeVERSION_C
}

Msg_NoSupportTARGET_C(){
    cat<<EOF
E: rpm build target ${TARGET} is NO support
EOF
}

Msg_NoSupportTARGET_ja(){
    Msg_NoSupportTARGET_C
}

##############################################################################

setup-vbuilder(){
    ## load default settings
    if [ -r /etc/vbootstrap/vbuilder.conf ]; then
	. /etc/vbootstrap/vbuilder.conf
    fi
    [ -z "${VBOOTSTRAP_DIR}" ] && \
	VBOOTSTRAP_DIR=@@VBUILDER_VBOOTSTRAP_DIR@@
    [ -z "${DEFAULT_VERSION}" ] && \
	DEFAULT_VERSION=@@VBUILDER_DEFAULT_VERSION@@
    [ -z "${BUILT_RPMS_DIR}" ] && \
	BUILT_RPMS_DIR=@@VBUILDER_BUILT_RPMS_DIR@@
    [ -d $VBOOTSTRAP_DIR ] || mkdir -p $VBOOTSTRAP_DIR
    VERSION=$DEFAULT_VERSION

    ## current stable relase version
    STABLE_VERSION=@@VBUILDER_STABLE_VERSION@@

    ## set locale
    case $LANG in
	ja*)  LOCALE=ja ;;
	*)    LOCALE=C ;;
    esac

    ## set boolian
    with_setup_vbootstrap=0
    with_dist_upgrade=0
}

check-next-parameter(){
    while read arg; do
	if [ $(echo ${arg} | grep '^-') ]; then
	    echo ${arg} | Msg_MissingParameter_$LOCALE
	    return 1
	fi
    done
}

setup-vbootstrap(){
    if [ ${with_setup_vbootstrap} -eq 0 ]; then
	with_setup_vbootstrap=1

	## check a chroot archtecture
	if [ ! -z ${VARCH} ]; then
	    case "${VARCH}" in
		i386)
		    [ "$(uname -i)" = "ppc" ] && \
			Msg_NoSupportVARCH_$LOCALE
		    [ $? -eq 0 ] && exit 1
		    ;;
		x86_64)
		    [ "$(uname -i)" = "ppc" ] && \
			Msg_NoSupportVARCH_$LOCALE
		    [ $? -eq 0 ] && exit 1
		    ;;
		ppc)
		    [ "$(uname -i)" = "i386" -o "$(uname -i)" = "x86_64" ] && \
			Msg_NoSupportVARCH_$LOCALE
		    [ $? -eq 0 ] && exit 1
		    ;;
	    esac
	fi

	[ -z ${VARCH} ] && VARCH=$(uname -i)

	##!! IRREGULAR: 4.2 is NO support on x86_64
	if [ "${VERSION}" = "4.2" -a "$(uname -i)" = "x86_64" ]; then
	    Msg_NoSupportVERSION_${LOCALE}
	    exit 1
	fi

	## support for i386 chroot on x86_64 below: 
	[ "${VARCH}" != "$(uname -i)" ] && VERSION=${VERSION}_${VARCH}

        ## check support ${VERSION}
	if [ -z "$(/usr/sbin/vbootstrap | sed -e s/^Usage:.*// -e s/^E:.*// | grep -m 1 ${VERSION})" ]; then
	    Msg_NoSupportVERSION_$LOCALE
	    exit 1
	fi

	## check ${VERSION} equals VineSeed*, when with_dist_upgrade=1
	if [ $with_dist_upgrade -eq 1 ]; then
	    if [ "$(echo ${VERSION} | sed -e "s/\(VineSeed\).*/\1/")" != "VineSeed" ]; then
		Msg_NoSupportDistUpgradeVERSION_$LOCALE
		exit 1
	    fi
	fi

	## check build target option ${TARGET}
	if [ ! -z "${TARGET}" ]; then
	    RPM_TARGET_LIST="$(cat /usr/lib/rpm/rpmrc | grep arch_canon: | sed -e "s/arch_canon:[[:blank:]]*\(.*\):.*/\1/")"
	    if [ -z "$(echo $RPM_TARGET_LIST | grep $TARGET)" ]; then
		Msg_NoSupportTARGET_$LOCALE
		exit 1
	    fi
	fi

    fi

    BUILD_ROOT=${VBOOTSTRAP_DIR}/${VERSION}
    BUILD_USER=vbuilder
    CACHE_DIR=${VBOOTSTRAP_DIR}/cache/${VERSION}
    BUILD_DIR=/home/${BUILD_USER}/rpm

    mkdir -p $VBOOTSTRAP_DIR
}

##############################################################################

Clean(){
    setup-vbootstrap

    # ## umount /home
    # [ -z "$(mount | grep ${BUILD_ROOT}/home)" ] || \
    # 	umount ${BUILD_ROOT}/home

    # ## umount /tmp for applications which use X
    # [ -z "$(mount | grep ${BUILD_ROOT}/tmp)" ] || \
    # 	umount ${BUILD_ROOT}/tmp

    # ## umount virtual file systems
    # for dir in /sys /proc /dev/shm /dev/pts /dev; do
    # [ -z "$(mount | grep ${BUILD_ROOT}${dir})" ] || \
    # 	umount ${BUILD_ROOT}${dir}
    # done
    [ -z "$(mount | grep ${BUILD_ROOT}/proc)" ] || \
	umount ${BUILD_ROOT}/proc

    if [ -d ${BUILD_ROOT}/var/cache/apt/archives ]; then
	echo -n "Caching RPMs in ${CACHE_DIR}/apt/archives ... "
	[ -d ${CACHE_DIR}/apt/archives ] || mkdir -p ${CACHE_DIR}/apt/archives
	mv -f ${BUILD_ROOT}/var/cache/apt/archives/*.rpm ${CACHE_DIR}/apt/archives/
	echo "done."
    fi

    if [ -d ${BUILD_ROOT} ]; then
	echo -n "Cleaning build root \"${BUILD_ROOT}\" ... "
	rm -rf ${BUILD_ROOT}
	echo "done."
    fi
}

Build(){
    setup-vbootstrap

    if [ $with_dist_upgrade -eq 1 ]; then
	## make bootstrap of ${STABLE_VERSION}
	/usr/sbin/vbootstrap \
	    $(echo ${VERSION} | sed -e "s/VineSeed/${STABLE_VERSION}/") \
	    ${BUILD_ROOT}

	## aim apt-line to VineSeed
	sed -i "s/apt ${STABLE_VERSION}/apt VineSeed/g" \
	    ${BUILD_ROOT}/etc/apt/sources.list.d/main.list
    else
	/usr/sbin/vbootstrap ${VERSION} ${BUILD_ROOT}
    fi

    # ## mount virtual file systems
    # for dir in /dev /dev/pts /dev/shm /proc /sys; do
    # 	[ -d ${BUILD_ROOT}${dir} ] || mkdir -p ${BUILD_ROOT}${dir}
    # 	mount --bind ${dir} ${BUILD_ROOT}${dir}
    # done
    [ -d ${BUILD_ROOT}/proc ] || mkdir -p ${BUILD_ROOT}/proc
    mount --bind /proc ${BUILD_ROOT}/proc

    # ## mount /tmp for applications which use X
    # [ -d ${BUILD_ROOT}/tmp ] || mkdir -p ${BUILD_ROOT}/tmp
    # mount --bind /tmp ${BUILD_ROOT}/tmp

    # ## mount /home
    # [ -d ${BUILD_ROOT}/home ] || mkdir -p ${BUILD_ROOT}/home
    # mount -o rbind /home ${BUILD_ROOT}/home

    if [ -d ${CACHE_DIR} ]; then
	echo -n "Copying cached RPMs to ${BUILD_ROOT}/var/cache/apt/archives ... "
	cp -f ${CACHE_DIR}/apt/archives/*.rpm ${BUILD_ROOT}/var/cache/apt/archives/
	echo "done."
    fi

    /usr/sbin/chroot ${BUILD_ROOT} \
	/bin/sh -c 'apt-get update && apt-get -y dist-upgrade'
    /usr/sbin/chroot ${BUILD_ROOT} \
	/bin/sh -c 'apt-get -y install apt-sourceslist-plus && apt-get update'
    /usr/sbin/chroot ${BUILD_ROOT} \
	/bin/sh -c 'apt-get -y install apt-sourceslist-nonfree && apt-get update'

    if [ $with_dist_upgrade -eq 1 ]; then
	/usr/sbin/chroot ${BUILD_ROOT} \
	    /bin/sh -c 'apt-get update && apt-get -y dist-upgrade'
    fi
    /usr/sbin/chroot ${BUILD_ROOT} \
	/bin/sh -c 'apt-get -y install build-essential'
    /usr/sbin/chroot ${BUILD_ROOT} \
	/bin/sh -c 'apt-get -y install self-build-setup'

    /usr/sbin/chroot ${BUILD_ROOT} \
	/bin/sh -c 'apt-get -y install etcskel shadow-utils'

    /usr/sbin/chroot ${BUILD_ROOT} /bin/sh -c 'cd /dev && /sbin/MAKEDEV console'
    /usr/sbin/chroot ${BUILD_ROOT} /bin/sh -c 'cd /dev && /sbin/MAKEDEV null'
    /usr/sbin/chroot ${BUILD_ROOT} /bin/sh -c 'cd /dev && /sbin/MAKEDEV zero'

    /usr/sbin/chroot ${BUILD_ROOT} /bin/sh -c '/usr/sbin/pwconv'
    /usr/sbin/chroot ${BUILD_ROOT} /bin/sh -c "/usr/sbin/useradd ${BUILD_USER}"

    echo "Making a build farm for ${VERSION} done."
}

setup-vbootstrap-rpm(){
    setup-vbootstrap

    ## check ${BUILD_ROOT}
    [ -d ${BUILD_ROOT} ] || Build

    DIST_RELEASE=$(cat ${BUILD_ROOT}/etc/vine-release | cut -f3 -d" " | cut -f1 -d.)

    if [ -f $RPM_PKG ]; then
	BASE_RPM_PKG=$(basename $RPM_PKG)
	cp -f $RPM_PKG $BUILD_ROOT${BUILD_DIR}
    else
	BASE_RPM_PKG=$RPM_PKG	
    fi
}

RPM_Remove(){
    setup-vbootstrap-rpm

    if [ -f $RPM_PKG ]; then
	echo "$RPM_PKG: not package name."
	exit 1
    fi
    /usr/sbin/chroot ${BUILD_ROOT} \
	/bin/sh -c "apt-get -y remove $BASE_RPM_PKG"
}

RPM_Install(){
    setup-vbootstrap-rpm

    /usr/sbin/chroot ${BUILD_ROOT} \
	/bin/sh -c "cd ${BUILD_DIR} && apt-get -y install $BASE_RPM_PKG"
}

RPM_Build(){
    setup-vbootstrap-rpm

    if [ ! -f $RPM_PKG ]; then
	echo "$RPM_PKG: not source RPM package."
	exit 1
    fi
    
    RPM_PKG_USER=$(stat -c %U $RPM_PKG)
    RPM_PKG_GROUP=$(stat -c %G $RPM_PKG)
    local __install="install -p -v -o ${RPM_PKG_USER} -g ${RPM_PKG_GROUP}"
    RPM_PKG_ARCH_LIST="RPMS/i386 RPMS/x86_64 RPMS/ppc RPMS/noarch SRPMS"
    [ -z "${TARGET}" ] || \
	RPM_PKG_ARCH_LIST="RPMS/${TARGET} ${RPM_PKG_ARCH_LIST}"

    ## make src.rpm for $VERSION
    /usr/sbin/chroot ${BUILD_ROOT} \
    	/bin/sh -c "cd ${BUILD_DIR} && su ${BUILD_USER} -c 'rpm -ivh $BASE_RPM_PKG'"
    /usr/sbin/chroot ${BUILD_ROOT} \
	/bin/sh -c "cd ${BUILD_DIR} && su ${BUILD_USER} -c 'rpmbuild -bs --nodeps --clean --rmsource --rmspec ${BUILD_DIR}/SPECS/*.spec'"


    ## change ${DIST_RELEASE}
    BASE_RPM_PKG=$(echo $BASE_RPM_PKG | sed -e "s/vl\([0-9]*\)\./vl${DIST_RELEASE}\./")

    ## rebuild $BASE_RPM_PKG on ${DIST_RELEASE}
    /usr/sbin/chroot ${BUILD_ROOT} \
    	/bin/sh -c "cd ${BUILD_DIR}/SRPMS && apt-get -y build-dep $BASE_RPM_PKG"
    /usr/sbin/chroot ${BUILD_ROOT} \
    	/bin/sh -c "cd ${BUILD_DIR}/SRPMS && su ${BUILD_USER} -c 'rpmbuild --rebuild $RPM_OPTS $BASE_RPM_PKG'"
    /usr/sbin/chroot ${BUILD_ROOT} \
	/bin/sh -c "cd ${BUILD_DIR} && apt-get -y install $(find $BUILD_ROOT${BUILD_DIR}/RPMS -type f -regex '.*\.rpm' | sed -e s@${BUILD_ROOT}@@g -e 's|.*\/compat32-.*||g' -e 's|.*\/.*\.src\.rpm||g' -e 's/$/ \\/g')"

    ## copy built rpms to ${HOME}/rpm/ for each archtectures
    echo "Copying built rpms to ${HOME}/rpm/ for each archtectures ... "
    for i in $RPM_PKG_ARCH_LIST; do \
	if [ -d $BUILD_ROOT${BUILD_DIR}/${i} ]; then
	    [ -d ${BUILT_RPMS_DIR}/${i} ] || \
		$__install -d ${BUILT_RPMS_DIR}/${i}/
	    find $BUILD_ROOT${BUILD_DIR}/${i} -type f -regex '.*\.rpm' \
		-exec $__install -m0644 {} ${BUILT_RPMS_DIR}/${i}/ \;
	fi
    done
    echo "done."
}


##############################################################################

setup-vbuilder

[ $# -eq 0 ] && Usage_$LOCALE
while [ $# -gt 0 ]; do
    tmpARG=$1
    case $tmpARG in
	--version|--arch|--target|--build-rpm|--install-rpm|--remove-rpm)
	    shift
	    echo $1 | check-next-parameter
	    [ $? -eq 1 ] && exit 1
	    ;;
	--dist-upgrade|--with-compat32|--build|--clean)
	    ;;
	*)
	    Usage_$LOCALE
	    exit 1
	    ;;
    esac

    case $tmpARG in
	--version)
	    VERSION=$1
	    ;;
	--arch)
	    VARCH=$1
	    ;;
	--dist-upgrade)
	    with_dist_upgrade=1
	    ;;
	--target)
	    TARGET=$1
	    RPM_OPTS="${RPM_OPTS} --target $TARGET"
	    ;;
	--with-compat32)
	    RPM_OPTS="${RPM_OPTS} --with compat32"
	    ;;
	--build-rpm)
	    RPM_PKG=$1
	    RPM_Build || exit 1
	    ;;
	--install-rpm)
	    RPM_PKG=$1
	    RPM_Install || exit 1
	    ;;
	--remove-rpm)
	    RPM_PKG=$1
	    RPM_Remove || exit 1
	    ;;
	--build)
	    Build
	    ;;
	--clean)
	    Clean
	    ;;
    esac
    shift
done

exit