#!/bin/sh /etc/rc.common

START=99
STOP=15

USE_PROCD=1
NAME=rgmqtt
PROG=/sbin/rgmqtt.sh
rgmqtt_native_pidfile=/var/rgmqtt/rgmqtt_mosquitto_pubsub.pid

validate_rgmqtt_section()
{
	uci_validate_section "${NAME}" client "${1}" \
		'host:string:mqtt.smartplasma.ru' \
		'port:uinteger:8883' \
		'http_server:string:upload.smartplasma.ru:443' \
		'keepalive:uinteger:300' \
		'cafile:string' \
		'cert:string' \
		'key:string'
}

service_triggers()
{
	procd_add_reload_trigger rgmqtt
	procd_add_validation validate_rgmqtt_section
}

start_service() {
	local host port http_server keepalive cafile cert key

	validate_rgmqtt_section tuning

	procd_open_instance
	procd_set_param command "$PROG"

	[ -n "$host" ] && procd_append_param command --host "$host"
	[ -n "$port" ] && procd_append_param command --port "$port"
	[ -n "$keepalive" ] && procd_append_param command -k "$keepalive"
	[ -n "$cafile" ] && procd_append_param command --cafile "$cafile"
	[ -n "$cert" ] && procd_append_param command --cert "$cert"
	[ -n "$key" ] && procd_append_param command --key "$key"
	[ -n "$http_server" ] && procd_append_param command --http-server "$http_server"

	procd_set_param respawn
	procd_set_param stderr 1
	procd_set_param term_timeout 10
	procd_close_instance
}

rgmqtt_stop_log() {
	logger -t rgmqtt "shutdown stage=$1 pid=${2:-0}"
}

# /proc/stat comm can contain spaces and parentheses. Fields after its last ')'
# start at state (3); starttime (22) is the twentieth remaining field.
rgmqtt_proc_identity() {
	local stat
	case "$1" in ''|*[!0-9]*) return 1;; esac
	[ "$1" -gt 1 ] || return 1
	IFS= read -r stat 2>/dev/null < "/proc/$1/stat" || return 1
	stat=${stat##*) }
	set -- $stat
	[ "$#" -ge 20 ] || return 1
	rgmqtt_state=$1
	rgmqtt_ppid=$2
	shift 19
	rgmqtt_starttime=$1
	[ "$rgmqtt_state" != Z ] && [ "$rgmqtt_state" != X ]
}

rgmqtt_identity_alive() {
	rgmqtt_proc_identity "$1" && [ "$rgmqtt_starttime" = "$2" ]
}

rgmqtt_capture_native() {
	local pid exe token
	[ -n "$rgmqtt_wrapper_start" ] || return 0
	rgmqtt_identity_alive "$rgmqtt_wrapper_pid" "$rgmqtt_wrapper_start" || return 0
	read -r pid 2>/dev/null < "$rgmqtt_native_pidfile" || return 0
	rgmqtt_proc_identity "$pid" || return 0
	[ "$rgmqtt_ppid" = "$rgmqtt_wrapper_pid" ] || return 0
	token=$rgmqtt_starttime
	exe=$(readlink "/proc/$pid/exe" 2>/dev/null) || return 0
	[ "${exe##*/}" = rg-mqtt-pubsub ] || return 0
	rgmqtt_identity_alive "$pid" "$token" || return 0
	case " $rgmqtt_native_tokens " in
		*" $pid:$token "*) ;;
		*) rgmqtt_native_tokens="$rgmqtt_native_tokens $pid:$token";;
	esac
}

rgmqtt_stop_pending() {
	local token
	for token in $rgmqtt_native_tokens; do
		rgmqtt_identity_alive "${token%:*}" "${token#*:}" && return 0
	done
	rgmqtt_identity_alive "$rgmqtt_wrapper_pid" "$rgmqtt_wrapper_start"
}

stop_service() {
	local snapshot service
	rgmqtt_wrapper_pid=
	rgmqtt_wrapper_start=
	rgmqtt_native_tokens=
	rgmqtt_snapshot_ok=0
	rgmqtt_service_absent=0
	rgmqtt_delete_ok=0
	if snapshot=$(ubus -t 1 call service list '{"name":"rgmqtt"}'); then
		if jsonfilter -s "$snapshot" -e '@' >/dev/null; then
			rgmqtt_snapshot_ok=1
			service=$(jsonfilter -s "$snapshot" -e '@.rgmqtt') || service=
			[ -n "$service" ] || rgmqtt_service_absent=1
			rgmqtt_wrapper_pid=$(jsonfilter -s "$snapshot" \
				-e '@.rgmqtt.instances.instance1.pid') || rgmqtt_wrapper_pid=
			if rgmqtt_proc_identity "$rgmqtt_wrapper_pid"; then
				rgmqtt_wrapper_start=$rgmqtt_starttime
				rgmqtt_capture_native
			fi
		fi
	fi
	[ "$rgmqtt_snapshot_ok" = 1 ] || rgmqtt_stop_log snapshot-failed
	# rc.common calls this immediately after stop_service. The pinned helper
	# otherwise uses ubus's 30s default AND loses its status in json_cleanup.
	procd_kill() {
		# Pinned procd returns NOT_FOUND on delete of an absent service.
		# Only a successful snapshot can authorize skipping that delete.
		if [ "$rgmqtt_snapshot_ok" = 1 ] && [ "$rgmqtt_service_absent" = 1 ]; then
			rgmqtt_delete_ok=1
			return 0
		fi
		if ubus -t 1 call service delete '{"name":"rgmqtt"}'; then
			rgmqtt_delete_ok=1
			return 0
		fi
		rgmqtt_stop_log delete-failed "$rgmqtt_wrapper_pid"
		return 1
	}
}

service_stopped() {
	local remaining=8 token
	# Restore the exact wrapper used by this pinned procd.sh (also for restart).
	procd_kill() { _procd_call _procd_kill "$@"; }
	# Failed delete may leave respawn enabled: never claim a successful stop or
	# kill a supervised wrapper in that state.
	[ "$rgmqtt_delete_ok" = 1 ] && [ "$rgmqtt_snapshot_ok" = 1 ] || exit 1
	rgmqtt_capture_native
	while rgmqtt_stop_pending && [ "$remaining" -gt 0 ]; do
		sleep 1
		remaining=$((remaining - 1))
		rgmqtt_capture_native
	done
	# Catch a native child spawned during startup after the first snapshot.
	rgmqtt_capture_native
	if rgmqtt_stop_pending; then
		for token in $rgmqtt_native_tokens "$rgmqtt_wrapper_pid:$rgmqtt_wrapper_start"; do
			if rgmqtt_identity_alive "${token%:*}" "${token#*:}"; then
				rgmqtt_stop_log kill "${token%:*}"
				kill -KILL "${token%:*}" 2>/dev/null || :
			fi
		done
		sleep 1
	fi
	if rgmqtt_stop_pending; then
		rgmqtt_stop_log still-running "$rgmqtt_wrapper_pid"
		exit 1
	fi
	rgmqtt_stop_log stopped "$rgmqtt_wrapper_pid"
}
