functions

# This file is part of newrun, copyright © M. Kristall
#
# This program is free software. You can redistribute it and/or modify it under
# the terms of version 2 of the GNU General Public License (GPL) as published by
# the Free Software Foundation.
#
# This program is distributed WITHOUT ANY WARRANTY; without even the implied
# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GPL
# for more details.
#
# You should have received a copy of the GPL with this distribution. If not,
# see <http://www.gnu.org/licenses/>.

preserve () {
	echo "$*"
}

upper () {
	echo "${*^^}"
}

lower () {
	echo "${*,,}"
}

warn () {
	echo "$@" >&2
}

[ -z "$DEBUG" ] && DEBUG=0
D_COMMAND=1
D_INCLUDE=2
D_SEND=4
D_NOISY=64
debug () {
	local l=$1
	shift 1
	(( DEBUG & ${!l} )) && warn "$@"
}

die () {
	local r=$1
	shift 1
	warn "$@"
	exit $r
}

include () {
	debug D_INCLUDE "include $1"
	. "$1" 2> /dev/null || die 3 "$_NAME: could not exec '$1'"
}

tryrun () {
	local func="$1"
	shift 1
	declare -f "$func" > /dev/null || return 127
	debug D_COMMAND "try $func $@"
	"$func" "$@"
	return $?
}

runcmd () {
	local cmd="$1" r
	shift 1
	debug D_COMMAND "$(shellify run "$cmd" "$@")"
	"$cmd" "$@"
	r=$?
	(( r )) && debug D_COMMAND "  $cmd fails $r"
	return $r
}

readconfig () {
	local config="$1"
	include "$_CONFIGPATH/$config"
	if [[ "$RUNAS" != "" && "$RUNAS" != "$USER" ]]; then
		warn "RUNAS may not work right"
		runcmd exec su "$RUNAS" -c "$_PATH/$_NAME"
	fi
	include "$_DEFPATH/$TYPE"

	local svname="$(basename "$config")"
	PIDFILE="$_PIDPATH/$svname.pid"
	debug D_NOISY "PID file will be saved to $PIDFILE"

	if [[ "$SERVER" == "" ]]; then
		SERVER="$_SERVER"
	fi
	if [ ! -x "$SERVER" ]; then
		die 4 "$_NAME: SERVER cannot be used: $SERVER"
	fi

	if [[ "$EXEC" == "" ]]; then
		EXEC=null
	fi
	include "$_EXECPATH/$EXEC"

	if [[ "$COMM" == "" ]]; then
		COMM="$EXEC"
	fi
	if [[ "$COMM" != "$EXEC" ]]; then
		include "$_EXECPATH/$COMM"
	fi

	debug D_NOISY "using COMM=$COMM, EXEC=$EXEC"

	case "$CASE" in
		lower|upper|preserve)
			;;
		*)
			CASE=preserve
			;;
	esac

	if [[ "$ARGDELIM" != "" && ! "$UNSAFE" =~ "$ARGDELIM" ]]; then
		UNSAFE="$UNSAFE$ARGDELIM"
	fi

	case "$QUOTE" in
		escape)
			if [[ "$ESCAPE" == "" ]]; then
				ESCAPE=\\
			fi
			if [[ ! "$UNSAFE" =~ "$ESCAPE" ]]; then
				UNSAFE="$UNSAFE$ESCAPE"
			fi
			;;
		single)
			QUOTE="'"
			;;
		double|*)
			QUOTE='"'
			;;
	esac

	init
}

getpid () {
	PID=
	if [ -f "$PIDFILE" ]; then
		read PID < "$PIDFILE"
		debug D_NOISY "getpid=$PID"
	else
		debug D_NOISY "getpid failed"
		return 1
	fi
}

savepid () {
	if [[ "$PIDFILE" != "" ]]; then
		echo "$PID" > "$PIDFILE"
		runcmd chmod 600 "$PIDFILE"
	fi
}

removepid () {
	runcmd rm -f "${DEFAULT_PIDFILE[@]}" "$PIDFILE"
}

