#!/bin/bash

# Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

# This script sets up a Gentoo chroot environment. The script is passed the
# path to an empty folder, which will be populated with a Gentoo stage3 and
# setup for development. Once created, the password is set to PASSWORD (below).
# One can enter the chrooted environment for work by running enter_chroot.sh.

# --- BEGIN COMMON.SH BOILERPLATE ---
# Load common CrOS utilities.  Inside the chroot this file is installed in
# /usr/lib/crosutils.  Outside the chroot we find it relative to the script's
# location.
find_common_sh() {
  local common_paths=(/usr/lib/crosutils $(dirname "$0"))
  local path

  SCRIPT_ROOT=
  for path in "${common_paths[@]}"; do
    if [ -r "${path}/common.sh" ]; then
      SCRIPT_ROOT=${path}
      break
    fi
  done
}

find_common_sh
. "${SCRIPT_ROOT}/common.sh" || (echo "Unable to load common.sh" && exit 1)
# --- END COMMON.SH BOILERPLATE ---

# Check if the host machine architecture is supported.
ARCHITECTURE="$(uname -m)"
if [[ "$ARCHITECTURE" != "x86_64" ]]; then
  echo "$SCRIPT_NAME: $ARCHITECTURE is not supported as a host machine architecture."
  exit 1
fi

# Script must be run outside the chroot
assert_outside_chroot

# Define command line flags
# See http://code.google.com/p/shflags/wiki/Documentation10x

DEFINE_string chroot "$DEFAULT_CHROOT_DIR" \
  "Destination dir for the chroot environment."
DEFINE_boolean usepkg $FLAGS_TRUE "Use binary packages to bootstrap."
DEFINE_boolean delete $FLAGS_FALSE "Delete an existing chroot."
DEFINE_boolean replace $FLAGS_FALSE "Overwrite existing chroot, if any."
DEFINE_integer jobs -1 "How many packages to build in parallel at maximum."
DEFINE_boolean fast ${DEFAULT_FAST} "Call many emerges in parallel"
DEFINE_string stage3_date "2010.03.09" \
  "Use the stage3 with the given date."

# Parse command line flags
FLAGS_HELP="usage: $SCRIPT_NAME [flags]"
FLAGS "$@" || exit 1
eval set -- "${FLAGS_ARGV}"
check_flags_only_and_allow_null_arg "$@" && set --

assert_not_root_user


# Only now can we die on error.  shflags functions leak non-zero error codes,
# so will die prematurely if 'set -e' is specified before now.
# TODO: replace shflags with something less error-prone, or contribute a fix.
set -e

FULLNAME="ChromeOS Developer"
DEFGROUPS="eng,adm,cdrom,floppy,audio,video,portage"
PASSWORD=chronos
CRYPTED_PASSWD=$(perl -e 'print crypt($ARGV[0], "foo")', $PASSWORD)

USEPKG=""
if [[ $FLAGS_usepkg -eq $FLAGS_TRUE ]]; then
  # Use binary packages. Include all build-time dependencies,
  # so as to avoid unnecessary differences between source
  # and binary builds.
  USEPKG="--getbinpkg --usepkg --with-bdeps y"
fi

# Support faster build if necessary.
EMERGE_CMD="emerge"
if [ "$FLAGS_fast" -eq "${FLAGS_TRUE}" ]; then
  CHROOT_CHROMITE_DIR="/home/${USER}/trunk/chromite"
  EMERGE_CMD="${CHROOT_CHROMITE_DIR}/bin/parallel_emerge"
fi

function in_chroot {
  sudo chroot "$FLAGS_chroot" "$@"
}

function bash_chroot {
  # Use $* not $@ since 'bash -c' needs a single arg
  # Use -l to force source of /etc/profile (login shell)
  sudo "${CHROOT_PASSTHRU[@]}" chroot "$FLAGS_chroot" bash -l -c "$*"
}

function cleanup {
  # Clean up mounts
  #
  # HACK ALERT: Instead of tracking our nested mounts, we assume they will
  # HACK ALERT: be shown in mount order. So we just reverse the list and
  # HACK ALERT: umount them.
  mount | grep "on $(readlink -f "$FLAGS_chroot")" | awk '{print $3}' \
    | sort -r | xargs -r -L1 sudo umount -l
}

function delete_existing {
  # Delete old chroot dir
  if [[ -e "$FLAGS_chroot" ]]; then
    echo "$SCRIPT_NAME: Cleaning up old mount points..."
    cleanup
    echo "$SCRIPT_NAME: Deleting $FLAGS_chroot..."
    sudo rm -rf "$FLAGS_chroot"
    echo "$SCRIPT_NAME: Done."
  fi
}

