integ/tools/engtools/hostdata-collectors/scripts/engtools_util.sh

#!/bin/bash
TOOLNAME=$(basename $0)
PIDFILE=/var/run/${TOOLNAME}.pid
TOOL_DEBUG=1
TOOL_EXIT_SIGNAL=0
TOOL_USR1_SIGNAL=0
TOOL_USR2_SIGNAL=0
TOOL_TTY=0
if tty 1>/dev/null ; then
  TOOL_TTY=1
fi

# [ JGAULD : SHOULD RENAME TO TOOL_X ]
OPT_USE_INTERVALS=0
OPT_FOREVER=0
PERIOD_MIN=5
INTERVAL_SEC=60
CPULIST=0

# Include lsb functions
if [ -d /lib/lsb ]; then
. /lib/lsb/init-functions
else
. /etc/init.d/functions
fi
# Lightweight replacement for pidofproc -p <pid>
function check_pidfile ()
{
  local pidfile pid

  OPTIND=1
  while getopts p: opt ; do
    case "$opt" in
      p)
        pidfile="$OPTARG"
        ;;
    esac
  done
  shift $(($OPTIND - 1))

  read pid < "${pidfile}"
  if [ -n "${pid:-}" ]; then
    if $(kill -0 "${pid:-}" 2> /dev/null); then
      echo "$pid"
      return 0
    elif ps "${pid:-}" >/dev/null 2>&1; then
      echo "$pid"
      return 0 # program is running, but not owned by this user
    else
      return 1 # program is dead and /var/run pid file exists
    fi
  fi
}

# tools_init - initialize tool resources
function tools_init ()
{
  local rc=0
  local error=0
  TOOLNAME=$(basename $0)

  # Check for sufficient priviledges
  if [ $UID -ne 0 ]; then
    ERRLOG "${NAME} requires sudo/root access."
    return 1
  fi

  # Check for essential binaries
  ECHO=$(which echo 2>/dev/null)
  rc=$?
  if [ $rc -ne 0 ]; then
    ECHO=echo   # use bash built-in echo
    ${ECHO} "FATAL, 'echo' not found, rc=$rc";
    error=$rc
  fi
  DATE=$(which date 2>/dev/null)
  rc=$?
  if [ $rc -ne 0 ]; then
    ${ECHO} "FATAL, 'date' not found, rc=$rc";
    error=$rc
  fi

  # Check for standard linux binaries, at least can use LOG functions now
  # - these are used in tools_header
  CAT=$(which cat 2>/dev/null)
  rc=$?
  if [ $rc -ne 0 ]; then
    ERRLOG "'cat' not found, rc=$rc";
    error=$rc
  fi

  ARCH=$(which arch 2>/dev/null)
  rc=$?
  if [ $rc -ne 0 ]; then
    ERRLOG "'arch' not found, rc=$rc";
    error=$rc
  fi

  SED=$(which sed 2>/dev/null)
  rc=$?
  if [ $rc -ne 0 ]; then
    ERRLOG "'sed' not found, rc=$rc";
    error=$rc
  fi

  GREP=$(which grep 2>/dev/null)
  rc=$?
  if [ $rc -ne 0 ]; then
    ERRLOG "'grep' not found, rc=$rc";
    error=$rc
  fi

  WC=$(which wc 2>/dev/null)
  rc=$?
  if [ $rc -ne 0 ]; then
    ERRLOG "'wc' not found, rc=$rc";
    error=$rc
  fi

  UNAME=$(which uname 2>/dev/null)
  rc=$?
  if [ $rc -ne 0 ]; then
    ERRLOG "'uname' not found, rc=$rc";
    error=$rc
  fi

  SORT=$(which sort 2>/dev/null)
  rc=$?
  if [ $rc -ne 0 ]; then
    ERRLOG "'sort' not found, rc=$rc";
    error=$rc
  fi

  TR=$(which tr 2>/dev/null)
  rc=$?
  if [ $rc -ne 0 ]; then
    ERRLOG "'tr' not found, rc=$rc";
    error=$rc
  fi

  AWK=$(which awk 2>/dev/null)
  rc=$?
  if [ $rc -ne 0 ]; then
    ERRLOG "'awk' not found, rc=$rc";
    error=$rc
  fi

  PKILL=$(which pkill 2>/dev/null)
  rc=$?
  if [ $rc -ne 0 ]; then
    ERRLOG "'pkill' not found, rc=$rc";
    error=$rc
  fi

  LS=$(which ls 2>/dev/null)
  rc=$?
  if [ $rc -ne 0 ]; then
    ERRLOG "'ls' not found, rc=$rc";
    error=$rc
  fi

  # The following block is needed for LSB systems such as Windriver Linux.
  # The utility is not available on CentOS so comment it out.
  # Generic utility, but may not be available
  # LSB=$(which lsb_release 2>/dev/null)
  # rc=$?
  # if [ $rc -ne 0 ]; then
  #   WARNLOG "'lsb_release' not found, rc=$rc";
  # fi

  # Let parent program decide what to do with the errors,
  # give ominous warning
  if [ $error -eq 1 ]; then
    WARNLOG "possibly cannot continue, missing linux binaries"
  fi

  # Check if tool was previously running
  if [ -e ${PIDFILE} ]; then
    # [ JGAULD - remove pidofproc() / LSB compatibility issue ]
    if check_pidfile -p "${PIDFILE}" >/dev/null; then
      ERRLOG "${PIDFILE} exists and ${TOOLNAME} is running"
      return 1
    else
      # remove pid file
      WARNLOG "${PIDFILE} exists but ${TOOLNAME} is not running; cleaning up"
      rm -f ${PIDFILE}
    fi
  fi

  # Create pid file
  echo $$ > ${PIDFILE}

  # Setup trap handler - these signals trigger child shutdown and cleanup
  trap tools_exit_handler INT HUP TERM EXIT
  trap tools_usr1_handler USR1
  trap tools_usr2_handler USR2

  return ${rc}
}

