flyinweb's blog

系统负载监控

#!/bin/ksh  
 
 
SECS=300   # Defines the number of seconds for each sample  
INTERVAL=2    # Defines the total number of sampling intervals  
STATCOUNT=0   # Initialize a loop counter to 0, zero  
OS=$(uname)   # Defines the UNIX flavor  
 
###################################################  
##### SETUP THE ENVIRONMENT FOR EACH OS HERE ######  
###################################################  
 
# These "F-numbers" point to the correct field in the  
# command output for each UNIX flavor.  
 
case $OS in  
AIX|HP-UX)   SWITCH='-t'  
             F1=3  
             F2=4  
             F3=5  
             F4=6  
             echo "\nThe Operating System is $OS\n"  
             ;;  
Linux|SunOS) SWITCH='-c'  
             F1=1  
             F2=2  
             F3=3  
             F4=4  
             echo "\nThe Operating System is $OS\n"  
             ;;  
 
*) echo "\nERROR: $OS is not a supported operating system\n"  
   echo "\n\t...EXITING...\n"  
   exit 1  
   ;;  
esac  
 
###################################################  
######## BEGIN GATHERING STATISTICS HERE ##########  
###################################################  
 
echo "Gathering CPU Statistics using vmstat...\n"  
echo "There are $INTERVAL sampling periods with"  
echo "each interval lasting $SECS seconds"  
echo "\n...Please wait while gathering statistics...\n"  
 
# Use "iostat" to monitor the CPU utilization and  
# remove all lines that contain alphabetic characters  
# and blank spaces. Then use the previously defined  
# field numbers, for example F1=4,to point directly  
# to the 4th position, for this example. The syntax  
# for this techniques is ==>  $'$F1'.  
 
iostat $SWITCH $SECS $INTERVAL | egrep -v '[a-zA-Z]|^$' \  
          | awk '{print $'$F1', $'$F2', $'$F3', $'$F4'}' \  
          | while read FIRST SECOND THIRD FOURTH  
do  
  if ((STATCOUNT == 1)) # Loop counter to get the second set  
  then                  # of data produces by "iostat"  
 
      case $OS in # Show the results based on the UNIX flavor  
      AIX)  
            echo "\nUser part is ${FIRST}%"  
            echo "System part is ${SECOND}%"  
            echo "Idle part is ${THIRD}%"  
            echo "I/O wait state is ${FOURTH}%\n"  
            ;;  
      HP-UX|Linux)  
            echo "\nUser part is ${FIRST}%"  
            echo "Nice part is ${SECOND}%"  
            echo "System part is ${THIRD}%"  
            echo "Idle time is ${FOURTH}%\n"  
            ;;  
      SunOS)  
            echo "\nUser part is ${FIRST}%"  
            echo "System part is ${SECOND}%"  
            echo "I/O Wait is ${THIRD}%"  
            echo "Idle time is ${FOURTH}%\n"  
            ;;  
      esac  
 
  fi  
  ((STATCOUNT = STATCOUNT + 1)) # Increment the loop counter  
done 

#!/bin/ksh  
 
 
SECS=30  # Defines the number of seconds for each sample  
INTERVAL=10 # Defines the total number of sampling intervals  
OS=$(uname) # Defines the UNIX flavor  
 
###################################################  
##### SETUP THE ENVIRONMENT FOR EACH OS HERE ######  
###################################################  
 
# These "F-numbers" point to the correct field in the  
# command output for each UNIX flavor.  
 
case $OS in  
AIX|HP-UX|SunOS)     
       F1=2  
       F2=3  
       F3=4  
       F4=5  
       echo "\nThe Operating System is $OS\n"  
       ;;  
Linux)  
       F1=3  
       F2=4  
       F3=5  
       F4=6  
       echo "\nThe Operating System is $OS\n"  
       ;;  
*) echo "\nERROR: $OS is not a supported operating system\n"  
   echo "\n\t...EXITING...\n"  
   exit 1  
   ;;  
esac  
 
###################################################  
######## BEGIN GATHERING STATISTICS HERE ##########  
###################################################  
 
echo "Gathering CPU Statistics using sar...\n"  
echo "There are $INTERVAL sampling periods with"  
echo "each interval lasting $SECS seconds"  
echo "\n...Please wait while gathering statistics...\n"  
 
# This "sar" command take $INTERVAL samples, each lasting  
# $SECS seconds. The average of this output is captured.  
 
sar $SECS $INTERVAL | grep Average \  
          | awk '{print $'$F1', $'$F2', $'$F3', $'$F4'}' \  
          | while read FIRST SECOND THIRD FOURTH  
