#!/bin/sh
# Filename:      grml-bootstrap
# Purpose:       wrapper around debootstrap for installing plain Debian via grml
# Authors:       grml-team (grml.org), (c) Michael Prokop <mika@grml.org>
# Bug-Reports:   see http://grml.org/bugs/
# License:       This file is licensed under the GPL v2.
# Latest change: Don Apr 12 11:39:22 CEST 2007 [mika]
################################################################################
# http://www.debian.org/releases/stable/i386/index.html.en

set -e # exit on any error

VERSION='0.6'

# source core functions {{{
. /etc/grml/lsb-functions
. /etc/grml/script-functions
# }}}

# make sure we have what we need {{{
check4progs debootstrap || exit 1
check4root || exit 1
# }}}

# cmdline handling {{{
case $* in
   -h*|--h*)
     einfo "$0 - wrapper around debootstrap for installing plain Debian via grml"
     einfo "Adjust /etc/debootstrap/config and invoke $0 afterwards."
     eend 0
     exit 0
   ;;
   -v|--v*)
     einfo "$0 version $VERSION"
     einfo "Send bug reports to Michael Prokop <mika@grml.org>."
     eend 0
     exit 0
   ;;
esac
# }}}

# without config file it won't work {{{
if [ -r /etc/debootstrap/config ] ; then
   . /etc/debootstrap/config
else
   eerror "/etc/debootstrap/config could not be read, exiting." ; eend 1
   exit 1
fi
# }}}

# set/check variables {{{

# inside the chroot system the locales might not be available, so use minimum:
export LANG=C
export LC_ALL=C

if [ -z "$STAGES" ] ; then
   STAGES='/etc/debootstrap/stages'
   [ -d "$STAGES" ] || mkdir -p "$STAGES"
fi

if grep -q done $STAGES/grml-debootstrap ; then
   eerror "Error: grml-debootstrap has been executed already, won't continue therefore."
   eerror "If you want to re-execute grml-debootstrap just manually remove ${STAGES}" ; eend 1
fi

PARTITION=''
DIRECTORY=''

