mkdeploy.sht

#%shebang
#%version 11

#%prolog

################

#%include sys/checkdir
#%include sys/checkfile
#%include sys/cmd
#%include sys/config
#%include sys/findcmd
#%include sys/msg
#%include sys/pathabs
#%include sys/vars

#%include deploy/checksum
#%include deploy/encode
#%include deploy/pack

################

# Print usage information
usage ()
{
    cat << EOF
Usage: ${PROG} [-c config] [-d destdir] -f file... -i initfile [-o outfile]
	[-s srcdir] [-w workdir] [-P product] [-V version]
EOF
}

# Print help information
usage_help ()
{
    usage
    cat << EOF

    -c config	configuration file
    -d destdir	where to write output file (default: current directory)
    -f file	file to add to archive (path relative to srcdir)
    -i initfile	init-file to execute by deploy after unpacking
    -o outfile	output file name (either absolute name or relative to destdir)
    -s srcdir	where to look source files (default: current directory)
    -w workdir	where to place temporary working files (default: /tmp)
    -P product	product name to write to deploy file
    -V version	version of product to write to deploy file
EOF
    exit 0
}

####

# Parse command line options
get_options ()
{
    local _opt=""

    case "$1" in ( '-?' | '-help' | '--help' ) usage_help ;; esac
    while getopts ":c:d:f:i:o:s:w:P:V:" _opt ; do
	case "${_opt}" in
	    ( 'c' ) OPT_CONF_FILE="$(absolute_path "${OPTARG}")"	;;
	    ( 'd' ) OPT_OUTDIR="${OPTARG}"	;;
	    ( 'i' ) OPT_INITFILE="${OPTARG}"	;;
	    ( 'o' ) OPT_OUTFILE="${OPTARG}"	;;
	    ( 's' ) OPT_SRCDIR="${OPTARG}"	;;
	    ( 'w' ) OPT_WORKDIR="${OPTARG}"	;;
	    ( 'P' ) OPT_PRODUCT="${OPTARG}"	;;
	    ( 'V' ) OPT_VERSION="${OPTARG}"	;;
	    ( 'f' ) OPT_FILELIST="${OPT_FILELIST:+"${OPT_FILELIST} "}${OPTARG}" ;;
	    ( ':' )
		err "missing argument for option -- '${OPTARG}'"
		usage
		return 1
		;;
	    ( '?' )
		err "unknown option -- '${OPTARG}'"
		usage
		return 1
		;;
	    (  *  )
		err "no handler for option '${_opt}'"
		return 1
		;;
	esac
    done
    shift $((${OPTIND} - 1))
    if test $# -gt 0 ; then
	err "too many arguments"
	usage
	return 1
    fi
}

####

# Create archive
mkpack ()
{
    if ! pack_${pack_cmd} "${W_ARCH}" "${SRCDIR}" "${FILELIST}" ; then
	err "can't pack file '${W_ARCH}'"
	return 1
    fi
    if test -n "${chksum_cmd}" ; then
	MD5SUM="$(chksum_${chksum_cmd} "${W_ARCH}")"
	MD5SUM="${MD5SUM%%[[:space:]]*}"
    fi
}

# Create blob
mkblob ()
{
    if ! cat "${W_ARCH}" | encode_${encode_cmd} "${W_BLOB}" ; then
	err "can't encode file '${W_ARCH}'"
	return 1
    fi
}

# Generate deploy script
mkdeploy ()
{
    embed_deploy > "${W_OUT}"
}

# Copy generated deploy script
cpdeploy ()
{
    cmd cp "${W_OUT}" "${OUTFILE}"
    if test $? -ne 0 ; then
	err "can't copy file '${W_OUT}' to file '${OUTFILE}'"
	return 1
    fi
}

####

