Shell Programming and Scripting

			while [[ ! -z "${scripts_remains[@]}" ]]
				do	# Start the script:
					script="${scripts_remains[$counter_start]}"
					scripts_todo[$counter_start]="$script"
					
					# Generate the command
					[[ [./] = "${script:0:1}" ]] && PRE="" || PRE="./"
					cmd="${PRE}\"$script\" ; echo \$? > \"$TEMP/$script.ret\""
					#doLog "Executing: $cmd"
					
					# Get PID to array
					( eval $cmd ) &
					scripts_id[$counter_start]="$!"
					
					# Remove it from array, and move to next entry
					unset scripts_remains[$counter_start]
					((counter_start++))
				done

while [[ ! -z "${scripts_remains[@]}" ]]

# loop over array
for X in "${ARRAY[@]}" ; do ...  ; done

# loop over string
for X in $string ; do ... ; done

# rotating an array
TMP=${ARR[0]}
for((N=1; N<${#ARR[@]}; N++)) ; do ARR[$((N-1))]=ARR[$N] ; done ; ARR[${#ARR[@]}]=$TMP

# rotating a string
set -- $string ; set -- "$@" $1 ; shift
string="$*"

#!/bin/bash
#
#	Variables
#
	scripts_remains=( "${@}" )
	scripts_total=${#scripts_remains[@]}
	TMP_DIR=$HOME/.cache/$$
	
	# Filled in the process
	unset scripts_todo[@] scripts_id[@]
	unset done_scripts[@] done_ret[@]
	
	# Defaults
	LIMIT=5
	WAIT=5
	
	# Counters - Fixed
	counter_done=0
	
	# Counters - Dynamic
	counter_start=0
	counter_running=0
#
#	Environment check
#
	[[ -d "$TMP_DIR" ]] || mkdir -p "$TMP_DIR"
#
#	Display & Action --> limit 5, passing 4
#
	while [[ $counter_done -lt $scripts_total ]]
	do	# Loop the menu & Reset some values
		
		# Step 1
		# Check if there are files to be started
		echo "Scripts @ start"
# The Limit check is worthless, even when set to 2, all passed scripts gets executed on first loop...
		if [[ $counter_running -lt $LIMIT ]]
		then	# So we look in the script_remains for tasks
			num=0
			for S in ${scripts_remains[@]};do
				[[ -z "$S" ]] && break
				# Generate the command & save to new array
				[[ [./] = "${S:0:1}" ]] && PRE="" || PRE="./" 
				cmd="$PRE$S ; echo \$? > $TMP_DIR/$S.tmp"
				echo "Starting: $S"
				(eval $cmd) &
				scripts_id[$counter_start]="$!"
				scripts_todo[$counter_start]="$S"
				unset scripts_remains[$num]
				((counter_start++))
				((counter_running++))
				((num++))
			done
		fi
		
		# Step 2
		# Print status of already done scripts
		echo "Scrips @ done"
		C=0
		for D in "${done_scripts[@]}";do
			R=${done_id[$C]}
			echo "$D ended $R"
			((C++))
		done
		
		# Step 3
		# Show current tasks running -- now loops here endlessly...  because a script gets lost within the loop
		num=0
		echo "Scripts @ work"
		for W in "${scripts_todo[@]}";do
			# Only display if array element is not empty
			if [[ ! -z "$W" ]]
			then	val=${scripts_id[$num]}
				if [[ ! -z "$val" ]]
				then	if ps -ha | grep $val|grep -v -q grep
					then	echo "$W works : $val"
					else	echo "$W has ended..."
						# Unset this item now
						done_scripts[$counter_done]="$W"
						read R < $TMP_DIR/$W.tmp
						done_id[$counter_done]="$R"
						unset scripts_todo[$num] scripts_id[$num]
						((counter_done++))
						((counter_running--))
					fi
				fi
				((num++))
			fi
			
		done
		
		[[ $counter_done -lt $scripts_total ]] && \
			echo "wait for update: $WAIT" && \
			sleep $WAIT && \
			clear
	done
#
#	Clean up temp files
#
	rm -fr "$TMP_DIR"

grep -n sleep *
script1:2:sleep 30 
script2:2:sleep 9
script3:2:sleep 20
script4:2:sleep 15

+ ~/tmp/9388 $ sh ../../psm-mini.sh *
Scripts @ start
Starting: script1
Starting: script2
Starting: script3
Starting: script4
Scrips @ done
Scripts @ work
script1 works : 19364
script2 works : 19365
script3 works : 19367
script4 works : 19369
wait for update: 5
...
some screen updates later
...
Scripts @ start
Scrips @ done
script2 ended 0
script4 ended 0
script1 ended 0
Scripts @ work
wait for update: 5

#!/bin/bash

# This is a ring buffer.  Append at PIDS[$PW], read at PIDS[$PR].
# PW increments when a process is added, PR when a process dies,
# and both wrap at MAX.  Order is not important when removing
# since it shuffles the last process to whatever got deleted.
PIDS=()
PW=0
PR=0
MAX=2

running() {     # running "arrayindex"
        ps "${PIDS[$1]}" >/dev/null
}

add() {         # add "pid"
        PIDS[$PW]="$1"
        PW=$(( (PW+1)%MAX ))
        ((TOTAL++))
}

rem() {         # rem "arrayindex"
        # Take PID from the end, plunk it where the one to be deleted is
        PW=$(( (PW-1) % MAX ))
        [[ "$PW" -lt 0 ]] && PW=$((PW+MAX))

        PIDS[$PR]="${PIDS[$PW]}"
        ((TOTAL--))
}

# Start each given program in turn
for X in "$@"
do
        while [[ "$TOTAL" -ge "$MAX" ]]
        do
        for((N=0, I=PR; (TOTAL>=MAX) && (N<TOTAL); N++, I=(I+1)%MAX ))
        do
                if ! running "$I"
                then
                        rem "$I"
                        break
                fi
        done
                [[ "$TOTAL" -ge "$MAX" ]] && sleep 0.1
        done

        # Refers to array indexes, i.e. /tmp/$$-0 for array index 0.
        $X >/tmp/$$-$PW &
        add "$!"
done

while [[ "$TOTAL" -ge "$MAX" ]]
do
        for((N=0, I=PR; N<$TOTAL; N++, I=(I+1)%MAX ))
        do
                if ! running "$I"
                then
                        rem "$I"
                        break
                fi
        done
done

wait
rm -f /tmp/$$-*