ChrootHelper

#!/usr/bin/env bash
. "${BASH_SOURCE[0]%/*}/function.sh" "" || exit

run() {	init && args "$@" && ${command}Command "${args[@]}"; }

init()
{ 
	config="/etc/schroot"

	os="/var/chroot"
	osBak="/var/chroot/bak"

	debianMirror="http://deb.debian.org/debian"
	ubuntuMirror="http://archive.ubuntu.com/ubuntu/"

	defaultPackages="sudo"
	copyOptions=( --archive -–one-file-system --info=progress2 )
}

usage()
{
	echot "\
usage: ChrootHelper delete|dir|exists|install|installed|list|run NAME
	
	backup|restore DIST					backup or restore a distribution	
	config [DIST](default) 			edit distribution configuration
	install DIST [SUITE](dist) 	install a new distribution
		The SUITE may be a release code name (eg, sid, stretch, jessie) or a symbolic name (eg, unstable, 
		testing, stable, oldstable)

		-d, --debian 		use the Debian mirror
		-u, --ubuntu 		use the Ubuntu mirror

	run NAME
		-a|--arch	ARCH	use the specified architecture for the distribution"
	exit $1
}

args()
{
	arch="" command="" noPrompt="" args=()
	
	while [ "$1" != "" ]; do
		case "$1" in
			-a|--arch) arch="$2"; shift 2; [[ ! $arch ]] && MissingOperand "arch"; continue;;
			-h|--help) usage 0;;
			config|c) command="config";;
			install|i) command="install";;
			run|r) command="run";;
			*) 
				[[ ! $command ]] && IsFunction "${1,,}Command" && { command="${1,,}"; shift; continue; }
				args+=("$1")
		esac
		shift
	done

	[[ ! $command ]] && command="run"
	[[ $arch && "$arch" != "armhf" ]] && { EchoErr "ChrootHelper: only ARM emulation is supported"; return 1; }

	return 0
}

distArg() {	dist="$1"; [[ ! $dist ]] && MissingOperand "dist"; ! distExists "$dist" && { EchoErr "Distribution $dist does not exist"; exit 1; }; }
distDirValidate() { local distDir; distDir="$(distDir "$1")" || return; [[ -d "$distDir" ]] && return; EchoErr "$dist directory \"$distDir\" does not exist"; return 1; }
distExists() { ! InPath schroot && return 0; schroot --list | grep '^chroot:'$1'$' >& /dev/null; }

distDir()
{ 
	! distExists "$1" && return 1
	! InPath schroot && { EchoErr "ChrootHelper: unable to local the $dist distribution"; return 1; }
	schroot -c "$1" --config | grep '^directory=' | cut -d"=" -f2
}

#
# Commands
#

dirCommand() { distDir "$1"; }
existsCommand() { distExists "$1"; }
installedCommand() { InPath schroot; }
listCommand() { schroot --list --all "$@"; }

backupCommand()
{
	local dist; distArg "$1"; shift

	initDirs || returns
	distDirValidate	"$dist" || return

	if [[ -d "$osBak/$dist" ]]; then
		ask -dr n "Do you want to delete the $dist backup" || return
		printf "Removing $dist backup..."
		sudo rm -fr "$osBak/$dist" || return
		echo "done"
	fi

	sudo rsync "${copyOptions[@]}" "$(distDir "$dist")/" "$osBak/$dist"
}

