%pre --erroronfail

############################################################################
#
# This miniboot kickstart tells Anaconda to install the subcloud
# from one of the following repo sources listed in order of priority.
#
# 1. Prestaged Content ; Packages and repodata      (highest priority)
#
#    prestaged source  ... /opt/platform-backup/rel-xx.xx/Packages
#    prestaged source  ... /opt/platform-backup/rel-xx.xx/repodata
#    prestaged source  ... xxxHTTP_URLxxx/patches
#
#    Anaconda install  ... /opt/platform-backup/rel-xx.xx
#
# 2. Prestaged ISO image
#
#    prestaged source  ... /opt/platform-backup/rel-xx.xx/bootimage.iso
#    prestaged check   ... /opt/platform-backup/rel-xx.xx/bootimage.md5
#    prestaged source  ... xxxHTTP_URLxxx/patches
#
#    Anaconda install  ... /mnt/bootimage
#
# 3. Staged feeds after %pre fetch from System Controller (lowest priority)
#
#    stage source wget xxxHTTP_URLxxx/Packages -> /mnt/install/repo/Packages
#    stage source wget xxxHTTP_URLxxx/repodata -> /mnt/install/repo/repodata
#    stage source wget xxxHTTP_URLxxx/patches  -> /mnt/install/repo/patches
#
#    Anaconda install  ... /mnt/install/repo/
#
# All of the above methods must mirror the system controller's feed,
# updates and patching repos from the staged or prestaged source.
#
#    feed   .... for installing system nodes  /var/www/pages/feed/rel-xx.xx
#
#    updates ... for managing updates         /var/www/pages/updates
#
#    patching .. for managing patches         /opt/patching/commit
#                                             /opt/patching/available
#                                             /opt/patching/applied
#
# Miniboot checks and reports on found prestaged container images or
# other files with md5 checks present. Miniboot leaves them to be
# utilized by software.
#
#   prestaged container images ... /opt/platform-backup/rel-xx.xx/image#
#   prestaged image checks     ... /opt/platform-backup/rel-xx.xx/image#.md5
#
# Miniboot also downloads the file "package_checksums" from the system
# controller and copies it to two locations: /usr/local/share/pkg-list and
# to /var/www/pages/feed/rel-<version>. This file is required for prestaging
# operations. The file is renamed to packages_list at the target location.
############################################################################

# Source common functions
. /tmp/ks-functions.sh

SW_VERSION=xxxPLATFORM_RELEASExxx
STAGING_DIR="platform-backup"
BACKUP_DEVICE=
BACKUP_PART_GUID="BA5EBA11-0000-1111-2222-000000000002"
BACKUP_MOUNT=/mnt/${STAGING_DIR}
BOOTIMAGE_ISO=""

# Staging and Prestaging Directories
INSTALL_MOUNT=/mnt/install/repo
BOOTIMAGE_MOUNT=/mnt/bootimage
PRESTAGE_DIR=${BACKUP_MOUNT}/${SW_VERSION}

KS="Miniboot  pre:"

wlog "${KS} Local Install check"

iso_check=false
iso_mount=false
prestaging_files=false

# Search for a backup partition, using GUID (which appears lower case in the blkid output):
while read -r device_path; do
    if [ "$(blkid -p "${device_path}" | grep -c -i "${BACKUP_PART_GUID}")" -gt 0 ]; then
        BACKUP_DEVICE=${device_path}
        wlog "Found backup device: ${BACKUP_DEVICE}"
        break
    fi
done <<<"$(lsblk --noheadings --list --path --output NAME)"

