make-vm

#!/usr/bin/env bash
#
# Template VM Image Builder
# Copyright (C) 2017-2024 by Thomas Dreibholz
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
# Contact: dreibh@simula.no

set -e


# ###### Generate serial number based on date, number <= 999999999 ##########
function generate-serial-number ()
{
   # shellcheck disable=SC2016
   flock serial.lock bash -c '
      serialFile="$(dirname .)/serial.txt"
      # Serial format: YYMMDDhnn, h=0..9, nn=0..99
      h=$(date +%H/2.4 | bc)
      serialToday="$(date +"%y%m%d${h}00")"
      if [ ! -e "${serialFile}" ] ; then
         serial="${serialToday}"
      else
         serial="$(cat "${serialFile}")"
         if [[ ! "${serial}" =~ ^[0-9]+$ ]] ; then
            # Not a valid serial number -> start new!
            serial="${serialToday}"
         elif [[ "${serial}" -lt "${serialToday}" ]] ; then
            # Old serial number -> start new!
            serial="${serialToday}"
         else
            serial=$((serial+1))
         fi
      fi
      echo "${serial}" | tee "${serialFile}"
'
}


# ###### Defaults ###########################################################
# PACKER="${HOME}/src/packer/bin/packer"
PACKER="/usr/bin/packer"

PROJECT="NorNet"
HYPERVISOR="VirtualBox"
DISTRIBUTION="Ubuntu"
RELEASE="20.04"
PROVISIONERS=""

DRY_RUN=0

VM_CHIPSET=ich9
VM_FIRMWARE=efi
VM_CORES=4
VM_MEMORY=4096
VM_BALLOON=0

USE_SEPARATE_DISKS=1
VM_DISK_ROOT=32768
VM_DISK_HOME=131072
VM_DISK_SWAP=4096

VIDEO="1024x768"
XKBMODEL="pc105"
XKBLAYOUT="de"
XKBVARIANT="nodeadkeys"
XKBOPTIONS=""
FQDN="akerbrygge.simula.nornet"

USER_NAME="nornetpp"
USER_REALNAME="NorNet Praesum Presum"
USER_PASSWORD="!NorNetInst!"

BOOTSPLASH="/usr/share/bootsplash/Bjørnsund-3840x2160.jpeg"
BACKGROUND_SDDM="/usr/share/desktop/Nordmarka-3840x2160-mosaic.jpeg"
BACKGROUND_LOCKSCREEN="/usr/share/desktop/Flåm-3840x2160-mosaic.jpeg"
BACKGROUND_DESKTOP="/usr/share/desktop/Flåm-3840x2160-plain.jpeg"

OUTPUT_DIRECTORY="."
CACHE_DIRECTORY="cache"
PACKER_LOG=1

VSPHERE_CONFIG_FILE=""
VSPHERE_VERSION="15"
VSPHERE_USERNAME="MY-VSPHERE-USERNAME"
VSPHERE_PASSWORD="MY-VSPHERE-PASSWORD"
VSPHERE_SERVER="MY-VSPHERE-SERVER"
VSPHERE_DATACENTER="MY-VSPHERE-DATACENTER"
VSPHERE_CLUSTER="MY-VSPHERE-CLUSTER"
VSPHERE_FOLDER="MY-VSPHERE-FOLDER"
VSPHERE_HOST="MY-VSPHERE-HOST"
VSPHERE_DATASTORE="MY-VSPHERE-DATASTORE"
VSPHERE_NETWORK="MY-VSPHERE-NETWORK"
VSPHERE_HTTP_IP="MY-VSPHERE-HTTP-IP"

PROXMOX_USERNAME="MY-PROXMOX-USERNAME"
PROXMOX_PASSWORD="MY-PROXMOX-PASSWORD"
PROXMOX_URL="MY-PROXMOX-URL"
PROXMOX_NODE="MY-PROXMOX-NODE"
PROXMOX_POOL="MY-PROXMOX-POOL"
PROXMOX_ISO_STORAGE="MY-PROXMOX-ISO-STORAGE"
PROXMOX_DISK_STORAGE="MY-PROXMOX-DISK-STORAGE"
PROXMOX_BRIDGE="vmbr0"
PROXMOX_VLAN_ID=""
PROXMOX_HTTP_IP="MY-PROXMOX-HTTP-IP"

PROXMOX_CONFIG_FILE=""

DOCKER_REPOSITORY="dreibh"
DOCKER_TAG=""


