#!/usr/bin/sh
#
# K2HR3 Utilities - Get K2HR3 Resource Helper for Systemd service
#
# Copyright 2021 Yahoo Japan Corporation.
#
# K2HR3 is K2hdkc based Resource and Roles and policy Rules, gathers
# common management information for the cloud.
# K2HR3 can dynamically manage information as "who", "what", "operate".
# These are stored as roles, resources, policies in K2hdkc, and the
# client system can dynamically read and modify these information.
#
# For the full copyright and license information, please view
# the license file that was distributed with this source code.
#
# AUTHOR:   Takeshi Nakatani
# CREATE:   Wed Jan 20 2021
# REVISION:
#

#---------------------------------------------------------------------
# Common variables
#---------------------------------------------------------------------
PRGNAME=$(basename "${0}")
BASE_PRGNAME=$(echo "${PRGNAME}" | sed -e 's/\.*$//g')
SCRIPTDIR=$(dirname "${0}")
SCRIPTDIR=$(cd "${SCRIPTDIR}" || exit 1; pwd)

#---------------------------------------------------------------------
# Variables
#---------------------------------------------------------------------
#
# systemd timer name
#
SYSTEMD_TIMER_NAME="k2hr3-get-resource.timer"

#
# Instance ID file by cloud-init
#
CLOUDINIT_DATA_DIR="/var/lib/cloud/data"
INSTANCE_ID_FILE="${CLOUDINIT_DATA_DIR}/instance-id"

#
# Default configuration values
#
SCRIPT_DIR_PART_NAME="antpickax"

CONFDIR="/etc/${SCRIPT_DIR_PART_NAME}"
SCRIPT_CONF_FILE="${BASE_PRGNAME}.conf"
OVERRIDE_FILE="override.conf"

PIDDIR="/var/run/${SCRIPT_DIR_PART_NAME}"
SCRIPT_PIDFILE="${BASE_PRGNAME}.pid"
SCRIPT_DAEMON_PIDFILE="${BASE_PRGNAME}-daemon.pid"

# [NOTE]
# The following are the variables used to specify this helper script
# and the log file for the subprocess.
# Normally, the log is left to jounald or syslog related to systemd,
# so it is not specified.
# If you want to collect logs yourself, set the values in the following
# variables. For reference, it can be set as follows:
#
#	LOGDIR="/var/log/${SCRIPT_DIR_PART_NAME}"
#	SCRIPT_LOGFILE="${BASE_PRGNAME}.log"
#
# These values can be specified in configuration file or override.conf.
#
LOGDIR=""
SCRIPT_LOGFILE=""

#
# Load K2HR3 variables from files
#
# [NOTE]
# Set/Load default resource yrn path and output directory/file name.
#

# K2HR3 related files
K2HR3_ROLE_TOKEN_FILE="${CONFDIR}/k2hr3-role-token"
K2HR3_ROLE_NAME_FILE="${CONFDIR}/k2hr3-role-name"
K2HR3_API_HOST_URI_FILE="${CONFDIR}/k2hr3-api-uri"

if [ -f "${K2HR3_ROLE_NAME_FILE}" ]; then
	RESOURCE_PATH=$(sed -e 's/:[rR][oO][lL][eE]:/:resource:/g' "${K2HR3_ROLE_NAME_FILE}")
else
	RESOURCE_PATH=
fi
if [ -n "${RESOURCE_PATH}" ]; then
	OUTPUT_FILE=$(echo "${RESOURCE_PATH}" | sed -e 's#[:/]# #g' | awk '{print $NF}')
else
	OUTPUT_FILE=
fi
OUTPUT_DIR="${CONFDIR}"

#---------------------------------------------------------------------
# Utilitiy functions
#---------------------------------------------------------------------
#
# Message
#
# $1 	:	1(stdout) or 2(stderr)
# $2 	:	Level
# $3... :	Messages
#
print_message()
{
	if [ -n "$1" ] && [ "$1" -eq 2 ]; then
		_PRINT_STDERR=1
	else
		_PRINT_STDERR=0
	fi
	if [ -z "$2" ]; then
		_PRINT_LEVEL="ERROR"
	else
		_PRINT_LEVEL="$2"
	fi

	_PRINT_DATE="$(date '+%FT%T%z')"
	shift;
	shift;

	if [ -n "${LOGDIR}" ] && [ -n "${SCRIPT_LOGFILE}" ]; then
		echo "${_PRINT_DATE} ${PRGNAME} [${_PRINT_LEVEL}] $*" >> "${LOGDIR}/${SCRIPT_LOGFILE}"
	else
		if [ "${_PRINT_STDERR}" -eq 1 ]; then
			echo "${_PRINT_DATE} ${PRGNAME} [${_PRINT_LEVEL}] $*" 1>&2
		else
			echo "${_PRINT_DATE} ${PRGNAME} [${_PRINT_LEVEL}] $*"
		fi
	fi
}

