Processen - Knowledge of Laravel

Inleiding

De Process-facade van Laravel is een dunne wrapper rond de Symfony Process-component. Hij biedt een beknopte API om shellcommando’s vanuit je Laravel-applicatie aan te roepen en de resultaten te verwerken.

Een proces starten

Met Process::run() voer je een commando synchroon uit en haal je het resultaat op.

use Illuminate\Support\Facades\Process;

$result = Process::run('ls -la');

return $result->output();

De ProcessResult-instantie biedt diverse methodes om het resultaat te inspecteren.

$result = Process::run('ls -la');

$result->command();       // Het uitgevoerde commando
$result->successful();    // Geslaagd (exitcode 0)
$result->failed();        // Mislukt (exitcode anders dan 0)
$result->output();        // Standaarduitvoer (stdout)
$result->errorOutput();   // Standaardfoutuitvoer (stderr)
$result->exitCode();      // Exitcode

Een exception gooien bij falen

Om een Illuminate\Process\Exceptions\ProcessFailedException te laten gooien wanneer de exitcode groter is dan 0, gebruik je throw() of throwIf().

$result = Process::run('ls -la')->throw();

$result = Process::run('ls -la')->throwIf($condition);

Procesopties

Werkdirectory

Met path() geef je de werkdirectory op. Laat je die weg, dan wordt de werkdirectory van het huidige PHP-script gebruikt.

$result = Process::path(__DIR__)->run('ls -la');

Standaardinvoer

Met input() geef je data door aan de standaardinvoer van het proces.

$result = Process::input('Hello World')->run('cat');

Timeout

De standaard is 60 seconden. Met timeout() wijzig je die. Bij een timeout wordt het proces afgebroken en wordt een ProcessTimedOutException gegooid.

$result = Process::timeout(120)->run('bash import.sh');

Je kunt ook de CarbonInterval-helperfuncties gebruiken.

use function Illuminate\Support\minutes;

$result = Process::timeout(minutes(2))->run('bash import.sh');

Gebruik forever() om de timeout uit te schakelen.

$result = Process::forever()->run('bash import.sh');

Je kunt ook een idle-timeout instellen (het aantal seconden zonder uitvoer).

$result = Process::timeout(60)->idleTimeout(30)->run('bash import.sh');

Omgevingsvariabelen

Met env() voeg je omgevingsvariabelen toe of overschrijf je ze. De omgevingsvariabelen van het systeem worden automatisch overgenomen.

$result = Process::forever()
    ->env(['IMPORT_PATH' => __DIR__])
    ->run('bash import.sh');

Om een overgenomen variabele uit te sluiten, geef je false op.

$result = Process::forever()
    ->env(['LOAD_PATH' => false])
    ->run('bash import.sh');

Uitvoer uitschakelen

Heb je geen grote hoeveelheden uitvoer nodig, dan beperk je met quietly() het geheugengebruik.

$result = Process::quietly()->run('bash import.sh');

Realtime uitvoer

Geef je een closure door als tweede argument van run(), dan ontvang je de uitvoer in realtime.

$result = Process::run('ls -la', function (string $type, string $output) {
    echo $output;
});

Pipelines

Met Process::pipe() geef je de uitvoer van een commando door als invoer voor het volgende commando.

use Illuminate\Process\Pipe;
use Illuminate\Support\Facades\Process;

$result = Process::pipe(function (Pipe $pipe) {
    $pipe->command('cat example.txt');
    $pipe->command('grep -i "laravel"');
});

if ($result->successful()) {
    // ...
}

Je kunt ook een array van commandostrings doorgeven.

$result = Process::pipe([
    'cat example.txt',
    'grep -i "laravel"',
]);

Geef je elk proces met as() een sleutel, dan kun je in de uitvoerclosure bepalen van welk proces de uitvoer komt.

$result = Process::pipe(function (Pipe $pipe) {
    $pipe->as('first')->command('cat example.txt');
    $pipe->as('second')->command('grep -i "laravel"');
}, function (string $type, string $output, string $key) {
    // $key is 'first' of 'second'
});

Asynchrone processen

Met Process::start() start je een proces asynchroon. Terwijl het proces draait, kan je applicatie andere taken blijven uitvoeren.

$process = Process::timeout(120)->start('bash import.sh');

while ($process->running()) {
    // Andere verwerking
}

$result = $process->wait();

Proces-ID en signalen

Met id() haal je het OS-proces-ID van een lopend proces op.

$process = Process::start('bash import.sh');

return $process->id();

Met signal() stuur je een signaal naar het proces.

$process->signal(SIGUSR2);

Uitvoer van asynchrone processen

Gebruik je tijdens de uitvoering latestOutput() en latestErrorOutput(), dan haal je de nieuwe uitvoer op sinds de vorige keer dat je die ophaalde.

