Exec shell asynchrone en PHP

J'ai un script PHP qui doit invoquer un script shell mais ne se soucie pas du tout de la sortie. Le script shell effectue un certain nombre d'appels SOAP et est lent à terminer, donc je ne veux pas ralentir la demande PHP pendant qu'il attend une réponse. En fait, la requête PHP devrait pouvoir se terminer sans terminer le processus shell.

Je l' ai regardé dans les différents exec(), shell_exec(), pcntl_fork(), etc. fonctions, mais aucun d'entre eux semblent offrir exactement ce que je veux. (Ou, s'ils le font, je ne sais pas trop comment.) Des suggestions?

S'il "ne se soucie pas de la sortie", ne pourrait-on pas appeler l'exec du script avec l' &arrière-plan du processus?

EDIT - incorporant ce que @ AdamTheHut a commenté à ce post, vous pouvez l'ajouter à un appel à exec:

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

Cela redirigera stdio(en premier >) et stderr( 2>) vers /dev/nullet s'exécutera en arrière-plan.

Il existe d'autres façons de faire la même chose, mais c'est la plus simple à lire.

Une alternative à la double redirection ci-dessus:

" &> /dev/null &"

Je à pour cela, car il commence vraiment à un processus indépendant.

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

Pour tous les utilisateurs de Windows: j'ai trouvé un bon moyen d'exécuter un script PHP asynchrone (en fait, cela fonctionne avec presque tout).

Il est basé sur les commandes popen () et pclose (). Et fonctionne bien à la fois sur Windows et Unix.

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

Code d'origine de: http://php.net/manual/en/function.exec.php#86329

Sous Linux, vous pouvez effectuer les opérations suivantes:

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

Cela exécutera la commande à l'invite de commande, puis renverra simplement le PID, que vous pouvez vérifier pour> 0 pour vous assurer qu'il fonctionne.

Cette question est similaire: PHP a-t-il du filetage?

php-execute-a-background-process a de bonnes suggestions. Je pense que le mien est assez bon, mais je suis partial :)

Sous Linux, vous pouvez démarrer un processus dans un nouveau thread indépendant en ajoutant une esperluette à la fin de la commande

mycommand -someparam somevalue &

Sous Windows, vous pouvez utiliser la commande DOS "start"

start mycommand -someparam somevalue

la bonne façon (!) de le faire est de

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

fork forks, setsid indique au processus en cours de devenir maître (pas de parent), execve indique au processus appelant d'être remplacé par celui appelé. afin que le parent puisse arrêter sans affecter l'enfant.

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

 // parent's stuff
 exit();

J'ai utilisé ça ...

/** 
 * 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 &");
}

(où PHP_PATHest un const défini comme define('PHP_PATH', '/opt/bin/php5')similaire ou similaire)

Il passe des arguments via la ligne de commande. Pour les lire en PHP, voir argv .

La seule façon dont j'ai trouvé que cela fonctionnait vraiment pour moi était:

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

J'ai également trouvé Symfony Process Component utile pour cela.

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

Découvrez comment cela fonctionne dans son référentiel GitHub .

Vous pouvez également exécuter le script PHP en tant que démon ou cronjob :#!/usr/bin/php -q

Utilisez un fifo nommé.

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

Ensuite, chaque fois que vous souhaitez démarrer la tâche longue, écrivez simplement une nouvelle ligne (non bloquante dans le fichier déclencheur.

Tant que votre entrée est inférieure à PIPE_BUFet qu'il s'agit d'une seule write()opération, vous pouvez écrire des arguments dans le fifo et les faire apparaître comme $REPLYdans le script.

sans utiliser la file d'attente, vous pouvez utiliser proc_open()comme ceci:

    $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);