do  
      # Based on the UNIX Flavor, tell the user the   
      # result of the statistics gathered.  
 
      case $OS in  
      AIX|HP-UX|SunOS)  
            echo "\nUser part is ${FIRST}%"  
            echo "System part is ${SECOND}%"  
            echo "I/O wait state is ${THIRD}%"  
            echo "Idle time is ${FOURTH}%\n"  
            ;;  
      Linux)  
            echo "\nUser part is ${FIRST}%"  
            echo "Nice part is ${SECOND}%"  
            echo "System part is ${THIRD}%"  
            echo "Idle time is ${FOURTH}%\n"  
            ;;  
      esac  
done 

#!/bin/ksh  
 
 
MAXLOAD=2.00  
typeset -i INT_MAXLOAD=$MAXLOAD  
 
# Find the correct field to extract based on how long  
# the system has been up, or since the last reboot.  
 
if $(uptime | grep day | grep min >/dev/null)  
then  
     FIELD=11  
elif $(uptime | grep day | grep hrs >/dev/null)  
then  
     FIELD=11  
elif $(uptime | grep day >/dev/null)  
then  
     FIELD=10  
elif $(uptime | grep min >/dev/null)  
then  
     FIELD=9  
else  
     FIELD=8  
fi  
 
###################################################  
######## BEGIN GATHERING STATISTICS HERE ##########  
###################################################  
 
echo "\nGathering System Load Average using the \"uptime\" command\n"  
 
# This next command statement extracts the latest   
# load statistics no matter what the UNIX flavor is.  
 
LOAD=$(uptime | sed s/,//g | awk '{print $'$FIELD'}')  
 
# We need an integer representation of the $LOAD  
# variable to do the test for the load going over   
# the set threshold defince by the $INT_MAXLOAD  
# variable  
 
typeset -i INT_LOAD=$LOAD  
 
# If the current load has exceeded the threshold then   
# issue a warning message. The next step always shows  
# the user what the current load and threshold values  
# are set to.  
 
((INT_LOAD >= INT_MAXLOAD)) && echo "\nWARNING: System load has \  
reached ${LOAD}\n"   
 
echo "\nSystem load value is currently at ${LOAD}"  
echo "The load threshold is set to ${MAXLOAD}\n" 

#!/bin/ksh  
 
 
SECONDS=300  # Defines the number of seconds for each sample  
INTERVAL=2   # Defines the total number of sampling intervals  
STATCOUNT=0  # Initialize a loop counter to 0, zero  
OS=$(uname)  # Defines the UNIX flavor  
 
###################################################  
##### SETUP THE ENVIRONMENT FOR EACH OS HERE ######  
###################################################  
 
# These "F-numbers" point to the correct field in the  
# command output for each UNIX flavor.  
 
case $OS in  
AIX)   # AIX has four relative columns in the output   
       F1=14  
       F2=15  
       F3=16  
       F4=17  
 
       echo "\nThe Operating System is $OS\n"  
       ;;  
HP-UX) # HP-UX only has three relative columns in the output  
       F1=16  
       F2=17  
       F3=18  
       F4=1   # This "F4=1" is bogus and not used for HP-UX  
 
       echo "\nThe Operating System is $OS\n"  
       ;;  
Linux) # Linux only has three relative columns in the output  
       F1=14  
       F2=15  
       F3=16  
       F4=1   # This "F4=1" is bogus and not used for Linux  
 
       echo "\nThe Operating System is $OS\n"  
       ;;  
SunOS) # SunOS only has three relative columns in the output  
       F1=20  
       F2=21  
       F3=22  
       F4=1   # This "F4=1" is bogus and not used for SunOS  
 
       echo "\nThe Operating System is $OS\n"  
       ;;  
*) echo "\nERROR: $OS is not a supported operating system\n"  
   echo "\n\t...EXITING...\n"  
   exit 1  
   ;;  
esac  
 
###################################################  
######## BEGIN GATHERING STATISTICS HERE ##########  
###################################################  
 
echo "Gathering CPU Statistics using vmstat...\n"  
echo "There are $INTERVAL sampling periods with"  
echo "each interval lasting $SECONDS seconds"  
echo "\n...Please wait while gathering statistics...\n"  
 
# Use "vmstat" to monitor the CPU utilization and   
# remove all lines that contain alphabetic characters  
# and blank spaces. Then use the previously defined   
# field numbers, for example F1=20,to point directly  
# to the 20th position, for this example. The syntax  
# for this techniques is ==>  $'$F1', and points directly  
# to the $20 positional parameter.  
 