# ###### Handle command-line parameters #####################################
while [ $# -gt 0 ] ; do
   if [ "$1" == "--output-directory" ] || [ "$1" == "-O" ] ; then
      OUTPUT_DIRECTORY="$2"
      shift
   elif [ "$1" == "--cache-directory" ] || [ "$1" == "-C" ] ; then
      CACHE_DIRECTORY="$2"
      shift
   elif [ "$1" == "--hypervisor" ] || [ "$1" == "-H" ] ; then
      HYPERVISOR="$2"
      shift
   elif [ "$1" == "--project" ] || [ "$1" == "-P" ] ; then
      PROJECT="$2"
      shift
   elif [ "$1" == "--distribution" ] || [ "$1" == "-D" ] ; then
      DISTRIBUTION="$2"
      shift
   elif [ "$1" == "--release" ] || [ "$1" == "-R" ] ; then
      RELEASE="$2"
      shift
   elif [ "$1" == "--system" ] || [ "$1" == "-S" ] ; then
      # shellcheck disable=SC2001
      DISTRIBUTION=$(echo "$2" | sed -e "s/-.*$//g")
      # shellcheck disable=SC2001
      RELEASE=$(echo "$2" | sed -e "s/^[^\-]*-//g")
      shift
   elif [ "$1" == "--chipset" ] || [ "$1" == "-I" ] ; then
      VM_CHIPSET="$2"
      if [[ ! "${VM_CHIPSET}" =~ ^ich9$|^piix3$|^NA$ ]] ; then
         echo >&2 "ERROR: Bad chipset setting: ${VM_CHIPSET}"
         exit 1
      fi
      shift
   elif [ "$1" == "--firmware" ] || [ "$1" == "-F" ] ; then
      VM_FIRMWARE="$2"
      if [[ ! "${VM_FIRMWARE}" =~ ^efi$|^bios$|^NA$ ]] ; then
         echo >&2 "ERROR: Bad firmware setting: ${VM_FIRMWARE}"
         exit 1
      fi
      shift
   elif [ "$1" == "--cores" ] || [ "$1" == "-c" ] ; then
      VM_CORES="$2"
      if [[ ! "${VM_CORES}" =~ ^[0-9]*|NA$ ]] ; then
         echo >&2 "ERROR: Bad value for cores: ${VM_CORES}"
         exit 1
      fi
      if [ "${VM_CORES}" == "NA" ] ; then
         VM_CORES=1
      fi
      if [ "${VM_CORES}" -lt 1 ] ; then
         VM_CORES=1
      fi
      shift
   elif [ "$1" == "--memory" ] || [ "$1" == "-m" ] ; then
      VM_MEMORY="$2"
      if [[ ! "${VM_MEMORY}" =~ ^[0-9]+$|^NA$ ]] ; then
         echo >&2 "ERROR: Bad size for memory: ${VM_MEMORY} MiB"
         exit 1
      fi
      if [ "${VM_MEMORY}" != "NA" ] ; then
         if [ "${VM_MEMORY}" -lt 64 ] ; then
            VM_MEMORY=64
         fi
      fi
      shift
   elif [ "$1" == "--balloon" ] || [ "$1" == "-b" ] ; then
      VM_BALLOON="$2"
      if [[ ! "${VM_BALLOON}" =~ ^[0-9]+$|^NA$ ]] ; then
         echo >&2 "ERROR: Bad size for memory balloon: ${VM_BALLOON} MiB"
         exit 1
      fi
      if [ "${VM_BALLOON}" == "NA" ] ; then
         VM_BALLOON=0
      fi
      shift
   elif [ "$1" == "--root" ] || [ "$1" == "-r" ] ; then
      VM_DISK_ROOT="$2"
      if [[ ! "${VM_DISK_ROOT}" =~ ^[0-9]+$|^NA$ ]] ; then
         echo >&2 "ERROR: Bad size for root: ${VM_DISK_ROOT} MiB"
         exit 1
      fi
      if [ "${VM_DISK_ROOT}" != "NA" ] ; then
         if [ "${VM_DISK_ROOT}" -lt 64 ] ; then
            VM_DISK_ROOT=64
         fi
      fi
      shift
   elif [ "$1" == "--home" ] || [ "$1" == "-r" ] ; then
      VM_DISK_HOME="$2"
      if [[ ! "${VM_DISK_HOME}" =~ ^[0-9]+$|^NA$ ]] ; then
         echo >&2 "ERROR: Bad size for home: ${VM_DISK_HOME} MiB"
         exit 1
      fi
      if [ "${VM_DISK_HOME}" != "NA" ] ; then
         if [ "${VM_DISK_HOME}" -lt 64 ] ; then
            VM_DISK_HOME=64
         fi
      fi
      shift
   elif [ "$1" == "--swap" ] || [ "$1" == "-r" ] ; then
      VM_DISK_SWAP="$2"
      if [[ ! "${VM_DISK_SWAP}" =~ ^[0-9]+$|^NA$ ]] ; then
         echo >&2 "ERROR: Bad size for swap: ${VM_DISK_SWAP} MiB"
         exit 1
      fi
      if [ "${VM_DISK_SWAP}" != "NA" ] ; then
         if [ "${VM_DISK_SWAP}" -lt 0 ] ; then
            VM_DISK_SWAP=0
         fi
      fi
      shift
   elif [ "$1" == "--one-disk-only" ] || [ "$1" == "-1" ] ; then
      USE_SEPARATE_DISKS=0
   elif [ "$1" == "--video" ] || [ "$1" == "-V" ] ; then
      VIDEO="$2"
      if [ "${VIDEO}" == "XGA" ] ; then
         VIDEO="1024x768"   # Standard, 4:3
      elif [ "${VIDEO}" == "SXGA" ] ; then
         VIDEO="1280x960"   # SXGA, 4:3
      elif [ "${VIDEO}" == "HD" ] ; then
         VIDEO="1280x720"   # HD, 16:9
      elif [ "${VIDEO}" == "HD+" ] ; then
         VIDEO="1600x900"   # HD+, 16:9
      elif [ "${VIDEO}" == "FHD" ] ; then
         VIDEO="1920x1080"  # Full HD, 16:9
      elif [ "${VIDEO}" == "UHD" ] ; then
         VIDEO="3840x2160"  # 4K, 16:9
      fi
      if [ "${VIDEO}" != "NA" ] ; then
         if [[ ! "${VIDEO}" =~ ^[0-9]+x[0-9]+$ ]] ; then
            echo >&2 "ERROR: Bad video setting: ${VIDEO}"
            exit 1
         fi
      fi
      shift
   elif [ "$1" == "--keyboard-model" ] || [ "$1" == "-m" ] ; then
      XKBMODEL="$2"
      shift
   elif [ "$1" == "--keyboard-layout" ] || [ "$1" == "-l" ] ; then
      XKBLAYOUT="$2"
      shift
   elif [ "$1" == "--keyboard-variant" ] || [ "$1" == "-v" ] ; then
      XKBVARIANT="$2"
      shift
   elif [ "$1" == "--keyboard-options" ] || [ "$1" == "-o" ] ; then
      XKBOPTIONS="$2"
      shift
   elif [ "$1" == "--hostname" ] || [ "$1" == "-h" ] ; then
      FQDN="$2"
      shift
   elif [ "$1" == "--username" ] || [ "$1" == "-u" ] ; then
      USER_NAME="$2"
      shift
   elif [ "$1" == "--realname" ] || [ "$1" == "-r" ] ; then
      USER_REALNAME="$2"
      shift
   elif [ "$1" == "--password" ] || [ "$1" == "-p" ] ; then
      USER_PASSWORD="$2"
      shift
   elif [ "$1" == "--bootsplash" ] || [ "$1" == "-BB" ] ; then
      BOOTSPLASH="$2"
      shift
   elif [ "$1" == "--background-sddm" ] || [ "$1" == "-BS" ] ; then
      BACKGROUND_SDDM="$2"
      shift
   elif [ "$1" == "--background-lockscreen" ] || [ "$1" == "-BL" ] ; then
      BACKGROUND_LOCKSCREEN="$2"
      shift
   elif [ "$1" == "--background-desktop" ] || [ "$1" == "-BD" ] ; then
      BACKGROUND_DESKTOP="$2"
      shift
   elif [ "$1" == "--vsphere" ] || [ "$1" == "-VC" ] ; then
      if [ ! -e "$2" ] ; then
         echo "ERROR: vSphere configuration $2 not found!"
         exit 1
      fi
      VSPHERE_CONFIG_FILE="$2"
      shift
   elif [ "$1" == "--proxmox" ] || [ "$1" == "-PC" ] ; then
      if [ ! -e "$2" ] ; then
         echo "ERROR: Proxmox configuration $2 not found!"
         exit 1
      fi
      PROXMOX_CONFIG_FILE="$2"
      shift
   elif [ "$1" == "--packer" ] || [ "$1" == "-K" ] ; then
      PACKER="$2"
      shift
   elif [ "$1" == "--dry-run" ] || [ "$1" == "-n" ] ; then
      DRY_RUN=1
   elif [ "$1" == "--verbose" ] || [ "$1" == "-x" ] ; then
      PACKER_LOG=1
   else
      echo >&2 "ERROR: Unknown option $1!"
      echo >&2 "Usage: $0"
      echo >&2 "   [--output-directory|-O directory]"
      echo >&2 "   [--cache-directory|-C directory]"
      echo >&2 "   [--hypervisor|-H VirtualBox|QEMU|vSphere]"
      echo >&2 "   [--vsphere|-VC vsphere_configuration_file]"
      echo >&2 "   [--project|-P Template|NEAT|MELODIC|...]"
      echo >&2 "   [--destination|-D Ubuntu|Fedora|FreeBSD]"
      echo >&2 "   [--release|-R RELEASE]"
      echo >&2 "   [--system|-D DISTRIBUTION-RELEASE]"
      echo >&2 "   [--chipset|-I ich9|piix3]"
      echo >&2 "   [--firmware|-F efi|bios]"
      echo >&2 "   [--cores|-c cores]"
      echo >&2 "   [--memory|-m MiB]"
      echo >&2 "   [--balloon|-b MiB]"
      echo >&2 "   [--root|-r MiB]"
      echo >&2 "   [--home|-h MiB]"
      echo >&2 "   [--swap|-s MiB]"
      echo >&2 "   [--one-disk-only|-1]"
      echo >&2 "   [--video|-V WIDTHxHEIGHT|XGA|SXGA|HD|HD+|FHD|UHD]"
      echo >&2 "   [--keyboard-model|-m model]"
      echo >&2 "   [--keyboard-layout|-l layout]"
      echo >&2 "   [--keyboard-variant|-v variant]"
      echo >&2 "   [--keyboard-options|-o options]"
      echo >&2 "   [--user|-u username]"
      echo >&2 "   [--realname|-r real_user_name]"
      echo >&2 "   [--password|-p password]"
      echo >&2 "   [--hostname|-h FQDN"
      echo >&2 "   [--background-sddm|-BD image_file]"
      echo >&2 "   [--background-lockscreen|-BL image_file]"
      echo >&2 "   [--background-desktop|-BD image_file]"
      echo >&2 "   [--packer|-K full_path_to_packer_executable]"
      echo >&2 "   [--dry-run|-n]"
      echo >&2 "   [--verbose|-x]"
      exit 1
   fi
   shift
done


# ###### Get configuration ##################################################
if [ ! -e "${PACKER}" ] ; then
   echo >&2 "ERROR: Packer (${PACKER}) not found!"
   exit 1
fi

NAME=""
if [ "${HYPERVISOR}" == "VirtualBox" ] ; then
   BUILDER_VMSETUP="virtualbox"
   NAME="VirtualBox"
   VM_DISK_PREFIX="/dev/sd"   # Using /dev/sd<N> for disks!
   VM_DISK_ROOT_DEVICE="${VM_DISK_PREFIX}a"
   VM_DISK_HOME_DEVICE="${VM_DISK_PREFIX}b"
   VM_DISK_SWAP_DEVICE="${VM_DISK_PREFIX}c"
elif [ "${HYPERVISOR}" == "QEMU" ] ; then
   BUILDER_VMSETUP="qemu"
   NAME="QEMU"
   VM_DISK_PREFIX="/dev/vd"   # Using /dev/vd<N> for disks!
   VM_DISK_ROOT_DEVICE="${VM_DISK_PREFIX}a"
   VM_DISK_HOME_DEVICE="${VM_DISK_PREFIX}b"
   VM_DISK_SWAP_DEVICE="${VM_DISK_PREFIX}c"
elif [ "${HYPERVISOR}" == "vSphere" ] ; then
   BUILDER_VMSETUP="vsphere"
   NAME="vSphere"
   VM_DISK_PREFIX="/dev/sd"   # Using /dev/sd<N> for disks!
   VM_DISK_ROOT_DEVICE="${VM_DISK_PREFIX}a"
   VM_DISK_HOME_DEVICE="${VM_DISK_PREFIX}b"
   VM_DISK_SWAP_DEVICE="${VM_DISK_PREFIX}c"
   if [ "${VSPHERE_CONFIG_FILE}" == "" ] ; then
      echo >&2 "ERROR: No vSphere configuration file specified (--vsphere parameter)!"
      exit 1
   fi
   # shellcheck disable=SC1090
   source "${VSPHERE_CONFIG_FILE}"
elif [ "${HYPERVISOR}" == "Proxmox" ] ; then
   BUILDER_VMSETUP="proxmox"
   NAME="Proxmox"
   VM_DISK_PREFIX="/dev/sd"   # Using /dev/sd<N> for disks!
   VM_DISK_ROOT_DEVICE="${VM_DISK_PREFIX}a"
   VM_DISK_HOME_DEVICE="${VM_DISK_PREFIX}b"
   VM_DISK_SWAP_DEVICE="${VM_DISK_PREFIX}c"
   if [ "${PROXMOX_CONFIG_FILE}" == "" ] ; then
      echo >&2 "ERROR: No Proxmox configuration file specified (--proxmox parameter)!"
      exit 1
   fi
   # shellcheck disable=SC1090
   source "${PROXMOX_CONFIG_FILE}"
elif [ "${HYPERVISOR}" == "Docker" ] ; then
   BUILDER_VMSETUP="docker"
   NAME="Docker"
   release="${RELEASE/-LTS/}"
   DOCKER_REPOSITORY="${DOCKER_REPOSITORY}/${PROJECT,,}-${DISTRIBUTION,,}"
   DOCKER_TAG="${release,,}"
else
   echo >&2 "ERROR: Invalid hypervisor ${HYPERVISOR}!"
   exit 1
fi

pushd projects
projectConfiguration="${PROJECT}.config"
if [[ "${projectConfiguration}" =~ ^.*-OpenStack.*$ ]] ; then
   projectConfiguration=${projectConfiguration/-OpenStack/}
   PROVISIONERS="prepare-openstack-guest ${PROVISIONERS}"
fi
if [ ! -e "${projectConfiguration}" ] ; then
   echo >&2 "ERROR: Configuration ${projectConfiguration} does not exist!"
   exit 1
fi
# shellcheck disable=SC1090
. "./${projectConfiguration}"
popd

NAME="${NAME}-${PROJECT}"
PROVISIONERS="$(echo "${PROVISIONERS}" | xargs -n1 | sort -u)"
echo "Provisioners:"
for provisioner in ${PROVISIONERS} ; do
   echo "- ${provisioner}"
done

if [ ${USE_SEPARATE_DISKS} -ne 0 ] ; then
   BUILDER_VMSETUP="${BUILDER_VMSETUP}-3disks"
fi

if [ "${DISTRIBUTION}" == "Ubuntu" ] ; then
   RELEASE="${RELEASE/-LTS/}"   # Remove "-LTS" from release
   BUILDER_INSTALL="ubuntu-${RELEASE}"
   NAME="${NAME}-Ubuntu-${RELEASE}"
   HTTP_DIRECTORY="http/ubuntu"
   if [[ "${RELEASE}" =~ ^([0-9]*).([0-9]*)$ ]] ; then
      y=${BASH_REMATCH[1]}
      m=${BASH_REMATCH[2]}
      isNonLTSYear=$(( y%2 ))
      if [ ${isNonLTSYear} -eq 0 ] && [ "$m" -eq 4 ] ; then
         NAME="${NAME}-LTS"
         RELEASE="${RELEASE} LTS"
      fi
      if [ "$y" -lt 20 ] ; then
         HTTP_DIRECTORY="${HTTP_DIRECTORY}-legacy"
      fi
   else
      echo >&2 "ERROR: Invalid Ubuntu release ${RELEASE}!"
      exit 1
   fi
elif [ "${DISTRIBUTION}" == "Debian" ] ; then
   BUILDER_INSTALL="debian-${RELEASE}"
   NAME="${NAME}-Debian-${RELEASE}"
   HTTP_DIRECTORY="http/debian"
   if [[ "${RELEASE}" =~ ^([0-9]*)$ ]] ; then
      RELEASE=${BASH_REMATCH[1]}
   elif [[ "${RELEASE}" =~ ^Testing$ ]] ; then
      RELEASE="Testing"
   else
      echo >&2 "ERROR: Invalid Debian release ${RELEASE}!"
      exit 1
   fi
elif [ "${DISTRIBUTION}" == "Fedora" ] ; then
   BUILDER_INSTALL="fedora-${RELEASE}"
   NAME="${NAME}-Fedora-${RELEASE}"
   HTTP_DIRECTORY="http/fedora"
elif [ "${DISTRIBUTION}" == "FreeBSD" ] ; then
   BUILDER_INSTALL="freebsd-${RELEASE}"
   NAME="${NAME}-FreeBSD-${RELEASE}"
   HTTP_DIRECTORY="http/freebsd"
   if [[ ! "${RELEASE}" =~ ^([0-9]*).([0-9]*)-(RELEASE|STABLE|CURRENT)$ ]] ; then
      echo >&2 "ERROR: Invalid FreeBSD release ${RELEASE}!"
      exit 1
   fi
else
   echo >&2 "ERROR: Invalid distribution ${DISTRIBUTION}!"
   exit 1
fi

if [ "${HTTP_DIRECTORY}" != "http/ubuntu-legacy" ] && [ "${HTTP_DIRECTORY}" != "http/debian" ] ; then
   if [ ${USE_SEPARATE_DISKS} -eq 0 ] ; then
      HTTP_DIRECTORY="${HTTP_DIRECTORY}-1disk"
   else
      HTTP_DIRECTORY="${HTTP_DIRECTORY}-3disks"
   fi
fi

USER_HASHED_PASSWORD=$(echo "${USER_PASSWORD}" | mkpasswd -s -m sha-512)
# shellcheck disable=SC2001
HOSTNAME=$(echo "${FQDN}" | sed -e 's/\([a-zA-Z0-9]*\)\.\([a-zA-Z0-9\.]*\)/\1/g')
# shellcheck disable=SC2001
DOMAINNAME=$(echo "${FQDN}" | sed -e 's/\([a-zA-Z0-9]*\)\.\([a-zA-Z0-9\.]*\)/\2/g')

VM_BALLOON_MIN=$(( VM_MEMORY-VM_BALLOON ))
if [ ${VM_BALLOON_MIN} -lt 0 ] ; then
   echo >&2 "ERROR: Bad memory settings: VM_MEMORY=${VM_MEMORY}, VM_BALLOON=${VM_BALLOON} => ${VM_BALLOON_MIN}"
   exit 1
fi


# ###### Check Packer version ###############################################
packerVersion=$(${PACKER} version)
requiredMinVersion="1.7.1~"
check=$(echo -e "${requiredMinVersion}\n${packerVersion}" | sort -V -r | head -n1)
if [ "${check}" == "${requiredMinVersion}" ] ; then
   echo >&2 "ERROR: Packer version ${packerVersion} is not suitable! Required is at least version ${requiredMinVersion}."
   exit 1
fi


# ###### Write Packer configuration #########################################
CACHE_DIRECTORY="$(realpath "${CACHE_DIRECTORY}")"
mkdir -p "${CACHE_DIRECTORY}"

mkdir -p "${OUTPUT_DIRECTORY}/${NAME}"
JSON="$(realpath "${OUTPUT_DIRECTORY}"/"${NAME}")/${NAME}.json"
JSONTMP="${JSON}.tmp"


# ====== Read and insert JSON block =========================================
insert-json()
{
   sed -e "/^[ \t]*\/\/.*$/d" <"$1" | jq . | \
      sed -e '1d; $d'
}

# ====== Variables ==========================================================
rm -f "${JSONTMP}"
cat >>"${JSONTMP}" <<EOF
{
  "variables": {
    "version": ""
  },
EOF

# ====== Builders ===========================================================
cat >>"${JSONTMP}" <<EOF
  "builders": [
    {
EOF
if [ ! -d "${HTTP_DIRECTORY}" ] ; then
   echo >&2 "ERROR: HTTP_DIRECTORY ${HTTP_DIRECTORY} does not exist!"
   exit 1
fi

# Copy all files from HTTP directory and replace placeholders:
mkdir -p "${OUTPUT_DIRECTORY}/${NAME}/http"
httpFiles=$(find "${HTTP_DIRECTORY}/" -maxdepth 1 -type f -name "*")
for httpFile in ${httpFiles} ; do
   echo "Processing: ${httpFile} -> ${NAME}/http/$(basename "${httpFile}")"
   # shellcheck disable=SC2094
   sed -e "s%<SET_ROOT_DISK_DEVICE_HERE>%${VM_DISK_ROOT_DEVICE}%g" \
       -e "s%<SET_HOME_DISK_DEVICE_HERE>%${VM_DISK_HOME_DEVICE}%g" \
       -e "s%<SET_SWAP_DISK_DEVICE_HERE>%${VM_DISK_SWAP_DEVICE}%g" \
       -e "s/<SET_XKBMODEL_HERE>/${XKBMODEL}/g" \
       -e "s/<SET_XKBLAYOUT_HERE>/${XKBLAYOUT}/g" \
       -e "s/<SET_XKBVARIANT_HERE>/${XKBVARIANT}/g" \
       -e "s/<SET_XKBOPTIONS_HERE>/${XKBOPTIONS}/g" \
       -e "s/<SET_HOSTFQDN_HERE>/${FQDN}/g" \
       -e "s/<SET_HOSTNAME_HERE>/${HOSTNAME}/g" \
       -e "s/<SET_DOMAINNAME_HERE>/${DOMAINNAME}/g" \
       -e "s/<SET_USERNAME_HERE>/${USER_NAME}/g" \
       -e "s/<SET_REALNAME_HERE>/${USER_REALNAME}/g" \
       -e "s/<SET_PASSWORD_HERE>/${USER_PASSWORD}/g" \
       -e "s#<SET_HASHED_PASSWORD_HERE>#${USER_HASHED_PASSWORD}#g" \
       <"${httpFile}" >"${OUTPUT_DIRECTORY}/${NAME}/http/$(basename "${httpFile}")"
done

# Configure HTTP directory:
if [ ! -e vmsetup/${BUILDER_VMSETUP}.json ] ; then
   echo >&2 "ERROR: vmsetup/${BUILDER_VMSETUP}.json does not exist!"
   exit 1
fi
if [ "${HYPERVISOR}" == "Docker" ] ; then
   BUILDER_INSTALLTYPE="docker"
else
   BUILDER_INSTALLTYPE="installer"
fi
if [ ! -e ${BUILDER_INSTALLTYPE}/"${BUILDER_INSTALL}".json ] ; then
   echo >&2 "ERROR: ${BUILDER_INSTALLTYPE}/${BUILDER_INSTALL}.json does not exist!"
   exit 1
fi
(
   insert-json "vmsetup/${BUILDER_VMSETUP}.json"
   echo ","
   if [ "${BUILDER_INSTALLTYPE}" == "installer" ] ; then
      echo "\"http_directory\": \"http\","
   fi
   insert-json "${BUILDER_INSTALLTYPE}/${BUILDER_INSTALL}.json"
cat <<EOF
    }
  ],
EOF
) >>"${JSONTMP}"

# ====== Provisioners =======================================================
cat >>"${JSONTMP}" <<EOF
  "provisioners": [
EOF

if [ "${HYPERVISOR}" == "Docker" ] ; then
   cat >>"${JSONTMP}" <<EOF
       {
         "type": "shell",
         "execute_command": "{{.Vars}} bash '{{.Path}}'",
         "script": "$(realpath scripts/prepare-docker-container)",
         "environment_vars": [ "FQDN=${FQDN}",
                               "USER_NAME=${USER_NAME}",
                               "USER_PASSWORD=${USER_PASSWORD}",
                               "USER_REALNAME=${USER_REALNAME}" ]
       }
EOF
   p=1
else
   p=0
fi

for provisioner in ${PROVISIONERS} ; do
   found=0

   # ------ File provisioner ------------------------------------------------
   if [ -e "files/${provisioner}" ] ; then
      found=1

      while read -r s destination ; do
         if [ "${s}" != "" ] && [[ ! "${s}" =~ ^# ]] ; then
            source="$(realpath files/"${s}")"
            if [ ! -e "${source}" ] ; then
               echo >&2 "ERROR: Cannot find source file ${source} in files/${provisioner}!"
               exit 1
            fi

            if [ "${destination}" == "" ] ; then
               echo >&2 "ERROR: Destination has to be provided in files/${provisioner}!"
               exit 1
            fi

            p=$(( p+1 ))
            if [ $p -gt 1 ] ; then
               echo "," >>"${JSONTMP}"
            fi
            cat >>"${JSONTMP}" <<EOF
       {
         "type": "file",
         "source": "${source}",
         "destination": "${destination}"
       }
EOF

         fi
      done <"files/${provisioner}"
   fi

   # ------ Script provisioner ----------------------------------------------
   if [ -e scripts/"${provisioner}" ] ; then
      found=1
      p=$(( p+1 ))
      if [ $p -gt 1 ] ; then
         echo "," >>"${JSONTMP}"
      fi
      cat >>"${JSONTMP}" <<EOF
       {
         "type": "shell",
         "execute_command": "echo '${USER_PASSWORD}' | {{.Vars}} sudo -S -E bash '{{.Path}}'",
         "script": "$(realpath scripts/"${provisioner}")",
         "environment_vars": [ "VIDEO=${VIDEO}",
                               "XKBMODEL=${XKBMODEL}",
                               "XKBLAYOUT=${XKBLAYOUT}",
                               "XKBVARIANT=${XKBVARIANT}",
                               "XKBOPTIONS=${XKBOPTIONS}",
                               "FQDN=${FQDN}",
                               "USER_NAME=${USER_NAME}",
                               "USER_REALNAME=${USER_REALNAME}",
                               "BOOTSPLASH=${BOOTSPLASH}",
                               "BACKGROUND_SDDM=${BACKGROUND_SDDM}",
                               "BACKGROUND_LOCKSCREEN=${BACKGROUND_LOCKSCREEN}",
                               "BACKGROUND_DESKTOP=${BACKGROUND_DESKTOP}" ]
       }
EOF
   fi
done

   if [ "${found}" -eq 0 ] ; then
      echo >&2 "ERROR: Did not found provisioner ${provisioner}!"
      exit 1
   fi

cat >>"${JSONTMP}" <<EOF
  ]
EOF


# ====== Post-processors ====================================================
if [ "${HYPERVISOR}" == "Docker" ] ; then
   cat >>"${JSONTMP}" <<EOF
  ,
  "post-processors": [
    [
      {
        "type": "docker-tag",
        "repository": "${DOCKER_REPOSITORY}",
        "tags": [ "${DOCKER_TAG}" ]
      }
    ]
  ]
EOF
fi


cat >>"${JSONTMP}" <<EOF
}
EOF


# ###### Clean up and check #################################################
if [ "${HYPERVISOR}" == "QEMU" ] ; then
   # QEMU has no vboxmanage!
   jq "del(.builders[].vboxmanage)" <"${JSONTMP}" >"${JSON}"
elif [ "${HYPERVISOR}" == "Proxmox" ] ; then
   # Proxmox has no shutdown_command/vboxmanage!
   jq "del(.builders[].vboxmanage,.builders[].shutdown_command)" <"${JSONTMP}" >"${JSON}"
else
   jq . <"${JSONTMP}" >"${JSON}"
fi
rm -f "${JSONTMP}"


# ###### Run Packer #########################################################

# ====== Prepare some variables =============================================
vm_id="$(generate-serial-number)"
vm_name="${NAME/${HYPERVISOR}-/}"
vm_version=$(date +"%Y.%m.%d-%H%M%S")
vm_product="${HYPERVISOR} ${PROJECT} VM with ${DISTRIBUTION} ${RELEASE}"
vm_producturl="https://github.com/simula/nornet-vmimage-builder-scripts"
vm_vendor="Simula Metropolitan Centre for Digital Engineering"
vm_vendorurl="https://www.simula.no/people/dreibh"
vm_description="This is a ${PROJECT} VM with ${DISTRIBUTION} ${RELEASE} for ${HYPERVISOR}."
vm_tags="${PROJECT//[+-]/;};${DISTRIBUTION};${DISTRIBUTION}-${RELEASE//[ -]LTS/}"
if [[ "${NAME}" =~ (-LTS)$ ]] ; then
   vm_tags="${vm_tags};LTS"
elif [ "${DISTRIBUTION}" == "Debian" ] && [[ "${RELEASE}" =~ ^[0-9]+$ ]] ; then
   vm_tags="${vm_tags};LTS"
elif [ "${DISTRIBUTION}" == "FreeBSD" ] && [[ "${RELEASE}" =~ ^RELEASE- ]] ; then
   vm_tags="${vm_tags};LTS"
fi


# ====== Print configuration ================================================
echo "Configuration:"
echo " - HYPERVISOR=${HYPERVISOR}"
echo " - NAME=${NAME}"
echo " - VM_ID=${vm_id}"
echo " - VM_NAME=${vm_name}"
echo " - PROJECT=${PROJECT}"
echo " - DISTRIBUTION=${DISTRIBUTION}"
echo " - RELEASE=${RELEASE}"
echo " - PROVISIONERS=${PROVISIONERS}"
echo " - HTTP_DIRECTORY=${HTTP_DIRECTORY}"
echo " - VM_CHIPSET=${VM_CHIPSET}"
echo " - VM_FIRMWARE=${VM_FIRMWARE}"
echo " - VM_CORES=${VM_CORES}"
echo " - VM_MEMORY=${VM_MEMORY} (MiB)"
echo " - VM_BALLOON=${VM_BALLOON} (MiB)"
echo " - VM_DISK_PREFIX=${VM_DISK_PREFIX}"
echo " - VM_DISK_ROOT=${VM_DISK_ROOT} (MiB)"
if [ ${USE_SEPARATE_DISKS} -ne 0 ] ; then
   echo " - VM_DISK_HOME=${VM_DISK_HOME} (MiB)"
   echo " - VM_DISK_SWAP=${VM_DISK_SWAP} (MiB)"
fi
echo " - VIDEO=${VIDEO}"
echo " - BOOTSPLASH=${BOOTSPLASH}"
echo " - BACKGROUND_SDDM=${BACKGROUND_SDDM}"
echo " - BACKGROUND_LOCKSCREEN=${BACKGROUND_LOCKSCREEN}"
echo " - BACKGROUND_DESKTOP=${BACKGROUND_DESKTOP}"
echo " - XKBMODEL=${XKBMODEL}"
echo " - XKBLAYOUT=${XKBLAYOUT}"
echo " - XKBVARIANT=${XKBVARIANT}"
echo " - XKBOPTIONS=${XKBOPTIONS}"
echo " - FQDN=${FQDN}"
echo " - HOSTNAME=${HOSTNAME}"
echo " - DOMAINNAME=${DOMAINNAME}"

if [ ${DRY_RUN} -ne 0 ] ; then
   echo "Dry run -> exiting."
   exit
fi


# ====== Hypervisor-specific preparations ===================================
if [ "${HYPERVISOR}" == "VirtualBox" ] ; then
   # ====== VirtualBox Ensure that VirtualBox modules are loaded ============
   if [ "$(lsmod|grep "^vboxdrv")" == "" ] ; then
      echo "Need to load vboxdrv ..."
      sudo service virtualbox start || true
      sudo service vboxdrv start || true
   fi

   # ====== VirtualBox: Stop VM, if it is running ===========================
   # Power off the VM, if it exists
   timeout --kill-after=30 15 vboxmanage controlvm "${vm_name}" poweroff || true
   # shellcheck disable=SC2009
   pid=$(ps ax | grep VBoxHeadless | grep -- " --comment ${vm_name} " | awk '{ print $1 }')
   if [ "${pid}" != "" ] ; then
      echo "VM is still running (PID ${pid}) -> sending SIGKILL!"
      kill -KILL "${pid}"
      sleep 5
   fi

   # ====== VirtualBox: Stop VM, if it exists ===============================
   vboxmanage unregistervm "${vm_name}" --delete || true


# ====== QEMU: Ensure that VirtualBox modules are unloaded ==================
elif [ "${HYPERVISOR}" == "QEMU" ] ; then
   if [ "$(lsmod|grep "^vboxdrv")" != "" ] ; then
      echo "Need to unload vboxdrv ..."
      sudo service virtualbox stop || true
      sudo service vboxdrv stop || true
   fi
fi


# ====== Finally, let Packer build the VM ===================================
echo "Running Packer for ${JSON}:"
cd "${OUTPUT_DIRECTORY}/${NAME}"
rm -rf "${vm_name}"
env CHECKPOINT_DISABLE=1 PACKER_LOG=${PACKER_LOG} PACKER_CACHE_DIR="${CACHE_DIRECTORY}" "${PACKER}" build --force \
   -warn-on-undeclared-var \
   -timestamp-ui \
   -parallel-builds=0 \
   -var "vm_directory=${OUTPUT_DIRECTORY}/${NAME}/${NAME}" \
   -var "vm_id=${vm_id}"                                   \
   -var "vm_name=${vm_name}"                               \
   -var "vm_name_dnsname=${vm_name//[^a-zA-Z0-9\\.-]/}"    \
   -var "vm_version=${vm_version}"                         \
   -var "vm_version=${vm_version}"                         \
   -var "vm_chipset=${VM_CHIPSET}"                         \
   -var "vm_firmware=${VM_FIRMWARE}"                       \
   -var "vm_cores=${VM_CORES}"                             \
   -var "vm_memory=${VM_MEMORY}"                           \
   -var "vm_balloon=${VM_BALLOON}"                         \
   -var "vm_balloon_min=${VM_BALLOON_MIN}"                 \
   -var "vm_disk_prefix=${VM_DISK_PREFIX}"                 \
   -var "vm_disk_root=${VM_DISK_ROOT}"                     \
   -var "vm_disk_home=${VM_DISK_HOME}"                     \
   -var "vm_disk_swap=${VM_DISK_SWAP}"                     \
   -var "vm_video=${VIDEO}"                                \
   -var "vm_vendor=${vm_vendor}"                           \
   -var "vm_vendorurl=${vm_vendorurl}"                     \
   -var "vm_product=${vm_product}"                         \
   -var "vm_producturl=${vm_producturl}"                   \
   -var "vm_description=${vm_description}"                 \
   -var "vm_tags=${vm_tags}"                               \
   -var "host_name=${HOSTNAME}"                            \
   -var "host_domain=${DOMAINNAME}"                        \
   -var "user_name=${USER_NAME}"                           \
   -var "user_realname=${USER_REALNAME}"                   \
   -var "user_password=${USER_PASSWORD}"                   \
   -var "vsphere_version=${VSPHERE_VERSION}"               \
   -var "vsphere_username=${VSPHERE_USERNAME}"             \
   -var "vsphere_password=${VSPHERE_PASSWORD}"             \
   -var "vsphere_server=${VSPHERE_SERVER}"                 \
   -var "vsphere_datacenter=${VSPHERE_DATACENTER}"         \
   -var "vsphere_cluster=${VSPHERE_CLUSTER}"               \
   -var "vsphere_folder=${VSPHERE_FOLDER}"                 \
   -var "vsphere_host=${VSPHERE_HOST}"                     \
   -var "vsphere_datastore=${VSPHERE_DATASTORE}"           \
   -var "vsphere_network=${VSPHERE_NETWORK}"               \
   -var "vsphere_http_ip=${VSPHERE_HTTP_IP}"               \
   -var "proxmox_username=${PROXMOX_USERNAME}"             \
   -var "proxmox_password=${PROXMOX_PASSWORD}"             \
   -var "proxmox_url=${PROXMOX_URL}"                       \
   -var "proxmox_node=${PROXMOX_NODE}"                     \
   -var "proxmox_pool=${PROXMOX_POOL}"                     \
   -var "proxmox_disk_storage=${PROXMOX_DISK_STORAGE}"     \
   -var "proxmox_iso_storage=${PROXMOX_ISO_STORAGE}"       \
   -var "proxmox_bridge=${PROXMOX_BRIDGE}"                 \
   -var "proxmox_vlan_id=${PROXMOX_VLAN_ID}"               \
   -var "proxmox_http_ip=${PROXMOX_HTTP_IP}"               \
   -on-error=abort                                         \
   "${JSON}"


# ====== Log result =========================================================
(
   echo "TIMESTAMP=$(date +"%Y/%m/%d-%H:%M:%S")"
   if [ "${HYPERVISOR}" == "VirtualBox" ] ; then
      echo "RESULT=$(realpath --relative-to=. "${OUTPUT_DIRECTORY}/${NAME}/${NAME}/${vm_name}.ova")"
   elif [ "${HYPERVISOR}" == "QEMU" ] ; then
      # Rename QEMU image to have qcow2 extension!
      mv "${OUTPUT_DIRECTORY}/${NAME}/${vm_name}/${vm_name}" "${OUTPUT_DIRECTORY}/${NAME}/${vm_name}/${vm_name}".qcow2
      # Create a compressed version as well:
      nice xz -T0 -k "${OUTPUT_DIRECTORY}/${NAME}/${vm_name}/${vm_name}".qcow2
      echo "RESULT=${OUTPUT_DIRECTORY}/${NAME}/${vm_name}/${vm_name}.qcow2"
   elif [ "${HYPERVISOR}" == "vSphere" ] ; then
      echo "RESULT=${OUTPUT_DIRECTORY}/${NAME}/successfully-built.txt"
   elif [ "${HYPERVISOR}" == "Proxmox" ] ; then
      echo "RESULT=${OUTPUT_DIRECTORY}/${NAME}/successfully-built.txt"
   fi
) >successfully-built.txt