Asynchrone Shell-Ausführung in PHP

Ich habe ein PHP-Skript, das ein Shell-Skript aufrufen muss, sich aber überhaupt nicht um die Ausgabe kümmert. Das Shell-Skript führt eine Reihe von SOAP-Aufrufen durch und ist langsam abzuschließen. Daher möchte ich die PHP-Anforderung nicht verlangsamen, während sie auf eine Antwort wartet. Tatsächlich sollte die PHP-Anforderung beendet werden können, ohne den Shell-Prozess zu beenden.

Ich habe in den verschiedenen sah exec(), shell_exec(), pcntl_fork()etc. Funktionen, aber keiner von ihnen scheinen genau zu bieten , was ich will. (Oder wenn doch, ist mir nicht klar, wie.) Irgendwelche Vorschläge?

Wenn es "die Ausgabe nicht interessiert", konnte der Exec zum Skript nicht mit dem aufgerufen werden & Hintergrund des Prozesses werden?

BEARBEITEN - Wenn Sie berücksichtigen, was @ AdamTheHut zu diesem Beitrag kommentiert hat, können Sie dies einem Aufruf hinzufügen an exec:

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

Dadurch werden sowohl stdio(first >) als auch stderr( 2>) zum /dev/nullHintergrund umgeleitet und ausgeführt.

Es gibt andere Möglichkeiten, dasselbe zu tun, aber dies ist am einfachsten zu lesen.

Eine Alternative zur obigen Doppelumleitung:

" &> /dev/null &"

Früher habe ich bei dafür, wie es wirklich ist ein unabhängiger Prozess zu starten.

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

An alle Windows-Benutzer: Ich habe eine gute Möglichkeit gefunden, ein asynchrones PHP-Skript auszuführen (eigentlich funktioniert es mit fast allem).

Es basiert auf den Befehlen popen () und pclose (). Und funktioniert sowohl unter Windows als auch unter Unix.

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

Originalcode von: http://php.net/manual/en/function.exec.php#86329

Unter Linux können Sie Folgendes tun:

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

Dadurch wird der Befehl an der Eingabeaufforderung ausgeführt und anschließend einfach die PID zurückgegeben, die Sie auf> 0 prüfen können, um sicherzustellen, dass sie funktioniert.

Diese Frage ist ähnlich: Hat PHP Threading?

Der PHP-Execute-A-Background-Prozess hat einige gute Vorschläge. Ich finde meine ziemlich gut, aber ich bin voreingenommen :)

Unter Linux können Sie einen Prozess in einem neuen unabhängigen Thread starten, indem Sie am Ende des Befehls ein kaufmännisches Und anhängen

mycommand -someparam somevalue &

In Windows können Sie den DOS-Befehl "start" verwenden

start mycommand -someparam somevalue

Der richtige Weg (!) dazu ist

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

Fork Forks, Setsid weisen den aktuellen Prozess an, ein Master-Prozess zu werden (kein übergeordnetes Element). Execve weist den aufrufenden Prozess an, durch den aufgerufenen Prozess ersetzt zu werden. damit der Elternteil kündigen kann, ohne das Kind zu beeinträchtigen.

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

 // parent's stuff
 exit();

Ich habe das benutzt ...

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

(wo PHP_PATHist eine Konstante wie define('PHP_PATH', '/opt/bin/php5')oder ähnlich definiert )

Es werden Argumente über die Befehlszeile übergeben. Informationen zum Lesen in PHP finden Sie unter argv .

Der einzige Weg, den ich fand, der wirklich für mich funktionierte, war:

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

Ich fand auch Symfony Process Component nützlich dafür.

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

Sehen Sie, wie es in seinem GitHub-Repo funktioniert .

Sie können das PHP-Skript auch als Daemon oder Cronjob ausführen :#!/usr/bin/php -q

Verwenden Sie ein benanntes Fifo.

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

Wenn Sie dann die lange laufende Aufgabe starten möchten, schreiben Sie einfach eine neue Zeile (nicht blockierend in die Triggerdatei).

Solange Ihre Eingabe kleiner als PIPE_BUFund eine einzelne write()Operation ist, können Sie Argumente in das FIFO schreiben und sie wie $REPLYim Skript anzeigen lassen .

Ohne Verwendungswarteschlange können Sie Folgendes verwenden proc_open():

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