mkqueue.sh

Go to the documentation of this file.

#!/usr/bin/env zsh
#
# \author mdejong
#
script=${0##*/}
 
# ----------------------------------------------------------------------------------------
# Simple desktop batch queue processor.
#
# The batch queue is defined by a standard FIFO.
# The entries in the queue are processed line-by-line.
# Each entry is executed as a separate process in the background,
# commonly referred to as a job.
# The number of jobs that can simultaneously run is limited by the queue size.
# The batch queue can be terminated by submitting a job with contents "exit".
# The user can wait for the batch queue to complete processing of all submitted jobs
# by submitting a job with contents "wait".
#
# The batch queue may also be an existing regular file.
# The entries in the queue are processed as normal.
# The batch queue will terminate when the end-of-file is reached.
#
# A job can be submitted using the puts_queue function (see qlib.sh or qlib.csh).
# A series of joint commands can be submitted using a sequence of
# calls to put_queue, terminated by a single puts_queue call.
# ----------------------------------------------------------------------------------------
 
if [ -z $JPP_DIR ]; then
    echo "Variable JPP_DIR undefined."
    exit
fi
 
source $JPP_DIR/setenv.sh $JPP_DIR >& /dev/null
source qlib.sh
 
set_variable:  DEBUG        MKQUEUE_DEBUG       3
set_variable:  SLEEP_TIME   MKQUEUE_SLEEP_TIME  1s    # sleep time
set_variable   QUEUE_SIZE   1                         # default size of queue
set_variable   COMMAND      mkqueue.sh
 
if do_usage $*; then
    usage "$script <queue name> [queue size] <option>"\
          "\nPossible options: start, stop, continue, wait, restart."
fi
 
case $# in
    3)  set_variable  QUEUE_SIZE   $argv[2];&
    2)  set_variable  QUEUE_NAME   $argv[1];
        set_variable  OPTION       $argv[-1];;
    *)  fatal "Wrong number of options.";;
esac
 
if ( is_CCLyon ); then
    fatal "This batch queue processor is intended for use on a desktop."
fi
 
if (( $QUEUE_SIZE < 1 )); then
    fatal "Invalid queue size $QUEUE_SIZE."
fi
 
if   [[ "$OPTION" != "start" ]] && [[ "$OPTION" != "stop" ]] && [[ "$OPTION" != "continue" ]] && [[ "$OPTION" != "wait" ]] && [[ "$OPTION" != "restart" ]]; then
    fatal "Invalid option $OPTION."
fi
 
 
# short-hand to get PID of batch queue processor
 
alias get_mypid="pgrep -f \"$COMMAND *$QUEUE_NAME\""
 
 
#
# Run queue.
#
# \param   1         queue name
# \param   2         queue size
# \param   3         sleep time [s]
#
function queue()
{
    queue_name=$1
    queue_size=$2
    sleep_time=$3
 
    if [[ -e $queue_name ]]; then
 
            if [[ -p $queue_name ]]; then
                fatal "Queue $queue_name in use."
            fi    
    else
            
            mkfifo $queue_name                                # create a new FIFO
    fi
 
    fd=7                                                  # file descriptor
 
    eval "exec $fd<>$queue_name"                          # attach file descriptor to FIFO
 
    while read job <& $fd; do                             # read job from file descriptor
            
            if [[ -n $job ]]; then
                
                if [[ ${(Q)job} = "exit" ]]; then
                        break
                fi
 
                if [[ ${(Q)job} = "wait" ]]; then
 
                wait                                      # wait child processes
 
                break
                fi
 
                notice "submit $job" 
                eval exec $job &                              # submit job
 
            # wait for free slot
                
                while (( ${#jobstates} >= $queue_size )); do
                        sleep $sleep_time
                done
            fi
    done
    
    rm -f $queue_name                                     # remove FIFO
}
 
 
if   [[ "$OPTION" == "stop" || "$OPTION" == "restart" ]]; then
 
    PID=(`get_mypid`)
 
    PID[$PID[(i)$$]]=
    
    if [[ -n $PID ]]; then 
        notice "Stop $COMMAND $QUEUE_NAME."
        kill -9 $PID
    fi
    
    rm -f $QUEUE_NAME                                     # remove FIFO
    
    OPTION=${OPTION/restart/start}
 
elif [[ "$OPTION" == "continue" ]]; then
    
    PID=(`get_mypid`)
 
    PID[$PID[(i)$$]]=
 
    if [[ -n $PID ]]; then 
        notice "$script is running with PID(s) $PID"
    else
        OPTION=start
    fi
 
elif [[ "$OPTION" == "wait" ]]; then
 
    puts_queue  $QUEUE_NAME  wait
 
    while (( 1 )); do
 
        PID=(`get_mypid`)
 
        PID[$PID[(i)$$]]=
 
        if [[ -n $PID ]]; then
            sleep $SLEEP_TIME
        else
            break
        fi
    done
fi
 
if [[ "$OPTION" = "start" ]]; then
 
    notice "Start batch queue ${QUEUE_NAME} >& ${QUEUE_NAME}_log"
 
    trap "" HUP                                           # trap hangup
    
    queue $QUEUE_NAME $QUEUE_SIZE $SLEEP_TIME >& ${QUEUE_NAME}_log &
 
    while [[ ! -e $QUEUE_NAME ]]; do
        sleep $SLEEP_TIME
    done
fi