vmstat $SECONDS $INTERVAL | egrep -v '[a-zA-Z]|^$' \  
          | awk '{print $'$F1', $'$F2', $'$F3', $'$F4'}' \  
          | while read FIRST SECOND THIRD FORTH  
do  
  if ((STATCOUNT == 1)) # Loop counter to get the second set  
  then                  # of data produces by "vmstat"  
 
      case $OS in  # Show the results based on the UNIX flavor  
      AIX)  
            echo "\nUser part is ${FIRST}%"  
            echo "System part is ${SECOND}%"  
            echo "Idle part is ${THIRD}%"  
            echo "I/O wait state is ${FORTH}%\n"  
            ;;  
      HP-UX|Linux|SunOS)  
            echo "\nUser part is ${FIRST}%"  
            echo "System part is ${SECOND}%"  
            echo "Idle time is ${THIRD}%\n"  
            ;;  
      esac  
 
  fi  
  ((STATCOUNT = STATCOUNT + 1)) # Increment the loop counter  
done 

页面调度与交换空间监控

#!/usr/bin/ksh  
 
 
PC_LIMIT=65            # Upper limit of Swap space percentage  
                       # before notification  
 
THISHOST=$(hostname)   # Host name of this machine  
 
echo "\nSwap Space Report for $THISHOST\n"  
date  
 
function SUN_swap_mon  
{  
SW_USED=$(swap -s | awk '{print $9}' | cut -dk -f1)  
SW_FREE=$(swap -s | awk '{print $11}' | cut -dk -f1)  
((SW_TOTAL = SW_USED + SW_FREE))  
PERCENT_USED=$(bc <<EOF  
scale=4  
($SW_USED / $SW_TOTAL) * 100  
EOF  
)  
 
PERCENT_FREE=$(bc <<EOF  
scale=4  
($SW_FREE / $SW_TOTAL) * 100  
EOF  
)  
 
# Convert the KB measurements to MB measurements  
 
((SW_TOTAL_MB = SW_TOTAL / 1000))  
((SW_USED_MB  = SW_USED / 1000))  
((SW_FREE_MB  = SW_FREE / 1000))  
 
# Produce the remaining part of the report  
 
echo "\nTotal Amount of Swap Space:\t${SW_TOTAL_MB}MB"  
echo "Total KB of Swap Space Used:\t${SW_USED_MB}MB"  
echo "Total KB of Swap Space Free:\t${SW_FREE_MB}MB"  
echo "\nPercent of Swap Space Used:\t${PERCENT_USED}%"  
echo "\nPercent of Swap Space Free:\t${PERCENT_FREE}%"  
 
# Grab the integer portion of the percent used  
 
INT_PERCENT_USED=$(echo $PERCENT_USED | cut -d. -f1)  
 
# Check to see if the percentage used maxmum threshold  
# has beed exceeded  
 
if (( PC_LIMIT <= INT_PERCENT_USED ))  
then  
    # Percent used has exceeded the threshold, send notification  
 
    tput smso # Turn on reverse video!  
    echo "\n\nWARNING: Swap Space has Exceeded the ${PC_LIMIT}% Upper Limit!\n"  
    tput rmso # Turn off reverse video!  
fi  
 
echo "\n"  
}  
 
 
function Linux_swap_mon  
{  
 
free -m | grep -i swap | while read junk SW_TOTAL SW_USED SW_FREE  
do  
PERCENT_USED=$(bc <<EOF  
scale=4  
($SW_USED / $SW_TOTAL) * 100  
EOF  
)  
 
PERCENT_FREE=$(bc <<EOF  
scale=4  
($SW_FREE / $SW_TOTAL) * 100  
EOF  
)  
 
     # Produce the rest of the paging space report:  
     echo "\nTotal Amount of Swap Space:\t${SW_TOTAL}MB"  
     echo "Total KB of Swap Space Used:\t${SW_USED}MB"  
     echo "Total KB of Swap Space Free:\t${SW_FREE}MB"  
     echo "\nPercent of Swap Space Used:\t${PERCENT_USED}%"  
     echo "\nPercent of Swap Space Free:\t${PERCENT_FREE}%"  
 
     # Grap the integer portion of the percent used to  
     # test for the over limit threshold  
 
     INT_PERCENT_USED=$(echo $PERCENT_USED | cut -d. -f1)  
 
     if (( PC_LIMIT <= INT_PERCENT_USED ))  
     then  
          tput smso  
          echo "\n\nWARNING: Paging Space has Exceeded the \  
${PC_LIMIT}% Upper Limit!\n"  
          tput rmso  
     fi  
 
done  
 
echo "\n"  
}  
 
###########################################################  
 
