#!/bin/bash
#(C)DatuX 2005 - all rights reserved
#-kijkt of er een goede (ongewijzigde) buildroot aanwezig is
#-genereerd indien nodig een nieuwe buildroot (oude word dan gewist)
#-copy de directory waar het programma staat naar de buildroot
#-start het programma chrootted
#-kopieer nieuwe files in de directory (niet de subdirs) terug naar orginenele plek
#-geeft een overzicht van de gewijzigde files. (als het programma de buildroot dus sloopt)
#-de tmp dir in de buildroot word niet meegenomene met wijzigingen en word altijd
# opnieuw gemaakt.


if [ -z $1 ]; then
    echo "Geef scriptnaam op!"
    echo "$0 <scriptnaam> [nocheck] [nodep]"
#    echo " rebuildroot: haal hele buildroot weg, alles opnieuw"
    echo " nocheck:   repareer de buildroot niet. "
    echo "              (alleen als je zelfde package nog een keer bouwt)"
    echo " nodep:     installeer dependencies niet"
    echo " progress: progress indicator tonen. (pv dient geinstalleerd te zijn voor progress indicators)"
    exit 1
fi

for PAR in $*; do eval "$PAR=1" &>/dev/null; done

#unieke identifier voor deze lokale checkout. Op dit moment gebruiken we hier het lokale pad voor:
SVNID=`pwd|tr / _`

export ROOTCOPY=/tmp/buildroot.copy.$SVNID

#bepaal welke buildroot 'vrij' is om te gebruiken
NR=0
export BUILDROOT=/tmp/buildroot$NR.$SVNID
while ! lockfile-create -r0 $BUILDROOT ; do
	(( NR++ ))
	BUILDROOT=/tmp/buildroot$NR.$SVNID
	if [ "$NR" -ge 10 ]; then
		echo "No more free buildroots, giving up."
		exit 1
	fi
done
#always remove lockfile on exit!
trap "rm $BUILDROOT.lock &>/dev/null" 0


PGMPATH=$1
DIR=`dirname "$PGMPATH"`;
PGM=`basename "$PGMPATH"`;
ROOTEDWORKDIR=/tmp/build
WORKDIR=$BUILDROOT$ROOTEDWORKDIR

if [ ! -x $PGMPATH ] || [ ! -f $PGMPATH ]; then
    echo "Exectubable $PGMPATH bestaat niet!"
    exit 1
fi

#root helemaal rebuilden?
#if [ "$rebuildroot" ]; then
#    echo "Deleting old buildroot..."
#    rm -r $BUILDROOT
#fi

#ivm snelheid
#echo "Buildroot opschonen.."
#rm -rf $BUILDROOT/tmp/* &>/dev/null


#buildroot controleren/fixen/voorbereiden?
if [ "$nocheck" ] ; then
    echo "(skipping buildroot check..)"
else
    mkdir $BUILDROOT &>/dev/null
    ./chkbuildroot $BUILDROOT $ROOTCOPY $* || exit 1
fi


if [ "$nodep" ]; then
    echo "(skipping dependency install..)"
else
	CONFIG=
	#bepaal de build dependencies:

	NEEDS=`../npl/findbuilddeps $PGMPATH` || exit 1
	for NEED in $NEEDS; do

		CONFIG=1
        	echo -n "Finding dependency $NEED: "
	    	TGZ=`../npl/findpkg "$NEED"` || exit 1
		echo -n "$TGZ"
		
		PKGNAME=`basename "$TGZ"|sed 's/.tgz$//'`

		#already installed?
		if [ -e "$BUILDROOT/var/log/packages/$PKGNAME" ]; then
			echo " (already installed, skipping)"
			continue
		else
			echo " (installing)"
		fi

		#Bepaal waar het pakketje in de buildroot moet terecht komen, ivm crosscompiling.
		#Zon pakketje mag niet in de buildroot zelf, omdat dan de bestaande libraries overschreven kunnen worden met die van een andere architectuur.
		#eerst moeten we de architectuur van het pakketje weten:
		NEEDHOST=
		if NEEDBUILD=`../npl/findbuild "$NEED"`; then
		    #FIXME: dit klopt niet, bij perlmod_XML_Parser pakt hij nu buildmods.arch ipv perlmod_XML_Parser.arch!
		    NEEDHOST=`cat $NEEDBUILD.arch 2>/dev/null`
		fi
		#als het er een directory naast npl bestaat is het een crosscomplile architectuur:
		if [ "$NEEDHOST" ] && [ -e ../$NEEDHOST ]; then
		    #cross-architectuur, install
		    #in een subdirectory onder buildroot, met naam van architectuur:
		    echo "(Cross architecture detected, installing package in $NEEDHOST toolchain directory)"
		    export ROOT=$BUILDROOT/usr/$NEEDHOST/$NEEDHOST
		else
		    #gewoon direct in de buildroot pleuren:
		    export ROOT=$BUILDROOT
		fi

		installpkg "$TGZ" >/dev/null || exit 1

		#_dev niet gespecificeerd?
