adpn-package-do

#!/bin/bash
#
# adpn-package-do: script to handle adpn package commands
#
# @version 2021.0918

SCRIPTPATH="$(which "$0")"
SCRIPTPATH="$( readlink --canonicalize "${SCRIPTPATH}" )"
SCRIPTDIR="$(dirname "${SCRIPTPATH}")"
SCRIPT="$(basename "${SCRIPTPATH}")"

source "${SCRIPTDIR}/adpn-define-aliases"

__USAGE__="Usage: ${SCRIPT} [--version] [--help] <CMD> [<ARGS>]"
__HELP__="[${SCRIPT}] Try '${SCRIPT} help' for more information."
__DOC__="""${__USAGE__}

  --version 	Display the version of the script
  --help    	Display these usage notes

The most commonly used ${SCRIPT} commands are:
  enclose      	Enclose a directory of data files in a BagIt preservation package.
  validate     	Validate completeness and correctness of a Bagit-enclosed preservation package
  
Exit codes:
0 = success (successful operation and expected result)
1-254 = error in executing command
255 = command not supported
"""

##########################################################################################
### COMMAND LINE: loop through switches ##################################################
##########################################################################################

declare -a _CMDLINE ; _CMDLINE=("$0")

shopt -s lastpipe

declare -a SWITCHFILES ; SWITCHFILES=()
if [[ -r "${CONFFILE}" ]] ; then
	SWITCHFILES+=(${CONFFILE})
fi

CMDLINETXT=$(mktemp)

until [[ "$#" -lt 1 ]] ; do
	_CMDLINE+=("$1")
	printf "%s\n" "$1" >> "${CMDLINETXT}"
	shift
done

SWITCHFILES+=(${CMDLINETXT})

adpn_command_line "${SWITCHFILES[@]}"

rm "${CMDLINETXT}"

##########################################################################################
### SCRIPT: DETERMINE COMMAND, THEN EXECUTE PIPELINE  ####################################
##########################################################################################

EXITCODE=0
CMD="${_ARGV[1]}"

adpn_set_display_settings # V, VV, Q, QQ, DBG, DBGLEVEL, DDBG, SCRIPT_CMD_NAME / @see adpn-define-aliases
adpn_script_handle_version_or_help

if [[ ! -z "${_PARAM[remote]}" ]] ; then

	adpn_script_handle_remote_execution -t "package" "${_CMDLINE[@]:1}"
	EXITCODE="$?"

else 