# Look for and validate the local iso image
if [ -n "${BACKUP_DEVICE}" ] && [ -e "${BACKUP_DEVICE}" ]; then
    mkdir -p ${BACKUP_MOUNT}
    mount ${BACKUP_DEVICE} ${BACKUP_MOUNT} 2>/dev/null
    rc=$?
    if [ $rc -eq 0 ] ; then
        sleep 2
        # does the prestaging dir for the specified sw version exist
        if [ -d "${BACKUP_MOUNT}/${SW_VERSION}" ] ; then

            # are there files in it ?
            if [ "$(ls -A ${BACKUP_MOUNT}/${SW_VERSION})" ] ; then

                # change to prestaging dir and load the file names
                cd ${BACKUP_MOUNT}/${SW_VERSION}

                # Local Install Bundle Validation:
                #
                # ISO Image: There must be an iso image whose base
                #            filename matches an md5 check file and
                #            that check must pass.
                #
                # Container Images: Missing container image check file(s) or
                #                   container image validation check failure
                #                   does not reject a Local Install.
                #
                # Find the iso image first.
                #  - there should be only one so use the first one found
                #    just in case there are others there.

                # Loop over the files if there are any looking for the iso
                iso_filename=""
                for file in $(ls -A .) ; do
                    prestaging_files=true
                    filename="${file%.*}"
                    extension="${file##*.}"
                    if [ "${extension}" = "iso" ] ; then
                        iso_filename="${filename}"

                        # Found the iso name for the mount operation below
                        BOOTIMAGE_ISO=${BACKUP_MOUNT}/${SW_VERSION}/${file}
                        wlog "${KS} found prestaged iso image ${BOOTIMAGE_ISO}"
                        if [ -f ${filename}.md5 ] ; then
                            md5sum -c "${filename}.md5"
                            if [ $? -eq 0 ] ; then
                                wlog "${KS} ${file} iso check passed"
                                iso_check=true
                                mkdir -p ${BOOTIMAGE_MOUNT}
                                mount -o loop ${BOOTIMAGE_ISO} ${BOOTIMAGE_MOUNT}
                                if [ $? -eq 0 ] ; then
                                    iso_mount=true
                                    wlog "${KS} local iso mounted ${BOOTIMAGE_MOUNT}"
                                else
                                    wlog "${KS} local iso mount failed"
                                fi
                            else
                                wlog "${KS} ${file} iso check failed"
                            fi
                        else
                            wlog "${KS} no iso image check file found ${filename}.md5"
                        fi
                        break
                    fi
                done

                # Loop over the files again this time to run checks
                # on md5 files that are not the iso.
                # Such files are expected to be checks for container image sets.
                # Failure of container image sets check will not reject
                # the local install.
                for file in $(ls -A .) ; do
                    prestaging_files=true
                    filename="${file%.*}"
                    extension="${file##*.}"
                    if [ "${extension}" = "md5" -a "${filename}" != "${iso_filename}" ] ; then
                        wlog "${KS} prestaged file : ${file}"
                        md5sum -c "${file}"
                        if [ $? -eq 0 ] ; then
                            wlog "${KS} ${file} check passed"
                        else
                            wlog "${KS} ${file} check failed"
                        fi
                    fi
                done
            fi

            if [ "${prestaging_files}" = false ] ; then
                wlog "${KS} no prestaged files"
            fi
        else
            wlog "${KS} ${BACKUP_MOUNT} not mounted"
        fi
    else
        wlog "${KS} mount of '${BACKUP_DEVICE}' to ${BACKUP_MOUNT} failed rc:$rc"
    fi
else
    wlog "${KS} backup device '${BACKUP_DEVICE}' does not exist"
fi

wlog "${KS} iso_check: ${iso_check} iso_mount: ${iso_mount}"
if [ "${iso_check}" = true -a "${iso_mount}" = true ] ; then
    wlog "${KS} Local Install ready"
elif [ "${iso_mount}" = false ] ; then
    wlog "${KS} Prestaged ISO not present or invalid"
fi

# Make sure the prestage directory exists, as well as the required subdirectories.
exists_prestage=false
wlog "${KS} Checking prestaged content PRESTAGE_DIR: ${PRESTAGE_DIR}"
if [ ! -e ${PRESTAGE_DIR} ] || [ ! -e ${PRESTAGE_DIR}/Packages ] || [ ! -e ${PRESTAGE_DIR}/repodata ]; then
    exists_prestage=false
    wlog "${KS} Prestaged content not present"