function init_users () {
   echo "$SCRIPT_NAME: Set timezone..."
   # date +%Z has trouble with daylight time, so use host's info
   if [ -f /etc/localtime ] ; then
      sudo cp /etc/localtime "${FLAGS_chroot}/etc"
   else
   in_chroot [ -f /usr/share/zoneinfo/$TZ ] || TZ=PST8PDT
     in_chroot rm -f /etc/localtime
     in_chroot ln -sf /usr/share/zoneinfo/PST8PDT /etc/localtime
   fi
   echo "$SCRIPT_NAME: Adding user/group..."
   # Add ourselves as a user inside the chroot
   in_chroot groupadd -g 5000 eng
   in_chroot useradd -G ${DEFGROUPS} -g eng -u `id -u` -s \
     /bin/bash -m -c "${FULLNAME}" -p ${CRYPTED_PASSWD} ${USER}
}

function init_setup () {
   echo "$SCRIPT_NAME: Running init_setup()..."
   sudo mkdir -p "${FLAGS_chroot}/usr"
   sudo ln -sf "${CHROOT_TRUNK}/src/third_party/portage" \
     "${FLAGS_chroot}/usr/portage"
   sudo mkdir -p "${FLAGS_chroot}/usr/local/portage"
   sudo chmod 755 "${FLAGS_chroot}/usr/local/portage"
   sudo ln -sf "${CHROOT_TRUNK}/src/third_party/chromiumos-overlay" \
     "${FLAGS_chroot}"/"${CHROOT_OVERLAY}"

   # Some operations need an mtab
   in_chroot ln -s /proc/mounts /etc/mtab

   # Set up sudoers.  Inside the chroot, the user can sudo without a password.
   # (Safe enough, since the only way into the chroot is to 'sudo chroot', so
   # the user's already typed in one sudo password...)
   bash_chroot "echo Defaults env_keep += CROS_WORKON_SRCROOT >> /etc/sudoers"
   bash_chroot "echo Defaults env_keep += CHROMEOS_OFFICIAL >> /etc/sudoers"
   bash_chroot "echo Defaults env_keep += PORTAGE_USERNAME >> /etc/sudoers"
   bash_chroot "echo Defaults env_keep += http_proxy >> /etc/sudoers"
   bash_chroot "echo Defaults env_keep += ftp_proxy >> /etc/sudoers"
   bash_chroot "echo Defaults env_keep += all_proxy >> /etc/sudoers"
   bash_chroot "echo %adm ALL=\(ALL\) ALL >> /etc/sudoers"
   bash_chroot "echo root ALL=\(ALL\) ALL >> /etc/sudoers"
   bash_chroot "echo $USER ALL=NOPASSWD: ALL >> /etc/sudoers"
   bash_chroot chmod 0440 /etc/sudoers
   bash_chroot chown root:root /etc/sudoers # Fix bad group on some systems

   echo "$SCRIPT_NAME: Setting up hosts/resolv..."
   # Copy config from outside chroot into chroot
   sudo cp /etc/hosts "$FLAGS_chroot/etc/hosts"
   sudo chmod 0644 "$FLAGS_chroot/etc/hosts"
   sudo cp /etc/resolv.conf "$FLAGS_chroot/etc/resolv.conf"
   sudo chmod 0644 "$FLAGS_chroot/etc/resolv.conf"

   # Setup host make.conf. This includes any overlay that we may be using
   # and a pointer to pre-built packages.
   # TODO: This should really be part of a profile in the portage
   echo "$SCRIPT_NAME: Setting up /etc/make.*..."
   sudo mv "${FLAGS_chroot}"/etc/make.conf{,.orig}
   sudo ln -sf "${CHROOT_CONFIG}/make.conf.amd64-host" \
     "${FLAGS_chroot}/etc/make.conf"
   sudo mv "${FLAGS_chroot}"/etc/make.profile{,.orig}
   sudo ln -sf "${CHROOT_OVERLAY}/profiles/default/linux/amd64/10.0" \
     "${FLAGS_chroot}/etc/make.profile"

   # Create make.conf.user
   sudo touch "${FLAGS_chroot}"/etc/make.conf.user
   sudo chmod 0644 "${FLAGS_chroot}"/etc/make.conf.user

   # Create directories referred to by our conf files.
   sudo mkdir -p -m 775 "${FLAGS_chroot}/var/lib/portage/distfiles"
   sudo mkdir -p -m 775 "${FLAGS_chroot}/var/lib/portage/distfiles-target"
   sudo mkdir -p -m 775 "${FLAGS_chroot}/var/lib/portage/pkgs"

   if [[ $FLAGS_jobs -ne -1 ]]; then
     EMERGE_JOBS="--jobs=$FLAGS_jobs"
   fi

   # Configure basic stuff needed
   in_chroot env-update
   bash_chroot ls -l /etc/make.conf
   bash_chroot ls -l /etc/make.profile
   bash_chroot ls -l /usr/local/portage/chromiumos/profiles/default/linux/amd64/10.0

   # Niceties for interactive logins ('enter_chroot.sh'); these are ignored
   # when specifying a command to enter_chroot.sh.
   # Warn less when apt-get installing packqages
   echo "export CROS_WORKON_SRCROOT=\"${CHROOT_TRUNK}\"" >> \
     "$FLAGS_chroot/home/$USER/.bash_profile"
   echo "export LANG=C" >> "$FLAGS_chroot/home/$USER/.bashrc"
   echo "export PS1=\"(cros-chroot) \$PS1\"" >> "$FLAGS_chroot/home/$USER/.bashrc"

   # Add chromite/bin into the user's path; note that the chromite wrapper
   # itself might also be found in depot_tools.
   echo "PATH=\$PATH:/home/$USER/trunk/chromite/bin" >> \
     "${FLAGS_chroot}/home/$USER/.bashrc"

   # Add chromite as a local site-package.
   mkdir -p "${FLAGS_chroot}/home/$USER/.local/lib/python2.6/site-packages"
   ln -s ../../../../trunk/chromite \
     "${FLAGS_chroot}/home/$USER/.local/lib/python2.6/site-packages/"

   echo "PATH=\$PATH:/home/$USER/depot_tools" >> \
     "${FLAGS_chroot}/home/$USER/.bashrc"

   echo "export PORTAGE_USERNAME=$USER" >> "$FLAGS_chroot/home/$USER/.bash_profile"
   chmod a+x "$FLAGS_chroot/home/$USER/.bashrc"
   # Automatically change to scripts directory
   echo "cd trunk/src/scripts" >> "$FLAGS_chroot/home/$USER/.bash_profile"

   # Enable bash completion for build scripts
   echo ". bash_completion" >> "$FLAGS_chroot/home/$USER/.bash_profile"

   # Warn if attempting to use source control commands inside the chroot
   for NOUSE in svn gcl gclient
   do
     echo "alias $NOUSE='echo In the chroot, it is a bad idea to run $NOUSE'" \
       >> "$FLAGS_chroot/home/$USER/.bash_profile"
   done

   if [[ "$USER" = "chrome-bot" ]]; then
     # Copy ssh keys, so chroot'd chrome-bot can scp files from chrome-web.
     cp -r ~/.ssh "$FLAGS_chroot/home/$USER/"
   fi

   if [[ -f $HOME/.gitconfig ]]; then
     # Copy .gitconfig into chroot so repo and git can be used from inside
     # This is required for repo to work since it validates the email address
     echo "Copying ~/.gitconfig into chroot"
     cp $HOME/.gitconfig "$FLAGS_chroot/home/$USER/"
   fi
}

