abctl

#!/bin/bash

#set -x

# abort on error
set -eE -o functrace
failure() {
  local lineno=$1
  local msg=$2
  echo "Failed at $lineno: $msg"
}
trap 'failure ${LINENO} "$BASH_COMMAND"' ERR

ORIGIN_DIR=$(pwd)
THIS_DIR=$(dirname $0)

cd $THIS_DIR

function loadenv {
	source env/$1
}

loadenv unix
mkdir -p bin
mkdir -p $ABANU_OSDIR
mkdir -p $ABANU_LOGDIR
mkdir -p $ABANU_TMPDIR
mkdir -p $ABANU_ISODIR
#dd if=/dev/zero of=/tmp/network-disk.img bs=10M count=1
#touch tmp/network-disk.img
if [ ! -f $ABANU_TMPDIR/network-disk.img ]; then
	dd if=/dev/zero of=$ABANU_TMPDIR/network-disk.img bs=10M count=1
fi
loadenv auto

#set -x

rm -f os/*.lock

function configure {
	case $1 in
		all)
			configure patch apply
			;;

		external)
			git clone --recursive git@github.com:abanu-org/abanu-tools.git tools
			;;

		git)
			git remote set-url origin git@github.com:abanu-org/abanu.git

			cd external/MOSA-Project
			git remote set-url origin git@github.com:arakis/MOSA-Project.git
			git remote add upstream https://github.com/mosa/MOSA-Project.git 2> /dev/null
			git remote add tgiphil https://github.com/tgiphil/MOSA-Project.git 2> /dev/null
			git fetch origin
			git fetch upstream
			git fetch tgiphil
			cd ../..
			;;

		patch)
			patch ${@:2}
			;;

		mosa)
			external/MOSA-Project/Source/Compile.sh
			;;

		packages)
			rm -rf external/MOSA-Project/Source/packages;
			
			${nuget} restore external/MOSA-Project/Source/Mosa.sln
			${nuget} restore src/Abanu.sln
			;;

		cloud-test)
			git submodule update --recursive --init
			./abctl configure packages
			;;

		*)
			echo $"Usage: abctl configure {all|patch|mosa|packages|git}"
			exit 1
	esac
}

function clean {
	loadenv unix
	case $1 in
		all)
			clean packages
			clean bin
			clean os
			clean logs
			;;

		bin)
			rm -rf bin
			rm -rf external/MOSA-Project/bin
			find src -type d -name "bin" -exec rm -rf {} \;
			;;

		logs)
			rm -rf logs
			;;

		obj)
			find . -type d -name "obj" -exec rm -rf {} \;
			;;
			
		os)
			rm -rf os
			;;

		packages)
			rm -rf external/MOSA-Project/Source/packages
			;;

		*)
			echo $"Usage: abctl clean {all|bin|os||logs|packages}"
			exit 1
	esac
	loadenv auto
}

function reset {
	case $1 in
		all)
			#reset git
			echo Skipping reset git. Call reset git manually.
			;;

		git)
			if [ -d external/MOSA-Project ]; then
				cd external/MOSA-Project
				git clean -xfd
				git reset --hard
				cd ../../
			fi
			git clean -xfd
			git reset --hard
			git submodule init
			git submodule update --recursive
			;;

		*)
			echo $"Usage: abctl reset {all|git}"
			exit 1
	esac
}

function update {
	case $1 in
		all)
			update git
			;;

		git)
			cd external/MOSA-Project
			git pull
			cd ../../
			git pull
			git submodule update --recursive
			;;

		*)
			echo $"Usage: abctl reset {all|git}"
			exit 1
	esac
}

function patch {
	case $1 in
		apply)
			patches/apply
			;;

		revert)
			patches/apply --reverse
			;;

		*)
			echo $"Usage: abctl configure patch {apply|revert}"
			exit 1
	esac
}

function build {
	case $1 in
		all)

			if [ ! -d external/MOSA-Project/Source/packages ]; then
				./abctl configure packages
			fi

			if [ ! -d external/MOSA-Project/bin ]; then
				./abctl configure mosa
			fi

			build builder
			build assembly
			build native
			build app
			build app2
			build service.consoleserver
			build service.basic
			build service.hostcommunication
			build app.shell
			build loader
			build kernel
			build image
			build disk
			;;

		builder)
			# mono: /verbosity:minimal
			(cd src && ${msbuild} Abanu.Tools.sln /p:Configuration=Release /verbosity:minimal /p:RunCodeAnalysis=false -m)
			cp external/MOSA-Project/bin/Mosa.Plug.Korlib.dll bin
			cp external/MOSA-Project/bin/Mosa.Plug.Korlib.x86.dll bin
			cp external/MOSA-Project/bin/Mosa.Plug.Korlib.x64.dll bin
			cp external/MOSA-Project/bin/dnlib.* bin
			cp external/MOSA-Project/bin/Priority\ Queue.dll bin
			;;

		assembly)
			#(cd src && ${msbuild} Abanu.Kernel.sln /p:Configuration=Debug -verbosity:minimal -m)
			#set -x

			# mono: /verbosity:minimal
			(cd src && ${msbuild} Abanu.sln /p:Configuration=Debug /verbosity:minimal /p:RunCodeAnalysis=false -m)
			;;

		native)
			src/Abanu.Native.${ABANU_ARCH}/build
			;;

		app)
			(cd bin && $ABANU_BUILD build --bin=app)
			;;
		app2)
			(cd bin && $ABANU_BUILD build --bin=app2)
			;;

		app.shell)
			(cd bin && $ABANU_BUILD build --bin=app.shell)
			;;

		service.basic)
			(cd bin && $ABANU_BUILD build --bin=service.basic)
			;;
		external)
			(cd bin && $ABANU_BUILD build --bin=external $2)
			;;

		service.consoleserver)
			(cd bin && $ABANU_BUILD build --bin=service.consoleserver)
			;;

		service.hostcommunication)
			(cd bin && $ABANU_BUILD build --bin=service.hostcommunication)
			;;

		loader)
			(cd bin && $ABANU_BUILD build --bin=loader)
			;;

		kernel)
			(cd bin && $ABANU_BUILD build --bin=kernel)
			;;

		loader,kernel)
			build loader
			build kernel
			;;

		image)
			_image
			;;

		disk)
			_disk
			;;

		*)
			echo $"Usage: abctl build {all|builder|assembly|native|app|app2|image|disk}"
			exit 1
	esac
}

function run {
	case $1 in
		bochs)
			_bochs ${@:2}
			;;

		qemu)
			_qemu ${@:2}
			;;

		*)
			echo $"Usage: abctl run {qemu|bochs}"
			exit 1
	esac
}

function debug {
	loadenv auto

	case $1 in
		qemu-kernel)
			export ABANU_DEBUG_TARGET=$1;
			# TODO: Maybe this will never the case, but we should check if this is really our instance
			pkill gdb || :
			#trap '' SIGINT
			#./abctl debug qemu-kernel-run &
			#debug qemu-kernel-run
			#$ABANU_PROJDIR/bin/Abanu.Tools.HostCommunication.exe &
			#sleep 1
			HostCommunication_PID=$!
			gdb -x conf/gdb-load-symbols -nx -x conf/gdbinit -x conf/gdb-attach-unix -x conf/gdb-workspace
			#kill -9 $HostCommunication_PID
			#gdb -x conf/gdb-load-symbols -x conf/gdb-attach-mswin -x conf/gdb-workspace
			;;

		qemu-kernel-run)
			#loadenv $QEMU_RUNTIME
			loadenv unix
			_renameLogs
			#trap '' SIGINT

			rootdisk=${ABANU_OSDIR}/Abanu.Kernel.Core.x86-efi.disk.img

			# Uncomment if not required!
			DEBUG_INTERRUPTS=,int

			#qemu_app=$QEMU_X64
			qemu_app=$QEMU_X86
			#echo $qemu_app
			#-gdb stdio
			$qemu_app \
				-drive file=${ABANU_OSDIR}/Abanu.OS.Core.${ABANU_ARCH}.img,index=0,media=disk,format=raw \
				-drive file=${rootdisk},index=1,media=disk,format=raw,copy-on-read=off,cache=none \
				-drive file=${ABANU_TMPDIR}/network-disk.img,index=2,media=disk,format=raw,copy-on-read=off,cache=none \
				-kernel os/Abanu.OS.Image.${ABANU_ARCH}.bin -serial file:${ABANU_LOGDIR}/kernel.log -serial tcp::2244,server,nowait,reconnect=100 -S -gdb stdio -d pcall,cpu_reset,guest_errors${DEBUG_INTERRUPTS} -D ${ABANU_LOGDIR}/emulator.log -m 256 \
				2> /dev/null
			;;

		qemu-attach-unix)
			#echo "####################"
			#echo /$ABANU_DEBUG_TARGET/
			#echo ~~~~~~~~~~~~~
			case $ABANU_DEBUG_TARGET in
				qemu-kernel)
					debug qemu-kernel-run
					;;

				qemu-grub-hybrid)
					debug qemu-grub-hybrid-run
					;;

				*)
					echo $"Unkown debug name"
					exit 1
			esac
			;;

		qemu-grub-hybrid)
			export ABANU_DEBUG_TARGET=$1;
			#gdb -x conf/gdb-qemu-grub-hybrid
			gdb -x conf/gdb-load-symbols -nx -x conf/gdbinit -x conf/gdb-attach-unix -x conf/gdb-workspace
			;;

		qemu-grub-hybrid-run)
			loadenv unix
			_renameLogs

			rootdisk=${ABANU_OSDIR}/Abanu.Kernel.Core.x86-efi.disk.img

			# Uncomment if not required!
			DEBUG_INTERRUPTS=,int

			qemu_app=$QEMU_X86

			bios="-L /usr/share/seabios"

			disk=${ABANU_OSDIR}/Abanu.Kernel.Core.x86-grub-hybrid.disk.img

			$qemu_app ${bios} \
				-drive file=${disk},index=0,media=disk,format=raw \
				-drive file=${rootdisk},index=1,media=disk,format=raw,copy-on-read=off,cache=none \
				-drive file=${ABANU_TMPDIR}/network-disk.img,index=2,media=disk,format=raw,copy-on-read=off,cache=none \
				-serial file:${ABANU_LOGDIR}/kernel.log -serial tcp::2244,server,nowait,reconnect=100 -S -gdb stdio -d pcall,cpu_reset,guest_errors${DEBUG_INTERRUPTS} -D ${ABANU_LOGDIR}/emulator.log -m 256 \
				2> /dev/null

			;;

		*)
			echo $"Usage: abctl run {qemu-kernel|qemu-grub-hybrid}"
			exit 1
	esac
	loadenv auto
}

function _renameLogs {
	current=${ABANU_LOGDIR}/kernel.log
	prev1=${ABANU_LOGDIR}/kernel.1.log
	prev2=${ABANU_LOGDIR}/kernel.2.log
	if [ -f $prev2 ]; then
		rm $prev2
	fi
	if [ -f $prev1 ]; then
		mv $prev1 $prev2
	fi
	if [ -f $current ]; then
		mv $current $prev1
	fi
}

function _image {
	(cd bin && ${ABANU_BUILD} build --image)
}

function _disk {
	#image=$ABANU_OSDIR/abanu.kernel.image.bin
	#loader=$ABANU_PROJDIR/os/Abanu.Kernel.Loader.bin
	#kernel=$ABANU_PROJDIR/os/Abanu.Kernel.Core.bin
	#rm -f $image
	#cat $loader $kernel > $image
	#printf '\x31\xc0\xc3' | dd of=$image bs=1 seek=3 count=3 conv=notrunc
	
	create_efi_disk
	create_grub_hybrid_disk
}

function _bochs {
	case $1 in
		x86)
			arch=x86
			;;

		x86-grub-vbe)
			arch=x86-grub-vbe
			;;

		x64)
			arch=x64
			;;

		*)
			echo $"Usage: abctl run bochs {x86|x86-grub-vbe|x64|host}"
			exit 1
	esac

	bochsrc="${ABANU_PROJDIR}/conf/bochs-${arch}.bxrc"
	bochs -f ${bochsrc} -rc "${ABANU_PROJDIR}/conf/bochs.rc"
}

function _qemu {
	loadenv unix
	disk=${ABANU_OSDIR}/Abanu.OS.Core.x86.img

	case $1 in
		x86)
			arch=x86
			qemubin=qemu-system-i386
			cpu=qemu32,+sse4.1
			bios="-L /usr/share/seabios"
			;;

		x86-grub-vbe)
			arch=x86
			qemubin=qemu-system-i386
			cpu=qemu32,+sse4.1
			bios="-L /usr/share/seabios"

			disk=${ABANU_OSDIR}/Abanu.Kernel.Core.x86-grub-hybrid.disk.img
			;;

		x86-efi)
			arch=x86
			qemubin=qemu-system-i386
			cpu=qemu32,+sse4.1
			bios="-bios ${ABANU_PROJDIR}/tools/ovmf-ia32/OVMF-pure-efi.fd"

			disk=${ABANU_OSDIR}/Abanu.Kernel.Core.x86-efi.disk.img
			;;

		x64)
			arch=x64
			qemubin=qemu-system-x86_64
			cpu=qemu64
			bios="-L /usr/share/seabios"
			;;

		host)
			arch=x64
			qemubin=qemu-system-x86_64
			cpu=host
			kvmargs=-enable-kvm
			bios="-L /usr/share/seabios"
			;;

		*)
			echo $"Usage: abctl run qemu {x86|x86-efi|x86-grub-vbe|x64|host}"
			exit 1
	esac

	echo ${qemubin} ${bios} ${kvmargs} -cpu ${cpu} -hda $disk -serial file:${ABANU_PROJDIR}/logs/kernel.log -d pcall,cpu_reset,guest_errors -D ${ABANU_PROJDIR}/logs/emulator.log -m 256
	     ${qemubin} ${bios} ${kvmargs} -cpu ${cpu} -hda $disk -serial file:${ABANU_PROJDIR}/logs/kernel.log -d pcall,cpu_reset,guest_errors -D ${ABANU_PROJDIR}/logs/emulator.log -m 256

	loadenv auto
}

#function create_chroot {
	#wget ${alpine_mirror}/latest-stable/main/x86_64/apk-tools-static-${alpine_version}.apk
	#tar -xzf apk-tools-static-*.apk
	#wget https://raw.githubusercontent.com/alpinelinux/alpine-chroot-install/v0.9.0/alpine-chroot-install \
    #&& echo 'e5dfbbdc0c4b3363b99334510976c86bfa6cb251  alpine-chroot-install' | sha1sum -c \
    #|| exit 1
	#chmod +x alpine-chroot-install
#}

function create_efi_disk {
	loadenv unix
	disk=${ABANU_OSDIR}/Abanu.Kernel.Core.x86-efi.disk.img
	size=51100 #kb
	let "block=((size * 1024) / (512 * 16 * 16)) - 1"
	echo $block
	dd if=/dev/zero of=$disk bs=1k count=$size
	mformat -i $disk -h 16 -t 16 -s $block ::

	# TODO: avoid code duplication
	isodir=$ABANU_PROJDIR/tmp/iso-efi-disk
	mkdir -p $isodir
	rm -f $isodir/TEST.TXT
	echo "This is a test file V2" > $isodir/TEST.TXT

	mcopy -i $disk -s $ABANU_TOOLSDIR/grub-efi-x86/efi ::/
	mcopy -i $disk -s $ABANU_TOOLSDIR/grub-efi-x86/boot ::/
	mcopy -i $disk -s $ABANU_TOOLSDIR/grub-efi-x86/NvVars ::/
	mcopy -i $disk -s $ABANU_TOOLSDIR/grub-efi-x86/.disk ::/
	mcopy -i $disk -s $ABANU_OSDIR/Abanu.OS.Image.${ABANU_ARCH}.bin ::/abanu.bin
	if [ -f $ABANU_OSDIR/Abanu.DisplayServer.bin ]; then
		mcopy -i $disk -s  $ABANU_OSDIR/Abanu.DisplayServer.bin ::/DSPSRV.BIN
	fi
	if [ -f $ABANU_OSDIR/App.GuiDemo.bin ]; then
		mcopy -i $disk -s  $ABANU_OSDIR/App.GuiDemo.bin ::/GUIDEMO.BIN
	fi
	if [ -f $ABANU_OSDIR/c-hello-world.bin ]; then
		mcopy -i $disk -s  $ABANU_OSDIR/c-hello-world.bin ::/CHELLO.BIN
	fi
	mcopy -i $disk -s $isodir/TEST.TXT ::/TEST.TXT

	echo $disk created
	loadenv auto
}

function create_grub_hybrid_disk {
	loadenv unix
	disk=${ABANU_OSDIR}/Abanu.Kernel.Core.x86-grub-hybrid.disk.img
	isodir=$ABANU_PROJDIR/tmp/iso-grub-hybrid
	mkdir -p $isodir;
	cp $ABANU_OSDIR/Abanu.OS.Image.${ABANU_ARCH}.bin $isodir/abanu.bin

	# additional files
	if [ -f $ABANU_OSDIR/Abanu.DisplayServer.bin ]; then
		cp $ABANU_OSDIR/Abanu.DisplayServer.bin $isodir/DSPSRV.BIN 2>/dev/null
	fi
	if [ -f $ABANU_OSDIR/App.GuiDemo.bin ]; then
		cp $ABANU_OSDIR/App.GuiDemo.bin $isodir/GUIDEMO.BIN 2>/dev/null
	fi
	if [ -f $ABANU_OSDIR/c-hello-world.bin ]; then
		cp $ABANU_OSDIR/c-hello-world.bin $isodir/CHELLO.BIN 2>/dev/null
	fi
	rm -f $isodir/TEST.TXT
	echo "This is a test file V2" > $isodir/TEST.TXT

	mkdir -p $isodir/boot/grub
	cp $ABANU_TOOLSDIR/grub-efi-x86/boot/grub/grub.cfg $isodir/boot/grub
	grub-mkrescue -o $disk $isodir
	echo $disk created
	loadenv auto
}

function logs {
	case $1 in
		kernel)
			less +F "${ABANU_PROJDIR}/logs/kernel.log"
			;;

		emulator)
			less +F "${ABANU_PROJDIR}/logs/emulator.log"
			;;

		*)
			echo $"Usage: abctl logs {kernel|emulator}"
			exit 1
	esac
}

function _test {
	case $1 in
		cloud)
			(cd bin && ${ABANU_BUILD} run --emulator=qemu --boot=direct --test)
			echo Test finished
			;;

		*)
			echo $"Usage: abctl test {cloud}"
			exit 1
	esac
}

function _tool {
	case $1 in
		msbuild)
			(cd $ORIGIN_DIR && $msbuild ${@:2})
			;;

		*)
			echo $"Usage: tool {msbuild}"
			exit 1
	esac
}

function _abspath {
	loadenv auto
	cd $ORIGIN_DIR;
	echo $(__platform_abspath $1)
	cd $THIS_DIR;
}

case $1 in
	configure)
		configure ${@:2}
		;;

	clean)
		clean ${@:2}
		;;

	update)
		update ${@:2}
		;;

	reset)
		reset ${@:2}
		;;

	build)
		build ${@:2}
		;;

	run)
		run ${@:2}
		;;

	logs)
		logs ${@:2}
		;;

	f1)
		create_efi_disk ${@:2}
		#create_chroot
		;;

	debug)
		debug ${@:2}
		;;

	test)
		_test ${@:2}
		;;

	abspath)
		_abspath ${@:2}
		;;

	tool)
		_tool ${@:2}
		;;

	*)
		echo $"Usage: abctl {configure|build|run|debug|clean|reset|logs|update}"
		exit 1
esac