#!/bin/bash # Create a dedicated systemd config # # usage: ynh_config_add_systemd [--service=service] [--template=template] # | arg: -s, --service= - Service name (optionnal, `$app` by default) # | arg: -t, --template= - Name of template file (optionnal, this is 'systemd' by default, meaning `../conf/systemd.service` will be used as template) # # This will use the template `../conf/.service`. # # See the documentation of `ynh_config_add` for a description of the template # format and how placeholders are replaced with actual variables. # # Requires YunoHost version 4.1.0 or higher. ynh_config_add_systemd() { # ============ Argument parsing ============= local -A args_array=([s]=service= [t]=template=) local service local template ynh_handle_getopts_args "$@" service="${service:-$app}" template="${template:-systemd.service}" # =========================================== ynh_config_add --template="$template" --destination="/etc/systemd/system/$service.service" systemctl enable $service --quiet systemctl daemon-reload } # Remove the dedicated systemd config # # usage: ynh_config_remove_systemd service # | arg: service - Service name (optionnal, $app by default) ynh_config_remove_systemd() { local service="${1:-$app}" if [ -e "/etc/systemd/system/$service.service" ]; then ynh_systemctl --service=$service --action=stop systemctl disable $service --quiet ynh_safe_rm "/etc/systemd/system/$service.service" systemctl daemon-reload fi } # Start (or other actions) a service, print a log in case of failure and optionnaly wait until the service is completely started # # usage: ynh_systemctl [--service=service] [--action=action] [ [--wait_until="line to match"] [--log_path=log_path] [--timeout=300] [--length=20] ] # | arg: -n, --service= - Name of the service to start. Default : `$app` # | arg: -a, --action= - Action to perform with systemctl. Default: start # | arg: -w, --wait_until= - The pattern to find in the log to attest the service is effectively fully started. # | arg: -p, --log_path= - Log file - Path to the log file. Default : `/var/log/$app/$app.log` # | arg: -t, --timeout= - Timeout - The maximum time to wait before ending the watching. Default : 300 seconds. # | arg: -e, --length= - Length of the error log displayed for debugging : Default : 20 # # Requires YunoHost version 3.5.0 or higher. ynh_systemctl() { # ============ Argument parsing ============= local -A args_array=([n]=service= [a]=action= [w]=wait_until= [p]=log_path= [t]=timeout= [e]=length=) local service local action local wait_until local length local log_path local timeout ynh_handle_getopts_args "$@" service="${service:-$app}" action=${action:-start} wait_until=${wait_until:-} length=${length:-20} log_path="${log_path:-/var/log/$service/$service.log}" timeout=${timeout:-300} # =========================================== # Manage case of service already stopped if [ "$action" == "stop" ] && ! systemctl is-active --quiet $service; then return 0 fi # Start to read the log if [[ -n "$wait_until" ]]; then local templog="$(mktemp)" # Following the starting of the app in its log if [ "$log_path" == "systemd" ]; then # Read the systemd journal journalctl --unit=$service --follow --since=-0 --quiet >"$templog" & # Get the PID of the journalctl command local pid_tail=$! else # Read the specified log file tail --follow=name --retry --lines=0 "$log_path" >"$templog" 2>&1 & # Get the PID of the tail command local pid_tail=$! fi fi # Use reload-or-restart instead of reload. So it wouldn't fail if the service isn't running. if [ "$action" == "reload" ]; then action="reload-or-restart" fi local time_start="$(date --utc --rfc-3339=seconds | cut -d+ -f1) UTC" # If the service fails to perform the action if ! systemctl $action $service; then # Show syslog for this service journalctl --quiet --no-hostname --no-pager --lines=$length --unit=$service >&2 # If a log is specified for this service, show also the content of this log if [ -e "$log_path" ]; then tail --lines=$length "$log_path" >&2 fi _ynh_clean_check_starting return 1 fi # Start the timeout and try to find wait_until if [[ -n "${wait_until:-}" ]]; then set +x local i=0 local starttime=$(date +%s) for i in $(seq 1 $timeout); do # Read the log until the sentence is found, that means the app finished to start. Or run until the timeout if [ "$log_path" == "systemd" ]; then # For systemd services, we in fact dont rely on the templog, which for some reason is not reliable, but instead re-read journalctl every iteration, starting at the timestamp where we triggered the action if journalctl --unit=$service --since="$time_start" --quiet --no-pager --no-hostname | grep --extended-regexp --quiet "$wait_until"; then ynh_print_info "The service $service has correctly executed the action ${action}." break fi else if grep --extended-regexp --quiet "$wait_until" "$templog"; then ynh_print_info "The service $service has correctly executed the action ${action}." break fi fi if [ $i -eq 30 ]; then echo "(this may take some time)" >&2 fi # Also check the timeout using actual timestamp, because sometimes for some reason, # journalctl may take a huge time to run, and we end up waiting literally an entire hour # instead of 5 min ... if [[ "$(( $(date +%s) - $starttime))" -gt "$timeout" ]] then i=$timeout break fi sleep 1 done set -x if [ $i -ge 3 ]; then echo "" >&2 fi if [ $i -eq $timeout ]; then ynh_print_warn "The service $service didn't fully executed the action ${action} before the timeout." ynh_print_warn "Please find here an extract of the end of the log of the service $service:" journalctl --quiet --no-hostname --no-pager --lines=$length --unit=$service >&2 if [ -e "$log_path" ]; then ynh_print_warn "===" tail --lines=$length "$log_path" >&2 fi fi _ynh_clean_check_starting fi } _ynh_clean_check_starting() { if [ -n "${pid_tail:-}" ]; then # Stop the execution of tail. kill -SIGTERM $pid_tail 2>&1 fi if [ -n "${templog:-}" ]; then ynh_safe_rm "$templog" 2>&1 fi }