#!/bin/bash
######################################################################################
# arg defaults
IFMODES=()
NOTMODES=()
IFGROUPS=()
NOTGROUPS=()
IFFROMS=()
NOTFROMS=()
MYFAILOVERRIDE=fail
MYRUN=once
MYDEPENDS=()
MYOVERRIDES=()
######################################################################################
#parse command line arguments
until [ -z "$1" ]
do
  CURARG=$1
  case "$CURARG" in
    "--abort")        MYABORT=1  ;;
    "--cache")        MYCACHE=1  ;;
    "--rerun")         MYRERUN=1  ;;
    "--continue")        MYCONTINUE=1  ;;
    "--break")        MYBREAK=1  ;;
    "--reboot")        MYREBOOT=1  ;;
    "--run="* )        MYRUN=${CURARG#*=} ;;
    "--run"   ) shift; MYRUN=$1 ;;
    "--fail-override="* )        MYFAILOVERRIDE=${CURARG#*=} ;;
    "--fail-override"   ) shift; MYFAILOVERRIDE=$1 ;;
    "--if-mode="* )        IFMODES+=(${CURARG#*=}) ;;
    "--if-mode"   ) shift; IFMODES+=($1) ;;
    "--not-mode="* )        NOTMODES+=(${CURARG#*=}) ;;
    "--not-mode"   ) shift; NOTMODES+=($1)  ;;
    "--if-group="* )        IFGROUPS+=(${CURARG#*=}) ;;
    "--if-group"   ) shift; IFGROUPS+=($1) ;;
    "--not-group="* )        NOTGROUPS+=(${CURARG#*=}) ;;
    "--not-group"   ) shift; NOTGROUPS+=($1)  ;;
    "--if-from="* )        IFFROMS+=(${CURARG#*=}) ;;
    "--if-from"   ) shift; IFFROMS+=($1) ;;
    "--not-from="* )        NOTFROMS+=(${CURARG#*=}) ;;
    "--not-from"   ) shift; NOTFROMS+=($1)  ;;
    "--background")        MYBACKGROUND=1  ;;
    "--name="* )        MYNAME=${CURARG#*=} ;;
    "--name"   ) shift; MYNAME=$1 ;;
    "--vdir="* )        MYVDIR=${CURARG#*=} ;;
    "--vdir"   ) shift; MYVDIR=$1 ;;
    "--subvdir="* )        MYSUBVDIR=${CURARG#*=} ;;
    "--subvdir"   ) shift; MYSUBVDIR=$1 ;;
    "--order="* )        MYORDER=${CURARG#*=} ;;
    "--order"   ) shift; MYORDER=$1 ;;
    "--server="* )        MYSERVER=${CURARG#*=} ;;
    "--server"   ) shift; MYSERVER=$1 ;;
    "--depends="* )        MYDEPENDS+=(${CURARG#*=}) ;;
    "--depends"   ) shift; MYDEPENDS+=($1)  ;;
    "--overrides="* )        MYOVERRIDES+=(${CURARG#*=}) ;;
    "--overrides"   ) shift; MYOVERRIDES+=($1)  ;;
    "--before="* )        MYBEFORE=${CURARG#*=} ;;
    "--before"   ) shift; MYBEFORE=$1 ;;
    "--after="* )        MYAFTER=${CURARG#*=} ;;
    "--after"   ) shift; MYAFTER=$1 ;;


  esac
  shift
done
#handle undefined variables here
#for booleans, undefined or "" is the only boolean false, test using: if [ $MYFLAG ]
######################################################################################

#################################################################################
# functions
#############################################################################################

function in_array () {
	local T
	local HAYSTACK
	local NEEDLE
	NEEDLE=$1
	#echo NEEDLE IS $NEEDLE
	HAYSTACK=$2
	#echo HAYSTACK IS $HAYSTACK
	#for e in ${@:2} ; do echo e is $e and 1 is $1 ; [[ "$e" == "$1" ]] && return 0; done
	#for T in ${HAYSTACK[*]} ; do echo T is $T and NEEDLE is $NEEDLE ; [[ "$T" == "$NEEDLE" ]] && return 0; done
	for T in ${HAYSTACK[*]} ; do [[ "$T" == "$NEEDLE" ]] && return 0; done
	return 1
}

