get

#!/usr/bin/env bash

##############################
# archibold.io (C) 2016-2020 #
##############################

# first ting: update the time or HTTPS won't work
if [ "$(which ntpdate 2> /dev/null)" != "" ]; then
  sudo ntpdate pool.ntp.org
  sudo timedatectl set-local-rtc 1
fi

source <(curl -s https://archibold.io/require)

require echomd
require partid

echoWithHeader() {
  echomd "
# archibold.io
$@
"
}

welcomeMessage() {
  echoWithHeader '
  Welcome to Archibold installer.'
}

updatePacman() {
  echoWithHeader '
  Updating *pacman*, the default ArchLinux package manager'

  sudo pacman -Sy --noconfirm archlinux-keyring
  sudo pacman-db-upgrade
  sudo pacman-key --init
  sudo pacman-key --populate archlinux
}

grabDiskSize() {
  local found=0
  local size=
  for size in $(lsblk --output SIZE $1); do
    if [ "$found" = "0" ]; then
      found=1
    else
      echo $size
      return
    fi
  done
}

findTheDisk() {
  local i=0
  local choice=
  local disks=
  local disk=
  echoWithHeader '
  Please select the disk you would like to use
  to install Arch Linux (pick a number).

  *Please note:* #red(all data) in the chosen disk will be #red(lost).'

  for disk in $(lsblk --output NAME); do
    if [ "$(echo $disk | sed -e 's/^[a-z]//')" != "$disk" ] && [ "$(echo $disk | grep loop)" = "" ]; then
      ((i=i+1))
      disks="$disks $disk"
      printf "  $(tput bold)$i$(tput sgr0) %-24s %-6s\n" /dev/$disk $(grabDiskSize /dev/$disk)
    fi
  done

  echo ''
  read -n1 -s choice

  if [ "$choice" -gt "0" ] && [ "$choice" -le "$i" ]; then
    i=0
    for disk in $disks; do
      ((i=i+1))
      if [ "$i" = "$choice" ]; then
        DISK="/dev/$disk"
      fi
    done
  else
    echomd "  #red(*Nope*), let's try again ... "
    sleep 2 && clear && findTheDisk
  fi
}

askAboutEncryption() {
  local choice=
  echoWithHeader "
  Would you like to use *encryption* ? [Y/n]"
  read -n1 -s choice

  if [ "$choice" = "n" ] || [ "$choice" = "N" ]; then
    ENCRYPTION=no
  else
    ENCRYPTION=yes
  fi

}

askAboutGNOME() {
  local choice=
  echoWithHeader "
  Would you like to also install *GNOME* ? [Y/n]"
  read -n1 -s choice

  if [ "$choice" = "n" ] || [ "$choice" = "N" ]; then
    GNOME=no
  else
    GNOME=yes
  fi

}

askAboutUEFI() {
  local choice=
  echoWithHeader "
  Is *${DISK}* installed for a system
  compatible with *UEFI* ? [Y/n]
"
  read -n1 -s choice
  if [ "$choice" = "n" ] || [ "$choice" = "N" ]; then
    UEFI="no"
  else
    UEFI="64"
  fi

}

askAboutUEFILike() {
  local choice=
  echoWithHeader "
  Would you like regardless an *UEFI* like
  partition *boot structure* ? [Y/n]"
  read -n1 -s choice

  if [ "$choice" != "n" ] && [ "$choice" != "N" ]; then
    UEFI=yes
  fi

}

askAboutEDD() {
  local choice=
  echoWithHeader "
  Can this system use standard *EDD* settings ? [Y/n]
"
  echomd "  BIOS Enhanced Disk Drive Services
  is usually available in modern systems."
  read -n1 -s choice

  if [ "$choice" = "n" ] || [ "$choice" = "N" ]; then
    EDD=" edd=off"
  fi
}

askAboutSWAP() {
  local choice=
  echoWithHeader "
  How much *swap* do you need?

  Please specify an amount and press enter.

  Valid options can be 0, 100M or 1G or 2Gi, etc"
  read choice

  SWAP=$(echo $choice | sed -r 's/^([0-9]+[A-Z]i)[bB]$/\1/' | numfmt --from=auto)
  if [[ $? -ne 0 ]] ; then
    echo ''
    echomd "  #red(*Nope*), $choice is not valid, let's try again ... "
    sleep 2 && clear && askAboutSWAP
  fi

}

encryptPartition() {
  local partition="$1"
  local name="$2"
  local uuid=$(partid $partition)
  mkdir -p /run/cryptsetup
  echo "$PASSWORD" | cryptsetup -v --uuid=$uuid luksFormat $partition
  echo "$PASSWORD" | cryptsetup open $partition $name
}

createPartitions() {
  local start=2048s
  local part=
  echoWithHeader "
  Preparing *$DISK*"
  sudo dd if=/dev/zero of=$DISK bs=1 count=2048 > /dev/null 2>&1
  sync
  if [ "$UEFI" = "no" ] || [ "$UEFI" = "yes" ]; then
    echomd '  with an *msdos* label'
    echo ''
    sudo parted --script $DISK mklabel msdos > /dev/null 2>&1
  else
    echomd '  with UEFI *gpt* label'
    echo ''
    sudo parted --script $DISK mklabel gpt > /dev/null 2>&1
  fi
  if [ "$UEFI" != "no" ]; then
    echomd '  with 512MiB *boot* partition'
    echo ''
    sudo parted --script --align optimal $DISK mkpart primary fat16 $start 512MiB > /dev/null 2>&1
    sudo parted $DISK set 1 boot on
    start=512MiB
  fi
  if [ "$SWAP" = "0" ]; then
    echomd '  *without swap* partition'
    echo ''
    sudo parted --script --align optimal $DISK mkpart primary ext4 $start 100% > /dev/null 2>&1
  else
    echomd "  with *$(numfmt --to=si $SWAP) swap* partition"
    ((SWAP=SWAP+$(numfmt --from=auto ${start:0:-1})))
    SWAP=$(numfmt --to=si $SWAP)
    echo ''
    sudo parted --script --align optimal $DISK mkpart primary linux-swap $start $SWAP > /dev/null 2>&1
    sudo parted --script --align optimal $DISK mkpart primary ext4 $SWAP 100% > /dev/null 2>&1
  fi
  sleep 2
  clear
  echoWithHeader "
  The *$DISK* will be partitioned as such:
"
  BOOT=
  ROOT=
  for part in $(ls ${DISK}*); do
    if [[ "$part" =~ ^([a-z/]+([0-9]n)?[0-9]p|[a-z/]+)[0-9]$ ]]; then
      if [ "$part" != "$DISK" ]; then
        if [ "$UEFI" != "no" ] && [ "$BOOT" = "" ]; then
          BOOT=$part
          echo "  boot: $(tput bold)$BOOT$(tput sgr0)"
        elif [ "$UEFI" = "no" ] && [ "$SWAP" = "0" ]; then
          ROOT=$part
          echo "  root: $(tput bold)$ROOT$(tput sgr0)"
        elif [ "$SWAP" != "0" ] && [ "$ROOT" = "" ]; then
          SWAP=$part
          ROOT=$part
          echo "  swap: $(tput bold)$SWAP$(tput sgr0)"
        else
          ROOT=$part
          echo "  root: $(tput bold)$ROOT$(tput sgr0)"
          break
        fi
      fi
    fi
  done
  if [ "$ROOT" = "" ]; then
    echo 'unable to find the partition'
    exit 1
  fi
  clear
  echoWithHeader "
  targeting partitions:
  "
  if [ "$BOOT" != "" ]; then
    echo "  boot: $BOOT"
  fi
  if [ "$SWAP" != "0" ]; then
    if [ "$ENCRYPTION" = "yes" ]; then
      echo "  swap: $SWAP (encrypted)"
    else
      echo "  swap: $SWAP"
    fi
  fi
  if [ "$ROOT" != "" ]; then
    if [ "$ENCRYPTION" = "yes" ]; then
      echo "  root: $ROOT (encrypted)"
    else
      echo "  root: $ROOT"
    fi
  fi
  sleep 2
  if [ "$BOOT" != "" ]; then
    clear
    echoWithHeader "
  formatting *boot* partition"
    if [ "$UEFI" = "yes" ]; then
      sudo bash -c "mkfs.ext2 -F $BOOT"
    else
      sudo bash -c "mkfs.fat -F32 $BOOT"
    fi
    sleep 2
  fi
  if [ "$SWAP" != "0" ]; then
    clear
    echoWithHeader "
  creating *swap* partition"
    sudo bash -c "mkfs.ext2 -F $SWAP"
    partid create $SWAP
    sudo bash -c "yes y | mkswap $SWAP"
    if [ "$ENCRYPTION" = "yes" ]; then
      encryptPartition $SWAP swap
      sudo bash -c "yes y | mkswap /dev/mapper/swap"
    fi
    sleep 2
  fi
  clear
    echoWithHeader "
  creating *root* partition"
  if [ "$BOOT" = "" ] && [ "$(uname -m)" = "x86_64" ]; then
    echomd '  *disabling* pure *64bit* mode'
    if [ "$ENCRYPTION" = "yes" ]; then
      echomd '  *warning* encryption not supported without /boot'
      sleep 2
    fi
    echo ''
    sudo bash -c "mkfs.ext4 -F -O ^64bit $ROOT"
    partid create $ROOT
  else
    sudo bash -c "mkfs.ext4 -F $ROOT"
    partid create $ROOT
    if [ "$ENCRYPTION" = "yes" ]; then
      encryptPartition $ROOT root
      mkfs.ext4 -F /dev/mapper/root
    fi
  fi
  sleep 2
}

askAboutQUIET() {
  local choice=
  echoWithHeader "
  Would you like a *quiet boot* ? [Y/n]"
  read -n1 -s choice
  if [ "$choice" = "n" ] || [ "$choice" = "N" ]; then
    QUIET=no
  else
    QUIET=yes
  fi
}

askAboutLANGUAGE() {
  local choice=
  echoWithHeader "
  Which *language* do you need ?

  Pleas specify just 2 chars like: en, or de, or it ...
"
  read choice
  if [[ "$choice" =~ ^([a-z][a-z])$ ]]; then
    LANGUAGE="$choice"
  else
    echo ''
    echomd "  #red(*Nope*), $choice is not valid, let's try again ... "
    sleep 2 && clear && askAboutLANGUAGE
  fi
}

askAboutLTS() {
  local choice=
  echoWithHeader "
  Would you like an *LTS kernel* ? [y/N]"
  read -n1 -s choice
  if [ "$choice" = "y" ] || [ "$choice" = "Y" ]; then
    LTS=yes
  else
    LTS=no
  fi
}

askForUser() {
  local choice=
  echoWithHeader "
  Which *user name* would you like to use ?
  Write one and press enter.

  Please note *only lowercase* letters are valid."
  read choice
  if [ "$choice" = "root" ] || [ "$(echo $choice | sed -e 's/[a-z]//g')" != "" ]; then
    echo ''
    echomd "  #red(*Nope*), $choice is not valid, let's try again ... "
    sleep 2 && clear && askForUser
  else
    USER="$choice"
  fi
}

askForPassword() {
  local choice=
  echoWithHeader "
  Which *password* would you like to use ?
  Write one and press enter.

  Please note it will be used as *both* *root* and *${USER}* password,
  and you can change it at any time via _passwd_ command."
  if [ "$ENCRYPTION" = "yes" ]; then
    echo ''
    echomd "  *Encryption Warning*"
    echomd "   * the same password will also be used to *unlock* the disk"
    echomd "   * it is *not possible to change* the disk password later on"
  fi
  echo ''
  read -r choice
  if [ "$choice" = "" ]; then
    PASSWORD="Passw0rd!"
    echomd "
    Password set automatically as *${PASSWORD}*"
    sleep 3
  else
    PASSWORD="$choice"
  fi
}

# The Archibold Installer
clear && welcomeMessage && sleep 2
clear && updatePacman && sleep 2

if [ "$INTEL" = "" ] && [ "$(lscpu | grep GenuineIntel)" != "" ]; then
  INTEL="yes"
fi

if [ "$ENCRYPTION" = "" ]; then
  clear && askAboutEncryption
fi
if [ "$USER" = "root" ] || [ "$USER" = "" ] || [ "$(echo $USER | sed -e 's/[a-z]//g')" != "" ]; then
  clear && askForUser
fi
if [ "$PASSWORD" = "" ]; then
  clear && askForPassword
fi
if [ "$LTS" = "" ]; then
  clear && askAboutLTS
fi
if [ "$GNOME" = "" ]; then
  clear && askAboutGNOME
fi
if [ "$DISK" = "" ]; then
  clear && findTheDisk
fi

sudo umount ${DISK}* 2> /dev/null

if [ "$UEFI" != "32" ] && [ "$UEFI" != "64" ] && [ "$UEFI" != "yes" ]; then
  if [ "$UEFI" = "" ]; then
    clear && askAboutUEFI
    if [ "$UEFI" = "no" ]; then
      clear && askAboutUEFILike
    fi
  else
    UEFI=no
  fi
fi

if [ "$UEFI" = "32" ] || [ "$UEFI" = "64" ]; then
  UEFI="efi${UEFI}"
else
  if [ "$EDD" = "" ]; then
    clear && askAboutEDD
  else
    EDD=" edd=$EDD"
  fi
fi

if [ "$SWAP" = "" ]; then
  clear && askAboutSWAP
fi

if [ "$QUIET" = "" ]; then
  clear && askAboutQUIET
fi
if [ "$QUIET" = "yes" ]; then
  # QUIET=" quiet splash loglevel=0 console=tty2"
  QUIET=" quiet splash"
else
  QUIET=""
fi

if [ "$LANGUAGE" = "" ]; then
  clear && askAboutLANGUAGE
fi

clear && createPartitions

if [ -d archibold.env ]; then
  sudo rm -rf archibold.env
fi

mkdir -p archibold.env
sleep 1
sync

if [ "$ENCRYPTION" = "yes" ]; then
  sudo mount /dev/mapper/root archibold.env
else
  sudo mount $ROOT archibold.env
fi
if [ "$BOOT" != "" ]; then
  sudo mkdir -p archibold.env/boot
  sudo mount $BOOT archibold.env/boot
fi

clear
echoWithHeader "
  Bootstrapping *Arch Linux* via pacstrap
"

sudo pacstrap archibold.env arch-install-scripts base gptfdisk

clear
echoWithHeader "
  Creating basic installation via *arch-chroot*
"

echo "#!/usr/bin/env bash

LABEL=archibold
LANGUAGE=$LANGUAGE
LTS=$LTS
DISK=$DISK
BOOT=$BOOT
SWAP=$SWAP
ROOT=$ROOT
UEFI=$UEFI
USER='$USER'
PASSWORD='$PASSWORD'
EDD='$EDD'
QUIET='$QUIET'
ENCRYPTION='$ENCRYPTION'
GNOME='$GNOME'

" > /tmp/install
curl -Ls -o /tmp/install-chroot https://archibold.io/setup-utils/get
cat /tmp/install-chroot >> /tmp/install
rm /tmp/install-chroot
sudo chmod a+x /tmp/install
sudo mv /tmp/install archibold.env/archibold.install
sudo arch-chroot archibold.env /archibold.install
rm -rf archibold.env/archibold.install
sudo umount archibold.env/boot
sudo umount archibold.env
echoWithHeader "
  Congratulations. Arch Linux is ready.

  These are your user/pass credentials:

    *${USER}*: *${PASSWORD}*

  If you installed GNOME, please open the terminal
  once you are connected to the internet, to complete
  the setup (it's a one/off operation).

  Please type #green(shutdown -h now) and
  remove the media before rebooting.
"