function HP_UX_swap_mon  
{  
############# CAPTURE AND PROCESS THE DATA ################  
 
# Start a while read loop by using the piped in input from  
# the swapinfo -tm command output.  
 
 
swapinfo -tm | grep dev | while read junk SW_TOTAL SW_USED \  
                               SW_FREE PERCENT_USED junk2  
do  
    # Calculate the percentage of free swap space  
 
    ((PERCENT_FREE = 100 - $(echo $PERCENT_USED | cut -d% -f1) ))  
 
    echo "\nTotal Amount of Swap Space:\t${SW_TOTAL}MB"  
    echo "Total MB of Swap Space Used:\t${SW_USED}MB"  
    echo "Total MB of Swap Space Free:\t${SW_FREE}MB"  
    echo "\nPercent of Swap Space Used:\t${PERCENT_USED}"  
    echo "\nPercent of Swap Space Free:\t${PERCENT_FREE}%"  
 
    # Check for paging space exceeded the predefined limit  
 
    if (( PC_LIMIT <= $(echo $PERCENT_USED | cut -d% -f1) ))  
    then  
        # Swap space is over the predefined limit, send notification  
 
       tput smso # Turn on reverse video!  
         echo "\n\nWARNING: Swap Space has Exceeded the\  
 ${PC_LIMIT}% Upper Limit!\n"  
         tput rmso # Turn reverse video off!  
    fi  
 
done  
 
echo "\n"  
}  
 
###########################################################  
 
function AIX_paging_mon  
{  
################ DEFINE VARIABLES HERE ####################  
 
PAGING_STAT=/tmp/paging_stat.out # Paging Stat hold file  
 
###########################################################  
############# CAPTURE AND PROCESS THE DATA ################  
 
# Load the data in a file without the column headings  
 
lsps -s | tail +2 > $PAGING_STAT  
 
# Start a while loop and feed the loop from the bottom using  
# the $PAGING_STAT file as redirected input  
 
while read TOTAL PERCENT  
do  
     # Clean up the data by removing the suffixes  
     PAGING_MB=$(echo $TOTAL | cut -d 'MB' -f1)  
     PAGING_PC=$(echo $PERCENT | cut -d% -f1)  
 
     # Calculate the missing data: %Free, MB used and MB free  
     (( PAGING_PC_FREE = 100 - PAGING_PC ))  
     (( MB_USED = PAGING_MB * PAGING_PC / 100 ))  
     (( MB_FREE = PAGING_MB - MB_USED ))  
 
     # Produce the rest of the paging space report:  
     echo "\nTotal MB of Paging Space:\t$TOTAL"  
     echo "Total MB of Paging Space Used:\t${MB_USED}MB"  
     echo "Total MB of Paging Space Free:\t${MB_FREE}MB"  
     echo "\nPercent of Paging Space Used:\t${PERCENT}"  
     echo "\nPercent of Paging Space Free:\t${PAGING_PC_FREE}%"  
 
     # Check for paging space exceeded the predefined limit  
     if ((PC_LIMIT <= PAGING_PC))  
     then  
          # Paging space is over the limit, send notification  
 
          tput smso  # Turn on reverse video!  
 
          echo "\n\nWARNING: Paging Space has Exceeded the ${PC_LIMIT}% \  
Upper Limit!\n"  
 
          tput rmso  # Turn off reverse video  
     fi  
 
done < $PAGING_STAT  
 
rm -f $PAGING_STAT  
 
# Add an extra new line to the output  
 
echo "\n"  
}  
 
###########################################################  
################## BEGINNING OF MAIN ######################  
###########################################################  
 
###########################################################  
################ DEFINE VARIABLES HERE ####################  
 
PC_LIMIT=65            # Upper limit of Swap space percentage  
                       # before notification  
 
THISHOST=$(hostname)   # Host name of this machine  
 
###########################################################  
 
# Find the Operating System and execute the correct function  
 
case $(uname) in  
 
     AIX) AIX_paging_mon  
     ;;  
     HP-UX) HP_UX_swap_mon  
     ;;  
     Linux) Linux_swap_mon  
     ;;  
     SunOS) SUN_swap_mon  
     ;;  
esac  
 
# End of all-in-one_swapmon.ksh 

进程监控

#!/bin/ksh  
 
typeset -u RUN_PRE_EVENT  # Force to UPPERCASE  
typeset -u RUN_STARTUP_EVENT  # Force to UPPERCASE  
typeset -u RUN_POST_EVENT # force to UPPERCASE  
 
RUN_PRE_EVENT='N'  # A 'Y' will execute, anything else will not  
RUN_STARTUP_EVENT='Y' # A 'Y' will execute, anything else will not  
RUN_POST_EVENT='Y' # A 'Y' will execute, anything else will not  
 
