#!/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: Sam Okt 06 18:01:53 CEST 2007 [mika]
################################################################################
# http://www.debian.org/releases/stable/i386/index.html.en

set -e # exit on any error

VERSION='0.11'

# 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
# }}}

# 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
# }}}

# cmdline handling {{{
usage() {
  einfo "$0 - version $VERSION"
  echo  "   A wrapper around debootstrap for installing plain Debian via grml"
  echo
  einfo "Usage: $0 [options]"
  echo  "   Adjust /etc/debootstrap/config and invoke $0 afterwards or use the cmdline option:"
  echo
  einfo "Valid options:"
  echo  "
    -h|--help                   Print this usage information and exit.
    -v|--version                Show summary of options and exit.

    -t|--target <target>        Target partition (/dev/...) or directory.
    -r|--release <release>      Specify release of new Debian system. Supported relases: sarge, etch, lenny and sid.
    -m|--mirror <URL>           Specify mirror which should be used for apt-get/aptitude.
    -i|--iso <mnt>              Specify mountpoint where Debian ISO is mounted to (instead of using mirror)
    -p|--mntpoint <mnt>         Specify mountpoint that should be used for mounting the target system.
    --groot <device>            Specify root device for usage in grub (corresponds with \$TARGET).
    --grub <device>             Where do you want to install grub to? Use grub syntax for specifying.
    --password <pwd>            Use specified password as password for user root. Use with caution.
    --boot_append <appendline>  Add specified appendline to kernel whilst booting

"
}

while [ "$#" -gt "0" ] ; do
    case $1 in
        -v|--version)
            einfo "$0 - version $VERSION"
            einfo "Send bug reports to Michael Prokop <mika@grml.org>."
            eend 0
            exit 0
            ;;
        -t|--target)
            shift
            TARGET=$1
            ;;
        --grub)
            shift
            GRUB=$1
            ;;
        --groot)
            shift
            GROOT=$1
            ;;
        --release)
            shift
            RELEASE=$1
            ;;
        -p|--mntpoint)
            shift
            MNTPOINT=$1
            ;;
        --password)
            shift
            ROOTPASSWORD=$1
            ;;
        -m|--mirror)
            shift
            MIRROR=$1
            CHROOTMIRROR=$1
            ;;
        -i|--iso)
            shift
            [ -n "$MIRROR" ] && unset MIRROR
            ISO=$1
            ;;
        -h|--help)
            usage ; eend 0
            eend 0
            exit 0
            ;;
        *)
            eerror "Syntax error."
            usage ; eend 1
            exit 1
            ;;
    esac
    shift
done
# }}}

# 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 [ -r "$STAGES"/grml-debootstrap ] ; then
   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
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 we have the right syntax when using an iso image
case $ISO in
   file*) # do nothing
    ;;
   *)
    ISO=file:$1
    ;;
esac
ISODIR=${ISO##file:}
ISODIR=${ISODIR%%/}

# provide variables to chroot system
touch /etc/debootstrap/variables
chmod 600 /etc/debootstrap/variables # make sure nobody except root can read it
[ -n "$ARCH" ]   && echo "ARCH=$ARCH"     >  /etc/debootstrap/variables
[ -n "$GRUB" ]   && echo "GRUB=$GRUB"     >> /etc/debootstrap/variables
[ -n "$GROOT" ]  && echo "GROOT=$GROOT"   >> /etc/debootstrap/variables
[ -n "$TARGET" ] && echo "TARGET=$TARGET" >> /etc/debootstrap/variables
[ -n "$ISO" ]    && echo "ISO=$ISO"       >> /etc/debootstrap/variables
[ -n "$ISODIR" ] && echo "ISODIR=$ISO"    >> /etc/debootstrap/variables
[ -n "$MIRROR" ] && echo "MIRROR=$MIRROR" >> /etc/debootstrap/variables
[ -n "$MIRROR" ] && echo "CHROOTMIRROR=$MIRROR" >> /etc/debootstrap/variables
[ -n "$ROOTPASSWORD" ] && echo "ROOTPASSWORD=$ROOTPASSWORD" >> /etc/debootstrap/variables

# 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 "$MNTPOINT" ] ; then
     if grep -q $MNTPOINT /proc/mounts ; then
        # make sure nothing is left inside chroot so we can unmount it
        [ -x "$MNTPOINT"/etc/init.d/ssh   ] && "$MNTPOINT"/etc/init.d/ssh stop
        [ -x "$MNTPOINT"/etc/init.d/mdadm ] && "$MNTPOINT"/etc/init.d/mdadm stop
        # ugly, but make sure we really don't leav anything
        [ -x "$MNTPOINT"/bin/umount ] && chroot "$MNTPOINT" umount /sys  1>/dev/null 2>&1
        [ -x "$MNTPOINT"/bin/umount ] && chroot "$MNTPOINT" umount -a    1>/dev/null 2>&1
        [ -x "$MNTPOINT"/bin/umount ] && chroot "$MNTPOINT" umount /proc 1>/dev/null 2>&1
        [ -x "$MNTPOINT"/bin/umount ] && chroot "$MNTPOINT" umount /proc 1>/dev/null 2>&1
        [ -d "$MNTPOINT/$ISODIR" ] && umount "$MNTPOINT/$ISODIR" 1>/dev/null 2>&1
        einfo "Unmounting $MNTPOINT" ; umount "$MNTPOINT" ; eend $?
     fi
  fi
  [ -n "$1" ] && EXIT="$1" || EXIT="1"
  [ -n "$3" ] && einfo "Notice: just remove $STAGES/$3 to reexecute the stage"
  exit "$EXIT"
}
trap bailout 1 2 3 15

