bash - programas - scripts linux ejercicios resueltos

script bash para verificar el proceso en ejecución

Question

Esta pregunta ya tiene una respuesta aquí:

• Script de Linux para verificar si el proceso se está ejecutando y actuar sobre el resultado 4 respuestas

Escribí un script bash para verificar si un proceso se está ejecutando. No funciona, ya que el comando ps siempre devuelve el código de salida 1. Cuando ejecuto el comando ps desde la línea de comandos, el $? está configurado correctamente, pero dentro del script siempre es 1. ¿Alguna idea?

#!/bin/bash
SERVICE=$1

ps -a | grep -v grep | grep $1 > /dev/null
result=$?
echo "exit code: ${result}"
if [ "${result}" -eq "0" ] ; then
    echo "`date`: $SERVICE service running, everything is fine"
else
    echo "`date`: $SERVICE is not running"
fi

Versión Bash: GNU bash, versión 3.2.25 (1) - liberación (x86_64-redhat-linux-gnu)

Answer 1

A pesar de cierto éxito con el enfoque / dev / null en bash. Cuando presioné la solución para cron, falló. Sin embargo, comprobar el tamaño de un comando devuelto funcionó perfectamente. El ampersrand permite a bash salir.

#!/bin/bash
SERVICE=/path/to/my/service
result=$(ps ax|grep -v grep|grep $SERVICE)
echo ${#result}
if  ${#result}> 0 
then
        echo " Working!"
else
        echo "Not Working.....Restarting"
        /usr/bin/xvfb-run -a /opt/python27/bin/python2.7 SERVICE &
fi

Answer 2

Debo hacer esto de vez en cuando y terminar pirateando la línea de comandos hasta que funcione.

Por ejemplo, aquí quiero ver si tengo alguna conexión SSH, (la octava columna devuelta por "ps" es la "ruta-a-nombre-de-proceso" en ejecución y está filtrada por "awk":

ps | awk -e ''{ print $8 }'' | grep ssh | sed -e ''s/.*////g''

Luego lo puse en un script de shell, ("eval" -ing la línea de comando dentro de los backticks), así:

#!/bin/bash

VNC_STRING=`ps | awk -e ''{ print $8 }'' | grep vnc | sed -e ''s/.*////g''`

if [ ! -z "$VNC_STRING" ]; then
    echo "The VNC STRING is not empty, therefore your process is running."
fi

La parte "sed" recorta el camino al token exacto y puede que no sea necesario para sus necesidades.

Aquí está mi ejemplo. Solía ​​obtener su respuesta. Lo escribí para crear automáticamente 2 túneles SSH y lanzar un cliente VNC para cada uno.

Lo ejecuto desde mi shell Cygwin para hacer el administrador en mi backend desde mi estación de trabajo de windows, así que puedo saltar a UNIX / LINUX-land con un comando, (esto también asume que las claves rsa del cliente ya han sido "ssh-copy-id" -ed y son conocidos por el host remoto).

Es idempotente en que cada comando / proceso solo se dispara cuando sus $ VAR eval a una cadena vacía.

Agrega "| wc -l" para almacenar el número de procs en ejecución que coinciden, (es decir, el número de líneas encontradas), en lugar de proc-name para cada $ VAR para satisfacer mis necesidades. Guardo las declaraciones de "eco" para poder volver a ejecutar y diagnosticar el estado de ambas conexiones.

#!/bin/bash

SSH_COUNT=`eval ps | awk -e ''{ print $8 }'' | grep ssh | sed -e ''s/.*////g'' | wc -l`
VNC_COUNT=`eval ps | awk -e ''{ print $8 }'' | grep vnc | sed -e ''s/.*////g'' | wc -l`

if  [ $SSH_COUNT = "2" ]; then
    echo "There are already 2 SSH tunnels."
elif  [ $SSH_COUNT = "1" ]; then
    echo "There is only 1 SSH tunnel."
elif [ $SSH_COUNT = "0" ]; then
    echo "connecting 2 SSH tunnels."
    ssh -L 5901:localhost:5901 -f -l USER1 HOST1 sleep 10;
    ssh -L 5904:localhost:5904 -f -l USER2 HOST2 sleep 10;
fi

if  [ $VNC_COUNT = "2" ]; then
    echo "There are already 2 VNC sessions."
elif  [ $VNC_COUNT = "1" ]; then
    echo "There is only 1 VNC session."
elif [ $VNC_COUNT = "0" ]; then
    echo "launching 2 vnc sessions."
    vncviewer.exe localhost:1 &
    vncviewer.exe localhost:4 &
fi

Esto es muy similar a mí y posiblemente más utilidades de Unix que el verdadero script de shell. Sé que hay muchos números "MAGIC" y cheezy hard-coded values ​​pero funciona, (creo que también soy de mal gusto para usar tanto UPPERCASE). Se puede agregar flexibilidad con algunos args de línea de cmd para hacer esto más versátil, pero quería compartir lo que funcionó para mí. Por favor, mejora y comparte. Aclamaciones.

Answer 3

Encontré el problema. ps -ae en cambio ps-funciona.

Supongo que tiene que ver con mis derechos en el entorno de alojamiento compartido. Aparentemente hay una diferencia entre ejecutar "ps -a" desde la línea de comando y ejecutarlo desde dentro de un bash-script.

Answer 4

Esas son sugerencias útiles. Solo necesitaba saber si un servicio se estaba ejecutando cuando comencé el script, para poder dejar el servicio en el mismo estado cuando me fui. Terminé usando esto:

   HTTPDSERVICE=$(ps -A | grep httpd | head -1)

   [ -z "$HTTPDSERVICE" ] &&  echo "No apache service running." 

Answer 5

Este truco funciona para mí. Espero que esto pueda ayudarte. Guardemos los siguientes como checkRunningProcess.sh

#!/bin/bash
ps_out=`ps -ef | grep $1 | grep -v ''grep'' | grep -v $0`
result=$(echo $ps_out | grep "$1")
if [[ "$result" != "" ]];then
    echo "Running"
else
    echo "Not Running"
fi

Haga el ejecutable checkRunningProcess.sh.Y luego úselo.
Ejemplo de uso.

20:10 $ checkRunningProcess.sh proxy.py
Running
20:12 $ checkRunningProcess.sh abcdef
Not Running

Answer 6

Hay algunos métodos realmente simples:

pgrep procname && echo Running 
pgrep procname || echo Not running 
killall -q -0 procname && echo Running 
pidof procname && echo Running

Answer 7

Intenté su versión en BASH versión 3.2.29, funcionó bien. Sin embargo, puedes hacer algo como lo sugerido anteriormente, un ejemplo aquí:

#!/bin/sh

SERVICE="$1"
RESULT=`ps -a | sed -n /${SERVICE}/p`

if [ "${RESULT:-null}" = null ]; then
    echo "not running"
else
    echo "running"
fi

Answer 8

La comprobación más simple por nombre de proceso:

 bash -c ''checkproc ssh.exe ; while  [ $? -eq 0  ] ; do  echo "proc running";sleep 10; checkproc ssh.exe; done''

Answer 9

Me preguntaba si sería una buena idea tener intentos progresivos en un proceso, por lo que le pasas a esta función un nombre de proceso func_terminate_process "firefox" y primero calienta las cosas más bien, luego pasa a matar.

# -- NICE: try to use killall to stop process(s)
killall ${1} > /dev/null 2>&1 ;sleep 10

# -- if we do not see the process, just end the function
pgrep ${1} > /dev/null 2>&1 || return

# -- UGLY: Step trough every pid and use kill -9 on them individually
for PID in $(pidof ${1}) ;do

    echo "Terminating Process: [${1}], PID [${PID}]" 
    kill -9 ${PID} ;sleep 10

    # -- NASTY: If kill -9 fails, try SIGTERM on PID
    if ps -p ${PID} > /dev/null ;then
        echo "${PID} is still running, forcefully terminating with SIGTERM"
        kill -SIGTERM ${PID}  ;sleep 10
    fi

done

# -- If after all that, we still see the process, report that to the screen.
pgrep ${1} > /dev/null 2>&1 && echo "Error, unable to terminate all or any of [${1}]" || echo "Terminate process [${1}] : SUCCESSFUL"

Answer 10

Trabajando uno.

!/bin/bash CHECK=$0 SERVICE=$1 DATE=`date` OUTPUT=$(ps aux | grep -v grep | grep -v $CHECK |grep $1) echo $OUTPUT if [ "${#OUTPUT}" -gt 0 ] ; then echo "$DATE: $SERVICE service running, everything is fine" else echo "$DATE: $SERVICE is not running" fi

Answer 11

Una solución con service y awk que service una lista de nombres de servicio delimitada por comas.

Primero, probablemente sea una buena apuesta que necesitarás privilegios de root para hacer lo que quieras. Si no necesita verificar, puede eliminar esa parte.

#!/usr/bin/env bash

# First parameter is a comma-delimited string of service names i.e. service1,service2,service3
SERVICES=$1

ALL_SERVICES_STARTED=true

if [ $EUID -ne 0 ]; then
  if [ "$(id -u)" != "0" ]; then
    echo "root privileges are required" 1>&2
    exit 1
  fi
  exit 1
fi

for service in ${SERVICES//,/ }
do
    STATUS=$(service ${service} status | awk ''{print $2}'')

    if [ "${STATUS}" != "started" ]; then
        echo "${service} not started"
        ALL_SERVICES_STARTED=false
    fi
done

if ${ALL_SERVICES_STARTED} ; then
    echo "All services started"
    exit 0
else
    echo "Check Failed"
    exit 1
fi

Answer 12

Una versión de script simple de una de las sugerencias anteriores de Andor:

!/bin/bash

pgrep $1 && echo Running

Si el script anterior se llama test.sh, entonces, para probar, escriba: test.sh NameOfProcessToCheck

por ejemplo test.sh php

Answer 13

Utilizo este para verificar que cada 10 segundos el proceso se esté ejecutando y comience si no y permite múltiples argumentos:

#!/bin/sh

PROCESS="$1"
PROCANDARGS=$*

while :
do
    RESULT=`pgrep ${PROCESS}`

    if [ "${RESULT:-null}" = null ]; then
            echo "${PROCESS} not running, starting "$PROCANDARGS
            $PROCANDARGS &
    else
            echo "running"
    fi
    sleep 10
done    

Answer 14

Verifica si el nombre de tus scripts no contiene $ SERVICE. Si lo hace, se mostrará en los resultados de ps, haciendo que el script siempre piense que el servicio se está ejecutando. Puedes grep contra el nombre de archivo actual de esta manera:

#!/bin/sh
SERVICE=$1
if ps ax | grep -v grep | grep -v $0 | grep $SERVICE > /dev/null
then
    echo "$SERVICE service running, everything is fine"
else
    echo "$SERVICE is not running"
fi

Answer 15

#!/bin/bash ps axho comm| grep $1 > /dev/null result=$? echo "exit code: ${result}" if [ "${result}" -eq "0" ] ; then echo "`date`: $SERVICE service running, everything is fine" else echo "`date`: $SERVICE is not running" /etc/init.d/$1 restart fi

Algo como esto