Initial commit.
This commit is contained in:
Sergey Fedosov
553
watchman.bash
Normal file
553
watchman.bash
Normal file
@@ -0,0 +1,553 @@
|
||||
#!@BASH_PATH@
|
||||
|
||||
# Config
|
||||
watchman_version='@VERSION@'
|
||||
|
||||
# Functions
|
||||
watchman.usage() {
|
||||
while read -r; do printf '%s\n' "$REPLY"; done <<- EOF
|
||||
Usage: watchman [flags] <service> <action>
|
||||
Flags:
|
||||
-h, --help Show this message.
|
||||
-v, --version Show watchman's version.
|
||||
-d, --verbose Verbose output.
|
||||
EOF
|
||||
}
|
||||
|
||||
watchman.msg() { printf '%s\n' "[watchman] $1"; }
|
||||
watchman.err() { watchman.msg "(error) $1"; }
|
||||
watchman.debug() {
|
||||
[[ "$flag_verbose" ]] && {
|
||||
watchman.msg "{v} $1"
|
||||
}
|
||||
}
|
||||
|
||||
watchman.init() {
|
||||
# Check if XDG_ stuff is set
|
||||
XDG_RUNTIME_DIR=${XDG_RUNTIME_DIR:-"/run/user/$UID"}
|
||||
XDG_CONFIG_HOME=${XDG_CONFIG_HOME:-"$HOME/.config"}
|
||||
|
||||
# Check if the user is root.
|
||||
if (( UID )); then
|
||||
cfg_dir="@CFGDIR_USER@"
|
||||
cfg_rundir="@RUNDIR_USER@"
|
||||
cfg_logdir="@LOGDIR_USER@"
|
||||
else
|
||||
cfg_dir="@CFGDIR@"
|
||||
cfg_rundir="@RUNDIR@"
|
||||
cfg_logdir="@LOGDIR@"
|
||||
fi
|
||||
|
||||
[[ -f "${cfg_dir}/watchman.conf" ]] && {
|
||||
source "${cfg_dir}/watchman.conf" || {
|
||||
watchman.err "Failed to source config: ${cfg_dir}/watchman.conf. Fix it to proceed."
|
||||
return 1
|
||||
}
|
||||
}
|
||||
|
||||
cfg_initdir="${cfg_dir}/init.d"
|
||||
cfg_init_dirs+=( "$cfg_dir"/{init.d,conf.d} "$cfg_rundir" "$cfg_logdir" )
|
||||
|
||||
for i in "${cfg_init_dirs[@]}"; do
|
||||
[[ -e "$i" ]] || {
|
||||
watchman.debug "$i does not exist, creating..."
|
||||
mkdir -p "$i" || {
|
||||
watchman.err "Can't create $i!"
|
||||
return 1
|
||||
}
|
||||
}
|
||||
done
|
||||
|
||||
return 0
|
||||
}
|
||||
|
||||
watchman.done() {
|
||||
>"$cfg_rundir/${service_name}.done" || {
|
||||
watchman.msg "Warning! Can't mark ${service_name} as enabled."
|
||||
}
|
||||
}
|
||||
|
||||
watchman.spawn() {
|
||||
[[ "$service_command" ]] || {
|
||||
watchman.err "Please specify what to run with \$service_command"
|
||||
}
|
||||
|
||||
if [[ "$service_respawn" == 'true' ]]; then
|
||||
[[ "$service_type" == 'oneshot' ]] && {
|
||||
watchman.err "A oneshot service can not be respawned. Choose one or the other."
|
||||
return 1
|
||||
}
|
||||
|
||||
if [[ "${service_pidfile}" ]]; then
|
||||
watchman.err "Respawning forking services is not supported!"
|
||||
return 1
|
||||
fi
|
||||
|
||||
watchman-svc -p "$service_pidfile_int" -l "$service_logfile" -r "$service_command" "${service_args[@]}"
|
||||
else
|
||||
if [[ "$service_type" == 'oneshot' ]]; then
|
||||
"${service_command}" "${service_args[@]}" 1>>"$service_logfile" 2>>"$service_logfile" || { return 1; }
|
||||
else
|
||||
watchman-svc -p "$service_pidfile_int" -l "$service_logfile" "$service_command" "${service_args[@]}"
|
||||
fi
|
||||
fi
|
||||
}
|
||||
|
||||
watchman.tempfiles() {
|
||||
# Create temporary files
|
||||
for f in "${service_tmpfiles[@]}"; do
|
||||
IFS=':' read -r f_path f_type f_args <<< "$f"
|
||||
|
||||
if ! [[ -e $f_path ]]; then
|
||||
case "$f_type" in
|
||||
symlink)
|
||||
f_target=$f_args
|
||||
ln -s "$f_target" "$f_path"
|
||||
;;
|
||||
|
||||
file|dir)
|
||||
IFS=':' read -r f_perms f_owner f_group <<< "$f_args"
|
||||
|
||||
if [[ $f_type == 'file' ]]; then
|
||||
> "$f_path"
|
||||
chmod "${f_perms:-644}" "$f_path"
|
||||
else
|
||||
mkdir -p -m "${f_perms:-755}" "$f_path"
|
||||
fi
|
||||
|
||||
if [[ "$f_owner" || "$f_group" ]]; then
|
||||
chown "${f_owner:-root}:${f_group:-root}" "$f_path"
|
||||
fi
|
||||
;;
|
||||
esac
|
||||
fi
|
||||
done
|
||||
}
|
||||
|
||||
watchman.start() {
|
||||
local try
|
||||
|
||||
watchman.status && {
|
||||
if [[ "$service_type" == 'oneshot' ]]; then
|
||||
watchman.err "$service_name is already enabled"
|
||||
else
|
||||
watchman.err "$service_name is already running"
|
||||
fi
|
||||
|
||||
return 0
|
||||
}
|
||||
|
||||
# Start dependencies
|
||||
for d in "${service_depends[@]}"; do
|
||||
IFS=':' read -r d_name d_type <<< "$d"
|
||||
|
||||
"$0" "$d_name" start || {
|
||||
err "Failed to start service dependency: $d_name"
|
||||
|
||||
if ! [[ $d_type == 'soft' ]]; then
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
done
|
||||
|
||||
# pre-start
|
||||
run_if_function pre_start || { return $?; }
|
||||
|
||||
[[ "$service_workdir" ]] && { cd "$service_workdir"; }
|
||||
|
||||
>"$service_logfile" 2>/dev/null || {
|
||||
watchman.msg "Warning! Logfile is not writeable! Defaulting to /dev/null"
|
||||
service_logfile='/dev/null'
|
||||
}
|
||||
|
||||
watchman.tempfiles
|
||||
|
||||
spawn 1>>"$service_logfile" 2>>"$service_logfile"
|
||||
spawn_result="$?"
|
||||
|
||||
case "$service_type" in
|
||||
(oneshot)
|
||||
(( spawn_result )) && {
|
||||
watchman.err "Failed to enable ${service_name}!"
|
||||
return 1
|
||||
}
|
||||
|
||||
watchman.done
|
||||
watchman.msg "$service_name enabled"
|
||||
;;
|
||||
|
||||
(*)
|
||||
if [[ "$service_pidfile" ]]; then
|
||||
if [[ ! -f "$service_pidfile" ]]; then
|
||||
watchman.msg "Making sure the process had time to wite its pidfile..."
|
||||
try=0; while [[ ! -f "$service_pidfile" && "$try" -lt "${service_spawn_delay:-3}" ]]; do
|
||||
((try++))
|
||||
sleep 1
|
||||
done
|
||||
fi
|
||||
|
||||
if ! [[ -f "$service_pidfile" ]]; then
|
||||
return 3
|
||||
fi
|
||||
fi
|
||||
|
||||
watchman.msg "$service_name started"
|
||||
|
||||
run_if_function post_start || { return $?; }
|
||||
;;
|
||||
esac
|
||||
}
|
||||
|
||||
watchman.depends() {
|
||||
[[ "$action" == 'start' ]] || { return 0; }
|
||||
|
||||
for s in "$@"; do
|
||||
"$0" "$s" status || {
|
||||
watchman.msg "Starting ${s} as ${service_name} depends on it."
|
||||
"$0" "$s" start || {
|
||||
watchman.err "Starting $s failed, aborting."
|
||||
return 31
|
||||
}
|
||||
}
|
||||
done
|
||||
|
||||
return 0
|
||||
}
|
||||
|
||||
watchman.pid_check() { kill -0 "$1" 2>/dev/null; }
|
||||
|
||||
watchman.pid_wait() {
|
||||
counter='0'
|
||||
printf "[watchman] Waiting for PID to exit: %s..." "$1"
|
||||
|
||||
while watchman.pid_check "$1"; do
|
||||
((counter++))
|
||||
|
||||
[[ "$counter" -ge "${service_stop_timeout:-30}" ]] && {
|
||||
printf 'timeout\n'
|
||||
return 1
|
||||
}
|
||||
|
||||
sleep 1
|
||||
printf '.'
|
||||
done
|
||||
|
||||
printf '\n'
|
||||
|
||||
return 0
|
||||
}
|
||||
|
||||
watchman.stop() {
|
||||
watchman.status || {
|
||||
watchman.err "$service_name doesn't seem to be running"
|
||||
return 1
|
||||
}
|
||||
|
||||
run_if_function pre_stop || { return $?; }
|
||||
|
||||
case "$service_type" in
|
||||
(oneshot)
|
||||
watchman.msg "Removing $cfg_rundir/${service_name}.done file..."
|
||||
rm "$cfg_rundir/${service_name}.done"
|
||||
;;
|
||||
|
||||
(*)
|
||||
kill "$service_pid"
|
||||
|
||||
watchman.pid_wait "$service_pid" || { return 3; }
|
||||
|
||||
rm -f "$service_pidfile" || {
|
||||
watchman.err "Failed to remove pidfile: $service_pidfile"
|
||||
}
|
||||
;;
|
||||
esac
|
||||
|
||||
run_if_function post_stop || { return $?; }
|
||||
}
|
||||
|
||||
watchman.status() {
|
||||
case "$service_type" in
|
||||
(oneshot)
|
||||
if [[ -e "$cfg_rundir/${service_name}.done" ]]; then
|
||||
return 0
|
||||
fi
|
||||
;;
|
||||
|
||||
(*)
|
||||
if [[ "$service_pid" ]]; then
|
||||
if kill -0 "$service_pid" &>/dev/null; then
|
||||
return 0
|
||||
fi
|
||||
fi
|
||||
;;
|
||||
esac
|
||||
|
||||
return 1
|
||||
}
|
||||
|
||||
watchman.service_usage() {
|
||||
local valid_actions
|
||||
|
||||
for i in "${service_actions[@]}"; do
|
||||
if is_function "$i"; then
|
||||
valid_actions+="$i|";
|
||||
fi
|
||||
done
|
||||
|
||||
watchman.msg "Usage: $service_name <${valid_actions%|*}>"
|
||||
}
|
||||
|
||||
watchman.service_get_pid() {
|
||||
local _pid
|
||||
|
||||
if [[ "$service_pidfile" ]]; then
|
||||
if [[ -f "$service_pidfile" ]]; then
|
||||
_pid=$(<"$service_pidfile")
|
||||
fi
|
||||
else
|
||||
if [[ -f "$service_pidfile_int" ]]; then
|
||||
_pid=$(<"$service_pidfile_int")
|
||||
fi
|
||||
fi
|
||||
|
||||
printf '%s' "$_pid"
|
||||
}
|
||||
|
||||
watchman.reload() {
|
||||
watchman.status || {
|
||||
watchman.err "$service_name is not running"
|
||||
return 1
|
||||
}
|
||||
|
||||
watchman.msg "Reloading ${service_name}..."
|
||||
kill -1 "$service_pid"
|
||||
}
|
||||
|
||||
watchman.logs() {
|
||||
if [[ -f "$service_logfile" ]]; then
|
||||
watchman.msg "Output for ${service_name}:"
|
||||
while read -r; do
|
||||
printf '%s\n' "$REPLY"
|
||||
done < "$service_logfile"
|
||||
else
|
||||
watchman.err "No log available for ${service_name}"
|
||||
fi
|
||||
|
||||
if [[ "$service_respawn" == 'true' ]]; then
|
||||
if [[ -f "$cfg_logdir/${service_name}_respawn.log" ]]; then
|
||||
watchman.msg "Output for ${service_name} (watchdog):"
|
||||
while read -r; do
|
||||
printf '%s\n' "$REPLY"
|
||||
done < "$cfg_logdir/${service_name}_respawn.log"
|
||||
fi
|
||||
fi
|
||||
}
|
||||
|
||||
watchman.edit() {
|
||||
if ! [[ "$EDITOR" ]]; then
|
||||
EDITOR='vim'
|
||||
fi
|
||||
|
||||
"$EDITOR" "$service_script"
|
||||
}
|
||||
|
||||
watchman.args() {
|
||||
while [[ "$1" ]]; do
|
||||
case "$1" in
|
||||
(-h) watchman.usage; exit;;
|
||||
(-d) flag_verbose='1';;
|
||||
(-v) printf '%s\n' "$watchman_version"; exit;;
|
||||
|
||||
(--) shift; break;;
|
||||
|
||||
(-*)
|
||||
watchman.err "Invalid key: $1"
|
||||
watchman.usage
|
||||
return 1
|
||||
;;
|
||||
|
||||
(*) args+=( "$1" );;
|
||||
esac; shift
|
||||
done
|
||||
}
|
||||
|
||||
nullerr() {
|
||||
"$@" 2>/dev/null
|
||||
}
|
||||
|
||||
is_variable() {
|
||||
declare param_args param=$1
|
||||
|
||||
read -r _ param_args _ <<< $( nullerr declare -p "$param" )
|
||||
|
||||
if (( $? )); then
|
||||
return 1
|
||||
fi
|
||||
|
||||
if [[ "$param_args" == '--' ]]; then
|
||||
return 0
|
||||
fi
|
||||
|
||||
return 1
|
||||
}
|
||||
|
||||
is_function() {
|
||||
declare word=$1 word_type
|
||||
|
||||
word_type=$( type -t "$word" )
|
||||
|
||||
if [[ $word_type == 'function' ]]; then
|
||||
return 0
|
||||
fi
|
||||
|
||||
return 1
|
||||
}
|
||||
|
||||
run_if_function() {
|
||||
declare func=$1; shift
|
||||
|
||||
if is_function "$func"; then
|
||||
"$func" "$@"
|
||||
fi
|
||||
|
||||
return 0
|
||||
}
|
||||
|
||||
spawn() { watchman.spawn; }
|
||||
|
||||
start() { watchman.start; }
|
||||
stop() { watchman.stop; }
|
||||
restart() { stop; start; }
|
||||
reload() { watchman.reload; }
|
||||
edit() { watchman.edit; }
|
||||
|
||||
status() {
|
||||
local service_status
|
||||
|
||||
watchman.status && {
|
||||
service_status='running'
|
||||
}
|
||||
|
||||
if [[ "$service_status" ]]; then
|
||||
[[ "$service_type" == 'oneshot' ]] && {
|
||||
watchman.msg "$service_name is enabled"
|
||||
} || {
|
||||
watchman.msg "$service_name is running ($service_pid)"
|
||||
}
|
||||
|
||||
return 0
|
||||
else
|
||||
watchman.msg "$service_name is down"
|
||||
fi
|
||||
|
||||
return 1
|
||||
}
|
||||
|
||||
logs() { watchman.logs; }
|
||||
|
||||
depends() { watchman.depends "$@"; }
|
||||
|
||||
watchman.main() {
|
||||
# Parse arguments
|
||||
watchman.args "$@" || { return "$?"; }
|
||||
set -- "${args[@]}"
|
||||
|
||||
watchman.init "$@" || { return "$?"; }
|
||||
|
||||
# Exit on no arguments
|
||||
(( $# )) || {
|
||||
watchman.usage
|
||||
return 9
|
||||
}
|
||||
|
||||
# Set default service actions.
|
||||
service_actions=( 'start' 'stop' 'restart' 'reload' 'status' )
|
||||
|
||||
# Set $action and exit immediately if it's not set.
|
||||
action="$2"
|
||||
[[ "$action" ]] || {
|
||||
watchman.err 'Syntax error: no action specified.'
|
||||
watchman.service_usage
|
||||
return 1
|
||||
}
|
||||
|
||||
# Basename for poor people.
|
||||
service_name="${1##*/}"
|
||||
|
||||
# Check if the first argument is an existing file,
|
||||
# set $service_script to it if it is. Otherwise, search
|
||||
# for the service in the initdir.
|
||||
if [[ -f "$1" ]]; then
|
||||
service_script="$1"
|
||||
else
|
||||
if [[ -f "${cfg_initdir}/${service_name}" ]]; then
|
||||
service_script="${cfg_initdir}/${service_name}"
|
||||
else
|
||||
watchman.err "$service_name doesn't exist in $cfg_initdir"
|
||||
return 1
|
||||
fi
|
||||
fi
|
||||
|
||||
# Source the script
|
||||
source "$service_script" || { return 13; }
|
||||
|
||||
# check if the command exists and is an executable file.
|
||||
[[ "$service_command" ]] && {
|
||||
[[ -e "${service_command}" ]] || {
|
||||
watchman.err "Service command for ${service_name} is set but does not exist: ${service_command}"
|
||||
return 1
|
||||
}
|
||||
|
||||
[[ -f "${service_command}" ]] || {
|
||||
watchman.err "Service command for ${service_name} is set but is not a file: ${service_command}"
|
||||
return 1
|
||||
}
|
||||
|
||||
[[ -x "${service_command}" ]] || {
|
||||
watchman.err "Service command for ${service_name} is set but is not executable: ${service_command}"
|
||||
return 1
|
||||
}
|
||||
}
|
||||
|
||||
# Source the additional service configuration if that exists.
|
||||
[[ -f "${cfg_dir}/conf.d/${service_name}.sh" ]] && {
|
||||
source "${cfg_dir}/conf.d/${service_name}.sh" || {
|
||||
return $?
|
||||
}
|
||||
}
|
||||
|
||||
# If $service_args is a variable, convert it into an array
|
||||
if is_variable service_args; then
|
||||
watchman.err "\$service_args for the $service_name service is a variable."
|
||||
watchman.err "Since watchman 1.11.1, \$service_args is supposed to be an array."
|
||||
watchman.err "Please fix it in the service definition."
|
||||
|
||||
read -r -a service_args <<< "$service_args"
|
||||
fi
|
||||
|
||||
# Set default service_logfile and internal pidfile
|
||||
# These need to be here so that services behave as expected if $service_name is explicitly set.
|
||||
[[ "$service_logfile" ]] || { service_logfile="$cfg_logdir/${service_name}.log"; }
|
||||
service_pidfile_int="$cfg_rundir/${service_name}.pid" # Does not need to be reassignable. Seriously. Don't.
|
||||
|
||||
# Try to get the service's pid.
|
||||
service_pid="$(watchman.service_get_pid)"
|
||||
|
||||
# If the action is defined, do it. If not, fail gracefully.
|
||||
if is_function "$action"; then
|
||||
"$action"
|
||||
|
||||
action_rcode="$?"
|
||||
(( action_rcode > 1 )) && {
|
||||
watchman.err "Function $action failed for ${service_name}."
|
||||
}
|
||||
|
||||
return "$action_rcode"
|
||||
else
|
||||
watchman.err "Function $action is not defined for ${service_name}."
|
||||
return 17
|
||||
fi
|
||||
}
|
||||
|
||||
# Main
|
||||
watchman.main "$@"
|
||||
Reference in New Issue
Block a user