# we want to execute all the functions only once, simple check for it:
stage() {
  if [ -n "$2" ] ; then
     echo "$2" > "$STAGES/$1"
     return 0
  elif grep -q done "$STAGES/$1" 2>/dev/null ; then
     ewarn "Notice: stage $1 has been executed already, skipping execution therefore." ; eend 0
     eindent
       ewarn "To reexecute it clean up the according directory inside $STAGES" ; eend 0
     eoutdent
     return 1
  fi
}
# }}}

# user should recheck his configuration {{{
# support full automatic installation:
checkforrun() {
   dialog --timeout 10 --title "$0" \
          --yesno "Do you want to stop at this stage?

Notice: you are running grml-debootstrap in non-interactive mode.
grml-debootstrap will install Debian ${RELEASE} on ${TARGET}.
Last chance to quit. Timeout of 10 seconds running....

Do you want to stop now?" 0 0 2>/dev/null
}

if [ -n "$AUTOINSTALL" ] ; then
   if checkforrun ; then
      eerror "Exiting as requested" ; eend 0
      exit 1
   fi
else # if not running automatic installation display configuration and prompt for execution:
   einfo "$0 - Please recheck configuration before execution:"
   echo
   echo "   Target:           $TARGET"
      case "$MNTPOINT" in "$TARGET") ;; *) echo "   Mount-point:      $MNTPOINT" ;; esac
      [ -n "$GRUB" ]   && echo "   Install grub to:  $GROOT / $GRUB"
      [ -n "$MIRROR" ] && echo "   Using mirror:     $MIRROR"
      [ -n "$ISO" ] && echo "   Using iso:        $ISO"
      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
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
  if [ -n "$ISODIR" ] ; then
     einfo "Mounting Debian image loopback to $MNTPOINT/$ISODIR."
     mkdir -p "$MNTPOINT/$ISODIR"
     mount --bind "$ISODIR" "$MNTPOINT/$ISODIR"
     eend $?
  fi
}
# }}}

# install main chroot {{{
debootstrap_system() {
  if ! grep -q $MNTPOINT /proc/mounts ; then
          mount_target
  fi
  if grep -q $MNTPOINT /proc/mounts ; then
     einfo "Running $DEBOOTSTRAP for release ${RELEASE}${ARCHINFO} using ${MIRROR}${ISO}"
     [ -n "$MIRROR" ] && $DEBOOTSTRAP $ARCHCMD $RELEASE $MNTPOINT $MIRROR || \
     $DEBOOTSTRAP $ARCHCMD $RELEASE $MNTPOINT $ISO
     eend $?
  else
     eerror "Error: $MNTPOINT not mounted, can not continue."
     eend 1
  fi
}
# }}}

# 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
  cp /etc/debootstrap/variables       $MNTPOINT/etc/debootstrap/variables

  cp -a /etc/debootstrap/extrapackages/ $MNTPOINT/etc/debootstrap/

  # 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() {
  if ! [ -r "$MNTPOINT/bin/chroot-script" ] ; then
     mount_target
  fi
  if [ -x "$MNTPOINT/bin/chroot-script" ] ; then
     einfo "Executing chroot-script now"
     chroot "$MNTPOINT" /bin/chroot-script
     eend $?
  else
     eerror "Fatal: $MNTPOINT/bin/chroot-script could not be found."
     eend 1
  fi
}
# }}}

# 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}:"
     [ -x /usr/sbin/grub-install ] && GRUBINSTALL=/usr/sbin/grub-install || GRUBINSTALL=/sbin/grub-install
     $GRUBINSTALL --root-directory="$MNTPOINT" "(${GRUB})"
     eend $?
  fi
}
# }}}

# unmount $MNTPOINRT {{{
umount_chroot() {
  if [ -n "$ISODIR" ] ; then
     if grep -q "$ISODIR" /proc/mounts ; then
        einfo "Unmount $MNTPOINT/$ISODIR"
        umount "$MNTPOINT/$ISODIR"
        eend $?
     fi
  fi
  if grep -q "$MNTPOINT" /proc/mounts ; then
     if [ -n "$PARTITION" ] ; then
        einfo "Unmount $MNTPOINT"
        umount $MNTPOINT
        eend $?
     fi
  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 {{{
for i in mkfs tunefs mount_target debootstrap_system preparechroot \
         chrootscript grub_install umount_chroot fscktool ; do
    if stage $i ; then
       $i && stage $i done || bailout 2 "i"
    fi
done
# }}}

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

if [ -n "$AUTOINSTALL" ] ; then
   dialog --title "$0" --msgbox \
          "Finished execution of ${0}.
Enjoy your Debian system." 6 60
else
   einfo "Finished execution of $0 - enjoy your Debian system." ; eend 0
fi

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