Add a symbolic link to the lfs-uefi-20170207.txt hint

[linux_from_scratch_hints.git] / ATTACHMENTS / pkg_unionfs / manager

#!/bin/sh

# The "pkg_dir" variable points to the directory containing the packages.
# This path must be absolute.
pkg_dir="/pkgs"

# The "target_dir" variable points to the directory where the target
# directories are located. This path must be absolute.
target_dir="/"


command="${1}"
pkg_name="${2}"
pkg_version="${3}"

# Unfortunately, bash does not support map or dictionary data structures.
# The goal of map_dir is to simulate this data structure. Given a source
# directory, it will map it to a target directory.
#
# Input: ${1} - the path of the source directory; the path cannot be absolute
#               but must be relative to the package's directory.
# Result: the target directory if the source directory has a target, otherwise
#         an empty string.
function map_dir ()
{
        dir_entries ()
        {
                # target-point source-dir
                echo "${target_dir}/bin bin"
                echo "${target_dir}/bin jre/bin"
                echo "${target_dir}/bin usr/bin"
                echo "${target_dir}/bin usr/local/bin"

                echo "${target_dir}/sbin sbin"
                echo "${target_dir}/sbin usr/sbin"
                echo "${target_dir}/sbin usr/local/sbin"

                echo "${target_dir}/lib lib"
                echo "${target_dir}/lib jre/lib"
                echo "${target_dir}/lib usr/lib"
                echo "${target_dir}/lib usr/local/lib"
                echo "${target_dir}/lib lib64"
                echo "${target_dir}/lib usr/lib64"
                echo "${target_dir}/lib usr/local/lib64"

                echo "${target_dir}/usr/include include"
                echo "${target_dir}/usr/include usr/include"
                echo "${target_dir}/usr/include usr/local/include"

                echo "${target_dir}/usr/share share"
                echo "${target_dir}/usr/share usr/share"
                echo "${target_dir}/usr/share usr/local/share"

                echo "${target_dir}/usr/man man"
                echo "${target_dir}/usr/man usr/man"
                echo "${target_dir}/usr/man usr/share/man"
                echo "${target_dir}/usr/man usr/local/share/man"

                echo "${target_dir}/etc etc"
                echo "${target_dir}/var var"
        }

        ( dir_entries ) | while read mount_point source_dir; do
                if [ "${source_dir}" == "${1}" ]; then
                        echo "${mount_point}"
                        exit 0
                fi
        done
        echo
}

function print_usage()
{
        echo "Usage: ${0} <command> <parameters>"
        echo "Commands:"
        echo "  list"
        echo "    list all packages"
        echo "  list package-name"
        echo "    list versions of specified package"
        echo "  load package-name [package-version]"
        echo "    load a package"
        echo "  unload package-name"
        echo "    unload a package"
        echo "  test package-name [package-version]"
        echo "    dump mount points of a package"
}

# Find all the sub-directories in a package directory. The prefix of ./ is
# stripped off from all sub-directory paths returned by find.
# Input: ${1} - the package name
#        ${2} - the package version
# Result: all of the sub-directories
function find_dirs()
{
        dir="${pkg_dir}/${1}/${2}/"
        cd ${dir}
        find . -maxdepth 3 -mindepth 1 -type d | sed 's/\.\///'
}

# Checks the variable ${pkg_name} to see if the package name exists.
# It prints messages to standard error if the package is not found.
# Input: ${pkg_name} - the name of the package.
# Result: 0 if the package directory is found, 1 if not.
function check_pkg_name()
{
        if [ "${pkg_name}" == "" ]; then
                echo "No package was specified" >&2
                exit 1
        elif [ ! -d "${pkg_dir}/${pkg_name}" ]; then
                echo "Package \`${pkg_name}' does not exist" >&2
                potential_pkg_names=""
                for potential_pkg_name in `${0} list`; do
                        matches=`echo ${potential_pkg_name} | grep ${pkg_name}`
                        if [ ! "${matches}" == "" ]; then
                                potential_pkg_names="${matches} ${potential_pkg_names}"
                        fi
                done
                if [ ! "${potential_pkg_names}" == "" ]; then
                        echo "Possible packages are: ${potential_pkg_names}" >&2
                fi
                exit 1
        else
                exit 0
        fi
}