LOGFILE="/tmp/proc_status.log"  
[[ ! -s $LOGFILE ]] && touch $LOGFILE  
 
SCRIPT_NAME=$(basename $0)  
TTY=$(tty)  
INTERVAL="1" # Seconds between sampling  
JOBS=  
 
####################################################  
############# DEFINE FUNCTIONS HERE ################  
####################################################  
 
usage ()  
{  
echo "\n\n\t*****USAGE ERROR*****"  
echo "\n\nUSAGE:  $SCRIPT_NAME  seconds  process"  
echo "\nWill monitor the specified process for the"  
echo "specified number of seconds."  
echo "\nUSAGE:  $SCRIPT_NAME  [-s|-S seconds] [-m|-M minutes]"  
echo "        [-h|-H hours] [-d|-D days] [-p|-P process]\n"  
echo "\nWill monitor the specified process for number of"  
echo "seconds specified within -s seconds, -m minutes,"  
echo "-h hours and -d days.  Any combination of command"  
echo "switches can be used.\n"  
echo "\nEXAMPLE: $SCRIPT_NAME  300  dtcalc"  
echo "\n\nEXAMPLE: $SCRIPT_NAME  -m 5 -p dtcalc"  
echo "\nBoth examples will monitor the dtcalc process"  
echo "for 5 minutes.  Can specify days, hours, minutes"  
echo "and seconds, using -d, -h, -m and -s\n\n"  
}  
 
####################################################  
 
trap_exit ()  
{  
# set -x # Uncommant to debug this function  
# Log an ending time for process monitoring  
echo "INTERRUPT: Program Received an Interrupt...EXITING..." > $TTY  
echo "INTERRUPT: Program Received an Interrupt...EXITING..." >> $LOGFILE  
TIMESTAMP=$(date +%D@%T) # Get a new time stamp...  
echo "MON_STOPPED: Monitoring for $PROCESS ended ==> $TIMESTAMP\n" \  
      >> $TTY  
echo "MON_STOPPED: Monitoring for $PROCESS ended ==> $TIMESTAMP\n" \  
      >> $LOGFILE  
echo "LOGFILE: All Events are Logged ==> $LOGFILE \n" > $TTY  
 
# Kill all functions  
JOBS=$(jobs -p)  
if [[ ! -z $JOBS && $JOBS != '' && $JOBS != '0' ]]  
then  
      kill $(jobs -p) 2>/dev/null 1>&2  
fi  
return 2  
}  
 
####################################################  
 
pre_event_script ()  
{  
# Put anything that you want to execute BEFORE the   
# monitored process STARTS in this function  
 
: # No-OP - Needed as a place holder for an empty function  
# Comment Out the Above colon, ':'  
 
PRE_RC=$?  
return $PRE_RC  
}  
 
####################################################  
startup_event_script ()  
{  
# Put anything that you want to execute WHEN, or AS, the  
# monitored process STARTS in this function  
 
: # No-OP - Needed as a place holder for an empty function  
# Comment Out the Above colon, ':'  
 
STARTUP_RC=$?  
return $STARTUP_RC  
}  
 
####################################################  
 
 
post_event_script ()  
{  
# Put anything that you want to execute AFTER the   
# monitored process ENDS in this function  
 
: # No-OP - Need as a place holder for an empty function  
# Comment Out the Above colon, ':'  
 
POST_RC=$?  
return $POST_RC  
}  
 
####################################################  
 
test_string ()  
{  
if (( $# != 1 ))  
then  
    echo 'ERROR'  
    return  
fi  
 
C_STRING=$1  
 
case $C_STRING in  
 
     +([0-9])) echo  'POS_INT' # Integer >= 0  
               ;;  
     +([-0-9])) echo 'NEG_INT' # Integer < 0  
               ;;  
     +([a-z])) echo  'LOW_CASE'   # lower case text  
               ;;  
     +([A-Z])) echo  'UP_CASE'    # UPPER case text   
               ;;  
     +([a-z]|[A-Z])) echo 'MIX_CASE' # MIxed CAse text  
               ;;  
               *) echo 'UNKNOWN'  # Anything else   
esac  
}  
 
####################################################  
 