# tools_cleanup() - terminate child processes
function tools_cleanup() {
  # restore signal handling to default behaviour
  trap - INT HUP TERM EXIT
  trap - USR1 USR2

  local VERBOSE_OPT=''
  if [ "$1" -ne "0" ]; then
    LOG "cleanup invoked with code: $1"
    if [ ${TOOL_DEBUG} -ne 0 ]; then
      VERBOSE_OPT='-v'
    fi
  fi


  # stop all processes launched from this process
  pkill -TERM -P $$
  if [ "$1" -ne "0" ]; then
    sleep 1
  fi

  # OK, if the above didn't work, use force
  pkill -KILL -P $$

  # remove pid file
  if [ -e ${PIDFILE} ]; then
    rm -f ${VERBOSE_OPT} ${PIDFILE}
  fi
  exit $1
}

# tools_exit_handler() - exit handler routine
function tools_exit_handler() {
  TOOL_EXIT_SIGNAL=1  
  tools_cleanup 128
}
# tools_usr1_handler() - USR1 handler routine
function tools_usr1_handler() {
  TOOL_USR1_SIGNAL=1
  LOG "caught USR1"
}
# tools_usr2_handler() - USR2 handler routine
function tools_usr2_handler() {
  TOOL_USR2_SIGNAL=1
  LOG "caught USR1"
}

# LOG(), WARNLOG(), ERRLOG() - simple print log functions (not logger)
function LOG ()
{
  local tstamp_H=$( date +"%Y-%0m-%0e %H:%M:%S" )
  echo "${tstamp_H} ${HOSTNAME} $0($$): $@";
}
function LOG_NOCR ()
{
  local tstamp_H=$( date +"%Y-%0m-%0e %H:%M:%S" )
  echo -n "${tstamp_H} ${HOSTNAME} $0($$): $@";
}
function WARNLOG () { LOG "WARN $@"; }
function ERRLOG ()  { LOG "ERROR $@"; }