case $TARGET in
  /dev/*)
    PARTITION=1
    ;;
  *)
    # assume we are installing into a directory, don't run mkfs and grub related stuff therefore
    DIRECTORY=1
    MNTPOINT="$TARGET"
    MKFS=''
    TUNE2FS=''
    FSCK=''
    GRUB=''
    GROOT=''
    ;;
esac

if [ -n "$ARCH" ] ; then
   ARCHCMD="--arch $ARCH"
   ARCHINFO=" (${ARCH})"
else
   ARCH="$(dpkg --print-architecture)"
   ARCHCMD="--arch $ARCH"
   ARCHINFO=" (${ARCH})"
fi

# make sure at least $TARGET is set [the partition for the new system]
if [ -z "$TARGET" ] ; then
   eerror "Please adjust /etc/debootstrap/config before running ${0}" ; eend 1
   exit 1
fi
# }}}

# helper functions {{{
# we want to exit smoothly and clean:
bailout(){
  # make sure $TARGET is not mounted when exiting grml-debootstrap
  if [ -n "$TARGET" ] ; then
     if grep -q $TARGET /proc/mounts ; then
        # make sure nothing is left inside chroot so we can unmount it
        [ -x "$TARGET"/etc/init.d/ssh   ] && "$TARGET"/etc/init.d/ssh stop
        [ -x "$TARGET"/etc/init.d/mdadm ] && "$TARGET"/etc/init.d/mdadm stop
        chroot "$TARGET" umount /sys  1>/dev/null 2>&1
        chroot "$TARGET" umount /proc 1>/dev/null 2>&1
        echo "Unmounting $TARGET"
        umount "$TARGET"
     fi
  fi
  [ -n "$1" ] && EXIT="$1" || EXIT="1"
  exit "$EXIT"
}
trap bailout 1 2 3 15

# we want to execute all the functions only once, simple check for it:
stage() {
  if grep -q done "$STAGES/$1" 2>/dev/null ; then
     ewarn "Notice: stage $1 has been executed already, skipping execution therefore." ; eend 0
     return 1
  else
     echo "$2" > "$STAGES/$1"
     return 0
  fi
}
# }}}

# user should recheck his configuration {{{
einfo "$0 - Please recheck configuration before execution:"
echo "
   Target:           $TARGET"
   case "$MNTPOINT" in "$TARGET") ;; *) echo "   Mount-point:      $MNTPOINT" ;; esac
   [ -n "$GRUB" ] && echo "   Install grub to:  $GROOT / $GRUB"
   case "$MNTPOINT" in "$TARGET") ;; *) echo "  Important! Continuing will delete all data from ${TARGET}!" ;; esac
   echo
einfon "Is this ok for you? [y/N] "

read a
if ! [ "$a" = 'y' -o "$a" = 'Y' ] ; then
   eerror "Exiting as requested." ; eend 1
   exit 1
fi
# }}}

# create filesystem {{{
mkfs() {
  if [ -n "$MKFS" ] ; then
     einfo "Running $MKFS on $TARGET"
     $MKFS $TARGET
     eend $?
  fi
}
# }}}

# modify filesystem settings {{{
tunefs() {
  if [ -n "$TUNE2FS" ] ; then
     einfo "Disabling automatic filesystem check on $TARGET via tune2fs"
     $TUNE2FS $TARGET
     eend $?
  fi
}
# }}}

# mount the new partition or if it's a directory do nothing at all {{{
mount_target() {
  if [ -n "$DIRECTORY" ] ; then
     einfo "Running grml-debootstrap on a directory, nothing to mount."
  else
     if grep -q $TARGET /proc/mounts ; then
        eerror "$TARGET already mounted, exiting."
     else
       [ -n "$MNTPOINT" ] || MNTPOINT='/mnt/test'
       [ -d "$MNTPOINT" ] || mkdir -p "$MNTPOINT"
       einfo "Mounting $TARGET to $MNTPOINT"
       mount -o rw,suid,dev $TARGET $MNTPOINT
       eend $?
     fi
  fi
}
# }}}

# install main chroot {{{
debootstrap_system() {
  einfo "Running $DEBOOTSTRAP for release ${RELEASE}${ARCHINFO} using mirror $MIRROR"
  $DEBOOTSTRAP $ARCHCMD $RELEASE $MNTPOINT $MIRROR
  eend $?
}
# }}}

# prepare chroot via chroot-script {{{
preparechroot() {
  einfo "Preparing chroot system"
  cp $CONFFILES/chroot-script $MNTPOINT/bin/chroot-script
  chmod 755 $MNTPOINT/bin/chroot-script
  mkdir $MNTPOINT/etc/debootstrap/

  # make sure we have our files for later use via chroot-script
  cp /etc/debootstrap/config $MNTPOINT/etc/debootstrap/
  cp /etc/debootstrap/packages $MNTPOINT/etc/debootstrap/packages

  # make sure we can access network [relevant for cdebootstrap]
  [ -f "$MNTPOINT/etc/resolv.conf" ] || cp /etc/resolv.conf $MNTPOINT/etc/resolv.conf

  # setup default locales
  [ -n "$LOCALES" ] && cp /etc/debootstrap/locale.gen  $MNTPOINT/etc/locale.gen

  # copy any existing existing files to chroot
  [ -d /etc/debootstrap/boot  ] && cp -a /etc/debootstrap/boot/*  $MNTPOINT/boot/
  [ -d /etc/debootstrap/etc   ] && cp -a /etc/debootstrap/etc/*   $MNTPOINT/etc/
  [ -d /etc/debootstrap/share ] && cp -a /etc/debootstrap/share/* $MNTPOINT/share/
  [ -d /etc/debootstrap/usr   ] && cp -a /etc/debootstrap/usr/*   $MNTPOINT/usr/
  [ -d /etc/debootstrap/var   ] && cp -a /etc/debootstrap/var/*   $MNTPOINT/var/
  eend 0
}
# }}}

# execute chroot-script {{{
chrootscript() {
  einfo "Executing chroot-script now"
  chroot "$MNTPOINT" /bin/chroot-script
  eend $?
}
# }}}

# install booloader grub {{{
grub_install() {
  if [ -z "$GRUB" -o -z "$GROOT" ] ; then
     echo "Notice: \$GRUB or \$GROOT not defined, will not install grub therefor."
  else
     einfo "Installing grub on ${GRUB}:"
     grub-install --root-directory="$MNTPOINT" "(${GRUB})"
     eend $?
  fi
}
# }}}

# unmount $MNTPOINRT {{{
umount_chroot() {
  if [ -n "$PARTITION" ] ; then
     einfo "Unmount $MNTPOINT"
     umount $MNTPOINT
     eend $?
  fi
}
# }}}

# execute filesystem check {{{
fscktool() {
  if [ "$FSCK" = 'yes' ] ; then
     [ -n "$FSCKTOOL" ] || FSCKTOOL="fsck.${MKFS#mkfs.}"
     einfo "Checking filesystem on $TARGET using $FSCKTOOL"
     $FSCKTOOL $TARGET
     eend $?
  fi
}
# }}}

# now execute all the functions {{{
  stage mkfs               && mkfs               && stage mkfs done
  stage tunefs             && tunefs             && stage tunefs done
  stage mount_target       && mount_target       && stage mount_target done
  stage debootstrap_system && debootstrap_system && stage debootstrap_system done
  stage preparechroot      && preparechroot      && stage preparechroot done
  stage chrootscript       && chrootscript       && stage chrootscript done
  stage grub_install       && grub_install       && stage grub_install done
  stage umount_chroot      && umount_chroot      && stage umount_chroot done
  stage fscktool           && fscktool           && stage fscktool done
# }}}

# stages {{{
  echo done > $STAGES/grml-debootstrap
# }}}

  einfo "Finished execution of $0 - enjoy your Debian system." ; eend 0

## END OF FILE #################################################################
# vim: ai tw=100 expandtab foldmethod=marker