proc_watch ()  
{  
# set -x # Uncomment to debug this function  
 
while :     # Loop Forever!!  
do  
    case $RUN in  
    'Y')  
          # This will run the startup_event_script, which is a function  
 
          if [[ $RUN_STARTUP_EVENT = 'Y' ]]  
          then  
             echo "STARTUP EVENT: Executing Startup Event Script..." > $TTY  
             echo "STARTUP EVENT: Executing Startup Event Script..." >> $LOGFILE  
 
             startup_event_script # USER DEFINED FUNCTION!!!  
             RC=$?  
             if (( "RC" == 0 ))  
             then  
                  echo "SUCCESS: Startup Event Script Completed RC - ${RC}"\  
                        > $TTY  
                  echo "SUCCESS: Startup Event Script Completed RC - ${RC}"\  
                        >> $LOGFILE  
 
             else  
                  echo "FAILURE: Startup Event Script FAILED RC - ${RC}"\  
                        > $TTY  
                  echo "FAILURE: Startup Event Script FAILED RC - ${RC}"\  
                        >> $LOGFILE  
 
             fi  
          fi  
 
          integer PROC_COUNT='-1' # Reset the Counters  
          integer LAST_COUNT='-1'  
 
          # Loop until the process(es) end(s)  
 
          until (( "PROC_COUNT" == 0 ))  
          do  
               # This function is a Co-Process. $BREAK checks to see if  
               # "Program Interrupt" has taken place. If so BREAK will  
               # be 'Y' and we exit both the loop and function.  
 
               read BREAK  
               if [[ $BREAK = 'Y' ]]  
               then  
                     return 3  
               fi  
               PROC_COUNT=$(ps -ef | grep -v "grep $PROCESS" \  
                           | grep -v $SCRIPT_NAME \  
                           | grep $PROCESS| wc -l) >/dev/null 2>&1  
 
               if (( "LAST_COUNT" > 0 && "LAST_COUNT" != "PROC_COUNT" ))  
               then  
                    # The Process Count has Changed...  
                    TIMESTAMP=$(date +%D@%T)  
                    # Get a list of the PID of all of the processes  
                    PID_LIST=$(ps -ef | grep -v "grep $PROCESS" \  
                           | grep -v $SCRIPT_NAME \  
                           | grep $PROCESS | awk '{print $2}')  
 
                    echo "PROCESS COUNT: $PROC_COUNT $PROCESS\  
 Processes Running ==> $TIMESTAMP" >> $LOGFILE &  
                    echo "PROCESS COUNT: $PROC_COUNT $PROCESS\  
 Processes Running ==> $TIMESTAMP" > $TTY  
              
                    echo ACTIVE PIDS: $PID_LIST >> $LOGFILE &  
                    echo ACTIVE PIDS: $PID_LIST > $TTY  
               fi  
               LAST_COUNT=$PROC_COUNT  
               sleep $INTERVAL # Needed to reduce CPU load!  
          done  
 
          RUN='N' # Turn the RUN Flag Off  
 
          TIMESTAMP=$(date +%D@%T)  
          echo "ENDING PROCESS: $PROCESS END time  ==>\  
 $TIMESTAMP" >> $LOGFILE &  
          echo "ENDING PROCESS: $PROCESS END time  ==>\  
 $TIMESTAMP" > $TTY  
 
          # This will run the post_event_script, which is a function  
 
          if [[ $RUN_POST_EVENT = 'Y' ]]  
          then  
              echo "POST EVENT: Executing Post Event Script..."\  
                    > $TTY  
              echo "POST EVENT: Executing Post Event Script..."\  
                    >> $LOGFILE  
 
              post_event_script # USER DEFINED FUNCTION!!!  
              RC=$?  
              if (( "RC" == 0 ))  
              then  
                  echo "SUCCESS: Post Event Script Completed RC -\  
                        ${RC}" > $TTY  
                  echo "SUCCESS: Post Event Script Completed RC - ${RC}"\  
                        >> $LOGFILE  
              else  
                  echo "FAILURE: Post Event Script FAILED RC - ${RC}"\  
                        > $TTY  
                  echo "FAILURE: Post Event Script FAILED RC - ${RC}"\  
                        >> $LOGFILE  
              fi  
          fi    
     ;;  
 
     'N')  
          # This will run the pre_event_script, which is a function  
 
          if [[ $RUN_PRE_EVENT = 'Y' ]]  
          then  
             echo "PRE EVENT: Executing Pre Event Script..." > $TTY  
             echo "PRE EVENT: Executing Pre Event Script..." >> $LOGFILE  
 
             pre_event_script # USER DEFINED FUNCTION!!!  
             RC=$?  
             if (( "RC" == 0 ))  
             then  
                  echo "SUCCESS: Pre Event Script Completed RC - ${RC}"\  
                        > $TTY  
                  echo "SUCCESS: Pre Event Script Completed RC - ${RC}"\  
                        >> $LOGFILE  
             else  
                  echo "FAILURE: Pre Event Script FAILED RC - ${RC}"\  
                        > $TTY  
                  echo "FAILURE: Pre Event Script FAILED RC - ${RC}"\  
                        >> $LOGFILE  
             fi  
          fi  
 
          echo "WAITING: Waiting for $PROCESS to startup...Monitoring..."  
 
          integer PROC_COUNT='-1' # Initialize to a fake value  
 
          # Loop until at least one process starts  
 
          until (( "PROC_COUNT" > 0 ))  
          do  
               # This is a Co-Process. This checks to see if a "Program  
               # Interrupt" has taken place. If so BREAK will be 'Y' and  
               # we exit both the loop and function  
 
               read BREAK  
               if [[ $BREAK = 'Y' ]]  
               then  
                     return 3  
               fi  
               PROC_COUNT=$(ps -ef | grep -v "grep $PROCESS" \  
                     | grep -v $SCRIPT_NAME | grep $PROCESS | wc -l) \  
                       >/dev/null 2>&1  
 
               sleep $INTERVAL # Needed to reduce CPU load!  
          done  
 
          RUN='Y' # Turn the RUN Flag On  
 
          TIMESTAMP=$(date +%D@%T)  
 
          PID_LIST=$(ps -ef | grep -v "grep $PROCESS" \  
                     | grep -v $SCRIPT_NAME \  
                     | grep $PROCESS | awk '{print $2}')  
 
          if (( "PROC_COUNT" == 1 ))  
          then  
               echo "START PROCESS: $PROCESS START time ==>\  
 $TIMESTAMP" >> $LOGFILE &  
               echo ACTIVE PIDS: $PID_LIST >> $LOGFILE &  
               echo "START PROCESS: $PROCESS START time ==>\  
 $TIMESTAMP" > $TTY  
               echo ACTIVE PIDS: $PID_LIST > $TTY  
          elif (( "PROC_COUNT" > 1 ))  
          then  
               echo "START PROCESS: $PROC_COUNT $PROCESS \  
