if start-stop-daemon --pidfile ${PIDFILE} --user="${instancename}-koha" --stop --retry=QUIT/30/KILL/5; then

        if start-stop-daemon --pidfile "${PIDFILE}" --user="${instancename}-koha" --stop --retry=QUIT/30/KILL/5; then

- 

#!/bin/bash

#

# koha-watcher -- restart starman/plack when a file is modified.

# Copyright 2022  Mason James

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

set -e

#set -x

usage()

{

    local scriptname=$(basename "$0")

    cat <<EOF

$scriptname

This script automatically restarts starman/plack when a file in $dir is modified

It can be run manually, which is useful for debugging the script; but it's intended use is to be started via the following command...

    koha-plack --start --watch instance

Usage:

$scriptname --dir /path/to/my/repo instancename

$scriptname -h|--help

    --dir|-d              Path of directory to be watched

    --help|-h             Display this help message

EOF

}

# Read command line parameters

while [ $# -gt 0 ]; do

    case "$1" in

        -h|--help)

            usage ; exit 0 ;;

        -d|--dir)

            dir="$2"

            shift 2 ;;

        *)

            # We expect the remaining stuff are the instance names

            instance=$1

            break ;;

    esac

done

if [ -z "$dir" ]; then

        echo "Error: you must provide a directory name"

        exit

elif [ -z "$instance" ]; then

        echo "Error: you must provide an instance name"

        exit

fi

tmpfile="/tmp/koha-watcher_${instance}.tmp"

logfile="/var/log/koha/${instance}/plack-watcher.log"

pidfile="/var/run/koha/${instance}/plack.pid"

# watch perl files in a dir

_watch_dir() {

    inotifywait  --recursive -m  --event CLOSE_WRITE "$dir" | \

        grep -E '\.pl$|\.pm$' --line-buffered | \

        while read -r path events file ; do

            echo "${events} event on ${path}${file}" >> "$tmpfile"

        done;

}

# restart plack, and check for failure

_restart_plack() {

    if [ ! -e "$pidfile" ] ; then

        # if plack is not running, then start with no --watch arg

        #  (koha-watcher is already running)

        koha-plack --start "$instance"

    else

        # else just HUP it, as its quicker

        kill -s HUP $( cat "$pidfile" )

    fi

    # wait 3 long secs for children to start... (yawn)

    sleep 3

    # compare child PIDs after 1 sec;

    #  if they are different, plack children failed to start

    CHILD_PIDS_1=$( pgrep -P $( cat "$pidfile") | tr -d '\n' )

    sleep 1

    CHILD_PIDS_2=$( pgrep -P $( cat "$pidfile") | tr -d '\n' )

    if [ "$CHILD_PIDS_1" != "$CHILD_PIDS_2" ] ; then

        FAIL=1

    else

        FAIL=0

    fi

}

# main reload loop

_reload_loop() {

    # note: it's possible for a user to run 'koha-plack --start' on a

    # broken repo.  in this situation, we can't know that koha-plack's child

    # PIDs are failing to start until we test a reload.  so setting FAIL=1

    # on start forces this initial test

    FAIL=1

    # maximum number of seconds to sleep on reload failure.

    # 10 secs seems to be a good value, to help reduce system load

    MAXSLEEP=10

    # default number of seconds for sleep loop

    SLEEP=1

    while true ; do

        # don't attempt a restart while git is busy

        if [ ! -e "${dir}/.git/index.lock" ]; then

            # attempt reload if dir has changed, or previous plack failed

            if [ -e "$tmpfile" ] || [ $FAIL -eq 1 ]; then

                # remove tmpfile after restart was triggered

                #  and add last line of $tmpfile to logfile (#nospam!)

                if [ -e "$tmpfile" ]; then

                    tail -1 "$tmpfile" >> "$logfile"

                    rm "$tmpfile"

                fi

                _restart_plack

                if [ "$FAIL" -eq 1 ] ; then

                    # stop failing plack from continuously restarting during

                    # sleep loop, so CPU does not thrash

                    koha-plack --stop --preserve-watcher "$instance"

                    # add 1 secs for every fail, until $MAXSLEEP

                    if (( SLEEP < MAXSLEEP )) ; then

                        (( SLEEP++ ))

                    fi

                    echo "koha-plack failed! sleeping $SLEEP secs" >> $logfile

                else

                    # plack started ok, so reset sleep loop to 1 sec

                    SLEEP=1

                    FAIL=0

                    echo "koha-plack reloaded ok" >> $logfile

                fi

            fi

        fi # git lock

        sleep $SLEEP

        # useful for debugging $SLEEP value

        # echo "sleeping $SLEEP secs" >> $logfile

    done;

}

# run _reload_loop() in subshell

_reload_loop &

_watch_dir

exit 0