# Handle deleting an existing environment
if [[ $FLAGS_delete  -eq $FLAGS_TRUE || \
      $FLAGS_replace -eq $FLAGS_TRUE ]]; then
  delete_existing
  [[ $FLAGS_delete -eq $FLAGS_TRUE ]] && exit 0
fi

CHROOT_TRUNK="${CHROOT_TRUNK_DIR}"
PORTAGE="${SRC_ROOT}/third_party/portage"
OVERLAY="${SRC_ROOT}/third_party/chromiumos-overlay"
CONFIG_DIR="${OVERLAY}/chromeos/config"
CHROOT_CONFIG="${CHROOT_TRUNK}/src/third_party/chromiumos-overlay/chromeos/config"
CHROOT_OVERLAY="/usr/local/portage/chromiumos"
CHROOT_STATE="${FLAGS_chroot}/etc/debian_chroot"
CHROOT_PASSTHRU=(CROS_WORKON_SRCROOT="$CHROOT_TRUNK" PORTAGE_USERNAME="$USER")

# Pass proxy variables into the environment.
for type in http ftp all; do
   value=$(env | grep ${type}_proxy || true)
   if [ -n "${value}" ]; then
      CHROOT_PASSTHRU=("${CHROOT_PASSTHRU[@]}" "$value")
   fi
done

# Create the base Gentoo stage3 based on last version put in chroot
STAGE3="${OVERLAY}/chromeos/stage3/stage3-amd64-${FLAGS_stage3_date}.tar.bz2"
if [ -f $CHROOT_STATE ] && \
  ! sudo egrep -q "^STAGE3=$STAGE3" $CHROOT_STATE >/dev/null 2>&1
then
  echo "$SCRIPT_NAME: STAGE3 version has changed."
  delete_existing
fi

# Create the destination directory
mkdir -p "$FLAGS_chroot"