Processes Started: START time ==> $TIMESTAMP" >> $LOGFILE &  
               echo ACTIVE PIDS: $PID_LIST >> $LOGFILE &  
               echo "START PROCESS: $PROC_COUNT $PROCESS \  
Processes Started: START time ==> $TIMESTAMP" > $TTY  
               echo ACTIVE PIDS: $PID_LIST > $TTY  
          fi  
     ;;  
   esac  
done  
}  
 
####################################################  
############## START OF MAIN #######################  
####################################################  
 
### SET A TRAP ####  
 
trap 'BREAK='Y';print -p $BREAK 2>/dev/null;trap_exit\  
 2>/dev/null;exit 0' 1 2 3 15  
 
BREAK='N' # The BREAK variable is used in the co-process proc_watch  
PROCESS=  
PROCESS_ID=$$  
integer TOTAL_SECONDS=0  
 
# Check commnand line arguments  
 
if (( $# > 10 || $# < 2 ))  
then  
     usage  
     exit 1  
fi  
 
# Check to see if only the seconds and a process are  
# the only arguments  
 
if [[ ($# -eq 2) && ($1 != -*) && ($2 != -*) ]]  
then  
     NUM_TEST=$(test_string $1)  
     if [[ "$NUM_TEST" = 'POS_INT' ]]  
     then  
          TOTAL_SECONDS=$1  
          PROCESS=$2  
     else  
          usage  
          exit 1  
     fi  
else  
     # Since getopts does not care what arguments it gets lets   
     # do a quick sanity check to make sure that we only have  
     # between 2 and 10 arguments and the first one must start  
     # with a -* (hyphen and anything), else usage error  
 
     case "$#" in  
     [2-10]) if [[ $1 != -* ]]; then  
                 usage; exit 1  
             fi  
          ;;  
     esac  
 
     HOURS=0   # Initialize all to zero  
     MINUTES=0  
     SECS=0  
     DAYS=0  
 
     # Use getopts to parse the command line arguments  
 
     # For each $OPTARG for DAYS, HOURS, MINUTES and DAYS check to see  
     # that each one is an integer by using the check_string function  
 
     while getopts ":h:H:m:M:s:S:d:D:P:p:" TIMED 2>/dev/null  
     do  
       case $TIMED in  
       h|H) [[ $(test_string $OPTARG) != 'POS_INT' ]] && usage && exit 1  
            (( HOURS = $OPTARG * 3600 )) # 3600 seconds per hour  
            ;;  
       m|H) [[ $(test_string $OPTARG) != 'POS_INT' ]] && usage && exit 1  
            (( MINUTES = $OPTARG * 60 )) # 60 seconds per minute  
            ;;  
       s|S) [[ $(test_string $OPTARG) != 'POS_INT' ]] && usage && exit 1  
            SECS="$OPTARG"            # seconds are seconds  
            ;;  
       d|D) [[ $(test_string $OPTARG) != 'POS_INT' ]] && usage && exit 1  
            (( DAYS = $OPTARG * 86400 )) # 86400 seconds per day  
            ;;  
       p|P) PROCESS=$OPTARG              # process can be anything  
            ;;  
        \?) usage                        # USAGE ERROR  
            exit 1  
            ;;  
         :) usage  
            exit 1  
            ;;  
         *) usage  
            exit 1  
            ;;  
       esac  
     done  
