Exec asíncrono de shell en PHP

Tengo un script PHP que necesita invocar un script de shell pero no me importa en absoluto la salida. El script de shell realiza varias llamadas SOAP y tarda en completarse, por lo que no quiero ralentizar la solicitud de PHP mientras espera una respuesta. De hecho, la solicitud de PHP debería poder salir sin terminar el proceso de shell.

He mirado en las diversas exec(), shell_exec(), pcntl_fork(), etc. funciones, pero ninguna de ellas parece ofrecer exactamente lo que quiero. (O, si lo hacen, no me queda claro cómo). ¿Alguna sugerencia?

Si "no le importa la salida", ¿no se podría llamar al ejecutivo del script con &el proceso de fondo?

EDITAR : incorporando lo que @ AdamTheHut comentó en esta publicación, puede agregar esto a una llamada a exec:

" > /dev/null 2>/dev/null &"

Eso redirigirá stdio(primero >) y stderr( 2>) a /dev/nully se ejecutará en segundo plano.

Hay otras formas de hacer lo mismo, pero esta es la más simple de leer.

Una alternativa a la doble redirección anterior:

" &> /dev/null &"

Solía al por esto, ya que está empezando un proceso independiente.

<?php
    `echo "the command"|at now`;
?>

Para todos los usuarios de Windows: encontré una buena manera de ejecutar un script PHP asincrónico (en realidad funciona con casi todo).

Se basa en los comandos popen () y pclose (). Y funciona bien tanto en Windows como en Unix.

function execInBackground($cmd) {
    if (substr(php_uname(), 0, 7) == "Windows"){
        pclose(popen("start /B ". $cmd, "r")); 
    }
    else {
        exec($cmd . " > /dev/null &");  
    }
} 

Código original de: http://php.net/manual/en/function.exec.php#86329

En linux puedes hacer lo siguiente:

$cmd = 'nohup nice -n 10 php -f php/file.php > log/file.log & printf "%u" $!';
$pid = shell_exec($cmd);

Esto ejecutará el comando en el símbolo del sistema y luego solo devolverá el PID, que puede verificar> 0 para asegurarse de que funcionó.

Esta pregunta es similar: ¿PHP tiene subprocesos?

php-execute-a-background-process tiene algunas buenas sugerencias. Creo que el mío es bastante bueno, pero soy parcial :)

En Linux, puede iniciar un proceso en un nuevo hilo independiente agregando un ampersand al final del comando

mycommand -someparam somevalue &

En Windows, puede usar el comando "iniciar" DOS

start mycommand -someparam somevalue

la forma correcta (!) de hacerlo es

1. tenedor()
2. setsid ()
3. execve ()

fork forks, setsid le dice al proceso actual que se convierta en uno maestro (no padre), execve le dice al proceso de llamada que sea reemplazado por el llamado. para que el padre pueda renunciar sin afectar al niño.

 $pid=pcntl_fork();
 if($pid==0)
 {
   posix_setsid();
   pcntl_exec($cmd,$args,$_ENV);
   // child becomes the standalone detached process
 }

 // parent's stuff
 exit();

Usé esto ...

/** 
 * Asynchronously execute/include a PHP file. Does not record the output of the file anywhere.  
 * Relies on the PHP_PATH config constant.
 *
 * @param string $filename  file to execute
 * @param string $options   (optional) arguments to pass to file via the command line
 */ 
function asyncInclude($filename, $options = '') {
    exec(PHP_PATH . " -f {$filename} {$options} >> /dev/null &");
}

(donde PHP_PATHse define una constante como define('PHP_PATH', '/opt/bin/php5')o similar)

Pasa argumentos a través de la línea de comando. Para leerlos en PHP, vea argv .

La única forma en que encontré que realmente funcionó para mí fue:

shell_exec('./myscript.php | at now & disown')

También encontré que Symfony Process Component es útil para esto.

use Symfony\Component\Process\Process;

$process = new Process('ls -lsa');
// ... run process in background
$process->start();

// ... do other things

// ... if you need to wait
$process->wait();

// ... do things after the process has finished

Vea cómo funciona en su repositorio de GitHub .

También puede ejecutar el script PHP como daemon o cronjob :#!/usr/bin/php -q

Use un fifo con nombre.

#!/bin/sh
mkfifo trigger
while true; do
    read < trigger
    long_running_task
done

Luego, cuando desee comenzar la tarea de larga duración, simplemente escriba una nueva línea (sin bloqueo en el archivo desencadenante).

Siempre que su entrada sea menor PIPE_BUFy sea una write()operación única , puede escribir argumentos en el fifo y hacer que aparezcan como $REPLYen el script.

sin cola de uso, puede usar el proc_open()siguiente:

    $descriptorspec = array(
        0 => array("pipe", "r"),
        1 => array("pipe", "w"),
        2 => array("pipe", "w")    //here curaengine log all the info into stderror
    );
    $command = 'ping stackoverflow.com';
    $process = proc_open($command, $descriptorspec, $pipes);