# TOOL_HIRES_TIME() - easily parsed date/timestamp and hi-resolution uptime
function TOOL_HIRES_TIME()
{
  echo "time: " $( ${DATE} +"%a %F %H:%M:%S.%N %Z %z" ) "uptime: " $( cat /proc/uptime )
}

# set_affinity() - set affinity for current script if a a CPULIST is defined
function set_affinity() {
  local CPULIST=$1
  if [ -z "${CPULIST}" ]; then
    return
  fi

  # Set cpu affinity for current program
  local TASKSET=$(which taskset 2>/dev/null)
  if [ -x "${TASKSET}" ]; then
    ${TASKSET} -pc ${CPULIST} $$ 2>/dev/null
  fi
}

# cmd_idle_priority() - command to set nice + ionice
function cmd_idle_priority() {
  local NICE=""
  local IONICE=""

  NICE=$( which nice 2>/dev/null )
  if [ $? -eq 0 ]; then
    NICE="${NICE} -n 19"
  else
    NICE=""
  fi
  IONICE=$( which ionice 2>/dev/null )
  if [ $? -eq 0 ]; then
    IONICE="${IONICE} -c 3"
  else
    IONICE=""
  fi
  echo "${NICE} ${IONICE}"
}


# print_separator() - print a horizontal separation line '\u002d' is '-'
function print_separator () {
  printf '\u002d%.s' {1..80}
  printf '\n'
}

# tools_header() - print out common GenWare tools header
function tools_header() {
  local TOOLNAME=$(basename $0)

  # Get timestamp
  #local tstamp=$( date +"%Y-%0m-%0e %H:%M:%S" 2>/dev/null )
  local tstamp=$( date --rfc-3339=ns | cut -c1-23 2>/dev/null )

  # Linux Generic
  local UPTIME=/proc/uptime

  # Get number of online cpus
  local CPUINFO=/proc/cpuinfo
  local online_cpus=$( cat ${CPUINFO} | grep -i ^processor | wc -l 2>/dev/null )

  # Get load average, run-queue size, and number of threads
  local LOADAVG=/proc/loadavg
  local LDAVG=( `cat ${LOADAVG} | sed -e 's#[/]# #g' 2>/dev/null` )

  # Get current architecture
  local arch=$( uname -m )

  # Determine processor name (there are many different formats... *sigh* )
  # - build up info from multiple lines
  local processor='unk'
  local NAME=$( cat ${CPUINFO} | grep \
    -e '^cpu\W\W:' \
    -e ^'cpu model' \
    -e ^'model name' \
    -e ^'system type' \
    -e ^Processor \
    -e ^[Mm]achine | \
    sort -u | awk 'BEGIN{FS=":";} {print $2;}' | \
    tr '\n' ' ' | tr -s [:blank:] 2>/dev/null )
  if [ ! -z "${NAME}" ]; then
    processor=${NAME}
  fi

  # Determine processor speed (abort grep after first match)
  local speed='unk'
  local BOGO=$( cat ${CPUINFO} | grep -m1 -e ^BogoMIPS -e ^bogomips | \
    awk 'BEGIN{FS=":";} {printf "%.1f", $2;}' 2>/dev/null )
  local MHZ=$( cat  ${CPUINFO} | grep -m1 -e ^'cpu MHz' -e ^clock | \
    awk 'BEGIN{FS=":";} {printf "%.1f", $2;}' 2>/dev/null )
  local MHZ2=$( cat ${CPUINFO} | grep -m1 -e ^Cpu0ClkTck -e ^'cycle frequency' | \
    awk 'BEGIN{FS=":";} {printf "%.1f", $2/1.0E6;}' 2>/dev/null )
  if [ ! -z "${MHZ}" ]; then
    speed=${MHZ}
  elif [ ! -z "${MHZ2}" ]; then
    speed=${MHZ2}
  elif [ ! -z ${BOGO} ]; then
    speed=${BOGO}
  fi

  # Determine OS and kernel version
  local os_name=$( uname -s 2>/dev/null )
  local os_release=$( uname -r 2>/dev/null )

  declare -a arr

  local dist_id=""
  # Determine OS distribution ID
  if [ lsb_pres == "yes" ]; then
     arr=( $( lsb_release -i 2>/dev/null ) )
	 dist_id=${arr[2]}
  else
	local dist_id=$(cat /etc/centos-release | awk '{print $1}' 2>/dev/null)
  fi
  
  local dist_rel=""
  if [ lsb_pres == "yes" ]; then
  # Determine OS distribution release
    arr=( $( cat /proc/version | awk '{print $3}' 2>/dev/null ) )
    local dist_rel=${arr[1]}
  else
    local dist_rel=$(cat /etc/centos-release | awk '{print $4}' 2>/dev/null)
  fi
  # Print generic header
  echo "${TOOLNAME} -- ${tstamp}  load average:${LDAVG[0]}, ${LDAVG[1]}, ${LDAVG[2]}  runq:${LDAVG[3]}  nproc:${LDAVG[4]}"
  echo " host:${HOSTNAME}  Distribution:${dist_id} ${dist_rel}  ${os_name} ${os_release}"
  echo " arch:${arch}  processor:${processor} speed:${speed} MHz  CPUs:${online_cpus}"
}