fi  
 
# We need to make sure that we have a process - sanity check  
 
if [[ -z "$PROCESS" || "$PROCESS" = '' ]]  
then  
     usage  
     exit 1  
fi  
 
# Check to see that TOTAL_SECONDS was not previously set  
 
if (( TOTAL_SECONDS == 0 ))  
then  
     # Add everything together if anything is > 0  
 
     if [[ $SECS -gt 0 || $MINUTES -gt 0 || $HOURS -gt 0 \  
                          || $DAYS -gt 0 ]]  
     then  
          (( TOTAL_SECONDS = SECS + MINUTES + HOURS + DAYS ))  
     fi  
          SECONDS_LEFT=$TOTAL_SECONDS # Set the countdown varaible...  
 
fi  
 
# Last Sanity Check!  
 
if (( TOTAL_SECONDS <= 0 )) || [ -z $PROCESS ]  
then  
     # Either There are No Seconds to Count or the  
     # $PROCESS Variable is Null...USAGE ERROR...  
 
     usage  
     exit 1  
fi  
 
echo "\nCurrently running $PROCESS processes:\n" > $TTY  
ps -ef | grep -v "grep $PROCESS" | grep -v $SCRIPT_NAME \  
       | grep $PROCESS > $TTY  
 
PROC_RC=$? # Get the initial state of the monitored function  
 
echo >$TTY # Send a blank line to the screen  
 
(( PROC_RC != 0 )) && echo "\nThere are no $PROCESS processes running\n"  
 
if (( PROC_RC == 0 )) # The Target Process(es) is/are running...  
then  
     RUN='Y' # Set the RUN flag to true, or yes.  
 
     integer PROC_COUNT # Strips out the "padding" for display  
 
     PROC_COUNT=$(ps -ef | grep -v "grep $PROCESS" | grep -v \  
                  $SCRIPT_NAME | grep $PROCESS | wc -l) >/dev/null 2>&1  
     if (( PROC_COUNT == 1 ))  
     then  
          echo "The $PROCESS process is currently running...Monitoring...\n"  
     elif (( PROC_COUNT > 1 ))  
     then  
          print "There are $PROC_COUNT $PROCESS processes currently running\  
...Monitoring...\n"  
     fi  
else  
     echo "The $PROCESS process is not currently\  running...monitoring..."  
     RUN='N' # Set the RUN flag to false, or no.  
fi  
 
TIMESTAMP=$(date +%D@%T) # Time that this script started monitoring  
 
# Get a list of the currently active process IDs  
 
PID_LIST=$(ps -ef | grep -v "grep $PROCESS" \  
                  | grep -v $SCRIPT_NAME  \  
                  | grep $PROCESS | awk '{print $2}')  
 
echo "MON_STARTED: Monitoring for $PROCESS began ==> $TIMESTAMP" \  
      | tee -a $LOGFILE  
echo ACTIVE PIDS: $PID_LIST | tee -a $LOGFILE  
 
 
proc_watch |&  # Create a Background Co-Process!!  
WATCH_PID=$!   # Get the process of the last background job!  
 
# Start the Count Down!  
 
integer SECONDS_LEFT=$TOTAL_SECONDS  
 
while (( SECONDS_LEFT > 0 ))  
do  
     print -p $BREAK 2>/dev/null  
 
     (( SECONDS_LEFT = SECONDS_LEFT - 1 ))  
     sleep 1 # Seconds Countdown  
done  
 
# Finished - Normal Timeout Exit...  
 
TIMESTAMP=$(date +%D@%T) # Get a new time stamp...  
echo "MON_STOPPED: Monitoring for $PROCESS ended ==> $TIMESTAMP\n" \  
      | tee -a $LOGFILE  
 
echo "LOGFILE: All Events are Logged ==> $LOGFILE \n"  
 
# Tell the proc_watch function to break out of the loop and die  
 
BREAK='Y'  
print -p $BREAK 2>/dev/null  
 
kill $WATCH_PID 2>/dev/null  
 
exit 0  
 
# End of Script