log_err()
{
	print_message 1 "ERROR" "$*"
}

log_warn()
{
	print_message 1 "WARNING" "$*"
}

log_info()
{
	print_message 1 "INFO" "$*"
}

# shellcheck disable=SC2317,SC2329
prn_err()
{
	print_message 2 "ERROR" "$*"
}

prn_warn()
{
	print_message 2 "WARNING" "$*"
}

# shellcheck disable=SC2317,SC2329
prn_info()
{
	print_message 2 "INFO" "$*"
}

#
# Check file
#
# $1 :	File name/path
#
is_safe_file()
{
	if [ $# -eq 0 ]; then
		echo "There are no arguments(is_safe_file)"
		return 1
	fi
	if [ -z "$1" ] || [ ! -f "$1" ]; then
		echo "$1 is not safe file."
		return 1
	fi
	return 0
}

#
# Get value by key name from file
#
# $1 :	Key name
# $2 :	File name/path
#
extract_value()
{
	#
	# Check parameters
	#
	if [ $# -lt 2 ]; then
		echo "Not enough arguments - $*"
		return 1
	fi

	_EXTRACTVALUE_KEY="$1"
	_EXTRACTVALUE_FILE="$2"
	if ! _ERROR_MSG=$(is_safe_file "${_EXTRACTVALUE_FILE}"); then
		echo "${_ERROR_MSG}"
		return 1
	fi

	#
	# Get latest matching line
	#
	_EXTRACTVALUE_LINE=$(grep -v "^[[:space:]]*#" "${_EXTRACTVALUE_FILE}" | grep "^[[:space:]]*${_EXTRACTVALUE_KEY}[[:space:]]*=" | tail -1)
	if [ -z "${_EXTRACTVALUE_LINE}" ]; then
		echo ""
		return 0
	fi

	#
	# Get value(trimed head/tail spaces)
	#
	_EXTRACTVALUE_VALUE=$(echo "${_EXTRACTVALUE_LINE}" | sed -e "s/^[[:space:]]*${_EXTRACTVALUE_KEY}[[:space:]]*=//g" -e "s/^[[:space:]]*//g" -e "s/[[:space:]]*$//g")
	echo "${_EXTRACTVALUE_VALUE}"

	return 0
}

#
# Get value by key name from file
#
# $1 :	Key name
# $2 :	File name/path
# $3 :	Override file name/path(allow empty)
#
get_value()
{
	#
	# Check parameters
	#
	if [ $# -lt 2 ]; then
		echo "Not enough arguments - $*"
		return 1
	fi

	_GETVALUE_KEY="$1"
	_GETVALUE_FILE="$2"
	if ! _ERROR_MSG=$(is_safe_file "${_GETVALUE_FILE}"); then
		echo "${_ERROR_MSG}"
		return 1
	fi

	if [ $# -ge 3 ]; then
		_GETVALUE_OVERRIDE_FILE="$3"
		if ! _ERROR_MSG=$(is_safe_file "${_GETVALUE_OVERRIDE_FILE}"); then
			#
			# Skip this file becase the file is optinal file
			#
			prn_warn "${_ERROR_MSG}"
			_GETVALUE_OVERRIDE_FILE=
		fi
	else
		_GETVALUE_OVERRIDE_FILE=
	fi

	#
	# Check override file and switch file and key
	#
	# [NOTE]
	# The override file is used to replace the file and key with different values
	# in the following formats(file and key pair):
	#
	# <file name>:<key name> = <replace file name/path>:<replace key name>
	#
	if [ -n "${_GETVALUE_OVERRIDE_FILE}" ]; then
		#
		# Make key for override file
		#
		_GETVALUE_FILE_NAME=$(basename "${_GETVALUE_FILE}")
		_GETVALUE_OVERRIDE_PAIRKEY="${_GETVALUE_FILE_NAME}:${_GETVALUE_KEY}"

		#
		# Search key in override configutation file
		#
		if _GETVALUE_OVERRIDE_VALUE=$(extract_value "${_GETVALUE_OVERRIDE_PAIRKEY}" "${_GETVALUE_OVERRIDE_FILE}"); then
			#
			# Found key and parse it
			#
			# [NOTE]
			# The value is "<replace file/path>:<replace key name>" or "value"
			#
			if echo "${_GETVALUE_OVERRIDE_VALUE}" | grep -q ':'; then
				#
				# Case : "<replace file/path>:<replace key name>"
				#
				_GETVALUE_REPLACE_FILE=$(echo "${_GETVALUE_OVERRIDE_VALUE}" | sed -e 's/:/ /g' | awk '{print $1}')
				_GETVALUE_REPLACE_KEY=$(echo "${_GETVALUE_OVERRIDE_VALUE}" | sed -e 's/:/ /g' | awk '{print $2}')

				if [ -n "${_GETVALUE_REPLACE_FILE}" ] && [ -n "${_GETVALUE_REPLACE_KEY}" ]; then
					#
					# Check override configuration file
					#
					if ! echo "${_GETVALUE_REPLACE_FILE}" | grep -q '^/'; then
						#
						# file is relative file path, convert to absolute path
						#
						_GETVALUE_TMP_FILENAME=$(basename "${_GETVALUE_REPLACE_FILE}")
						_GETVALUE_TMP_RELATIVE=$(dirname "${_GETVALUE_REPLACE_FILE}")
						_GETVALUE_TMP_CURRENT=$(dirname "${_GETVALUE_OVERRIDE_FILE}")
						_GETVALUE_TMP_ABSOLUTE=$(cd "${_GETVALUE_TMP_CURRENT}/${_GETVALUE_TMP_RELATIVE}" || exit 1; pwd)

						_GETVALUE_REPLACE_FILE="${_GETVALUE_TMP_ABSOLUTE}/${_GETVALUE_TMP_FILENAME}"
					fi

					if [ -f "${_GETVALUE_REPLACE_FILE}" ]; then
						#
						# file is safe, switch file and key
						#
						_GETVALUE_KEY="${_GETVALUE_REPLACE_KEY}"
						_GETVALUE_FILE="${_GETVALUE_REPLACE_FILE}"
					fi
				fi
			else
				#
				# Case : "value" directly
				#
				echo "${_GETVALUE_OVERRIDE_VALUE}"
				return 0
			fi
		fi
	fi

	#
	# Search key in configuration file
	#
	if ! _GETVALUE_VALUE=$(extract_value "${_GETVALUE_KEY}" "${_GETVALUE_FILE}"); then
		echo "Not found ${_GETVALUE_KEY} in ${_GETVALUE_FILE}"
		return 1
	fi

	#
	# Found key and return value
	#
	echo "${_GETVALUE_VALUE}"

	return 0
}

#---------------------------------------------------------------------
# Parse Option
#---------------------------------------------------------------------
OPT_DAEMON=0
OPT_CRON=0

while [ $# -ne 0 ]; do
	if [ -z "$1" ]; then
		break;

	elif echo "$1" | grep -q -i -e "^--daemon$" -e "^-daemon$"; then
		if [ "${OPT_DAEMON}" -ne 0 ]; then
			log_err "Already specified --daemon option."
			exit 1
		fi
		OPT_DAEMON=1

	elif echo "$1" | grep -q -i -e "^--cron" -e "^-cron"; then
		if [ "${OPT_CRON}" -ne 0 ]; then
			log_err "Already specified --cron option."
			exit 1
		fi
		OPT_CRON=1

	else
		log_err "Unknown option : \"$1\""
		exit 1
	fi
	shift
done

# [NOTE]
# The option only accepts "-daemon".
# If it is passed "-daemon" option, it acts as a daemon that waits
# until the systemd k2hr3-get-resource.timer is disabled.
# When k2hr3-get-resource.timer is disabled, the file that output the
# resource is deleted and the process is terminated.
#
if [ "${OPT_DAEMON}" -eq 1 ]; then
	SCRIPT_MODE="daemon"
else
	SCRIPT_MODE="normal"
fi

#
# Default
#
USE_DAEMON=1

#---------------------------------------------------------------------
# Load configuration and check
#---------------------------------------------------------------------
#
# PIDDIR
#
if ! _TMP_VALUE=$(get_value "PIDDIR" "${CONFDIR}/${SCRIPT_CONF_FILE}" "${CONFDIR}/${OVERRIDE_FILE}"); then
	log_err "Failed loading the configuration(PIDDIR) value : ${_TMP_VALUE}"
	exit 1
fi
if [ -n "${_TMP_VALUE}" ]; then
	PIDDIR="${_TMP_VALUE}"
fi
if [ -n "${PIDDIR}" ]; then
	if [ ! -d "${PIDDIR}" ]; then
		if ! mkdir -p "${PIDDIR}"; then
			log_err "Could not make directory ${PIDDIR} for PID file."
			exit 1
		fi
	fi
fi

#
# SCRIPT_PIDFILE
#
if ! _TMP_VALUE=$(get_value "SCRIPT_PIDFILE" "${CONFDIR}/${SCRIPT_CONF_FILE}" "${CONFDIR}/${OVERRIDE_FILE}"); then
	log_err "Failed loading the configuration(SCRIPT_PIDFILE) value : ${_TMP_VALUE}"
	exit 1
fi
if [ -n "${_TMP_VALUE}" ]; then
	SCRIPT_PIDFILE="${_TMP_VALUE}"
fi

#
# LOGDIR
#
if ! _TMP_VALUE=$(get_value "LOGDIR" "${CONFDIR}/${SCRIPT_CONF_FILE}" "${CONFDIR}/${OVERRIDE_FILE}"); then
	log_err "Failed loading the configuration(LOGDIR) value : ${_TMP_VALUE}"
	exit 1
fi
if [ -n "${_TMP_VALUE}" ]; then
	LOGDIR="${_TMP_VALUE}"
fi
if [ -n "${LOGDIR}" ]; then
	if [ ! -d "${LOGDIR}" ]; then
		if ! mkdir -p "${LOGDIR}"; then
			log_err "Could not make directory ${LOGDIR} for log files."
			exit 1
		fi
	fi
	# [NOTE]
	# If you start a subprocess other than the user of this script, you must allow permissions.
	#
	if ! chmod 0777 "${LOGDIR}"; then
		log_warn "Could not change attributes for directory ${LOGDIR}, but it is not critical so continue..."
	fi
fi

#
# SCRIPT_LOGFILE
#
if ! _TMP_VALUE=$(get_value "SCRIPT_LOGFILE" "${CONFDIR}/${SCRIPT_CONF_FILE}" "${CONFDIR}/${OVERRIDE_FILE}"); then
	log_err "Failed loading the configuration(SCRIPT_LOGFILE) value : ${_TMP_VALUE}"
	exit 1
fi
if [ -n "${_TMP_VALUE}" ]; then
	SCRIPT_LOGFILE="${_TMP_VALUE}"
fi

#
# RESOURCE_PATH
#
if ! _TMP_VALUE=$(get_value "RESOURCE_PATH" "${CONFDIR}/${SCRIPT_CONF_FILE}" "${CONFDIR}/${OVERRIDE_FILE}"); then
	if [ -z "${RESOURCE_PATH}" ]; then
		log_err "There is no configuration value(RESOURCE_PATH) in configuration files and default value is empty."
		exit 1
	fi
	log_info "There is no configuration value(RESOURCE_PATH) in configuration files, thus use default value(${RESOURCE_PATH})"
else
	if [ -n "${_TMP_VALUE}" ]; then
		RESOURCE_PATH="${_TMP_VALUE}"
	fi
fi
if [ -z "${RESOURCE_PATH}" ]; then
	log_err "The configuration value(RESOURCE_PATH) is empty."
	exit 1
fi

#
# OUTPUT_FILE
#
if ! _TMP_VALUE=$(get_value "OUTPUT_FILE" "${CONFDIR}/${SCRIPT_CONF_FILE}" "${CONFDIR}/${OVERRIDE_FILE}"); then
	if [ -z "${OUTPUT_FILE}" ]; then
		log_err "There is no configuration value(OUTPUT_FILE) in configuration files and default value is empty."
		exit 1
	fi
	log_info "There is no configuration value(OUTPUT_FILE) in configuration files, thus use default value(${OUTPUT_FILE})"
else
	if [ -n "${_TMP_VALUE}" ]; then
		OUTPUT_FILE="${_TMP_VALUE}"
	fi
fi
if [ -z "${OUTPUT_FILE}" ]; then
	log_err "The configuration value(OUTPUT_FILE) is empty."
	exit 1
fi

#
# OUTPUT_DIR
#
if ! _TMP_VALUE=$(get_value "OUTPUT_DIR" "${CONFDIR}/${SCRIPT_CONF_FILE}" "${CONFDIR}/${OVERRIDE_FILE}"); then
	if [ -z "${OUTPUT_DIR}" ]; then
		log_err "There is no configuration value(OUTPUT_DIR) in configuration files and default value is empty."
		exit 1
	fi
	log_info "There is no configuration value(OUTPUT_DIR) in configuration files, thus use default value(${OUTPUT_DIR})"
else
	if [ -n "${_TMP_VALUE}" ]; then
		OUTPUT_DIR="${_TMP_VALUE}"
	fi
fi

#
# USE_DAEMON
#
if ! _TMP_VALUE=$(get_value "USE_DAEMON" "${CONFDIR}/${SCRIPT_CONF_FILE}" "${CONFDIR}/${OVERRIDE_FILE}"); then
	if [ -z "${USE_DAEMON}" ]; then
		log_err "There is no configuration value(USE_DAEMON) in configuration files and default value is empty."
		exit 1
	fi
	log_info "There is no configuration value(USE_DAEMON) in configuration files, thus use default value(${USE_DAEMON})"
else
	if [ -n "${_TMP_VALUE}" ]; then
		if [ "${_TMP_VALUE}" = "true" ] || [ "${_TMP_VALUE}" = "TRUE" ] || [ "${_TMP_VALUE}" = "1" ]; then
			USE_DAEMON=1
		elif [ "${_TMP_VALUE}" = "false" ] || [ "${_TMP_VALUE}" = "FALSE" ] || [ "${_TMP_VALUE}" = "0" ]; then
			USE_DAEMON=0
		else
			log_warn "USE_DAEMON value in configuration is wrong value(${_TMP_VALUE}), then use default(${USE_DAEMON})."
		fi
	fi
fi

#
# USE_CRON
#
if ! _TMP_VALUE=$(get_value "USE_CRON" "${CONFDIR}/${SCRIPT_CONF_FILE}" "${CONFDIR}/${OVERRIDE_FILE}"); then
	if [ -z "${USE_CRON}" ]; then
		log_err "There is no configuration value(USE_CRON) in configuration files and default value is empty."
		exit 1
	fi
	log_info "There is no configuration value(USE_CRON) in configuration files, thus use default value(${USE_CRON})"
else
	if [ -n "${_TMP_VALUE}" ]; then
		if [ "${_TMP_VALUE}" = "true" ] || [ "${_TMP_VALUE}" = "TRUE" ] || [ "${_TMP_VALUE}" = "1" ]; then
			USE_CRON=1
		elif [ "${_TMP_VALUE}" = "false" ] || [ "${_TMP_VALUE}" = "FALSE" ] || [ "${_TMP_VALUE}" = "0" ]; then
			USE_CRON=0
		else
			log_warn "USE_CRON value in configuration is wrong value(${_TMP_VALUE}), then use default(${USE_CRON})."
		fi
	fi
fi

#
# Check K2HR3 variables
#	K2HR3_ROLE_TOKEN
#	K2HR3_API_HOST_URI
#
#
if [ -f "${K2HR3_ROLE_TOKEN_FILE}" ]; then
	K2HR3_ROLE_TOKEN=$(cat "${K2HR3_ROLE_TOKEN_FILE}")
else
	log_err "There is no K2HR3 role token file(${K2HR3_ROLE_TOKEN_FILE})."
	exit 1
fi
if [ -f "${K2HR3_API_HOST_URI_FILE}" ]; then
	K2HR3_API_HOST_URI=$(cat "${K2HR3_API_HOST_URI_FILE}")
else
	log_err "There is no K2HR3 REST API URI file(${K2HR3_API_HOST_URI_FILE})."
	exit 1
fi

#
# Check launching from cron
#
if [ "${OPT_CRON}" -eq 1 ] && [ "${USE_CRON}" -eq 0 ]; then
	#
	# Nothing to do
	#
	log_info "The process was started via cron, but since cron startup is disabled, the execution will be canceled."
	exit 0
fi

#---------------------------------------------------------------------
# Main
#---------------------------------------------------------------------
if [ "${SCRIPT_MODE}" != "daemon" ]; then
	#
	# Start getting processing
	#
	log_info "Start getting processing"

	#
	# Check old process
	#
	if [ -f "${PIDDIR}/${SCRIPT_PIDFILE}" ]; then
		OLD_PROCESS_PID=$(cat "${PIDDIR}/${SCRIPT_PIDFILE}")

		if [ $$ -ne "${OLD_PROCESS_PID}" ]; then
			# shellcheck disable=SC2009
			if ( ps -o pid,stat ax 2>/dev/null | grep -v 'PID' | awk '$2~/^[^Z]/ { print $1 }' | grep -q "^${OLD_PROCESS_PID}$" || exit 1 && exit 0 ); then
				log_err "Already process PID(${OLD_PROCESS_PID}) running, thus this script exits."
				exit 1
			fi
		fi
	fi
	#
	# Write process id to PID FILE
	#
	echo $$ > "${PIDDIR}/${SCRIPT_PIDFILE}"

	#
	# Check CUK(Instance ID)
	#
	if [ ! -f "${INSTANCE_ID_FILE}" ]; then
		log_warn "Not found ${INSTANCE_ID_FILE} file for CUK."
		INSTANCE_ID=
	else
		INSTANCE_ID=$(tr -d '\n' < "${INSTANCE_ID_FILE}" 2>/dev/null)
		if [ -z "${INSTANCE_ID}" ]; then
			log_warn "Empty value for Instance Id in ${INSTANCE_ID_FILE} file."
		fi
	fi

	#
	# Get resource
	#
	if ! GET_RESULT=$(curl -s -S -X GET -H "Content-Type: application/json" -H "x-auth-token: R=${K2HR3_ROLE_TOKEN}" "${K2HR3_API_HOST_URI}/v1/resource/${RESOURCE_PATH}" 2>&1); then
		log_err "Failed getting resource(path: ${RESOURCE_PATH})."
		rm -f "${PIDDIR}/${SCRIPT_PIDFILE}"
		exit 1
	fi
	log_info "Success accessing K2HR3 resource(${RESOURCE_PATH})"

	# Check response(expect -> "result": true)
	if ! echo "${GET_RESULT}" | grep -q -i '["]*RESULT["]*:[[:space:]]*TRUE[[:space:]]*,'; then
		# Get error message(expect -> "message": "...")
		GET_RESULT_MSG=$(echo "${GET_RESULT}" | sed -e 's/^.*["]*[mM][eE][sS][sS][aA][gG][eE]["]*:[[:space:]]*//g' -e 's/,.*$//g' -e 's/}.*//g' -e 's/"//g')
		log_err "Failed getting resource(path: ${RESOURCE_PATH}) with response(${GET_RESULT_MSG})."
		rm -f "${PIDDIR}/${SCRIPT_PIDFILE}"
		exit 1
	fi
	log_info "Success getting K2HR3 resource(${RESOURCE_PATH})"

	#
	# Check and Put resource to file
	#
	log_info "Check and put resource(${RESOURCE_PATH}) to file(${OUTPUT_DIR}/${OUTPUT_FILE})"

	# Put resource to temporary file with converting CR and instance id
	TEMP_RESOURCE_FILE="/tmp/.$$_${OUTPUT_FILE}"
	echo "${GET_RESULT}" | sed -e 's/^.*["]*[rR][eE][sS][oO][uU][rR][cC][eE]["]*:[[:space:]]*"//g' -e 's/"}$//g' -e 's/\\n/\n/g' -e "s/__SELF_INSTANCE_ID__/${INSTANCE_ID}/g" > "${TEMP_RESOURCE_FILE}" 2>/dev/null

	# Check file differences
	if ! diff "${TEMP_RESOURCE_FILE}" "${OUTPUT_DIR}/${OUTPUT_FILE}" >/dev/null 2>&1; then
		if ! cat "${TEMP_RESOURCE_FILE}" > "${OUTPUT_DIR}/${OUTPUT_FILE}"; then
			log_err "Could not update ${OUTPUT_DIR}/${OUTPUT_FILE} file."
			rm -f "${TEMP_RESOURCE_FILE}"
			rm -f "${PIDDIR}/${SCRIPT_PIDFILE}"
			exit 1
		fi
		log_info "Success updating ${OUTPUT_DIR}/${OUTPUT_FILE} file."
	else
		log_info "Nothing to update ${OUTPUT_DIR}/${OUTPUT_FILE} file, because ${RESOURCE_PATH} resoruce is not changed."
	fi
	rm -f "${TEMP_RESOURCE_FILE}"

	#
	# Launch daemon if not running
	#
	if [ "${USE_DAEMON}" -eq 1 ]; then
		#
		# Check daemon process running
		#
		IS_NEED_DAEMON_RUN=0
		if [ -f "${PIDDIR}/${SCRIPT_DAEMON_PIDFILE}" ]; then
			OLD_DAEMON_PROCESS_PID=$(cat "${PIDDIR}/${SCRIPT_DAEMON_PIDFILE}")

			# shellcheck disable=SC2009
			if ! ( ps -o pid,stat ax 2>/dev/null | grep -v 'PID' | awk '$2~/^[^Z]/ { print $1 }' | grep -q "^${OLD_DAEMON_PROCESS_PID}$" || exit 1 && exit 0 ); then
				rm -f "${PIDDIR}/${SCRIPT_DAEMON_PIDFILE}"
				IS_NEED_DAEMON_RUN=1
			fi
		else
			IS_NEED_DAEMON_RUN=1
		fi

		#
		# Run daemon process
		#
		if [ "${IS_NEED_DAEMON_RUN}" -eq 1 ]; then
			"${SCRIPTDIR}/${PRGNAME}" "-${SCRIPT_MODE}" >/dev/null 2>&1 </dev/null &
		fi
	fi

	#
	# Finish
	#
	rm -f "${PIDDIR}/${SCRIPT_PIDFILE}"

	log_info "Success getting processing"

else
	#
	# Start daemon process
	#
	log_info "Start daemon process"

	if [ "${USE_DAEMON}" -eq 1 ]; then
		#
		# Check systemctl command
		#
		if ! command -v systemctl >/dev/null 2>&1; then
			log_err "Not found systemctl command, thus this daemon exits."
			exit 1
		fi

		#
		# Check old process
		#
		if [ -f "${PIDDIR}/${SCRIPT_DAEMON_PIDFILE}" ]; then
			OLD_DAEMON_PROCESS_PID=$(cat "${PIDDIR}/${SCRIPT_DAEMON_PIDFILE}")

			# shellcheck disable=SC2009
			if ( ps -o pid,stat ax 2>/dev/null | grep -v 'PID' | awk '$2~/^[^Z]/ { print $1 }' | grep -q "^${OLD_DAEMON_PROCESS_PID}$" || exit 1 && exit 0 ); then
				log_err "Already process PID(${OLD_DAEMON_PROCESS_PID}) running, thus this daemon exits."
				exit 1
			fi
			rm -f "${PIDDIR}/${SCRIPT_DAEMON_PIDFILE}"
		fi
		#
		# Write process id to PID FILE
		#
		echo $$ > "${PIDDIR}/${SCRIPT_DAEMON_PIDFILE}"

		#
		# Wait for disable timer
		#
		IS_LOOP=1
		while [ "${IS_LOOP}" -eq 1 ]; do
			if ! sudo systemctl is-enabled "${SYSTEMD_TIMER_NAME}" >/dev/null 2>&1; then
				IS_LOOP=0
			fi
		done

		#
		# Delete file
		#
		rm -f "${OUTPUT_DIR}/${OUTPUT_FILE}"

		#
		# Finish
		#
		rm -f "${PIDDIR}/${SCRIPT_DAEMON_PIDFILE}"

		log_info "${SYSTEMD_TIMER_NAME} is disabled, so removed ${OUTPUT_DIR}/${OUTPUT_FILE}"

	else
		log_info "USE_DAEMON value is not enabled."
	fi
fi

exit 0

#
# Local variables:
# tab-width: 4
# c-basic-offset: 4
# End:
# vim600: noexpandtab sw=4 ts=4 fdm=marker
# vim<600: noexpandtab sw=4 ts=4
#