configCommand() 
{ 
	local dist="default"

	[[ $1 ]] && { distArg "$1"; shift; }
	[[ $# != 0 ]] && usage

	SetTextEditor || return
	sudoedit "$config/chroot.d/$dist"
}

deleteCommand()
{
	local dist="$1" dir; dir="$(distDir "$dist")" || return

	[[ ! -d "$dir" ]] && return
	ask -dr n "Do you want to delete the $dist distribution" || return

	printf "Removing $dist..."
	sudo rm -fr $dir || return
	echo "done"
}

fixCommand()
{
	local dist; distArg "$1"; shift
	sudo rm "$(distDir	"$dist")/etc/resolv.conf" || return
}

installCommand()
{

	local dist suite mirror

	initDirs || return

	while (( $# != 0 )); do
		case "$1" in "") : ;;
			-d|--debian) mirror="$debianMirror";;
			-u|--ubuntu) mirror="$ubuntuMirror";;
			*)
				! IsOption "$1" && [[ ! $dist ]] && { dist="$1"; shift; continue; }
				! IsOption "$1" && [[ ! $suite ]] && { suite="$1"; shift; continue; }
				UnknownOption "$1"; return
		esac
		shift
	done
	[[ ! $dist ]] && { MissingOperand "dist"; return; }
	[[ ! $suite ]] && suite="$dist"

	# find the mirror if not specified
	if [[ ! $mirror ]]; then
		if UrlExists "$debianMirror/dists/$suite"; then mirror="$debianMirror"
		elif UrlExists "$ubuntuMirror/dists/$suite"; then mirror="$ubuntuMirror"
		else EchoErr "Could not find suite $suite"; return 1
		fi
	fi

	# configuration
	if ! distExists "$dist"; then	
	echo "[$dist]
description=$dist ($mirror)
directory=$os/$dist
type=directory
users=$USER
root-users=$USER
root-groups=root" | sudo tee "$config/chroot.d/$dist" || return
	fi

	deleteCommand "$dist" || return
	sudo debootstrap --include=$defaultPackages "$suite" "$(distDir "$dist")" || return
	bootstrap-remote "$dist" || return
}

restoreCommand()
{
	local dist; distArg "$1"; shift

	initDirs || return
	[[ ! -d "$osBak/$dist" ]] && { EchoErr "$dist backup does not exist"; return 1; }
	deleteCommand "$dist" || return
	sudo rsync "${copyOptions[@]}" "$osBak/$dist/" "$(distDir "$dist")/"
}

emulate()
{
	local dist; distArg "$1"; shift
	local distDir result; distDir="$(distDir "$dist")" || return
	
	! InPath qemu-arm-static && { EchoErr "qemu-arm-static command not found. Try: sudo apt-get install binfmt-support qemu-user-static"; exit 1; }
  
  [[ -f "$distDir/etc/ld.so.preload" ]] && { sudo mv "$distDir/etc/ld.so.preload" "$distDir/etc/ld.so.preload.disabled" || return; }
	
	sudo install -m 0755 "/usr/bin/qemu-arm-static" "$distDir/usr/bin/qemu-arm-static" || return
	schroot -c "$dist" "$@"; result=$?

	[[ -f "$distDir/etc/ld.so.preload.disabled" ]] && { sudo mv "$distDir/etc/ld.so.preload.disabled" "$distDir/etc/ld.so.preload" || return; }

	return $result
}

runCommand() 
{	
	local dist; distArg "$1"; shift
		
  if [[ "$arch" != "$(dpkg --print-architecture)" ]]; then
		emulate "$dist" "$@"
	elif InPath schroot; then
		schroot -c "$dist" "$@"
	elif IsPlatform mac; then
		sudo HOME=/home/jjbutare chroot -u $USER "$dist" zsh --login "$@"
	elif InPath /opt/bin/chroot; then
		sudo HOME=/home/$USER /opt/bin/chroot --userspec=$USER . zsh --login "$@"
	elif InPath chroot; then
		sudo HOME=/home/$USER chroot --userspec=$USER . zsh --login "$@"
	else
		EchoErr "ChrootHelper: no chroot program found"
		return 1
	fi
}

#
# helper
#

initDirs()
{
	[[ ! -d "$os" ]] && { sudo ${G}mkdir --parents "$os" || return; }
	[[ ! -d "$osBak" ]] && { sudo ${G}mkdir --parents "$osBak" || return; }
	return 0
}

run "$@"