else
    repodata_files_count=$(ls ${PRESTAGE_DIR}/repodata | wc -l)
    if [ ${repodata_files_count} -ne 0 ]; then
        packages_files_count=$(ls ${PRESTAGE_DIR}/Packages | wc -l)
        if [ ${packages_files_count} -ne 0 ] ; then
            exists_prestage=true
            wlog "${KS} Prestaged content present"
            # unmount iso image if mounted
            if [ -d ${BOOTIMAGE_MOUNT} ]; then
                wlog "${KS} Unmounting ${BOOTIMAGE_MOUNT} for prestaged content install"
                umount ${BOOTIMAGE_MOUNT}
                rmdir ${BOOTIMAGE_MOUNT}
            else
                wlog "${KS} ${BOOTIMAGE_MOUNT} dir does not exist"
            fi
        else
            wlog "${KS} Prestaged Content is invalid ; no Package files present"
        fi
    else
        wlog "${KS} Prestaged Content is invalid ; no repodata files present ${repodata_files_count}"
    fi
fi

#
# This controls where the packages come from.
# Lower cost has higher priority ; making local install preferred.
#
# If ${BOOTIMAGE_MOUNT} exists then install from local iso - Local Install
# Otherwise, they are fetched from platform backup if the Packages have been
# prestaged.
# If this fails, they are fetched from the System Controller - Remote Install
#
if [ "${exists_prestage}" = true ]; then
    wlog "${KS} Prestage directory found: ${PRESTAGE_DIR}. Proceeding with prestaged install."
    cat << EOF > /tmp/repo-include
    repo --name=local-base --cost=100 --baseurl=file://${PRESTAGE_DIR}/
    repo --name=local-updates --cost=100 --baseurl=file://${PRESTAGE_DIR}/patches/
    repo --name=remote-base --cost=200 --baseurl=xxxHTTP_URLxxx/
    repo --name=remote-updates --cost=200 --baseurl=xxxHTTP_URLxxx/patches/
EOF
elif [ "${iso_check}" = true ] && [ "${iso_mount}" = true ] ; then
    wlog "${KS} Packages will be retrieved from prestage ISO. Proceeding with local (ISO) install."
    cat << EOF > /tmp/repo-include
    repo --name=local-base --cost=100 --baseurl=file://${BOOTIMAGE_MOUNT}/
    repo --name=local-updates --cost=100 --baseurl=file://${BOOTIMAGE_MOUNT}/patches/
    repo --name=remote-base --cost=200 --baseurl=xxxHTTP_URLxxx/
    repo --name=remote-updates --cost=200 --baseurl=xxxHTTP_URLxxx/patches/