# tools_usage() - show generic tools tool usage
function tools_usage() {
  if [  ${OPT_USE_INTERVALS} -eq 1 ]; then
    echo "usage: ${TOOLNAME} [-f] [-p <period_mins>] [-i <interval_seconds>] [-c <cpulist>] [-h]"
  else
    echo "Usage: ${TOOLNAME} [-f] [-p <period_mins>] [-c <cpulist>] [-h]"
  fi
}

# tools_print_help() - print generic tool help
function tools_print_help() {
  tools_usage
  echo
  echo "Options:";
  echo " -f                    : collect forever                        : default: none"
  echo " -p <period_minutes>   : overall collection period (minutes)    : default: ${DEFAULT_PERIOD_MIN}"
  if [  ${OPT_USE_INTERVALS} -eq 1 ]; then
    echo " -i <interval_seconds> : sample interval (seconds)              : default: ${DEFAULT_INTERVAL_SEC}"
  fi
  echo " -c <cpulist>          : cpu list where tool runs (e.g., 0-1,8) : default: none"
  echo
  if [  ${OPT_USE_INTERVALS} -eq 1 ]; then
    echo "Example: collect 5 minute period, sample every 30 seconds interval"
    echo " ${TOOLNAME} -p 5 -i 30"
  else
    echo "Example: collect 5 minute period"
    echo " ${TOOLNAME} -p 5"
  fi
}

# tools_parse_options() -- parse common options for tools scripts
function tools_parse_options() {
  # check for no arguments, print usage
  if [ $# -eq "0" ]; then
    tools_usage
    tools_cleanup 0
    exit 0
  fi

  # parse the input arguments
  while getopts "fp:i:c:h" Option
  do
    case $Option in
    f)
      OPT_FOREVER=1
      PERIOD_MIN=60
      ;;
    p) PERIOD_MIN=$OPTARG ;;
    i)
      OPT_USE_INTERVALS=1
      INTERVAL_SEC=$OPTARG
      ;;
    c) CPULIST=$OPTARG ;;
    h)
      tools_print_help
      tools_cleanup 0
      exit 0
      ;;
    *)
      tools_usage
      tools_cleanup 0
      exit 0
      ;;
    esac
  done

  # validate input arguments
  PERIOD_MAX=$[4*24*60]
  INTERVAL_MAX=$[60*60]

  error=0
  if [[ ${PERIOD_MIN} -lt 1 || ${PERIOD_MIN} -gt ${PERIOD_MAX} ]]; then
    echo "-p <period_mid> must be > 0 and <= ${PERIOD_MAX}."
    error=1
  fi
  if [[ ${INTERVAL_SEC} -lt 1 || ${INTERVAL_SEC} -gt ${INTERVAL_MAX} ]]; then
    echo "-i <interval> must be > 0 and <= ${INTERVAL_MAX}."
    error=1
  fi
  if [ ${error} -eq 1 ]; then
    tools_cleanup 0
    exit 1
  fi
}