echo
if [ -f $CHROOT_STATE ]
then
  echo "$SCRIPT_NAME: STAGE3 already set up.  Skipping..."
else
  echo "$SCRIPT_NAME: Unpacking STAGE3..."
  sudo tar xjp -C "$FLAGS_chroot" -f "$STAGE3"
fi

# Set up users, if needed, before mkdir/mounts below
[ -f $CHROOT_STATE ] || init_users

echo
echo "$SCRIPT_NAME: Setting up mounts..."
# Set up necessary mounts and make sure we clean them up on exit
trap cleanup EXIT
sudo mkdir -p "${FLAGS_chroot}/${CHROOT_TRUNK}"
sudo mount --bind /dev "${FLAGS_chroot}/dev"
sudo mount --bind "${GCLIENT_ROOT}" "${FLAGS_chroot}/${CHROOT_TRUNK}"
sudo mount none -t proc "$FLAGS_chroot/proc"
sudo mount none -t devpts "$FLAGS_chroot/dev/pts"
bash_chroot 'cat > /etc/make.conf.host_setup' <<EOF
# Created by make_chroot
MAKEOPTS="-j${NUM_JOBS}"
EOF
sudo chmod 0644 "${FLAGS_chroot}"/etc/make.conf.host_setup

if [ -f $CHROOT_STATE ];then
  echo "$SCRIPT_NAME: chroot already initialized.  Skipping..."
  # Update symlinks to point at latest version of make.conf. In older versions
  # of the chroot, it pointed at different files. TODO(asharif): This is only
  # needed for backwards compatibility, so we should remove this eventually.
  sudo ln -sf "${CHROOT_CONFIG}/make.conf.amd64-host" \
    "${FLAGS_chroot}/etc/make.conf"

  # Apply any hacks needed to update the chroot.
  # TODO: Should the above hacks be moved into this function?
  chroot_hacks_from_outside "${FLAGS_chroot}"

  # TODO(raymes): This unmerges crossdev-wrappers which is deprecated.
  # Remove this once everyone has upgraded their chroots.
  echo "$SCRIPT_NAME: Deselecting crossdev-wrappers"
  bash_chroot ${EMERGE_CMD} --deselect crossdev-wrappers
else
  # run all the init stuff to setup the env
  init_setup
fi

# Add file to indicate that it is a chroot
# Add version of $STAGE3 for update checks
sudo sh -c "echo STAGE3=$STAGE3 > $CHROOT_STATE"

echo "$SCRIPT_NAME: Running emerge portage"
bash_chroot emerge -uNv $USEPKG portage $EMERGE_JOBS

# dhcpcd is included in 'world' by the stage3 that we pull in for some reason.
# We have no need to install it in our host environment, so pull it out here.
echo "$SCRIPT_NAME: Deselecting dhcpcd"
bash_chroot $EMERGE_CMD --deselect dhcpcd

echo "$SCRIPT_NAME: Running emerge world ccache crossdev etc ..."
bash_chroot $EMERGE_CMD -uDNv $USEPKG system \
    ccache crossdev net-misc/curl sudo $EMERGE_JOBS

# Curl is now installed, so we can depend on it now.
bash_chroot 'cat >> /etc/make.conf.host_setup' <<'EOF'
FETCHCOMMAND='curl -f --retry 5 -L --output \${DISTDIR}/\${FILE} \${URI}'
RESUMECOMMAND='curl -f -C - --retry 5 -L --output \${DISTDIR}/\${FILE} \${URI}'
EOF
sudo chmod 0644 "${FLAGS_chroot}"/etc/make.conf.host_setup

echo "$SCRIPT_NAME: Running emerge hard-host-depends"
bash_chroot $EMERGE_CMD -uDNv $USEPKG hard-host-depends world $EMERGE_JOBS

# Unmount trunk
sudo umount "${FLAGS_chroot}/${CHROOT_TRUNK}"

# Clean up the chroot mounts
trap - EXIT
cleanup

if [[ "$FLAGS_chroot" = "$DEFAULT_CHROOT_DIR" ]]; then
  CHROOT_EXAMPLE_OPT=""
else
  CHROOT_EXAMPLE_OPT="--chroot=$FLAGS_chroot"
fi

print_time_elapsed

echo
echo "$SCRIPT_NAME: All set up.  To enter the chroot, run:"
echo "$SCRIPT_NAME: $ $SCRIPTS_DIR/enter_chroot.sh $CHROOT_EXAMPLE_OPT"
echo ""
echo "CAUTION: Do *NOT* rm -rf the chroot directory; if there are stale bind"
echo "mounts you may end up deleting your source tree too.  To unmount and"
echo "delete the chroot cleanly, use:"
echo "$ $0 --delete $CHROOT_EXAMPLE_OPT"