EOF
else
    # Mirror remote software repositories
    wlog "${KS} Staging Repo via ${feed_url}"

    # Check for inst.noverifyssl
    if grep -q inst.noverifyssl /proc/cmdline; then
        NOVERIFYSSL_WGET_OPT="--no-check-certificate"
    else
        NOVERIFYSSL_WGET_OPT=""
    fi

    declare -i cut_dirs=NUM_DIRS
    cd "${INSTALL_MOUNT}"
    mkdir -p logs
    mkdir -p Packages
    mkdir -p repodata
    feed_url=xxxHTTP_URLxxx

    # Fetch Packages
    wlog "${KS} Staged Install packages fetch from $feed_url/Packages"
    wget ${NOVERIFYSSL_WGET_OPT} --mirror --no-parent --no-host-directories --reject 'index.html*' --reject '*.log' \
        --cut-dirs=$cut_dirs ${feed_url}/Packages/ -o ${INSTALL_MOUNT}/logs/rpmget.log \
        || report_pre_failure_with_msg "Failed to fetch Packages ; see ${INSTALL_MOUNT}/logs/rpmget.log"
    wlog "${KS} Staged Packages to ${INSTALL_MOUNT}/Packages complete"

    # Fetch Repodata
    wlog "${KS} Staged Install repodata fetch from $feed_url/repodata"
    wget ${NOVERIFYSSL_WGET_OPT} --mirror --no-parent --no-host-directories --reject 'index.html*' --reject '*.log' \
        --cut-dirs=$cut_dirs ${feed_url}/repodata/ -o ${INSTALL_MOUNT}/logs/rpmget_repo.log \
        || report_pre_failure_with_msg "Failed to fetch repodata ; see ${INSTALL_MOUNT}/logs/rpmget_repo.log"
    wlog "${KS} Staged repodata to ${INSTALL_MOUNT}/repodata complete"

    # Fetch Patch Package Data quietly
    #  - Patch Packages
    #  - Patches repodata
    #  - Patches metadata
    #  - Save all patch packages to /opt/patching/packages/xxxPLATFORM_RELEASExxx
    patches_url=xxxHTTP_URLxxx/patches
    wget ${NOVERIFYSSL_WGET_OPT} -q --spider ${patches_url}/
    if [ $? -eq 0 ]; then
        wlog "${KS} Staged Install patch repository from $patches_url to ${INSTALL_MOUNT}/patches"
        mkdir -p ${INSTALL_MOUNT}/patches/Packages
        mkdir -p ${INSTALL_MOUNT}/patches/repodata
        cd ${INSTALL_MOUNT}/patches
        declare -i patches_cut_dirs=$((cut_dirs+1))

        wlog "${KS} Staged Install fetch patch Packages from $patches_url/Packages"
        wget ${NOVERIFYSSL_WGET_OPT} --mirror --no-parent --no-host-directories --reject 'index.html*' \
            --cut-dirs=$patches_cut_dirs $patches_url/Packages/ -o ${INSTALL_MOUNT}/logs/patches_rpmget.log \
            || report_post_failure_with_logfile ${INSTALL_MOUNT}/logs/patches_rpmget.log

        wlog "${KS} Staged Install fetch patch repodata from $patches_url/repodata"
        wget ${NOVERIFYSSL_WGET_OPT} --mirror --no-parent --no-host-directories --reject 'index.html*' \
            --cut-dirs=$patches_cut_dirs $patches_url/repodata/ -o ${INSTALL_MOUNT}/logs/patches_rpmget_repo.log \
            || report_post_failure_with_logfile ${INSTALL_MOUNT}/logs/patches_rpmget_repo.log

        wlog "${KS} Staged Install fetch patch metadata from $patches_url/metadata"
        wget ${NOVERIFYSSL_WGET_OPT} --mirror --no-parent --no-host-directories --reject 'index.html*' \
            --cut-dirs=$patches_cut_dirs $patches_url/metadata/ -o ${INSTALL_MOUNT}/logs/patches_rpmget_metadata.log \
            || report_post_failure_with_logfile ${INSTALL_MOUNT}/logs/patches_rpmget_metadata.log

        wlog "${KS} Staged patches to ${INSTALL_MOUNT}/patches complete"
    else
        wlog "${KS} get from patches url '$patches_url' failed"
    fi

    cat << EOF > /tmp/repo-include
    repo --name=local-base --cost=100 --baseurl=file://${INSTALL_MOUNT}/
    repo --name=local-updates --cost=100 --baseurl=file://${INSTALL_MOUNT}/patches/
    repo --name=remote-base --cost=200 --baseurl=xxxHTTP_URLxxx/
    repo --name=remote-updates --cost=200 --baseurl=xxxHTTP_URLxxx/patches/
EOF
fi
wlog "Using repo config:\n$(cat /tmp/repo-include)"
%end

# Repository arguments from %pre
%include /tmp/repo-include


%post --erroronfail

# Source common functions
. /tmp/ks-functions.sh

KS="Miniboot post:"

# wlog "${KS} cmdLine: $(cat /proc/cmdline)"
if [ -e /dev/disk/by-label/oe_iso_boot ]; then
    # This is a hybrid ISO/network install. Mount the media to ensure Anaconda
    # ejects it on reboot.
    mkdir /mnt/iso
    wlog "${KS} mount for eject"
    mount /dev/disk/by-label/oe_iso_boot /mnt/iso
else
    wlog "${KS} /dev/disk/by-label/oe_iso_boot does not exist"
fi

# persist the default http port number to platform configuration. This
# will get overwritten when config_controller is run.
echo http_port=8080 >> /etc/platform/platform.conf

# Build networking scripts
cat << EOF > /etc/sysconfig/network-scripts/ifcfg-lo
DEVICE=lo
IPADDR=127.0.0.1
NETMASK=255.0.0.0
NETWORK=127.0.0.0
BROADCAST=127.255.255.255
ONBOOT=yes
IPV6_AUTOCONF=no
NAME=loopback
EOF