# Initialization subroutine
init ()
{
    set -o noglob	# Do not expand pathnames
    # Initialize variables
    var_init FILELIST INITFILE OUTDIR  OUTFILE \
	     PRODUCT  SRCDIR   VERSION WORKDIR &&
    {
	# Set defaults
	DEF_OUTDIR="$(pwd)"
	DEF_OUTFILE="deploy.sh"
	DEF_SRCDIR="$(pwd)"
	DEF_WORKDIR="/tmp/${PROG}.$$"
	# Define 'internal' variables
	MD5SUM=""
    } &&
    # Set up configuration file variables
    var_init CONF_FILE		&&
    DEF_CONF_FILE="spxshell/mkdeploy.conf"	&&
    # Get options
    get_options "$@"		&&
    # Read configuration file
    var_set  CONF_FILE		&&
    read_config "${CONF_FILE}"	&&
    # Set variables
    var_set  FILELIST INITFILE OUTDIR  OUTFILE \
	     PRODUCT  SRCDIR   VERSION WORKDIR
}

# Startup subroutine
startup ()
{
    local _f=""
    local _flist=""

    # Check binaries
    # Encode
    encode_cmd="$(find_command uuencode base64 openssl)"
    if test -z "${encode_cmd}" ; then
	err "can't find encode binary"
	return 1
    fi
    # Pack
    pack_cmd="$(find_command pax tar)"
    if test -z "${pack_cmd}" ; then
	err "can't find pack binary"
	return 1
    fi
    # MD5 (if there is no MD5 binary then do not check MD5 sum)
    chksum_cmd="$(find_command md5sum openssl)"

    # Normalize output file path
    case "${OUTFILE}" in
	( /* ) OUTDIR="$(dirname -- "${OUTFILE}")" ;;
	(  * ) OUTFILE="${OUTDIR}/${OUTFILE}" ;;
    esac

    # Check directories
    if ! test -d "${SRCDIR}" ; then
	err "directory '${SRCDIR}' doesn't exist"
	return 1
    fi
    if ! test -d "${OUTDIR}" ; then
	err "directory '${OUTDIR}' doesn't exist"
	return 1
    fi

    # Check variables
    if test -z "${FILELIST}" ; then
	err "no 'file' or list of files are set"
	return 1
    fi
    if test -z "${INITFILE}" ; then
	err "no 'initfile' is set"
	return 1
    fi

    # Check files and convert to relative paths
    eval set -- ${FILELIST} \"${INITFILE}\"
    for _f in "$@" ; do
	case "${_f}" in
	    ( /* ) _f="${_f#"${SRCDIR}/"}" ;;
	esac
	check_file "${SRCDIR}/${_f}" || return 1
	case "${_f}" in
	    ( *[[:space:]]* ) _f="\"${_f}\"" ;;
	esac
	_flist="${_flist:+"${_flist} "}${_f}"
    done
    FILELIST="${_flist}"
    INITFILE="${INITFILE#"${SRCDIR}/"}"	# In the case of absolute path

    # Check working directory
    ( umask 0077 ; check_dir "${WORKDIR}" ) || return 1

    # Set working filenames
    W_ARCH="${WORKDIR}/archive.pax"
    W_BLOB="${WORKDIR}/blob"
    W_OUT="${WORKDIR}/out.sh"
}

# Clean working directory
cleanup ()
{
    if test -n "${WORKDIR}" ; then
	cmd rm -f "${W_ARCH}"
	cmd rm -f "${W_BLOB}"
	cmd rm -f "${W_OUT}"
	cmd rmdir "${WORKDIR}"
    fi
}

# Clean up the staff and exit with error
clean_fail ()
{
    cleanup
    fail "${1:-1}"
}

# Exit with error code
fail ()
{
    exit "${1:-1}"
}

####

# Main subroutine
main ()
{
    init "$@" && startup || fail
    trap 'clean_fail 130' HUP INT TERM
    {
	mkpack   &&
	mkblob   &&
	mkdeploy &&
	cpdeploy
    } || clean_fail
    cleanup
}

#%uinclude deploy/deploy-embed

# Call main subroutine
main "$@"