$process = Process::timeout(120)->start('bash import.sh');

while ($process->running()) {
    echo $process->latestOutput();
    echo $process->latestErrorOutput();

    sleep(1);
}

Gebruik waitUntil() om te wachten tot bepaalde uitvoer verschijnt.

$process = Process::start('bash import.sh');

$process->waitUntil(function (string $type, string $output) {
    return $output === 'Ready...';
});

Timeout controleren bij asynchrone processen

Roep je in de lus ensureNotTimedOut() aan, dan wordt een exception gegooid als het proces een timeout heeft bereikt.

$process = Process::timeout(120)->start('bash import.sh');

while ($process->running()) {
    $process->ensureNotTimedOut();

    sleep(1);
}

Gelijktijdige processen

Met Process::pool() voer je meerdere processen gelijktijdig uit.

use Illuminate\Process\Pool;
use Illuminate\Support\Facades\Process;

$pool = Process::pool(function (Pool $pool) {
    $pool->path(__DIR__)->command('bash import-1.sh');
    $pool->path(__DIR__)->command('bash import-2.sh');
    $pool->path(__DIR__)->command('bash import-3.sh');
})->start(function (string $type, string $output, int $key) {
    // ...
});

while ($pool->running()->isNotEmpty()) {
    // ...
}

$results = $pool->wait();

Met concurrently() schrijf je het direct starten van een pool en het wachten op de resultaten in één regel.

[$first, $second, $third] = Process::concurrently(function (Pool $pool) {
    $pool->path(__DIR__)->command('ls -la');
    $pool->path(app_path())->command('ls -la');
    $pool->path(storage_path())->command('ls -la');
});

echo $first->output();

Processen een naam geven

Geef je elk proces met as() een stringsleutel, dan wordt het ophalen van de resultaten duidelijker.

$pool = Process::pool(function (Pool $pool) {
    $pool->as('first')->command('bash import-1.sh');
    $pool->as('second')->command('bash import-2.sh');
    $pool->as('third')->command('bash import-3.sh');
})->start(function (string $type, string $output, string $key) {
    // ...
});

$results = $pool->wait();

return $results['first']->output();

Je kunt ook een signaal naar de hele pool sturen.

$pool->signal(SIGUSR2);

Testen

Processen faken

Met Process::fake() test je zonder daadwerkelijk shellcommando’s uit te voeren.

use Illuminate\Support\Facades\Process;

Process::fake();

$response = $this->get('/import');

Process::assertRan('bash import.sh');

Je kunt ook uitvoer en exitcodes opgeven.

Process::fake([
    '*' => Process::result(
        output: 'Test output',
        errorOutput: 'Test error output',
        exitCode: 1,
    ),
]);

Specifieke commando’s faken

Met wildcards of commandostrings als sleutel kun je fakes per commando instellen.

Process::fake([
    'cat *'    => Process::result(output: 'file contents'),
    'ls -la'   => Process::result(output: 'file listing'),
]);

Sequenties faken

Wanneer hetzelfde commando meerdere keren wordt aangeroepen, kun je de volgorde van de teruggegeven resultaten opgeven.

Process::fake([
    'ls *' => [
        Process::result('first time'),
        Process::result('second time'),
    ],
]);

Assertions

Methode	Beschrijving
`Process::assertRan('command')`	Controleert dat het commando is uitgevoerd
`Process::assertNotRan('command')`	Controleert dat het commando niet is uitgevoerd
`Process::assertRan(fn)`	Controleert de uitvoering in detail met een closure
`Process::assertRanTimes('command', 3)`	Controleert dat het commando het opgegeven aantal keren is uitgevoerd

Onverwachte processen voorkomen

Roep je Process::preventStrayProcesses() aan, dan wordt een exception gegooid wanneer een commando wordt uitgevoerd waarvoor geen fake is ingesteld.

Process::preventStrayProcesses();

Process::fake([
    'ls *' => Process::result('file listing'),
]);

// Exception: voor 'bash import.sh' is geen fake ingesteld
Process::run('bash import.sh');

​Inleiding

​Een proces starten

​Een exception gooien bij falen

​Procesopties

​Werkdirectory

​Standaardinvoer

​Timeout

​Omgevingsvariabelen

​Uitvoer uitschakelen

​Realtime uitvoer

​Pipelines

​Asynchrone processen

​Proces-ID en signalen

​Uitvoer van asynchrone processen

​Timeout controleren bij asynchrone processen

​Gelijktijdige processen

​Processen een naam geven

​Testen

​Processen faken

​Specifieke commando’s faken

​Sequenties faken

​Assertions

​Onverwachte processen voorkomen

​Gerelateerde pagina’s

Artisan-console

Queues