%end

%post --nochroot --erroronfail

# Source common functions
. /tmp/ks-functions.sh

# Mirror local software repositories
INSTALL_MOUNT=/mnt/install/repo
SYSIMAGE_MOUNT=/mnt/sysimage
FEED_DIR=${SYSIMAGE_MOUNT}/var/www/pages/feed/rel-xxxPLATFORM_RELEASExxx
UPDATES_DIR=${SYSIMAGE_MOUNT}/var/www/pages/updates/rel-xxxPLATFORM_RELEASExxx
PATCHING_DIR=${SYSIMAGE_MOUNT}/opt/patching
PACKAGES_DIR=${PATCHING_DIR}/packages/xxxPLATFORM_RELEASExxx/

KS="Miniboot post:"

need_patches=false

# Handle 3 prestaging conditions
#
# 1. Full local install  ; iso present in platform-backup/rel
# 2. Prioritized install ; use prestaged content fetch what's missing remotely
# 3. Staged install      ; no prestaging content
if [ -d /mnt/bootimage ]; then
    srcdir=/mnt/bootimage
    # Always need to fetch patches for Prestaged ISO install.
    # It is not sufficient to only get committed patches from the ISO,
    # There may also be non-committed patches applied to the system
    # controller that are needed as well.
    # Setting need_patches to true for the ISO install handles both commited
    # and non-committed patch cases.
    need_patches=true
    wlog "${KS} Local Install from $srcdir"
elif [ -d ${INSTALL_MOUNT}/Packages ] ; then
    srcdir=${INSTALL_MOUNT}
    wlog "${KS} Staged Install from $srcdir"
else
    srcdir=/mnt/platform-backup/xxxPLATFORM_RELEASExxx
    wlog "${KS} looking for packages in ${srcdir}"
fi

# prepare to boot other hosts by mirroring sw repository
if [ -d $srcdir/Packages ] ; then
    wlog "${KS} copying software repository $srcdir/Packages and $srcdir/repodata"
    mkdir -p ${FEED_DIR}
    if [ -d $srcdir/repodata ] ; then
        repodatafilecount=$(ls ${srcdir}/repodata | wc -l)
        if [ ${repodatafilecount} = 0 ]; then
            report_post_failure_with_msg "$srcdir/repodata files not found."
        else
            wlog "${KS} copying repodata from $srcdir/repodata to ${FEED_DIR}/repodata"
            cp -r $srcdir/repodata ${FEED_DIR}/repodata
        fi
    else
        report_post_failure_with_msg "$srcdir/repodata not found."
    fi
    packagesfilecount=$(ls ${srcdir}/Packages | wc -l)
    if [ ${packagesfilecount} = 0 ]; then
        report_post_failure_with_msg "$srcdir/Packages files not found."
    else
        wlog "${KS} copying packages from $srcdir/Packages to ${FEED_DIR}/Packages"
        cp -r $srcdir/Packages ${FEED_DIR}/Packages
    fi
else
    report_post_failure_with_msg "$srcdir/Packages not found."
fi

if [ -d $srcdir/patches ]; then
    if [ -d  $srcdir/patches/Packages ] ; then
        wlog "${KS} copying patch Packages from $srcdir/patches/Packages to ${UPDATES_DIR}/Packages"
        mkdir -p ${UPDATES_DIR}
        cp -r $srcdir/patches/Packages ${UPDATES_DIR}/Packages
    else
        wlog "${KS} $srcdir/patches/Packages doesn't exist. Fetching remotely"
        need_patches=true
    fi

    if [ -d $srcdir/patches/repodata ] ; then
        wlog "${KS} copying patch repodata from $srcdir/patches/repodata to ${UPDATES_DIR}/repodata"
        mkdir -p ${UPDATES_DIR}
        cp -r $srcdir/patches/repodata ${UPDATES_DIR}/repodata
    else
        wlog "${KS} $srcdir/patches/repodata doesn't exist. Fetching remotely"
        need_patches=true
    fi
