prisch

#!/bin/bash

# Version del script
version="v.1.19"
# Prioridad por defecto es 1
PRI=1
# Por defecto no se lockea nada
lock=0
# Por defecto no hay informacion de log
verbose=0
# Configuración de escritura de errores
salida_error="/dev/stderr"  # Fichero donde se loguearan los errores
flag_errores=1              # 1 para activar el log de errores y 0 para desactivarlo

function log()
{
  salida_log="/dev/stdout"
  if [ "$verbose" -eq 1 ]; then
    echo $(date "+%d/%m/%Y %H:%M:%S: ")"$1" >> $salida_log
  fi
}

function error()
{
  if [ "$flag_errores" -eq 1 ]; then
    echo $(date "+%d/%m/%Y %H:%M:%S")": ($1) $2" >> $salida_error
  fi
}

function help()
{
  echo "Usar $0 [params] -c \"comando\""
  echo ""
  echo "    -l / --lock        Evitar dobles ejecuciones"
  echo "    -L / --load        Abortar ejecucion si la sonda supera una determinada carga"
  echo "    -t / --timeout     Establecer un timeout. Si se supera se mata el proceso"
  echo "    -p / --priority    Establece una prioridad. Va desde 0 (minima prioridad) hasta 2 (maxima prioridad)"
  echo "    -r / --ratio       Numero de ejecuciones para que se ejecute una vez"
  echo "    -v / --verbose     Informacion extendida"
  echo "    -d / --directory   Permite ejecutar todos los scripts de un directorio"
  echo "    -h / --help        Ayuda"
  echo "    -V / --version     Muestra la version actual"
  echo "    -e / --exec        Permite ejecutar eval sobre el argumento dado"
}

function print_version()
{
  echo "priorityScheduler $version"	
}

function lock()
{
  log "[+] Generando lock de $1"
  fileName=$(basename $1)
  lockDir="/tmp/locks"
  mkdir -p ${lockDir}
  if [ "$?" -ne 0 ]; then
    # Error al generar la carpeta de locks
    return -1
  fi

  if [ -f "${lockDir}/${fileName}" ]; then
    PID=$(head -n1 "${lockDir}/${fileName}")
    # El proceso se esta ejecutando?
    ps --pid ${PID} &>/dev/null 2>&1
    if [ "$?" -eq 0 ]; then
      log "[-] Hay un proceso corriendo"
      # Hay un proceso corriendo
      error $1 "Hay un proceso corriendo"
      exit 1
    else
      log "[+] Reiniciando lock"
      unlock $1
    fi
  fi
  
  touch "${lockDir}/${fileName}"
  if [ "$?" -eq 0 ]; then
    # Fichero creado con exito
    log "[+] Fichero de lock creado con exito"
    return 0
  else
    # Error al crear el fichero
    log "[-] Error al generar el fichero de lock"
    error $1 "Error al generar el fichero de lock"
    exit 1
  fi 
}

function setPID()
{
  log "[+] Guardando la PID $2 en el lock $1"
  fileName=$(basename $1)
  lockDir="/tmp/locks"

  if [ ! -f "${lockDir}/${fileName}" ]; then
    # El fichero no existe
    return 1
  fi

  rm "${lockDir}/${fileName}"
  if [ "$?" -ne 0 ]; then
    # No se ha podido borrar el fichero
    return -1
  fi

  # PID guardado con exito
  echo "$2" > "${lockDir}/${fileName}"
  return 0
}

function unlock()
{
  log "[+] Borrando lock de $1"
  fileName=$(basename $1)
  lockDir="/tmp/locks"

  if [ ! -f "${lockDir}/${fileName}" ]; then
    # El fichero no existe
    return 1
  fi

  rm "${lockDir}/${fileName}"
  if [ "$?" -ne 0 ]; then
    # No se ha podido borrar el fichero
    return -1
  fi

  # Fichero borrado con exito
  return 0
}

function try()
{
  fileName=$(basename $1)
  counterDir="/tmp/counters"

  mkdir -p ${counterDir}
  if [ "$?" -ne 0 ]; then
    # Error al generar la carpeta de contadores
    log "[-] Error al generar la carpeta de contadores"
    error $1 "Error al generar la carpeta de contadores"
    exit -1
  fi

  if [ ! -f "${counterDir}/${fileName}" ]; then
    log "[-] Actualmente no existe el fichero de contador"
    echo -n "1" > "${counterDir}/${fileName}"
  fi

  if [ "$?" -ne 0 ]; then
      log "[-] Error al generar el fichero de contador"
      error $1 "Error al generar el fichero de contador"
      exit -1
  fi

  count=$(cat ${counterDir}/${fileName} | awk '($1 ~ /[0-9]+/){print $1}')
  if [ ! -n "$count" ]; then
    log "[-] El fichero contador esta corrupto"
    echo -n "2" > "${counterDir}/${fileName}"
    if [ "$?" -eq 0 ]; then
      # Fichero creado con exito
      log "[+] Fichero de contador restablecido con exito"
      return 1
    else
      # Error al crear el fichero
      log "[-] Error al generar el fichero de contador"
      error $1 "Error al generar el fichero de contador"
      exit -1
    fi 
  fi
  log "[+] Fichero de contador leido con exito"
  echo -n "$((count+1))" > "${counterDir}/${fileName}"
  if [ "$?" -eq 0 ]; then
    # Fichero creado con exito
    log "[+] Fichero de contador actualizado con exito"
  else
    # Error al crear el fichero
    log "[-] Error al actualizar el fichero de contador"
    error $1 "Error al actualizar el fichero de contador"
    exit -1
  fi 
  return $count

}