# Checks the package version in order to determine if it is valid.
# If ${pkg_version} is empty, the default package version is used instead.
# Input: ${pkg_version} - the package version to check
# Result: the package version to use. This can be different from the supplied
#         ${pkg_version} if it is an empty string.
function check_pkg_version()
{
        if [ "${pkg_version}" == "" ]; then
                cd "${pkg_dir}/${pkg_name}"
                for version in `ls -r`; do pkg_version=${version}; done
                if [ "${pkg_version}" == "" ]; then
                        echo "No package versions are available for package \`${pkg_name}'" >&2
                        exit 1
                else
                        echo "No package version was specified for \`${pkg_name}'; defaulting to \`${pkg_version}'" >&2
                fi
        else
                if [ ! -d "${pkg_dir}/${pkg_name}/${pkg_version}" ]; then
                        echo "Version \`${pkg_version}' does not exist for package \`${pkg_name}'" >&2
                        echo -n "Available versions are: " >&2
                        ${0} list ${pkg_name} >&2
                        exit 1
                fi
        fi
        echo "${pkg_version}"
        exit 0
}

# Performs a supplied function on each directory returned by map_dir.
# On each directory returned, the function will be called with the parameters:
# ${1} set to the absolute path to the source directory, and ${2} set to
# the path to the target directory.
# Input: ${1} - the function name to execute
#        ${2} - the package name
#        ${3} - the package version
# Result: 0 if the supplied function succeeded for each directory, 1 otherwise.
function for_each_mapped_dir ()
{
        for dir in `( find_dirs ${2} ${3} )`; do
                dest=`( map_dir ${dir} )`
                if [ "${dest}" != "" ]; then
                        ( "${1}" "${pkg_dir}/${2}/${3}/${dir}" "${dest}" )
                        if [ ! $? -eq 0 ]; then exit 1; fi
                fi
        done
}

case "${command}" in
        list)
                if [ "${pkg_name}" == "" ]; then
                        cd ${pkg_dir}
                        for pkg_name in *; do
                                if [ -d ${pkg_dir}/${pkg_name} ]; then
                                        echo -n "${pkg_name} "
                                        cd ${pkg_name}
                                        for version in *; do
                                                echo -n "${version} "
                                        done
                                        echo
                                        cd ..
                                fi
                        done
                        echo
                else
                        ( check_pkg_name ); if [ ! $? -eq 0 ]; then exit 1; fi
                        cd ${pkg_dir}/${pkg_name}
                        for version in *; do
                                echo -n "${version} "
                        done
                        echo
                fi
                ;;
        load)
                ( check_pkg_name ); if [ ! $? -eq 0 ]; then exit 1; fi
                pkg_version=`( check_pkg_version )`; if [ ! $? -eq 0 ]; then exit 1; fi
                do_load ()
                {
                        mount -n -t unionfs -o "remount,add=:${1}=rw" none "${2}"
                }
                ( for_each_mapped_dir "do_load" ${pkg_name} ${pkg_version} )
                exit ${?}
                ;;
        unload)
                ( check_pkg_name ); if [ ! $? -eq 0 ]; then exit 1; fi
                pkg_version=`( check_pkg_version )`; if [ ! $? -eq 0 ]; then exit 1; fi
                do_unload ()
                {
                        mount -n -t unionfs -o "remount,del=${1}" none "${2}"
                }
                ( for_each_mapped_dir "do_unload" ${pkg_name} ${pkg_version} )
                exit ${?}
                ;;
        test)
                ( check_pkg_name ); if [ ! $? -eq 0 ]; then exit 1; fi
                pkg_version=`( check_pkg_version )`; if [ ! $? -eq 0 ]; then exit 1; fi
                do_test ()
                {
                        echo ${2} \<== ${1}
                }
                ( for_each_mapped_dir "do_test" ${pkg_name} ${pkg_version} )
                exit $?
                ;;
        *)
                if [ ! "${command}" == "" ]; then
                        echo "Command \`${command}' not understood"
                fi
                ( print_usage )
                exit 1
                ;;
esac