else
    wlog "${KS} $srcdir/patches doesn't exist. Fetching remotely"
    need_patches=true
fi

if [ -d $srcdir/patches/metadata -a "${need_patches}" = false ] ; then
    mkdir -p ${PATCHING_DIR}
    wlog "${KS} copying patch metadata from $srcdir/patches/metadata to ${PATCHING_DIR}/metadata"
    cp -r $srcdir/patches/metadata ${PATCHING_DIR}/metadata
else
    wlog "${KS} $srcdir/patches/metadata doesn't exist. Fetching remotely"
    need_patches=true
fi

if [ -d $srcdir/patches -a "${need_patches}" = false ]; then
    mkdir -p ${PACKAGES_DIR}
    wlog "${KS} copying packages from ${UPDATES_DIR}/Packages to ${PACKAGES_DIR}"
    find ${UPDATES_DIR}/Packages -name '*.rpm' \
        | xargs --no-run-if-empty -I files cp --preserve=all files ${PACKAGES_DIR}
else
    wlog "${KS} $srcdir/patches doesn't exist: fetching remotely"
    need_patches=true
fi

if [ "${srcdir}" = "${INSTALL_MOUNT}" ] ; then

    # save the pre stage anaconda logs
    mkdir -p ${SYSIMAGE_MOUNT}/var/log/anaconda
    cp -a ${INSTALL_MOUNT}/logs/* ${SYSIMAGE_MOUNT}/var/log/anaconda
fi

if [ "${need_patches}" = true ]; then
    echo > ${SYSIMAGE_MOUNT}/tmp/needpatches
fi
true
%end


%post --erroronfail

# Source common functions
. /tmp/ks-functions.sh

KS="Miniboot post:"

FEED_DIR=/var/www/pages/feed/rel-xxxPLATFORM_RELEASExxx

# Create a uuid specific to this installation
INSTALL_UUID=`uuidgen`
echo $INSTALL_UUID > /var/www/pages/feed/rel-xxxPLATFORM_RELEASExxx/install_uuid
echo "INSTALL_UUID=$INSTALL_UUID" >> /etc/platform/platform.conf
wlog "${KS} updating platform.conf with install uuid : ${INSTALL_UUID}"

# Mirror remote software repositories
anaconda_logdir=/var/log/anaconda
mkdir -p $anaconda_logdir

# Check for inst.noverifyssl
if grep -q inst.noverifyssl /proc/cmdline; then
    NOVERIFYSSL_WGET_OPT="--no-check-certificate"
else
    NOVERIFYSSL_WGET_OPT=""
fi

# package_checksums
# copy the package_checksums file to /usr/local/share/pkg-list
INSTALL_MOUNT=/mnt/install/repo
PKG_FILE=package_checksums
# at the target directory, this file is called "<release_id>_packages_list.txt"
DEST_PKG_FILE="xxxPLATFORM_RELEASExxx_packages_list.txt"
PKG_FILE_LOC=/usr/local/share/pkg-list
pkg_url=xxxHTTP_URLxxx

# create ${PKG_FILE_LOC} if it does not exist already.
if [ ! -d ${PKG_FILE_LOC} ]; then
    wlog "${KS} Creating ${PKG_FILE_LOC}"
    mkdir -p ${PKG_FILE_LOC}
fi

# There are two paths to obtain the desired file. The file is
# named package_checksums in the bootimage.iso, and it must be
# stored in two locations here as packages_list.
#
# If this server is being installed from the iso file (through
# CD/DVD etc, for example), then, if the file exists at
# ${INSTALL_MOUNT}, just copy it over. Otherwise, it is possible
# that this install is happening on a subcloud. In this case,
# download the file from the server (system controller).
#
# If the file does not exist, it is an issue as future upgrades
# may not work, so we need to exit with error.

if [ -f ${INSTALL_MOUNT}/${PKG_FILE} ]; then
    wlog "${KS} copying package_checksums to ${PKG_FILE_LOC}"
    cp ${INSTALL_MOUNT}/${PKG_FILE} ${PKG_FILE_LOC}/${DEST_PKG_FILE}
else
    # the file does not exist because the install is not happening
    # from a bootimage.iso.
    # so get it from the system controller.
    wlog "${KS} downloading ${DEST_PKG_FILE} from the system controller"
    wget ${NOVERIFYSSL_WGET_OPT} ${pkg_url}/${DEST_PKG_FILE} \
         -O ${PKG_FILE_LOC}/${DEST_PKG_FILE} \
         -o $anaconda_logdir/${PKG_FILE}.log \
         || report_post_failure_with_logfile $anaconda_logdir/${PKG_FILE}.log
fi

# cp the package_checksum files to the feed directory
wlog "${KS} copying ${PKG_FILE_LOC}/${DEST_PKG_FILE} to ${FEED_DIR}/${PKG_FILE}"
cp ${PKG_FILE_LOC}/${DEST_PKG_FILE} ${FEED_DIR}/${PKG_FILE}

# If the path to $FEED_DIR does not exist then proceed to create it and
# fetch the ISO content in pieces from the system controller:
#
#  - Packages
#  - Repodata
#
declare -i cut_dirs=NUM_DIRS
declare need_patches=

if [ -f /tmp/needpatches ]; then
    wlog "${KS} patches need to be downloaded"
    need_patches=true
    rm /tmp/needpatches
else
    need_patches=false
fi

# Fetch Patch Package Data quietly
#  - Patch Packages
#  - Patches repodata
#  - Patches metadata
#  - Save all patch packages to /opt/patching/packages/xxxPLATFORM_RELEASExxx
patches_url=xxxHTTP_URLxxx/patches
wget ${NOVERIFYSSL_WGET_OPT} -q --spider ${patches_url}/
if [ $? -eq 0 ] && [ "${need_patches}" = true ]; then
    wlog "${KS} downloading patch repository $patches_url"
    cd /var/www/pages
    mkdir -p updates/rel-xxxPLATFORM_RELEASExxx/Packages
    mkdir -p updates/rel-xxxPLATFORM_RELEASExxx/repodata
    cd updates/rel-xxxPLATFORM_RELEASExxx
    declare -i patches_cut_dirs=$((cut_dirs+1))
    this_dir=$(pwd)

    wlog "${KS} fetch patch packages from $patches_url/Packages to ${this_dir}"
    wget ${NOVERIFYSSL_WGET_OPT} --mirror --no-parent --no-host-directories --reject 'index.html*' \
        --cut-dirs=$patches_cut_dirs $patches_url/Packages/ -o $anaconda_logdir/patches_rpmget.log \
        || report_post_failure_with_logfile $anaconda_logdir/patches_rpmget.log

    wlog "${KS} fetch patch repodata from $patches_url/repodata to ${this_dir}"
    wget ${NOVERIFYSSL_WGET_OPT} --mirror --no-parent --no-host-directories --reject 'index.html*' \
        --cut-dirs=$patches_cut_dirs $patches_url/repodata/ -o $anaconda_logdir/patches_rpmget_repo.log \
        || report_post_failure_with_logfile $anaconda_logdir/patches_rpmget_repo.log

    mkdir -p /opt/patching/metadata
    mkdir -p /opt/patching/packages/xxxPLATFORM_RELEASExxx
    cd /opt/patching

    wlog "${KS} fetch patch metadata from $patches_url/metadata to /opt/patching/metadata"
    wget ${NOVERIFYSSL_WGET_OPT} --mirror --no-parent --no-host-directories --reject 'index.html*' \
        --cut-dirs=$patches_cut_dirs $patches_url/metadata/ -o $anaconda_logdir/patches_rpmget_metadata.log \
        || report_post_failure_with_logfile $anaconda_logdir/patches_rpmget_metadata.log

    wlog "${KS} save a copy of all patch packages to /opt/patching/packages/xxxPLATFORM_RELEASExxx ; preserve attributes"
    find /var/www/pages/updates/rel-xxxPLATFORM_RELEASExxx/Packages -name '*.rpm' \
        | xargs --no-run-if-empty -I files cp --preserve=all files /opt/patching/packages/xxxPLATFORM_RELEASExxx/
else
    wlog "${KS} Patches are not required to be downloaded in post phase"
fi

%end