function rmTry()
{
  fileName=$(basename $1)
  counterDir="/tmp/counters"
  echo -n "1" > ${counterDir}/${fileName}
  if [ "$?" -ne 0 ]; then
    log "[-] Error al resetear el fichero contador"
    error $1 "Error al resetear el fichero contador"
    exit -1
  fi
}

function parallelBackgroundLock()
{
    preCMD=$1
    timeoutCMD=$2
    script=$3
    lock $(echo $script | awk '{print $1}')
    log "[+] Ejecutando: ${preCMD}${timeoutCMD}${script}"
    ${preCMD}${timeoutCMD}${script} &
    PID=$!
    setPID $(echo $script | awk '{print $1}') ${PID}
    wait
    unlock $(echo $script | awk '{print $1}')
}

function processLock()
{
    preCMD=$1
    timeoutCMD=$2
    script=$3
    args=$4
    lock $(echo $script | awk '{print $1}')
    log "[+] Ejecutando: ${preCMD}${timeoutCMD}${script}${args}"
    eval "(${preCMD}${timeoutCMD}${script}${args}) &"
    PID=$!
    setPID $(echo $script | awk '{print $1}') ${PID}
    wait ${PID}
    unlock $(echo $script | awk '{print $1}')
}

if [[ "$#" -lt 1 ]]; then
  help
  exit 1
fi

while [[ "$#" -gt 0 ]]; do case $1 in
  -L|--load) load="$2"; shift;;
  -l|--lock) lock=1;;
  -v|--verbose) verbose=1;;
  -c|--cmd) cmd="$2"; shift;;
  -p|--priority) PRI="$2"; shift;;
  -t|--timeout) timeout="$2"; shift;;
  -r|--ratio) ratio="$2"; shift;;
  -d|--directory) directory="$2"; shift;;
  -h|--help) verbose=1; help; exit 1;;
  -V|--version) print_version; exit 1;;
  -e|--exec) evalArg="$2"; shift;;
  *) log "[-] Parametro desconocido: $1"; help; exit 1;;
esac; shift; done

if [ -n "$load" ]; then
  log "[+] Carga maxima establecida en ${load}"
  cargaSonda=$(uptime | gawk -v maxLoad=${load} '{gsub(",",".",$0); if(match($0,/[0-9]{1,4}\.[0-9]{1,4}/,m)) {print m[0]} if (m[0] > maxLoad){exit 1}else{exit 0}}')
  if [ "$?" -eq 1 ]; then
    log "[-] La sonda esta cargada. Abortando.."
    exit 1
  fi
fi

if [ -n "$ratio" ]; then
  contador=$(try $(echo $cmd | awk '{print $1}'))
  n=$?
  if [ "$n" -lt "${ratio}" ]; then
    log "[-] Abortando: Intento $n de $ratio intentos necesarios"
    exit -1
  else
    rmTry $(echo $cmd | awk '{print $1}')
  fi
fi

if [ "$PRI" -eq 0 ]; then
  preCMD="ionice -c3 nice -n19 "
elif [ "$PRI" -eq 1 ]; then
  preCMD=""
elif [ "$PRI" -eq 2 ]; then
  preCMD="nice -n15 "
else
  log "[-] Prioridad no soportada. Abortando.."
  exit 1
fi

if [ -n "$timeout" ]; then
  timeoutCMD="timeout $timeout "
fi

if [ ! -z "$evalArg" ]; then
  log "[+] Ejecutando ${evalArg}"
  eval "(${evalArg})"
fi

if [ -n "$directory" ]; then
  if ! [ -z "$cmd" ]; then
    log "[-] La directiva -d / --directory no es compatible con -c / --cmd"
    exit 1
  fi

  # Se quieren ejecutar todos los scripts de un directorio
  for script in ${directory}/*
  do
    if ! [ -x ${script} ]; then
      log "[-] ${script} no existe o no es ejecutable"
      error $script "No existe o no es ejecutable"
    else
      if [ "$lock" -eq 1 ]; then
        parallelBackgroundLock "${preCMD}" "${timeoutCMD}" "${script}" &
      else
        log "[+] Ejecutando: ${preCMD}${timeoutCMD}${script}"
        ${preCMD}${timeoutCMD}${script} &
      fi
    fi
  done

else

  # Capturamos los argumentos y el comando
  args=$(echo $cmd | awk '{$1="";print $0}')
  cmd=$(echo $cmd | awk '{print $1}')

  # Es una ejecucion de un unico script
  if ! [ -x ${cmd} ]; then
    log "[-] ${cmd} no existe o no es ejecutable"
    error $cmd "No existe o no es ejecutable"
    exit 1
  fi

  if [ "$lock" -eq 1 ]; then
    processLock "${preCMD}" "${timeoutCMD}" "${cmd}" "${args}"
  else
    log "[+] Ejecutando: ${preCMD}${timeoutCMD}${cmd}${args}"
    eval "(${preCMD}${timeoutCMD}${cmd}${args})"
  fi
fi

wait