case "${CMD}" in
	
	"enclose")
		ADP_OUTPUT="$(mktemp)"
		
		declare -a ADP_ARGV=( "${_ARGV[@]:2}" )
		declare -A ADP_SWITCHES=( )
		for SWITCH in "${!_SWITCHES[@]}" ; do
			case "${SWITCH}" in 
				"output")
					# DROP IT -- WE'LL SET IT OURSELVES BELOW
					;;
				*)
					ADP_SWITCHES[${SWITCH}]="${_SWITCHES[$SWITCH]}"
					;;
			esac
		done
		
		declare -a ADPN_DO_PACKAGE_CMD=( adpn-do-package.py --output=application/json )
		ADPN_DO_PACKAGE_CMD+=( "${ADP_ARGV[@]}" )
		ADPN_DO_PACKAGE_CMD+=( "${ADP_SWITCHES[@]}" "${CONTEXT_SW[@]}" )
		
		adpn_debug 15,adpn,package "${LINENO}" '$ %s > %s' "$( printf "%q " "${ADPN_DO_PACKAGE_CMD[@]}" )" "${ADP_OUTPUT}"
		"${ADPN_DO_PACKAGE_CMD[@]}" > "${ADP_OUTPUT}"; EXITCODE="$?"
		
		if [[ "${EXITCODE}" -lt 255 ]] ; then
			JSON_PACKET="$( adpn_get_json_packets "${ADP_OUTPUT}" )"
			adpn_debug 35,adpn,package "${LINENO}" 'printf "%%s" "%s" | [...]' "${JSON_PACKET}"
			printf "%s" "${JSON_PACKET}"
		fi
		
		rm "${ADP_OUTPUT}"
		;;
	
	"validate")
		PIPELINE="$( adpn_parameter_from "--pipeline" "staged:validated" )"
		if [[ -n "${PIPELINE}" ]] ; then
			PIPEDFROM=$( printf "%s" "${PIPELINE}" | cut --field=1 --delimiter=":" )
			PIPEDTO=$( printf "%s" "${PIPELINE}" | cut --field=2 --delimiter=":" )
			adpn_debug 2 "${LINENO}" "SWITCH='%s', PIPELINE='%s': PIPEDFROM='%s', PIPEDTO='%s'\n" "${_SWITCHES[pipeline]}" "${PIPELINE}" "${PIPEDFROM}" "${PIPEDTO}" 1>&2
		fi

		declare -A TEMP_CLEANUP=()

		TEMP_CLEANUP[json_input]="$(mktemp)"

		adpn_read_json_packet_source "${_ARGV[2]}" "${SCRIPT_CMD_NAME}" "${V}" | adpn_get_json_packets | adpn_select_json_packet "${PIPEDFROM}" "-" "head -n 1" "${PIPEDTO}" > "${TEMP_CLEANUP[json_input]}"
		EXITCODE="$?"
		
		declare -a AU_LOCALPATHS=( )

		[[ "${EXITCODE}" -eq 0 ]] && JSON_TEXT="$( cat "${TEMP_CLEANUP[json_input]}" )" || JSON_TEXT="" 
		if [[ -n "${JSON_TEXT}" ]] ; then
			PUB_FROM=$( adpn_parameter_from "--from" ".From Publisher<${JSON_TEXT}" ".From Peer<${JSON_TEXT}" )
			SUBDIRECTORY=$( printf "%s" "${JSON_TEXT}" | adpn-json.py --key=parameters | grep -E "^(sub)?directory\s" | cut --field=2)
			LOCAL_BASE=$( adpn_parameter_from "--base_dir" ".stage/base_dir/${PUB_FROM}" ".stage/base_dir" )
			LOCAL_DIRECTORY="$( printf "%s/%s" "${LOCAL_BASE%%/}" "${SUBDIRECTORY}" )"
			[[ -n "${LOCAL_DIRECTORY}" && -d "${LOCAL_DIRECTORY}" && -r "${LOCAL_DIRECTORY}" ]] && AU_LOCALPATHS+=( "${LOCAL_DIRECTORY}" ) &&
			printf "* GETTING DIRECTORY FROM JSON: %s\n" "${LOCAL_DIRECTORY}" 1>&2
		else 
			AU_LOCALPATHS+=( "${_ARGV[@]:2}" )
			EXITCODE=0
		fi
		
		AU_LOCALPATHS+=( "${PWD}" )
		AU_LOCALPATHS=( "${AU_LOCALPATHS[@]/#/\\}" )
		
		AU_LOCALPATH="$( adpn_parameter_from "--local" "${AU_LOCALPATHS[@]}" )"
		AU_LOCALPATH="$( readlink -f "${AU_LOCALPATH}" )"
		AU_LOCALBASE="$( basename "${AU_LOCALPATH}" )"

		if [[ -d "${AU_LOCALPATH}" && -d "${AU_LOCALPATH}/data" ]] ; then
			declare -a PYTHON_OPTS=( ".python" )
			( which python3 >/dev/null 2>&1 ) && PYTHON_OPTS+=( "\\$( which python3 )" )
			( which python >/dev/null 2>&1 ) && PYTHON_OPTS+=( "\\$( which python )" )
			PYTHON="$( adpn_parameter_from "${PYTHON_OPTS[@]}" )"
			
			declare -a BAGIT_CMD=( "${PYTHON}" "${SCRIPTDIR}/externals/bagit-python/bagit.py" )
			BAGIT_CMD+=( --validate "${AU_LOCALPATH}" )
			[[ -n "${Q}" ]] && BAGIT_CMD+=( "${Q}" )
			
			"${BAGIT_CMD[@]}" 2>&1 ; EXITCODE="$?"
			
			if [[ -n "${_PARAM[passthru]}" && -n "${JSON_TEXT}" ]] ; then
				USER_EMAIL="$( adpn_get_user_email )"
				declare -a JSON_OVERLAY=( "${JSON_TEXT}" )
				JSON_OVERLAY+=( "$( adpn-json.py --output=application/json --key="Ingest Step" --value="validated" --key="Validated By" --value="${USER_EMAIL}" )" )
				
				[[ "${EXITCODE}" -eq 0 ]] && printf "\nOK: The bagged AU located at %s validated as complete and correct.\n" "${AU_LOCALPATH}" && printf "%s\n" "${JSON_OVERLAY[@]}" | adpn-json.py --cascade --output=application/json
			fi
			
		else
			adpn_notice "${LINENO}" "REQUIRED: AU path [%s] must be an accessible, BagIt-formatted directory." "${AU_LOCALPATH}"
		fi
		
		for FILE in "${TEMP_CLEANUP[@]}" ; do
			rm "${FILE}"
		done
		;;
	
	"describe")
		MYSQL_HOST="$( adpnprop 'mysql/host' )"

		EXITCODE=1
		AU="${_ARGV[2]}"
		if [[ -d "${AU}" ]] ; then
			if [[ -r "${AU}/manifest.html" ]] ; then
				cat "${AU}/manifest.html" | grep -E "${ADPN_JSON_PACKET_REGEX}"
				EXITCODE="$?"
			fi
		elif [[ ! -e "${AU}" && "${AU}" =~ ^daemon:(.*)$ ]] ; then
			INGEST_TITLE="${BASH_REMATCH[1]}"
			JSON="$( adpn_describe_title_from_daemon "${INGEST_TITLE}" | lockss-plugin-props-print-parameter.py --output=application/json )"
			declare -a JSON_OVERLAY=( "$( printf "%s" "${JSON}" | adpn-json.py --prolog --output=application/json )" )
			if [[ -n "${JSON}" ]] ; then
				INGEST_TITLE="$( printf "%s\n" "${JSON}" | adpn-json.py --key="lockssAU:Volume" )"
				
				LOCKSS_AU_KEY="$( printf "%s\n" "${JSON}" | adpn-json.py --key="lockssAU:key" )"
				declare -a LOCKSS_PARAMETERS=()
				JSON_OVERLAY+=( "$( adpn_describe_plugin_from_lockss_id "${LOCKSS_AU_KEY}" | lockss-plugin-props-print-parameter.py --output=application/json | adpn-json.py --output=application/json --prolog )" )
				[[ -n "${INGEST_TITLE}" ]] && JSON_OVERLAY+=( "$( adpn-json.py --key="Ingest Title" --value="${INGEST_TITLE}" --output=application/json --prolog )" )
				printf "%s\n" "${JSON_OVERLAY[@]}" | adpn-json.py --cascade --output=application/json --prolog
			fi
		elif [[ -n "${MYSQL_HOST}" && "${AU}" =~ ^au_title:(.*)$ ]] ; then
			INGEST_TITLE="${BASH_REMATCH[1]}"
			INGEST_TITLE_OP=""
			if [[ "${INGEST_TITLE}" =~ ^/(.*)/$ ]] ; then
				INGEST_TITLE="${BASH_REMATCH[1]}"
				INGEST_TITLE_OP="~"
			fi
			"${SCRIPTDIR}/adpn-titlelist-do" get --au_title="${INGEST_TITLE_OP}${INGEST_TITLE}" --batch | convertto_json_table titlesdb | get_titlesdb_identifiers ; EXITCODE="$?"
		elif [[ ! -e "${AU}" && "${AU}" =~ ^gitlab:(.*)$ ]] ; then
			adpn_read_json_packet_source "${AU}" "${SCRIPT_CMD_NAME}" "${V}" | adpn_get_json_packets | adpn_select_json_packet "${_ARGV[3]}" "-" "head -n 1" "described"
			EXITCODE="$?"
		elif [[ ! -e "${AU}" && "${AU}" =~ ^(.*[ ].*)$ ]] ; then
			INGEST_TITLE="${BASH_REMATCH[1]}"
		fi
		;;
		
	"version"|"help")
		EXITCODE=0
		;;
		
	*)
		echo "[${SCRIPT_CMD_NAME}] '${CMD}' command not understood." 1>&2
		echo "${__HELP__}" 1>&2
		EXITCODE=255
		;;
esac

fi 

##########################################################################################
### CLEANUP: exit with settled exit code. ################################################
##########################################################################################

exit ${EXITCODE}