bashbuild.ah

#!/bin/bash
set +x

DRY_RUN=0

PKG_NAME=""
PKG_ROOT_IT=""
PKG_VERS="default"
PKG_TAG=""

if ! echo "${BASH_SOURCE}" | grep "/" --silent; then
  BB_SCRIPT_DIR=$(readlink -f $PWD)
else
  BB_SCRIPT_DIR=$(readlink -f ${BASH_SOURCE%/*})
fi

while [[ ${#} -gt 0 ]]; do

  key="$1"
  case $key in

      -n)

      if [[ ${#} -lt 2 ]]; then
        echo "[ERROR]: ${1} expected a value."
        exit 1
      fi

      PKG_NAME="$2"
      echo "[OPT]: Attempting to build package named: \"${PKG_NAME}\""
      shift # past argument
      ;;

      -r)

      if [[ ${#} -lt 2 ]]; then
        echo "[ERROR]: ${1} expected a value."
        exit 1
      fi

      PKG_ROOT_IT="$2"
      echo "[OPT]: Building for root image: \"${PKG_ROOT_IT}\""
      shift # past argument
      ;;

      -t)

      if [[ ${#} -lt 2 ]]; then
        echo "[ERROR]: ${1} expected a value."
        exit 1
      fi

      PKG_TAG="$2"
      echo "[OPT]: Tagging image as: \"${PKG_TAG}\""
      shift # past argument
      ;;

      -v)

      if [[ ${#} -lt 2 ]]; then
        echo "[ERROR]: ${1} expected a value."
        exit 1
      fi

      PKG_VERS="$2"
      echo "[OPT]: Building version: \"${PKG_VERS}\""
      shift # past argument
      ;;

      -D|--root-dir)

      if [[ ${#} -lt 2 ]]; then
        echo "[ERROR]: ${1} expected a value."
        exit 1
      fi

      BB_ROOT=$(readlink -f $2)
      echo "[OPT]: BB_ROOT=${BB_ROOT}"
      shift # past argument
      ;;

      -R|--repo)

      if [[ ${#} -lt 2 ]]; then
        echo "[ERROR]: ${1} expected a value."
        exit 1
      fi

      BB_REPO="$2/"
      echo "[OPT]: BB_REPO=${2}"
      shift # past argument
      ;;

      -f|--rebuild-deps)

      BB_REBUILD="ON"
      echo "[OPT]: Rebuilding dependencies."
      ;;

      -j)

      if [[ ${#} -lt 2 ]]; then
        echo "[ERROR]: ${1} expected a value."
        exit 1
      fi

      N_CORES="$2"
      echo "[OPT]: Building with ${2} cores where supported."
      shift # past argument
      ;;

      -?|--help)
echo "[RUNLIKE] ${SCRIPTNAME} -n <pkg> -r <base os:tag> [opts]"
echo -e "\t-n <package name>                    : The name of the container "
echo -e "\t                                       package to build."
echo -e "\t-r <package name>                    : The name of the root image "
echo -e "\t                                       to use, this describes the "
echo -e "\t                                       base OS: e.g centos:7"
echo -e "\t-v <version>                         : Specify a version of the "
echo -e "\t                                       software to build."
echo -e "\t                                       defaults to \"default\"."
echo -e "\t-t <tag>                             : Tag to use for requested"
echo -e "\t                                       product. Will default to a "
echo -e "\t                                       sanitization of the root"
echo -e "\t                                       container name, e.g."
echo -e "\t                                       debian:stretch-slim => "
echo -e "\t                                       debian_stretch-slim. "
echo -e "\t-D|--root-dir <bb manifest root dir> : The directory to use as the"
echo -e "\t                                       root of the container build"
echo -e "\t                                       script manifest. This option"
echo -e "\t                                       overrides the BB_ROOT env"
echo -e "\t                                       var. If BB_ROOT is not set"
echo -e "\t                                       then the parent directory of "
echo -e "\t                                       this script will be used."
echo -e "\t-R|--repo <reponame>                 : The registry repo name to"
echo -e "\t                                       used."
echo -e "\t                                       this option overrides the"
echo -e "\t                                       BB_REPO env var."
echo -e "\t-f|--rebuild-deps                    : This flag will trigger the"
echo -e "\t                                       rebuild of all dependent are"
echo -e "\t                                       containers. N.B. As "
echo -e "\t                                       containers built by custom "
echo -e "\t                                       scripts, user defined caching"
echo -e "\t                                       stages may not be rebuilt. "
echo -e "\t                                       If you mean business, "
echo -e "\t                                       \'buildah rmi --all\'."
echo -e "\t-j <ncores>                          : Use <ncores> for builds that"
echo -e "\t                                       support it."
echo -e "\t-?|--help                            : Print this message."
      exit 0
      ;;

      *)
              # unknown option
      echo "Unknown option $1"
      exit 1
      ;;
  esac
  shift # past argument or value
done

if [ -z ${BB_ROOT} ]; then
  BB_ROOT=$(pwd)
fi

export BB_ROOT
export BB_SCRIPT_DIR
export BUILDAH_FORMAT=docker

export BB_REPO_SL=
if [ ! -z $BB_REPO ]; then
  BB_REPO_SL="${BB_REPO}/"
fi

if [ -z ${N_CORES} ]; then
  N_CORES=1
fi

export N_CORES

if [ -z ${PKG_ROOT_IT} ] && [ ! -z ${BB_ROOT_IT} ]; then
   PKG_ROOT_IT=${BB_ROOT_IT}
fi

export BB_REBUILD=OFF

source $BB_SCRIPT_DIR/framework.funcs

function bb_resolve_deps {
  local INDENT="${INDENT}+"
  local DEPFILE=$1
  echo "${INDENT}Resolving dependencies found in: \"${DEPFILE}\""

  local IFS=$'\n'
  {
  for line in $(cat ${DEPFILE}); do
    local SANIT_LINE=$(echo $line | sed "s/^[[:space:]]\+//g" | sed "s/[[:space:]]\{2,\}/ /g" | grep -v "^#")

    # Skip comments and empty lines
    if [ -z "${SANIT_LINE}" ]; then
      continue
    fi

    local DEP_NAME
    local DEP_VERS
    local DEP_TAG
    local DEP_ROOT_IMAGE
    local DEP_ROOT_TAG
    bb_parse_depends_on_line $SANIT_LINE
    DEP_NAME=$(bb_depends_on_strip_base ${DEP_NAME})

    local DEP_ROOT_IT=${DEP_ROOT_IMAGE}:${DEP_ROOT_TAG}

    local DEP_VERS_STR="\"${DEP_VERS}\""
    if [ "${DEP_VERS}" == "default" ] && [ "$(bb_resolve_vers ${DEP_NAME} ${DEP_VERS})" != "default" ]; then
      DEP_VERS_STR="${DEP_VERS}: \"($(bb_resolve_vers ${DEP_NAME} ${DEP_VERS}))\""
    fi

    local DEP_IMAGE_FQNAME=$(bb_get_image_FQName $DEP_NAME $DEP_ROOT_IT $DEP_VERS $DEP_TAG)

    echo "${INDENT}Attempt to build dependency:"
    echo -e "${INDENT}\timage     : \"${DEP_IMAGE_FQNAME}\""
    echo -e "${INDENT}\troot-image: \"${DEP_ROOT_IT}\""
    echo -e "${INDENT}\tversion   : ${DEP_VERS_STR}"

    local DID_BUILD=0
    if ! bb_build $DEP_NAME $DEP_ROOT_IT $DEP_VERS $DEP_TAG; then
      return 1
    fi

    if [ ${DID_BUILD} -eq 1 ]; then
      DEP_NEEDED_REBUILD=1
    fi

    # This check includes the repo name, to ensure that the dependency is fulfilled
    if [ ${DRY_RUN} -eq 0 ] &&
       ! podman image exists ${DEP_IMAGE_FQNAME}; then
      echo "[ERROR]: After building: \"${DEP_IMAGE_FQNAME}\" does not exist. Something went wrong."
      return 1
    fi
  done
  }
}

function bb_build {

    local INDENT="${INDENT}"

    local FORCEBUILD=${BB_REBUILD}
    # Used to force build of the specified container
    if [ "$1" = "FORCE" ]; then
      FORCEBUILD="ON"
      shift
    fi

    local PKG_NAME=$1
    local PKG_ROOT_IT=$2
    local PKG_ROOT_IMAGE
    local PKG_ROOT_TAG
    local PKG_VERS=$3
    local PKG_TAG=$4

    if ! bb_check_dir_structure $PKG_NAME $PKG_ROOT_IT $PKG_VERS; then
      return 1
    fi

    bb_sanitize_pkg_identifier $PKG_NAME $PKG_ROOT_IT $PKG_VERS $PKG_TAG

    local PKG_IMAGE_FQNAME=$(bb_get_image_FQName $PKG_NAME $PKG_ROOT_IT $PKG_VERS $PKG_TAG)
    PKG_VERS=$(bb_resolve_vers ${PKG_NAME} ${PKG_VERS})

    local PKG_DIR="${BB_ROOT}/${PKG_NAME}/${PKG_VERS}/${PKG_ROOT_IMAGE}/${PKG_ROOT_TAG}"

    local DEP_NEEDED_REBUILD=0
    if [ -e ${PKG_DIR}/depends.on ]; then
      if ! bb_resolve_deps ${PKG_DIR}/depends.on; then
        echo "[ERROR]: Failed to resolve dependencies of \"$PKG_NAME\" (v: $PKG_VERS, t: ${PKG_TAG}) rooted on: \"$PKG_ROOT_IMAGE:$PKG_ROOT_TAG\""
        return 1
      fi
    fi
    if [ ${DEP_NEEDED_REBUILD} -eq 1 ]; then
      FORCEBUILD="ON"
    fi

    if [ ! "${FORCEBUILD}" = "ON" ] && \
       podman image exists ${PKG_IMAGE_FQNAME}; then
      echo "${INDENT}Not rebuilding: \"${PKG_IMAGE_FQNAME}\""
      return 0
    else
      echo "${INDENT}Image \"${PKG_IMAGE_FQNAME}\" needs building..."
    fi

    export BB_PKG_DIR=${PKG_DIR}
    export BB_PKG_NAME=${PKG_NAME}
    export BB_PKG_ROOT_IT=${PKG_ROOT_IT}
    export BB_PKG_VERS=${PKG_VERS}
    export BB_PKG_TAG=${PKG_TAG}
    export BB_PKG_IMAGE_FQNAME=${PKG_IMAGE_FQNAME}

    if [ ${DRY_RUN} -eq 0 ] &&
       ! ${BB_PKG_DIR}/build.ah; then
      echo "[ERROR]: Failed building ${PKG_IMAGE_FQNAME}"
      return 1
    fi

    if [ ${DRY_RUN} -eq 0 ]; then
      echo "${INDENT}Built: ${PKG_IMAGE_FQNAME}"
      DID_BUILD=1
    else
      echo "BUILD ENV:"
      echo -e "\tBB_ROOT=${BB_ROOT}"
      echo -e "\tBB_SCRIPT_DIR=${BB_SCRIPT_DIR}"
      echo -e "\tBB_PKG_DIR=${BB_PKG_DIR}"
      echo -e "\tBB_PKG_NAME=${BB_PKG_NAME}"
      echo -e "\tBB_PKG_ROOT_IT=${BB_PKG_ROOT_IT}"
      echo -e "\tBB_PKG_VERS=${BB_PKG_VERS}"
      echo -e "\tBB_PKG_TAG=${BB_PKG_TAG}"
      echo -e "\tBB_PKG_IMAGE_FQNAME=${BB_PKG_IMAGE_FQNAME}"
      echo "DRY RUN: Didn't attempt to build ${PKG_IMAGE_FQNAME}"
    fi

    export -n BB_PKG_DIR
    export -n BB_PKG_NAME
    export -n BB_PKG_ROOT_IT
    export -n BB_PKG_VERS
    export -n BB_PKG_TAG
    export -n BB_PKG_IMAGE_FQNAME
}

if [ -z $PKG_NAME ]; then
  echo "[ERROR]: Must specify a package name for the container to build (-n)."
  bb_say_packages
  exit 1
fi
if [ -z $PKG_ROOT_IT ]; then
  echo "[ERROR]: Must specify a root image name for the container structure."
  bb_say_root_names $PKG_NAME default
  exit 2
fi
if [ -z $PKG_TAG ]; then
  PKG_TAG=$(bb_get_root_tag $PKG_ROOT_IT)
fi

bb_build FORCE $PKG_NAME $PKG_ROOT_IT $PKG_VERS $PKG_TAG