pidfilehack () {
	local pf
	PID=
	for pf in "${DEFAULT_PIDFILE[@]}"; do
		if [[ -f "$pf" ]]; then
			read PID < "$pf"
			removepid
			break 1
		fi
	done
	if [[ "$PID" == "" ]]; then
		PID=($(pidof "$SERVER"))
		if (( ${#PID[@]} == 1 )); then
			PID="${PID[0]}"
		elif (( ${#PID[@]} > 1 )); then
			PID=-${#PID[@]}
		else
			PID=
		fi
	fi
	debug D_NOISY "pidfilehack=$PID"
}

isrunning () {
	if [[ "$PID" == "" ]]; then
		getpid
	fi
	if [[ "$PID" == "" ]]; then
		return 1
	fi
	kill -0 $PID &> /dev/null
	return $?
}

forcequit () {
	if isrunning; then
		sleep 1
		if ! isrunning; then
			break
		fi
		runcmd kill -TERM $PID
		sleep 1
		if isrunning; then
			warn "$_NAME: server doesn't want to quit"
			runcmd kill -KILL $PID
		fi
	fi
	removepid
}

shellify () {
	local i args
	for (( i = 1; i <= $#; i++ )); do
		args+="$(printf %q "${!i}") "
	done
	echo "$args"
}

stringify () {
	local str append arg i j
	for (( i = 1; i <= $#; i++ )); do
		arg="${!i}"
		if [[ "$QUOTE" == escape ]]; then
			for (( j = 0; j < ${#arg}; j++ )); do
				if [[ "${arg:j:1}" =~ ["$UNSAFE"] ]]; then
					append+="$ESCAPE${arg:j:1}"
				else
					append+="${arg:j:1}"
				fi
			done
		else
			if [[ "$arg" =~ ["$UNSAFE"] ]]; then
				append="$QUOTE$arg$QUOTE"
			else
				append="$arg"
			fi
		fi
		if [[ "$str" == "" ]]; then
			str="$append"
		else
			str="$str$ARGDELIM$append"
		fi
	done
	echo "$str"
}

## flags
F_SKIP=1	# skip
F_NOARG=2	# no arguments
F_NOPRE=4	# no PREFIX
F_NOVAL=8	# no value
F_NODEF=16	# no default value
init () {
	local flags typ varname val arg def opt i
	for (( i = 0; i < ${#ARGUMENTS[@]}; )); do
		opt=()
		flags=0
		def=
		typ="${ARGUMENTS[i++]}"
		varname="${ARGUMENTS[i++]}"
		val="${!varname}"
		if [[ "$val" == "" ]]; then
			(( flags |= F_SKIP ))
		fi
		case "$typ" in
			req)
				(( flags |= ( F_NOPRE | F_NODEF ) ))
				;;
			bool)
				(( flags |= ( F_NOVAL | F_NODEF ) ))
				if [[ "$val" == "0" ]]; then
					(( flags |= F_NOARG | F_SKIP ))
				fi
				;;
			int)
				val="$(echo "$val" | tr -d '[\0-/:-\xff]')"
				if [[ "$val" == "" ]]; then
					(( flags |= F_SKIP ))
				fi
				;;
			file)
				if (( !( flags & F_SKIP ) )) && [ ! -f "$val" ];
				then
					echo "$varname=$val not a file" >&2
		#			exit 4
				fi
				;;
			dir)
				if (( !( flags & F_SKIP ) )) && [ ! -d "$val" ];
				then
					echo "$varname=$val not a directory" >&2
		#			exit 4
				fi
				;;
			str|*)
				;;
		esac
		# default value
		if (( !( flags & ( F_NOVAL | F_NODEF ) ) )); then
			def="${ARGUMENTS[i++]}"
			if [[ "$val" == "" ]]; then
				declare -g "$varname"="$def"
				val="$def"
			fi
			if [[ "$val" == "$def" ]]; then
				# don't process args/value
				(( flags |= ( F_SKIP | F_NOARG ) ))
			fi
		fi
		# args
		if (( !( flags & F_NOARG ) )); then
			arg="${ARGUMENTS[i++]}"
			if (( !( flags & F_NOPRE ) )); then
				arg="$PREFIX$arg"
			fi
			opt+=("$arg")
			for (( ; i < ${#ARGUMENTS[@]}; i++ )); do
				arg="${ARGUMENTS[i]}"
				if [[ "$arg" == + ]]; then
					break 1
				fi
				opt+=("$arg")
			done
			# value
			if (( !( flags & F_NOVAL ) )); then
				if [[ "$EQUALS" != "" ]]; then
					(( arg=${#opt[@]} - 1 ))
					opt[arg]="${opt[arg]}$EQUALS$(stringify "$val")"
				else
					opt+=("$val")
				fi
			fi
		fi
		for (( ; i < ${#ARGUMENTS[@]}; i++ )); do
			if [[ "${ARGUMENTS[i]}" == + ]]; then
				(( i++ ))
				break
			fi
		done
		# need to add value here
		if (( !( flags & F_SKIP ) )); then
			run+=("${opt[@]}")
		fi
	done
}

Cmd () {
	local args="$(stringify "$@")"
	tryrun "$COMM"Cmd "$args" || \
	tryrun "$EXEC"Cmd "$args" || \
	die 3 "$_NAME: $COMM does not specify a way to communicate"
}

Start () {
	STARTCMD=()
	tryrun "$TYPE"StartCmd
	tryrun "$EXEC"StartCmd
	if [[ "$COMM" != "$EXEC" ]]; then
		tryrun "$COMM"StartCmd
	fi
	if ! tryrun "$EXEC"Start "${run[@]}" "${STARTCMD[@]}" "$@"; then
		debug D_COMMAND "run $SERVER ${run[@]} ${STARTCMD[@]}"
		"$SERVER" "${run[@]}" "${STARTCMD[@]}" "$@" < /dev/null &
		PID=$!
		disown
		savepid
	fi
}

Stop () {
	local args="$(stringify "$@")"
	if ! tryrun "$EXEC"Stop "$args"; then
		isrunning || die 125 "$_NAME: server may not be running"
		Cmd $QUIT "$args"
		forcequit
		removepid
	fi
}

Restart () {
	if ! tryrun "$EXEC"Restart "$@"; then
		isrunning || die 125 "$_NAME: server may not be running"
		Stop Please reconnect in a few seconds
		Start "$@"
	fi
}

Reload () {
	tryrun "$TYPE"Reload || Restart
}