R/ssm
2
0
Fork 0
forked from Spark/ssm
Code Issues Pull Requests Releases Wiki Activity

var

Browse Source 
Signed-off-by: fbt <fbt@fleshless.org>
This commit is contained in:
Jack L. Frost 2018-01-08 04:38:24 +03:00
parent a633061d30
commit 758e841e1e
1 changed files with 369 additions and 324 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

351
ssm
View File

@ -2,16 +2,78 @@
shopt -s nullglob shopt -s nullglob
# Utility functions # Utility functions
## Make setting default values a bit less awkward is_function() [[ $(type -t $1 2>/dev/null) == 'function' ]]
default() {
declare -n _p=$1; shift
[[ "$_p" ]] || { var() {
for v in "$@"; do declare varname=$1; shift
_p+=( "$v" )
done if ! is_function "$varname"; then
eval "
${varname}() {
declare mode=set
declare -n _var=\"${varname}\"
if (( \$# )); then
case \"\$1\" in
('=') mode=set;;
('+=') mode=append;;
('_=') mode=prepend;;
(':=') mode=default;;
('==') mode=compare;;
('=~') mode=regex;;
(*) die 71 \"Syntax error in \$FUNCNAME!\";;
esac
shift
else
mode='bool'
fi
case \"\$mode\" in
(set) _var=( \"\$@\" );;
(append) _var+=( \"\$@\" );;
(prepend) _var=( \"\$@\" \"\${var[@]}\" );;
(default) [[ \"\$_var\" ]] || _var=( \"\$@\" );;
(compare) [[ \"\$_var\" == \"\$*\" ]];;
(regex) [[ \"\$_var\" =~ \$@ ]];;
(bool)
case \"\${_var,,}\" in
(''|'false'|'0') return 1;;
(*) return 0;;
esac
;;
esac
}; readonly -f \"${varname}\"
${varname}++() {
declare -n _var=\"${varname}\"
(( ${varname}++ ))
}
${varname}--() {
declare -n _var=\"${varname}\"
(( ${varname}-- ))
}
"
fi
if (( $# )); then
case "$1" in
('='|'=='|'=~'|'+='|'_='|':=')
"$varname" "$@"
;;
(*)
for v in "$@"; do
var "$v"
done
;;
esac
fi
} }
}; readonly -f default
## Die. Why not? ## Die. Why not?
die() { die() {
@ -24,6 +86,7 @@ die() {
## Run the command and wait for it to die ## Run the command and wait for it to die
svc() { svc() {
declare job_pid declare job_pid
var job_pid
svc::cleanup() { svc::cleanup() {
kill -n "$service_stop_signal" "$job_pid" kill -n "$service_stop_signal" "$job_pid"
@ -36,7 +99,7 @@ svc() {
kill -n "$service_reload_signal" "$job_pid" kill -n "$service_reload_signal" "$job_pid"
}; trap 'svc::reload' HUP }; trap 'svc::reload' HUP
"$@" & job_pid=$! "$@" & job_pid = "$!"
printf '%s' "$job_pid" > "$svc_pidfile" printf '%s' "$job_pid" > "$svc_pidfile"
wait "$job_pid" wait "$job_pid"
@ -46,7 +109,8 @@ svc() {
## Respawn ## Respawn
respawn() { respawn() {
declare jobs job_pid declare job_pid
var job_pid
respawn::cleanup() { respawn::cleanup() {
kill -n "$service_stop_signal" "$job_pid" kill -n "$service_stop_signal" "$job_pid"
@ -58,7 +122,10 @@ respawn() {
}; trap 'respawn::cleanup' TERM }; trap 'respawn::cleanup' TERM
respawn::sigpass() { respawn::sigpass() {
declare sig=$1 pid=$2 declare sig pid
var sig = "$1"
var pid = "$2"
kill -n "$sig" "$pid" kill -n "$sig" "$pid"
} }
@ -69,7 +136,7 @@ respawn() {
}; respawn::set_traps }; respawn::set_traps
while true; do while true; do
exec "$@" & job_pid=$! exec "$@" & job_pid = "$!"
while nullexec kill -n 0 "$job_pid"; do while nullexec kill -n 0 "$job_pid"; do
wait "$job_pid" wait "$job_pid"
@ -83,39 +150,29 @@ readonly -f nullexec
## Wait for a pid to die ## Wait for a pid to die
pid_wait() { pid_wait() {
declare cnt=0 declare cnt
var cnt = 0
while nullexec kill -0 "$1"; do while nullexec kill -0 "$1"; do
(( cnt >= (service_stop_timeout*10) )) && return 1 (( cnt >= (service_stop_timeout*10) )) && return 1
sleep 0.1 sleep 0.1
(( cnt++ )) cnt++
done done
return 0 return 0
}; readonly -f pid_wait }; readonly -f pid_wait
## See if NAME is a function
is_function() {
declare name=$1 name_type
name_type=$( type -t "$name" )
if [[ $name_type == 'function' ]]; then
return 0
fi
return 1
}; readonly -f is_function
## Simple timer ## Simple timer
timer() { timer() {
declare cnt=0 timeout=$1 declare cnt timeout
var cnt = 0
var timeout = "$1"
shift shift
while ! "$@"; do while ! "$@"; do
(( cnt >= (timeout*10) )) && return 1 (( cnt >= (timeout*10) )) && return 1
sleep 0.1 sleep 0.1
(( cnt++ )) cnt++
done done
return 0 return 0
@ -136,7 +193,7 @@ depend() {
for s in "$@"; do for s in "$@"; do
if ! "$_self" "$s" qstatus; then if ! "$_self" "$s" qstatus; then
nullexec "$_self" "$s" start || { nullexec "$_self" "$s" start || {
failed_deps+=( "$s" ) failed_deps += "$s"
return 1 return 1
} }
fi fi
@ -177,14 +234,14 @@ depend_ready() {
for s in "$@"; do for s in "$@"; do
"$_self" "$s" wait_ready || { "$_self" "$s" wait_ready || {
failed_deps+=( "$s" ) failed_deps += "$s"
return 1 return 1
} }
done done
}; readonly -f depend_ready }; readonly -f depend_ready
result() { result() {
declare rc=$1; shift declare rc; var rc = "$1"; shift
declare -A msgs declare -A msgs
while (( $# )); do while (( $# )); do
@ -200,19 +257,20 @@ result() {
}; readonly -f result }; readonly -f result
read_systemd_service() { read_systemd_service() {
declare section key value declare section key value line
var key value line
while read -r line; do while read -r line; do
[[ $line =~ ^\[(.+)\] ]] && section=${BASH_REMATCH[1],,} line =~ '^\[(.+)\]' && var section = "${BASH_REMATCH[1],,}"
[[ $line =~ ^([^=]+)=(.+) ]] && { line =~ '^([^=]+)=(.+)' && {
key=${BASH_REMATCH[1],,} key = "${BASH_REMATCH[1],,}"
value=${BASH_REMATCH[2]} value = "${BASH_REMATCH[2]}"
} }
case $section in case $section in
(service) (service)
case $key in case $key in
(pidfile) service_pidfile=$value;; (pidfile) service_pidfile = "$value";;
(execstart) eval "service_command=( $value )";; (execstart) eval "service_command=( $value )";;
(execstop) eval "stop() { $value; }";; (execstop) eval "stop() { $value; }";;
(execreload) eval "reload() { $value; }";; (execreload) eval "reload() { $value; }";;
@ -223,47 +281,10 @@ read_systemd_service() {
done < "$1" done < "$1"
} }
# Some DSL for the config
setter() {
for i in "$@"; do
declare varname=$i
eval "
${varname}() {
declare mode=set
declare -n _var=${varname}
while (( \$# )); do
case \$1 in
(=) mode=set;;
(+=) mode=append;;
(_=) mode=prepend;;
(--) shift; break;;
(*) break;;
esac
shift
done
case \$mode in
(append) _var+=( \"\$@\" );;
(prepend) _var=( \"\$@\" \"\${_var[@]}\" );;
(set) _var=( \"\$@\" );;
esac
}; readonly -f ${varname}
"
done
}; readonly setter
setter \
service_path \
service_workdir \
service_stop_timeout service_ready_timeout \
service_stop_signal service_reload_signal service_signals \
systemd systemd_service_path
# Overloadable functions # Overloadable functions
## Start the service, write down the svc pid ## Start the service, write down the svc pid
start() { start() {
(( service_running )) && return 3 service_running && return 3
rm -f "$service_stopped_flag" rm -f "$service_stopped_flag"
@ -274,8 +295,8 @@ start() {
mktmpfiles || return 13 mktmpfiles || return 13
if (( service_managed )); then if service_managed; then
if (( service_respawn )); then if service_respawn; then
svc respawn "${service_command[@]}" &>"$service_logfile" & svc respawn "${service_command[@]}" &>"$service_logfile" &
else else
svc "${service_command[@]}" &>"$service_logfile" & svc "${service_command[@]}" &>"$service_logfile" &
@ -286,9 +307,9 @@ start() {
else else
return 5 return 5
fi fi
elif (( service_oneshot )); then elif service_oneshot; then
"${service_command[@]}" &>"$service_logfile"; res=$? "${service_command[@]}" &>"$service_logfile"; res=$?
(( $res )) && return "$res" (( res )) && return "$res"
printf '1' > "$service_enabled_flag" printf '1' > "$service_enabled_flag"
else else
exec "${service_command[@]}" & exec "${service_command[@]}" &
@ -300,7 +321,7 @@ start() {
## Reload the service ## Reload the service
## Usually just sends HUP ## Usually just sends HUP
reload() { reload() {
(( service_running )) || return 3 service_running || return 3
kill -n "$service_reload_signal" "$service_pid" kill -n "$service_reload_signal" "$service_pid"
} }
@ -309,14 +330,14 @@ reload() {
## Returns: ## Returns:
## 3: Service is not running. ## 3: Service is not running.
stop() { stop() {
if (( service_oneshot )); then if service_oneshot; then
(( service_enabled )) || return 3 service_enabled || return 3
rm -f "$service_enabled_flag" rm -f "$service_enabled_flag"
return 0 return 0
else else
(( service_running )) || return 3 service_running || return 3
nullexec kill -n "$service_stop_signal" "$service_pid" || return 1 nullexec kill -n "$service_stop_signal" "$service_pid" || return 1
@ -328,34 +349,32 @@ stop() {
} }
info() { info() {
declare \ declare _status_label _status _type _info_items
_status_label='Running' \ var _status_label = 'Running'
_status='no' var _status = 'no'
_type='daemon' var _type = 'daemon'
_info_items=() var _info_items
(( service_oneshot )) && { service_oneshot && {
_status_label = 'Enabled' _status_label = 'Enabled'
_type = 'oneshot' _type = 'oneshot'
} }
status && _status = 'yes' status && _status = 'yes'
_info_items=( _info_items = \
"Name" "$service_name" "Name" "$service_name" \
"Type" "$_type" "Type" "$_type" \
"$_status_label" "$_status" "$_status_label" "$_status" \
"Exec" "${service_command[*]} ${service_args[*]}" "Exec" "${service_command[*]} ${service_args[*]}" \
"Respawn" "${service_respawn:-false}" "Respawn" "${service_respawn:-false}" \
"Config path" "${service_config}" "Config path" "${service_config}" \
)
[[ "$_status" == 'yes' ]] && { if _status == 'yes'; then
_info_items+=( _info_items += \
"PIDfile" "${service_pidfile:-none}" "PIDfile" "${service_pidfile:-none}" \
"PID" "${service_pid:-none}" "PID" "${service_pid:-none}"
) fi
}
printf "%12s: %s\n" "${_info_items[@]}" printf "%12s: %s\n" "${_info_items[@]}"
} }
@ -366,8 +385,8 @@ restart() {
"$_self" "$service_name" start "$_self" "$service_name" start
} }
edit() { "${EDITOR:-vim}" "$service_config"; } edit() { $EDITOR "$service_config"; }
logs() { ${PAGER:-less} "$service_logfile"; } logs() { $PAGER "$service_logfile"; }
## Status is a bit of a special case. It's talkative. ## Status is a bit of a special case. It's talkative.
status() { status() {
@ -385,24 +404,59 @@ qstatus() { nullexec status; }
ready() { :; } ready() { :; }
# Main code # Main code
main() {
# Figure out our full path # Figure out our full path
case "$0" in case "$0" in
(/*) _self=$0;; (/*) var _self = "$0";;
(*) _self="$PWD/$0";; (*) var _self = "$PWD/$0";;
esac esac
# Needs to be global # check for some environment stuff
declare -g service_pid var EDITOR := 'vim'
var PAGER := 'less'
# Empty declarations
var service_pid
var service_pidfile
var service_type
var service_depends_ready
var service_command
var service_config
var service_path
var service_name
var service_args
var service_logfile
var service_ready_flag
var service_enabled_flag
var service_stopped_flag
var failed_deps
var svc_pidfile
var cfg_path
var cfg_dir
var rundir
var logdir
# Let's set some defaults # Let's set some defaults
service_managed=1 var service_managed = 0
usrdir='/usr/share/ssm' var service_respawn = 0
systemd_service_path=( /etc/systemd/system /run/systemd/system /lib/systemd/system ) var service_oneshot = 0
var service_running = 0
var service_enabled = 0
var service_stopped = 0
var service_systemd = 0
var service_workdir = '/'
var service_stop_timeout = 30
var service_ready_timeout = 15
var service_stop_signal = 15
var service_reload_signal = 1
var service_signals = 1 10 12
var systemd = 0
var systemd_service_path = /etc/systemd/system /run/systemd/system /lib/systemd/system
var ssm_config = 0
var usrdir = '/usr/share/ssm'
# XDG stuff # XDG stuff
default XDG_CONFIG_HOME "$HOME/.config" var XDG_CONFIG_HOME := "$HOME/.config"
default XDG_RUNTIME_DIR "/run/user/$UID" var XDG_RUNTIME_DIR := "/run/user/$UID"
if (( $UID )); then if (( $UID )); then
rundir = "$XDG_RUNTIME_DIR/ssm" rundir = "$XDG_RUNTIME_DIR/ssm"
@ -416,21 +470,21 @@ main() {
for p in "/etc/ssm/init.d" "$XDG_CONFIG_HOME/ssm/init.d"; do for p in "/etc/ssm/init.d" "$XDG_CONFIG_HOME/ssm/init.d"; do
if [[ -d "$p" ]]; then if [[ -d "$p" ]]; then
printf 'WARNING: `%s` was renamed to `%s`! Please move your scripts accordingly!\n' "$p" "${p%init.d}services" >&2 printf 'WARNING: `%s` was renamed to `%s`! Please move your scripts accordingly!\n' "$p" "${p%init.d}services" >&2
service_path+=( "$p" ) service_path += "$p"
fi fi
done done
# Common service path # Common service path
service_path+=( "$XDG_CONFIG_HOME/ssm/services" '/etc/ssm/services' "$rundir/services" "$usrdir/services" ) service_path += "$XDG_CONFIG_HOME/ssm/services" '/etc/ssm/services' "$rundir/services" "$usrdir/services"
# Common config path # Common config path
cfg_path+=( "$XDG_CONFIG_HOME/ssm" '/etc/ssm' ) cfg_path = "$XDG_CONFIG_HOME/ssm" '/etc/ssm'
# Load custom config and functions, reversing the PATH order # Load custom config and functions, reversing the PATH order
for (( idx=${#cfg_path[@]}-1; idx>=0; idx-- )); do for (( idx=${#cfg_path[@]}-1; idx>=0; idx-- )); do
cfg_dir = "${cfg_path[idx]}" cfg_dir = "${cfg_path[idx]}"
(( ssm_config )) || { ssm_config || {
[[ -f "$cfg_dir/ssm.conf" ]] && { [[ -f "$cfg_dir/ssm.conf" ]] && {
source "$cfg_dir/ssm.conf" || die 37 "Failed to load config: $cfg_dir/ssm.conf" source "$cfg_dir/ssm.conf" || die 37 "Failed to load config: $cfg_dir/ssm.conf"
ssm_config = 1 ssm_config = 1
@ -442,7 +496,6 @@ main() {
done done
done done
# Now create the needed runtime stuff # Now create the needed runtime stuff
for d in "$rundir" "$logdir"; do for d in "$rundir" "$logdir"; do
mkdir -p "$d" || die 3 "Failed to create runtime dir: $d" mkdir -p "$d" || die 3 "Failed to create runtime dir: $d"
@ -451,23 +504,24 @@ main() {
# If $1 is a full path, source it. # If $1 is a full path, source it.
# If not, search for it in the service path. # If not, search for it in the service path.
if [[ $1 == /* ]]; then if [[ $1 == /* ]]; then
service_config=$1 service_config = "$1"
else else
for i in "${service_path[@]/%//$1}"; do for i in "${service_path[@]/%//$1}"; do
[[ -f "$i" ]] && { [[ -f "$i" ]] && {
service_config=$i service_config = "$i"
break break
} }
done done
[[ $service_config ]] || { service_config || {
# Search for a systemd service too # Search for a systemd service too
(( systemd )) && { systemd && {
for i in "${systemd_service_path[@]/%//$1.service}"; do for i in "${systemd_service_path[@]/%//$1.service}"; do
[[ -f "$i" ]] && { [[ -f "$i" ]] && {
service_name=$1 var service_name = "$1"
service_systemd=1 var service_systemd = 1
service_config=$i var service_config = "$i"
read_systemd_service "$i" read_systemd_service "$i"
break break
} }
@ -477,10 +531,10 @@ main() {
fi fi
# Die if there is no service config file # Die if there is no service config file
[[ "$service_config" ]] || die 19 "Service not found: $1" service_config || die 19 "Service not found: $1"
# We can handle other people's service configs, poorly # We can handle other people's service configs, poorly
if (( service_systemd )); then if service_systemd; then
# I'm pretty sure we'll need this # I'm pretty sure we'll need this
: :
else else
@ -499,36 +553,30 @@ main() {
fi fi
# Legacy # Legacy
[[ "$service_args" ]] && service_command=( "${service_command[@]}" "${service_args[@]}" ) service_args && service_command += "${service_args[@]}"
[[ "$service_respawn" == 'true' ]] && service_respawn=1 service_respawn == 'true' && service_respawn = 1
[[ "$service_type" == 'oneshot' ]] && service_oneshot=1 service_type == 'oneshot' && service_oneshot = 1
(( service_oneshot )) && service_managed=0 service_oneshot && service_managed = 0
[[ "$service_pidfile" ]] && service_managed=0 service_pidfile && service_managed = 0
if ! (( service_managed )); then if ! service_managed; then
(( service_respawn )) && die 21 "Refusing to respawn a service that manages itself." service_respawn && die 21 "Refusing to respawn a service that manages itself."
fi fi
# Semi-hardcoded stuff # Semi-hardcoded stuff
svc_pidfile = "$rundir/$service_name.pid" svc_pidfile = "$rundir/$service_name.pid"
# Service-level defaults # Service-level defaults
default service_pidfile "$svc_pidfile" service_pidfile := "$svc_pidfile"
default service_logfile "$logdir/$service_name.log" service_logfile := "$logdir/$service_name.log"
default service_ready_flag "$rundir/$service_name.ready" service_ready_flag := "$rundir/$service_name.ready"
default service_enabled_flag "$rundir/$service_name.enabled" service_enabled_flag := "$rundir/$service_name.enabled"
default service_stopped_flag "$rundir/$service_name.stopped" service_stopped_flag := "$rundir/$service_name.stopped"
default service_workdir '/'
default service_stop_timeout 30
default service_ready_timeout 15
default service_stop_signal 15
default service_reload_signal 1
default service_signals 1 10 12
# Let's see if there's a PID # Let's see if there's a PID
if [[ -f "$service_pidfile" ]]; then if [[ -f "$service_pidfile" ]]; then
service_pid=$(<$service_pidfile) service_pid = "$(<$service_pidfile)"
# Let's see if it's running # Let's see if it's running
if nullexec kill -0 "$service_pid"; then if nullexec kill -0 "$service_pid"; then
@ -552,7 +600,7 @@ main() {
is_function "$2" || die 17 "Function $2 is not defined for $service_name." is_function "$2" || die 17 "Function $2 is not defined for $service_name."
# cd into the workdir, if defined. # cd into the workdir, if defined.
[[ "$service_workdir" ]] && { service_workdir && {
cd "$service_workdir" || die $? cd "$service_workdir" || die $?
} }
@ -591,7 +639,7 @@ main() {
;; ;;
status) status)
if (( service_oneshot )); then if service_oneshot; then
result "$res" \ result "$res" \
0 "$service_name is enabled" \ 0 "$service_name is enabled" \
1 "$service_name is not enabled" 1 "$service_name is not enabled"
@ -613,6 +661,3 @@ main() {
die 15 die 15
} }
fi fi
}; readonly -f main
main "$@"