php - remove - strip_tags()

¿Comprobando si el proceso sigue funcionando?

Question

Como una forma de construir el perro guardián de un hombre pobre y asegurarse de que la aplicación se reinicie en caso de que se bloquee (hasta que descubra por qué), necesito escribir un script PHP CLI que será ejecutado por cron cada 5 millones para verificar si el proceso sigue corriendo

Basado en esta página , probé el siguiente código, pero siempre devuelve Verdadero incluso si lo llamo con datos falsos:

function processExists($file = false) {
    $exists= false;
    $file= $file ? $file : __FILE__;

    // Check if file is in process list
    exec("ps -C $file -o pid=", $pids);
    if (count($pids) > 1) {
    $exists = true;
    }
    return $exists;
}

#if(processExists("lighttpd"))
if(processExists("dummy"))
    print("Exists/n")
else
    print("Doesn''t exist/n");

A continuación, probé este código ...

(exec("ps -A | grep -i ''lighttpd -D'' | grep -v grep", $output);)
print $output;

... pero no obtengas lo que espero

/tmp> ./mycron.phpcli 
Arrayroot:/tmp> 

FWIW, este script se ejecuta con la versión CLI de PHP 5.2.5, y el sistema operativo es uClinux 2.6.19.3.

Gracias por cualquier pista.

Edit: esto parece funcionar bien

exec("ps aux | grep -i ''lighttpd -D'' | grep -v grep", $pids);
if(empty($pids)) {
        print "Lighttpd not running!/n";
} else {
        print "Lighttpd OK/n";
}

Answer 1

El problema principal es que si ejecuta un script php, el comando exec se ejecutará como el usuario de los servidores web (www-data); este usuario no puede ver los pid de otros usuarios, a menos que use "pidof"

<?php
//##########################################
// desc: Diese PHP Script zeig euch ob ein Prozess läuft oder nicht
// autor: seevenup
// version: 1.3
// info: Da das exec kommando als apache user (www-data) ausgefuert
//       wird, muss pidof benutzt werden da es prozesse von
//       anderen usern anzeigen kann
//##########################################

if (!function_exists(''server_status'')) {
        function server_status($string,$name) {
                $pid=exec("pidof $name");
                exec("ps -p $pid", $output);

                if (count($output) > 1) {
                        echo "$string: <font color=''green''><b>RUNNING</b></font><br>";
                }
                else {
                        echo "$string: <font color=''red''><b>DOWN</b></font><br>";
                }
        }
}

//Beispiel "Text zum anzeigen", "Prozess Name auf dem Server"
server_status("Running With Rifles","rwr_server");
server_status("Starbound","starbound_server");
server_status("Minecraft","minecarf");
?>

Más información sobre el script aquí http://umbru.ch/?p=328

Answer 2

No vi esto mencionado aquí, pero aquí hay otro enfoque que saca el segundo grep de la ecuación, lo uso con muchos de mis scripts PHP y debería funcionar de manera universal

exec("ps aux | grep -i ''[l]ighttpd -D''", $pids);
if(empty($pids)) {
        print "Lighttpd not running!/n";
} else {
        print "Lighttpd OK/n";
}

Disfrutar.

Answer 3

Para verificar si el proceso se está ejecutando por su nombre, puede usar pgrep , por ejemplo

$is_running = shell_exec("pgrep -f lighttpd");

o:

exec("pgrep lighttpd", $output, $return);
if ($return == 0) {
    echo "Ok, process is running/n";
}

según este post

Si conoce el PID del proceso, puede usar una de las siguientes funciones:

  /**
   * Checks whether the process is running.
   *
   * @param int $pid Process PID.
   * @return bool
   */
  public static function isProcessRunning($pid) {
    // Calling with 0 kill signal will return true if process is running.
    return posix_kill((int) $pid, 0);
  }

  /**
   * Get the command of the process.
   * For example apache2 in case that''s the Apache process.
   *
   * @param int $pid Process PID.
   * @return string
   */
  public static function getProcessCommand($pid) {
    $pid = (int) $pid;
    return trim(shell_exec("ps o comm= $pid"));
  }

Relacionado: ¿Cómo verificar si el PID especificado se está ejecutando actualmente sin invocar ps desde PHP?

Answer 4

Prueba este

function processExists ($pid) {
    return file_exists("/proc/{$pid}");
}

La función verifica si el archivo de proceso existe en el /proc/ root. Funciona solo para Linux

Answer 5

Puedes probar esto, que combina bits de esos dos enfoques:

function processExists($processName) {
    $exists= false;
    exec("ps -A | grep -i $processName | grep -v grep", $pids);
    if (count($pids) > 0) {
        $exists = true;
    }
    return $exists;
}

Si eso no funciona, puede intentar simplemente ejecutar el comando ps en su sistema y ver qué salida proporciona.

Answer 6

Si lo estás haciendo en php, por qué no usar código php:

En el programa en ejecución:

define(''PIDFILE'', ''/var/run/myfile.pid'');

file_put_contents(PIDFILE, posix_getpid());
function removePidFile() {
    unlink(PIDFILE);
}
register_shutdown_function(''removePidFile'');   

Luego, en el programa de vigilancia, todo lo que necesita hacer es:

function isProcessRunning($pidFile = ''/var/run/myfile.pid'') {
    if (!file_exists($pidFile) || !is_file($pidFile)) return false;
    $pid = file_get_contents($pidFile);
    return posix_kill($pid, 0);
}

Básicamente, posix_kill tiene una señal especial 0 que en realidad no envía una señal al proceso, pero sí verifica si se puede enviar una señal (el proceso se está ejecutando).

Y sí, lo uso con bastante frecuencia cuando necesito procesos php de larga ejecución (o al menos visibles). Normalmente escribo scripts de inicio para iniciar el programa PHP, y luego tengo un cron watchdog para verificar cada hora para ver si se está ejecutando (y si no reiniciarlo) ...

Answer 7

Tengo una función para obtener el pid de un proceso ...

function getRunningPid($processName) {
    $pid = 0;
    $processes = array();
    $command = ''ps ax | grep ''.$processName;
    exec($command, $processes);
    foreach ($processes as $processString) {
        $processArr = explode('' '', trim($processString));
            if (
            (intval($processArr[0]) != getmypid())&&
            (strpos($processString, ''grep ''.$processName) === false)
        ) {
            $pid = intval($processArr[0]);
        }
    }
    return $pid;
}

Answer 8

pgrep para hacer esto (precaución, código no probado):

exec("pgrep lighttpd", $pids);
if(empty($pids)) {

    // lighttpd is not running!
}

Tengo un script de bash que hace algo similar (pero con túneles SSH):

#!/bin/sh

MYSQL_TUNNEL="ssh -f -N -L 33060:127.0.0.1:3306 tunnel@db"
RSYNC_TUNNEL="ssh -f -N -L 8730:127.0.0.1:873 tunnel@db"

# MYSQL
if [ -z `pgrep -f -x "$MYSQL_TUNNEL"` ] 
then
    echo Creating tunnel for MySQL.
    $MYSQL_TUNNEL
fi

# RSYNC
if [ -z `pgrep -f -x "$RSYNC_TUNNEL"` ]
then
    echo Creating tunnel for rsync.
    $RSYNC_TUNNEL
fi

Puede modificar este script con los comandos que desea supervisar.

Answer 9

<?php

function check_if_process_is_running($process)
{
    exec("/bin/pidof $process",$response);
    if ($response)
    {
         return true;
    } else
    {
         return false;
    }
}

if (check_if_process_is_running("mysqld"))
{
      echo "MySQL is running";
} else
{
      echo "Mysql stopped";
}

?>