function is_complete {
        #echo -n "GNC CHECKING UPDATE $LUPDATE ORDER $LUPDATEORDER for completeness ...  "
	#echo ls -l $UPDIR/$MYVDIR/$MYSUBVDIR/$MYNAME/$MYORDER.complete
	#ls -l $UPDIR/$MYVDIR/$MYSUBVDIR/$MYNAME/$MYORDER.complete
        if [ -e $UPDIR/$MYVDIR/$MYSUBVDIR/$MYNAME/$MYORDER.complete ] ; then
		#echo "does not need to run."
                return 0

        else
		#echo "needs to run."
                return 1
        fi
}

function process_overrides {
	local MODE
	local CORC
	local THISOVERRIDE
	MODE=$1

	# return 0 means we don't need to re-run
	# return 1 means we need to re-run
	CORC=0

	if [ "$MODE" = "store" ] ; then
                # we know we're going to run this gnc, remove any old overrides no matter what
                rm -rf $UPDIR/$MYVDIR/$MYSUBVDIR/$MYNAME/overrides/
	fi


	if [ -n "${MYOVERRIDES[*]}" ] ; then
	        for THISOVERRIDE in ${MYOVERRIDES[*]} ; do
	                #echo "checking override on $THISOVERRIDE"
	
	                # split on / , the more fields we have the more specific we go
	                DARRAY=(${THISOVERRIDE//\// })
	                # reverse it
	                DARRAYREV=()
	                for (( T=${#DARRAY[@]}-1 ; T>=0 ; T-- )) ; do    DARRAYREV+=(${DARRAY[T]}); done
	
	                unset DNAME
	                unset DGROUPNAME
	                unset DVERNAME
																					
	                DNAME=${DARRAYREV[0]}
	                DGROUPNAME=${DARRAYREV[1]}
	                DVERNAME=${DARRAYREV[2]}
	
	
	                if [ -z "$DVERNAME" ] ; then
	                        DVERNAME=$MYVDIR
	                fi
	
	                if [ -z "$DGROUPNAME" ] ; then
	                        DGROUPNAME=$MYSUBVDIR
	                fi
	
	                NEWORDER=$(cat $UPDIR/$DVERNAME/$DGROUPNAME/$DNAME/lastorder 2>/dev/null)

			if [ "$MODE" = "check" ] ; then
		                LASTORDER=$(cat $UPDIR/$MYVDIR/$MYSUBVDIR/$MYNAME/overrides/$DVERNAME/$DGROUPNAME/$DNAME/lastorder 2>/dev/null)
				# will be blank until the overridden gnc runs for the first time

				if [ -z "$NEWORDER" ] ; then
					echo "overridden gnc $DVERNAME/$DGROUPNAME/$DNAME has never been run, no need to re-run this gnc"
				else
					if [ "$NEWORDER" = "$LASTORDER" ] ; then
						echo "overridden gnc $DVERNAME/$DGROUPNAME/$DNAME has not run since this gnc last ran, no need to re-run this gnc"
					else
						echo "overridden gnc $DVERNAME/$DGROUPNAME/$DNAME changed from order $LASTORDER to $NEWORDER , need to re-run this gnc"
						CORC=1
						break
					fi
				fi
			elif [ "$MODE" = "store" ] ; then
				#store it for later use.  
				mkdir -p $UPDIR/$MYVDIR/$MYSUBVDIR/$MYNAME/overrides/$DVERNAME/$DGROUPNAME/$DNAME/
				echo "$NEWORDER"  > $UPDIR/$MYVDIR/$MYSUBVDIR/$MYNAME/overrides/$DVERNAME/$DGROUPNAME/$DNAME/lastorder
			fi
				
		
	        done
		# end of loop, now we can return
		return $CORC
	
	
	else
	        #echo "no overrides to process"
	        return 0
	fi
	
}

#############################################################################################
# start
#################################################################################

export UPDATE_RC_DISABLED=25
export UPDATE_RC_ALREADY_COMPLETE=24
export UPDATE_RC_SKIPPED=23
export UPDATE_RC_WARNING=21
export UPDATE_RC_FAIL=11

. /usr/share/groovix/global.conf



GNCDIR=/var/lib/groovix/net-control/
UPDIR=$GNCDIR/updates/
MYUPDATEPATH=$UPDIR/$MYVDIR/$MYSUBVDIR/$MYNAME

if [ -f $GNCDIR/break ] || [ -f $GNCDIR/continue ] ; then
	#echo "GNC SKIPPING $MYUPDATEPATH due to break/continue"
	exit $UPDATE_RC_SKIPPED
fi

mkdir -p $UPDIR/tmp
mkdir -p $MYUPDATEPATH

MYURLBASE=$(dirname $(dirname ${GNC_SERVER_URLS[$MYSERVER]}))/updates/

echo "GNC PROCESSING ORDER $MYORDER : $MYUPDATEPATH "



#############################################################################################
# determine mode
#############################################################################################

#what mode are we running in ?  these are mutually exclusive
#the default
MYMODE=normal 

# are we running live?
if groovix-running-live ; then
	MYMODE=live
fi

# are we running in install mode?
# install mode is technically running live - but we just call this mode install and not live as well
egrep "gxinstall|ubiquity" /proc/cmdline > /dev/null  2>&1
if [ $? -eq 0 ]; then
	MYMODE=install
fi

#even if we're building from inside a live cd, we consider build mode to trump live mode
if [ -e /tmp/customization-scripts/groovix-build.conf ] ; then
	MYMODE=build
fi


#############################################################################################
# determine skipping based on mode
#############################################################################################

#echo ${IFMODES[*]}
#if ifmodes is NOT blank
if [ -n "${IFMODES[*]}" ] ; then
        #if MYMODE is NOT in ifmodes
	if ! in_array "$MYMODE" "${IFMODES[*]}" ; then
		# SKIP IT !
		GNC_SKIP="--if-mode specifies another mode(s) - not $MYMODE mode"
	fi
fi

#echo ${NOTMODES[*]}
#if MYMODE is in notmodes
if [ -n "${NOTMODES[*]}" ] ; then
	if in_array "$MYMODE" "${NOTMODES[*]}" ; then
	        #SKIP IT !
	        GNC_SKIP="--not-mode $MYMODE was specified"
	fi
fi

#############################################################################################
# determine skipping based on where gnc was started from (startup|shutdown|ssh|shell|cmon) 
#############################################################################################
# $GNC_FROM  is exported by gnc
MYFROM=$GNC_FROM
#echo ${IFFROMS[*]}
#if iffroms is NOT blank
if [ -n "${IFFROMS[*]}" ] ; then
        #if MYFROM is NOT in iffroms
	if ! in_array "$MYFROM" "${IFFROMS[*]}" ; then
		# SKIP IT !
		GNC_SKIP="--if-from specifies another from(s) - not from $MYFROM "
	fi
fi

#echo ${NOTFROMS[*]}
#if MYMODE is in notfroms
if [ -n "${NOTFROMS[*]}" ] ; then
	if in_array "$MYFROM" "${NOTFROMS[*]}" ; then
	        #SKIP IT !
	        GNC_SKIP="--not-from $MYFROM was specified"
	fi
fi


#############################################################################################
# determine skipping based on group
#############################################################################################

#echo ${IFGROUPS[*]}
#if ifgroups is NOT blank
if [ -n "${IFGROUPS[*]}" ] ; then 
	MYGROUPS="$(groovix-get-parameter GX_ID) $(groovix-get-parameter GX_SITE) $(groovix-get-parameter GX_LABEL) $(groovix-get-parameter GX_TYPES)"
	for IFGROUP in ${IFGROUPS[*]} ; do
		#if specific if-group matches one of our actual groups:
		if in_array "$IFGROUP" "$MYGROUPS"; then
			true
		else
			# SKIP IT !
			GNC_SKIP="--if-group $IFGROUP was not one of this workstation\'s groups: $MYGROUPS "
			break
		fi
	done
fi
		
#echo ${NOTGROUPS[*]}
#if MYGROUPS is in notgroups
if [ -n "${NOTGROUPS[*]}" ] ; then
	MYGROUPS="$(groovix-get-parameter GX_ID) $(groovix-get-parameter GX_SITE) $(groovix-get-parameter GX_LABEL) $(groovix-get-parameter GX_TYPES)"
	for NOTGROUP in ${NOTGROUPS[*]} ; do
		if in_array "$NOTGROUP" "$MYGROUPS"; then
			#SKIP IT !
			GNC_SKIP="--not-group $NOTGROUP was specified"
			break
		fi
	done
fi

#############################################################################################
# determine skipping based on before/after date/time
#############################################################################################

if  [ -n "$MYBEFORE" ] || [ -n "$MYAFTER" ] ; then
	#don't need date unless using before/after
	NOWDATETIME=$(date +%Y%m%d%H%M)
fi

if [ -n "$MYBEFORE" ] ; then
	if [ "$NOWDATETIME" -ge "$MYBEFORE" ] ; then
		GNC_SKIP="datetime $NOWDATETIME is not before $MYBEFORE "
	fi
fi
#seconds assumed to be 0 so if minutes match exactly it is after
if [ -n "$MYAFTER" ] ; then
	if [ "$NOWDATETIME" -lt "$MYAFTER" ] ; then
		GNC_SKIP="datetime $NOWDATETIME is not after $MYAFTER "
	fi
fi





#############################################################################################
# determine skipping based on depends
#############################################################################################

if [ -n "${MYDEPENDS[*]}" ] ; then
	for THISDEPEND in ${MYDEPENDS[*]} ; do
		#echo "checking dependency on $THISDEPEND"

		# split on / , the more fields we have the more specific we go
		DARRAY=(${THISDEPEND//\// })
		# reverse it
		DARRAYREV=()
		for (( T=${#DARRAY[@]}-1 ; T>=0 ; T-- )) ; do    DARRAYREV+=(${DARRAY[T]}); done

		unset DVERNAME
		unset DGROUPNAME
		unset DNAME

                DNAME=${DARRAYREV[0]}
                DGROUPNAME=${DARRAYREV[1]}
                DVERNAME=${DARRAYREV[2]}


		if [ -z "$DVERNAME" ] ; then
			DVERNAME=$MYVDIR
		fi

		if [ -z "$DGROUPNAME" ] ; then
			DGROUPNAME=$MYSUBVDIR
		fi


		if [ -f $UPDIR/$DVERNAME/$DGROUPNAME/$DNAME/success ] ; then
			echo "dependency on $DVERNAME/$DGROUPNAME/$DNAME met"
			rm -f $UPDIR/$MYVDIR/$MYSUBVDIR/$MYNAME/depends/$DVERNAME/$DGROUPNAME/$DNAME/unmet
		else
			#echo "dependency on $DVERNAME/$DGROUPNAME/$DNAME NOT met"
			GNC_SKIP="dependency on $DVERNAME/$DGROUPNAME/$DNAME NOT met"
			#store it for later use.  
			mkdir -p $UPDIR/$MYVDIR/$MYSUBVDIR/$MYNAME/depends/$DVERNAME/$DGROUPNAME/$DNAME/
			touch $UPDIR/$MYVDIR/$MYSUBVDIR/$MYNAME/depends/$DVERNAME/$DGROUPNAME/$DNAME/unmet
		fi
	
	done


fi

#############################################################################################
# Do we need to actually run it?
#############################################################################################

if [ "$GNC_BACKGROUND" ] && ! [ "$MYBACKGROUND" ] ; then GNC_SKIP="running in background mode, skipping foreground update" ;  fi
if ! [ "$GNC_BACKGROUND" ] && [ "$MYBACKGROUND" ] ; then GNC_SKIP="running in foreground mode, skipping background update" ; fi

if [ "$GNC_SKIP" ] ; then
	MYRC_OVERRIDE=$UPDATE_RC_SKIPPED
else

	if  [ "$MYRUN" = "disabled" ]  ; then
		MYRC_OVERRIDE=$UPDATE_RC_DISABLED
	fi
	
	if [ "$MYRUN" = once ]  && is_complete ; then
		# can skip it UNLESS it overrides something
		if process_overrides check ; then
			#doesnt override another gnc, can completely skip it
			MYRC_OVERRIDE=$UPDATE_RC_ALREADY_COMPLETE
		fi
		#implicit else: does override another gnc, will run
	fi

fi

if [ -z "$MYRC_OVERRIDE" ] || [ -n "$MYCACHE" ] ; then
	#get it if we are going to run it or --cache was specified
	#echo " caching gnc (script only) because --cache was specified"
	#groovix-wget $MYURLBASE/$MYVDIR/$MYSUBVDIR/$MYNAME/gnc $MYUPDATEPATH/gnc --no-verbose  ;

	#could use value from lastorder but that is only saved off when it runs, this way we'll be sure we are comparing what we actually have
	#GNCFILEORDER=$(egrep "^GNC_ORDER=" $MYUPDATEPATH/gnc 2>/dev/null  | head -n 1 | cut -f 2 -d=)
	# changed - with the groovix 2013 "don't re-download gncs if order hasn't changed" feature, if a gnc is run between initial creation and while we are in the middle of editing it, it would need to be bumped after editing was done.  for now, go back to always re-downloading gncs until they are true and revisit this if load/bandwidth becomes a problem
	#GNCFILEORDER=alwaysdownloaditagain
	# changed again: gnc-new now auto bumps that gnc when initial edit is done
	GNCFILEORDER=$(egrep "^GNC_ORDER=" $MYUPDATEPATH/gnc 2>/dev/null  | head -n 1 | cut -f 2 -d=)
	# maybe in future have special exit code that indicates that it should be re-downloaded again no matter what

	if [ -z "$MYCACHE" ] && [ "$GNCFILEORDER" = "$MYORDER" ] ; then
		#echo "GNC DEBUG : the current order of the gnc in the filesystem $GNCFILEORDER matches the order in master.bash , not re-downloading"
		WGRC=0
	else
		# order has changed or they have specified --cache which means we always download the gnc no matter what
		groovix-wget $MYURLBASE/$MYVDIR/$MYSUBVDIR/$MYNAME/gnc $MYUPDATEPATH/gnc --no-verbose  ;
		WGRC=$?

		####################################################################
		# TODO:
		# maybe we should set MYORDER to be GNCFILEORDER - 
		# IF wget fails here but the master file was recently downloaded successfully and the order has since changed
		#  or if the gnc changes in between when the master and the gnc were downloaded, then:
		#    you can end up marking the gnc complete with the order from the master but you ran the old cached gnc
		# can't just change MYORDER mid process - things have already been done assuming current order
		#####################################################################
	
		NOWGNCFILEORDER=$(egrep "^GNC_ORDER=" $MYUPDATEPATH/gnc 2>/dev/null  | head -n 1 | cut -f 2 -d=)
		if [ "$NOWGNCFILEORDER" != "$MYORDER" ] ; then
			echo "!!! GNC ASSERTION FAILURE ERROR: master order is $MYORDER but file contains order $NOWGNCFILEORDER"
			#MYRC_OVERRIDE=$UPDATE_RC_SKIPPED
			MYRC_OVERRIDE=$UPDATE_RC_FAIL
		fi

	fi
fi
if [ -n "$MYRC_OVERRIDE" ] ; then
	MYRC=$MYRC_OVERRIDE
else
	# if we don't have an rc override then we need to run it and find out the rc

	#dos2unix $UPDIR/$MYSUBVDIR/$MYNAME/gnc
	echo GNC RUNNING $MYUPDATEPATH/gnc

	###########################################
	# set up environment

	if [ $MYABORT ] ; then
		BASHARGS="$BASHARGS -e";
	fi

	# in case we want to use some values inside an update script
	export UPDATE_NAME=$MYNAME
	export UPDATE_DIRBASE=$UPDIR
	export UPDATE_FILEBASE=$MYURLBASE/$MYVDIR/$MYSUBVDIR/$MYNAME/
	export UPDATE_ORDER=$MYORDER
	export UDPATE_DEPENDS=$MYDEPENDS
	export UPDATE_URLBASE=$MYURLBASE
	export UPDATE_RUN=$MYRUN
	export UPDATE_FAILOVERRIDE=$MYFAILOVERRIDE
	export UPDATE_MODE=$MYMODE
	export UPDATE_BACKGROUND=$MYBACKGROUND
	export UPDATE_VDIR=$MYVDIR
	export UPDATE_SUBVDIR=$MYSUBVDIR

        ###########################################

	# clear out old result
	for T in fail complete skipped success warning disabled ; do
        	rm -f $MYUPDATEPATH/$T
        	rm -f $MYUPDATEPATH/$MYORDER.$T
	done


        bash $BASHARGS $MYUPDATEPATH/gnc
        MYRC=$?

	#store current overridden gnc orders in place when this gnc ran
	process_overrides store

	# used for overridess processing 
	echo "$MYORDER" > $MYUPDATEPATH/lastorder
fi


#####################################################################
# override return code if specified
#####################################################################
	if [ $MYFAILOVERRIDE = fail ] ; then 
			OVERRIDE_STRING=""
	else
		# if fail (if return code is not any other value it must be fail)
		if [ $MYRC -ne 0 ] && [ $MYRC -ne $UPDATE_RC_WARNING  ] && [ $MYRC -ne $UPDATE_RC_SKIPPED ] && [ $MYRC -ne $UPDATE_RC_DISABLED ] && [ $MYRC -ne $UPDATE_RC_ALREADY_COMPLETE ]  ; then
			OVERRIDE_STRING=" (overridden from fail)"
			if  [ $MYFAILOVERRIDE = warning ] ; then
				MYRC=$UPDATE_RC_WARNING
			elif [ $MYFAILOVERRIDE = disabled ] ; then
				MYRC=$UPDATE_RC_DISABLED
			elif [ $MYFAILOVERRIDE = skip ] ; then
				MYRC=$UPDATE_RC_SKIPPED
			elif [ $MYFAILOVERRIDE = success ] ; then
				MYRC=0
			elif [ $MYFAILOVERRIDE = complete ] ; then
				MYRC=0
				OVERRIDE_STRING=" (overridden to complete)"
				#complete will get set down below, but we need to set fail since it won't be processed as a real fail
				touch  $MYUPDATEPATH/fail
				touch  $MYUPDATEPATH/$MYORDER.fail
			fi
		fi
	fi


        if  [ $MYRC -eq 0 ] ; then
                echo "GNC SUCCESS$OVERRIDE_STRING : $MYVDIR/$MYSUBVDIR/$MYNAME ORDER $MYORDER "
                touch $MYUPDATEPATH/success
                touch $MYUPDATEPATH/$MYORDER.success
		touch $MYUPDATEPATH/complete
		touch $MYUPDATEPATH/$MYORDER.complete

		if [ -n "$MYCONTINUE" ] ; then
			touch $GNCDIR/continue
			echo "GNC CONTINUE SET"
		fi
		if [ -n "$MYBREAK" ] ; then
			touch $GNCDIR/break
			echo "GNC BREAK SET"
		fi
		if [ -n "$MYRERUN" ] ; then
			touch $GNCDIR/rerun
			echo "GNC RERUN SET "
		fi
		if [ -n "$MYREBOOT" ] ; then
			if [  "$MYMODE" = "build" ] ; then 
				echo "GNC REBOOT NOT SET because this is build mode "
			else
				echo "GNC REBOOT SET "
				touch $GNCDIR/reboot
			fi
		fi

        elif [  $MYRC -eq $UPDATE_RC_SKIPPED ] ; then
                echo "GNC SKIPPED$OVERRIDE_STRING : $MYVDIR/$MYSUBVDIR/$MYNAME : $GNC_SKIP "
                touch $MYUPDATEPATH/skipped
                touch $MYUPDATEPATH/$MYORDER.skipped
        elif [  $MYRC -eq $UPDATE_RC_DISABLED ] ; then
                echo "GNC DISABLED${OVERRIDE_STRING} : $MYVDIR/$MYSUBVDIR/$MYNAME "
                touch $MYUPDATEPATH/disabled
                touch $MYUPDATEPATH/$MYORDER.disabled
        elif [  $MYRC -eq $UPDATE_RC_ALREADY_COMPLETE ] ; then
                echo "GNC ALREADY COMPLETE : $MYVDIR/$MYSUBVDIR/$MYNAME "
        elif [  $MYRC -eq $UPDATE_RC_WARNING ] ; then
                echo "! GNC WARNING${OVERRIDE_STRING} ! : $MYVDIR/$MYSUBVDIR/$MYNAME "
                touch $MYUPDATEPATH/warning
                touch $MYUPDATEPATH/$MYORDER.warning
        else
                echo
                echo "!!! GNC ERROR${OVERRIDE_STRING} !!! : $MYVDIR/$MYSUBVDIR/$MYNAME failed"
                echo
		if [[ "$GNC_ERROR_PAUSE" = "true"  ]] ; then
			echo
			echo
			echo
			echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
			echo "!!! pausing for error debug, hit enter to continue..."
			echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
			echo
			echo
			echo
			read pause
			echo
		fi
                #mark as failed
                touch  $MYUPDATEPATH/fail
                touch  $MYUPDATEPATH/$MYORDER.fail
        fi


exit $MYRC