#NO: findbuilddeps does this now
#	    	if ! echo "$NEEDS" | grep "$NEED""_dev"; then
#			#bestaat er wel een dev?
#			if TGZ=`../npl/findpkg "$NEED""_dev" 2>/dev/null`; then
#				echo "Auto selecting development package: $TGZ"
#				installpkg "$TGZ" >/dev/null || exit 1
#			fi
#		fi

	done

	if [ "$CONFIG" ]; then
		echo "Nieuwe packages ldconfiggen..."
		ldconfig -r $BUILDROOT || exit 1
		echo "etc-update doen"
		chroot $BUILDROOT "/bin/bash" -l -c "etc-update" || exit 1
	fi

	#paden fixen ivm cross compile?
	if [ "$HOST" ]; then
		echo -n "Adjusting crossplatform library configs in toolchain directory..."
		#fix pkgconfig files that are in crossplatform-path:
		sed -i "s@=/usr@=/usr/$NEEDHOST/$NEEDHOST/usr@" $BUILDROOT/usr/$HOST/$HOST/usr/lib/pkgconfig/*.pc
		#fix *-config files that are in crossplatform-path:
		sed -i "s@=/usr@=/usr/$HOST/$HOST/usr@" $BUILDROOT/usr/$HOST/$HOST/usr/bin/*-config
		sed -i "s@\"/usr@\"/usr/$HOST/$HOST/usr@" $BUILDROOT/usr/$HOST/$HOST/usr/bin/*-config
		echo "DONE"
	fi

fi

#hack kernel versie tools
cat arch > $BUILDROOT/bin/arch
chmod +x $BUILDROOT/bin/arch
KVER=`ls $BUILDROOT/lib/modules 2>/dev/null|cut -f1 -d'/'`
if [ "$KVER" == "" ]; then
	KVER=`cat ../npl/kernel/linux_src/linux_src.version` || exit 1
fi
cat uname |sed "s/#KVER#/$KVER/g" > $BUILDROOT/bin/uname
chmod +x $BUILDROOT/bin/uname

#vanaf hier is er een goede buildroot
echo "$DIR word gekopieerd naar werkdirectory $WORKDIR"
cp -a $DIR $WORKDIR || exit 1
chown -R root:root $WORKDIR || exit 1

#proc is needed for all kinds of things:
umount $BUILDROOT/proc &>/dev/null
mount -t proc none $BUILDROOT/proc || exit 1

#pts is needed for programs like 'Expect':
umount $BUILDROOT/dev/pts &>/dev/null
mount -t devpts none $BUILDROOT/dev/pts -o rw,nosuid,noexec,gid=5,mode=620 || exit 1

#put the logfile in top of the buildroot and not in /tmp/build, to not 'disrupt' smart SlackBuild that use file-times.
export LOG="$BUILDROOT/$PGM.log"

#log output and show progress info if pv is installed
progress()
{
	#use old logfile as reference for progress indication
	SIZE=`zcat $BUILDROOT/tmp/build/$PGM.log.gz 2>/dev/null|wc -c`
	if [ "$progress" ] && which pv &>/dev/null; then
		pv -s $SIZE -p -t -e  | tee $LOG
	else
		tee $LOG
	fi
}

#clear environment, set some variables and do the actual chrooting:
echo -e "\e[1;33m*** Chroot naar $BUILDROOT en starten van $PGM in $ROOTEDWORKDIR:\e[0m" >&2
CHROOT=`which chroot`
env - $CHROOT $BUILDROOT "/bin/bash" -l -c "
	export MAKEFLAGS='$MAKEFLAGS'
	cd $ROOTEDWORKDIR
	export PS4='\[\e[1;32m\]\$LINENO \$PWD > \[\e[0m\]'
	export HOST=$HOST
	bash -x ./$PGM" 2>&1 | progress ;

if [ "${PIPESTATUS[0]}" != "0" ]; then
	echo -e "\e[1;31m*** Er ging iets mis tijdens het bakken in de buildroot!\e[0m" >&2
	echo "Chroot naar $BUILDROOT zodat je kunt onderzoeken (ctrl-d om te stoppen):"
	env - $CHROOT $BUILDROOT "/bin/bash" -l -c "
	    export MAKEFLAGS='$MAKEFLAGS'
	    export TERM='$TERM'
	    cd $ROOTEDWORKDIR
	    export HOST=$HOST
	    bash" 2>&1

	umount $BUILDROOT/proc
	umount $BUILDROOT/dev/pts
	echo "Om verder te testen/onderzoeken, tik:"
	echo "chroot $BUILDROOT"
	echo "Logfile: $LOG"
	exit 1
else
	echo -e "\e[1;32m*** Build gelukt.\e[0m" >&2
fi

umount $BUILDROOT/proc
umount $BUILDROOT/dev/pts

echo "* Packages terugmoven naar originele directory..";
echo $WORKDIR/*.arch ...
mv $WORKDIR/*.arch $DIR || exit 1
echo $WORKDIR/*.version ...
mv $WORKDIR/*.version $DIR || exit 1

#copy check if pkg file is different and update build number when needed
for PKG in $WORKDIR/*.pkg; do
	NAME=`basename $PKG|sed 's/.pkg$//g'`
	if ! cmp $PKG $DIR/$NAME.pkg; then
		BUILD=`cat $DIR/$NAME.build 2>/dev/null`
		if [ "$BUILD" == "" ]; then
			BUILD=1
		else
			(( BUILD=BUILD+1 ))
		fi
		echo "$PKG was rebuilded, build $BUILD"
		mv $PKG $DIR || exit 1
		echo $BUILD > $DIR/$NAME.build || exit 1
	fi
done


echo Compressing $LOG ...
gzip $LOG || exit 1
mv $LOG.gz $DIR || exit 1


echo
echo "* Klaar ja!";