Artisan

Introduzione

Artisan è l’interfaccia a riga di comando inclusa in Laravel. Artisan si trova nella directory principale della tua applicazione come script artisan e offre diversi comandi utili che possono aiutarti mentre sviluppi la tua applicazione. Per visualizzare un elenco di tutti i comandi Artisan disponibili, puoi usare il comando list:

php artisan list

Ogni comando include anche una schermata di "help" che mostra e descrive gli argomenti e le opzioni disponibili del comando. Per visualizzare una schermata di aiuto, anteponi al nome del comando help:

php artisan help migrate

Laravel Sail

Se usi Laravel Sail come ambiente di sviluppo locale, ricorda di usare la linea di comando sail per eseguire i comandi Artisan. Sail eseguirà i tuoi comandi Artisan all’interno dei container Docker della tua applicazione:

./vendor/bin/sail artisan list

Tinker (REPL)

Laravel Tinker è un potente REPL per il framework Laravel, basato sul pacchetto PsySH.

Installazione

Tutte le applicazioni Laravel includono Tinker di default. Tuttavia, puoi installare Tinker usando Composer se lo hai rimosso precedentemente dalla tua applicazione:

composer require laravel/tinker

Cerchi il ricaricamento automatico, la modifica di codice su più linee e l’autocompletamento quando interagisci con la tua applicazione Laravel? Dai un’occhiata a Tinkerwell!

Utilizzo

Tinker ti permette di interagire con l’intera applicazione Laravel dalla riga di comando, inclusi i tuoi modelli Eloquent, job, eventi e altro. Per accedere all’ambiente Tinker, esegui il comando Artisan tinker:

php artisan tinker

Puoi pubblicare il file di configurazione di Tinker usando il comando vendor:publish:

php artisan vendor:publish --provider="Laravel\Tinker\TinkerServiceProvider"

La funzione helper dispatch e il metodo dispatch sulla classe Dispatchable dipendono dalla garbage collection per inserire il job nella coda. Pertanto, quando usi Tinker, dovresti usare Bus::dispatch o Queue::push per dispatchare i job.

Elenco dei Comandi Consentiti

Tinker utilizza una "allow" list per determinare quali comandi Artisan possono essere eseguiti nel suo shell. Per impostazione predefinita, puoi eseguire i comandi clear-compiled, down, env, inspire, migrate, migrate:install, up e optimize. Se desideri consentire ulteriori comandi, puoi aggiungerli all’array commands nel tuo file di configurazione tinker.php:

    'commands' => [
        // App\Console\Commands\ExampleCommand::class,
    ],

Classi che non dovrebbero essere aliasate

Di solito, Tinker alias automaticamente le classi mentre interagisci con esse. Tuttavia, potresti voler non aliasare mai alcune classi. Puoi farlo elencando le classi nell’array dont_alias nel tuo file di configurazione tinker.php:

    'dont_alias' => [
        App\Models\User::class,
    ],

Scrivere Comandi

Oltre ai comandi forniti con Artisan, puoi creare i tuoi comandi personalizzati. I comandi sono solitamente memorizzati nella directory app/Console/Commands; tuttavia, puoi scegliere liberamente un’altra posizione di archiviazione purché i tuoi comandi possano essere caricati da Composer.

Generating Commands

Per creare un nuovo comando, puoi usare il comando Artisan make:command. Questo comando creerà una nuova classe di comando nella directory app/Console/Commands. Non preoccuparti se questa directory non esiste nella tua applicazione: verrà creata la prima volta che esegui il comando Artisan make:command:

php artisan make:command SendEmails

Struttura del Comando

Dopo aver generato il tuo comando, dovresti definire valori appropriati per le proprietà signature e description della classe. Queste proprietà verranno utilizzate quando il tuo comando viene mostrato nella schermata list. La proprietà signature permette anche di definire le aspettative di input del tuo comando. Il metodo handle sarà chiamato quando il comando viene eseguito. Puoi inserire la logica del tuo comando in questo metodo.

Vediamo un esempio di comando. Nota che possiamo richiedere tutte le dipendenze necessarie tramite il metodo handle del comando. Il service container di Laravel inietterà automaticamente tutte le dipendenze specificate nel tipo di parametro di questo metodo:

<?php

namespace App\Console\Commands;

use App\Models\User;
use App\Support\DripEmailer;
use Illuminate\Console\Command;

class SendEmails extends Command
{
    /**
     * Il nome e la signature del comando console.
     *
     * @var string
     */
    protected $signature = 'mail:send {user}';

    /**
     * La descrizione del comando console.
     *
     * @var string
     */
    protected $description = 'Invia un email di marketing a un utente';

    /**
     * Esegui il comando console.
     */
    public function handle(DripEmailer $drip): void
    {
        $drip->send(User::find($this->argument('user')));
    }
}

Per una maggiore riusabilità del codice, è buona pratica mantenere leggeri i comandi console e delegare ai servizi dell’applicazione il compito di completare le loro attività. Nell’esempio sopra, nota che iniettiamo una classe di servizio per gestire il "lavoro pesante" di inviare le email.

Codici di Uscita

Se dal metodo handle non viene restituito nulla e il comando viene eseguito con successo, il comando uscirà con un codice di uscita 0, indicando il successo. Tuttavia, il metodo handle può opzionalmente restituire un intero per specificare manualmente il codice di uscita del comando:

$this->error('Something went wrong.');

return 1;

Se desideri "fallire" il comando da qualsiasi metodo all’interno del comando, puoi utilizzare il metodo fail. Il metodo fail terminerà immediatamente l’esecuzione del comando e restituirà un codice di uscita 1:

$this->fail('Something went wrong.');

Comandi tramite Closure

I comandi basati su closure offrono un’alternativa alla definizione dei comandi della console come classi. Proprio come le closure delle route possono sostituire i controller, le closure dei comandi possono sostituire le classi dei comandi.

Sebbene il file routes/console.php non definisca route HTTP, definisce punti di ingresso basati sulla console (route) nella tua applicazione. All’interno di questo file, puoi definire tutti i tuoi comandi console basati su closure usando il metodo Artisan::command. Il metodo command accetta due argomenti: la firma del comando e una closure che riceve gli argomenti e le opzioni del comando:

Artisan::command('mail:send {user}', function (string $user) {
    $this->info("Sending email to: {$user}!");
});

La closure è legata all’istanza del comando sottostante, così hai pieno accesso a tutti i metodi helper che normalmente potresti usare in una classe di comando completa.

Type-Hinting delle Dipendenze

Oltre a ricevere gli argomenti e le opzioni del comando, le closure dei comandi possono anche type-hintare dipendenze aggiuntive che desideri risolvere dal service container:

use App\Models\User;
use App\Support\DripEmailer;

Artisan::command('mail:send {user}', function (DripEmailer $drip, string $user) {
    $drip->send(User::find($user));
});

Descrizioni dei Comandi con Closure

Quando definisci un comando basato su closure, puoi usare il metodo purpose per aggiungere una descrizione al comando. Questa descrizione verrà mostrata quando esegui i comandi php artisan list o php artisan help:

Artisan::command('mail:send {user}', function (string $user) {
    // ...
})->purpose('Send a marketing email to a user');

Comandi Isolabili

Per utilizzare questa funzionalità, la tua applicazione deve utilizzare uno dei driver di cache memcached, redis, dynamodb, database, file o array come driver di cache predefinito. Inoltre, tutti i server devono comunicare con lo stesso server di cache centrale.

A volte potresti voler assicurarti che solo un’istanza di un comando possa essere eseguita alla volta. Per fare ciò, puoi implementare l’interfaccia Illuminate\Contracts\Console\Isolatable nella tua classe di comando:

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\Contracts\Console\Isolatable;

class SendEmails extends Command implements Isolatable
{
    // ...
}

Quando un comando è contrassegnato come Isolatable, Laravel aggiungerà automaticamente un’opzione --isolated al comando. Quando il comando viene invocato con questa opzione, Laravel garantirà che non ci siano altre istanze dello stesso comando in esecuzione. Laravel ottiene questo cercando di acquisire un lock atomico utilizzando il driver di cache predefinito dell’applicazione. Se altre istanze del comando sono in esecuzione, il comando non verrà eseguito; tuttavia, uscirà comunque con un codice di stato di uscita di successo:

php artisan mail:send 1 --isolated

Se desideri specificare il codice di stato di uscita che il comando dovrebbe restituire se non riesce a eseguire, puoi fornire il codice di stato desiderato tramite l’opzione isolated:

php artisan mail:send 1 --isolated=12

Lock ID

Di default, Laravel utilizzerà il nome del comando per generare la chiave stringa usata per acquisire il lock atomico nella cache della tua applicazione. Tuttavia, puoi personalizzare questa chiave definendo un metodo isolatableId nella classe del tuo comando Artisan, permettendoti di integrare gli argomenti o le opzioni del comando nella chiave:

/**
 * Ottieni l'ID isolabile per il comando.
 */
public function isolatableId(): string
{
    return $this->argument('user');
}

Tempo di Scadenza del Lock

Per impostazione predefinita, i lock di isolamento scadono dopo che il comando è terminato. Se il comando viene interrotto e non riesce a finire, il lock scade dopo un’ora. Tuttavia, puoi modificare il tempo di scadenza del lock definendo un metodo isolationLockExpiresAt nel tuo comando:

use DateTimeInterface;
use DateInterval;

/**
 * Determina quando un lock di isolamento scade per il comando.
 */
public function isolationLockExpiresAt(): DateTimeInterface|DateInterval
{
    return now()->addMinutes(5);
}

Definire le aspettative di input

Quando si scrivono comandi console, è comune ottenere input dall’utente tramite argomenti o opzioni. Laravel facilita la definizione dell’input previsto usando la proprietà signature nei comandi. La proprietà signature ti permette di definire il nome, gli argomenti e le opzioni del comando in un’unica sintassi espressiva, simile a quella delle route.

Argomenti

Tutti gli argomenti e le opzioni forniti dall’utente sono racchiusi tra parentesi graffe. Nell’esempio seguente, il comando definisce un argomento obbligatorio: user:

/**
 * Il nome e la firma del comando della console.
 *
 * @var string
 */
protected $signature = 'mail:send {user}';

È anche possibile rendere opzionali gli argomenti o definire valori predefiniti per gli argomenti:

// Argomento opzionale...
'mail:send {user?}'

// Argomento opzionale con valore predefinito...
'mail:send {user=foo}'

Opzioni

Le opzioni, come gli argomenti, sono un’altra forma di input dell’utente. Le opzioni sono prefissate da due trattini (--) quando sono fornite tramite la linea di comando. Esistono due tipi di opzioni: quelle che ricevono un valore e quelle che non lo ricevono. Le opzioni che non ricevono un valore funzionano come uno switch booleano. Vediamo un esempio di questo tipo di opzione:

    /**
     * Il nome e la firma del comando della console.
     *
     * @var string
     */
    protected $signature = 'mail:send {user} {--queue}';

In questo esempio, lo switch --queue può essere specificato quando si chiama il comando Artisan. Se lo switch --queue viene passato, il valore dell’opzione sarà true. Altrimenti, il valore sarà false:

php artisan mail:send 1 --queue

Opzioni con valori

Vediamo ora un’opzione che richiede un valore. Se l’utente deve specificare un valore per un’opzione, dovresti aggiungere un segno = dopo il nome dell’opzione:

/**
 * Il nome e la firma del comando console.
 *
 * @var string
 */
protected $signature = 'mail:send {user} {--queue=}';

In questo esempio, l’utente può passare un valore per l’opzione in questo modo. Se l’opzione non viene specificata quando si esegue il comando, il suo valore sarà null:

php artisan mail:send 1 --queue=default

Puoi assegnare valori predefiniti alle opzioni specificando il valore di default dopo il nome dell’opzione. Se l’utente non fornisce un valore per l’opzione, verrà utilizzato il valore predefinito:

'mail:send {user} {--queue=default}'

Scorciatoie per le Opzioni

Per assegnare una scorciatoia quando definisci un’opzione, puoi specificarla prima del nome dell’opzione e usare il carattere | come delimitatore per separare la scorciatoia dal nome completo dell’opzione:

'mail:send {user} {--Q|queue}'

Quando esegui il comando nel tuo terminale, le scorciatoie delle opzioni devono essere precedute da un solo trattino e non deve essere incluso il carattere = quando specifichi un valore per l’opzione:

php artisan mail:send 1 -Qdefault

Array di Input

Se vuoi definire argomenti o opzioni che si aspettano più valori di input, puoi usare il carattere *. Innanzitutto, diamo un’occhiata a un esempio che specifica tale argomento:

    'mail:send {user*}'

Quando chiami questo metodo, gli argomenti user possono essere passati tramite la linea di comando. Ad esempio, il seguente comando imposterà il valore di user su un array con 1 e 2 come valori:

php artisan mail:send 1 2

Questo carattere * può essere combinato con una definizione di argomento opzionale per permettere zero o più istanze di un argomento:

    'mail:send {user?*}'

Array di Opzioni

Quando si definisce un’opzione che si aspetta più valori di input, ogni valore dell’opzione passato al comando deve essere prefissato con il nome dell’opzione:

'mail:send {--id=*}'

Un comando di questo tipo può essere eseguito passando più argomenti --id:

php artisan mail:send --id=1 --id=2

Descrizioni degli Input

Puoi assegnare descrizioni agli argomenti di input e alle opzioni separando il nome dell’argomento dalla descrizione usando i due punti. Se hai bisogno di un po’ più di spazio per definire il tuo comando, puoi estendere la definizione su più linee:

    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'mail:send
                            {user : The ID of the user}
                            {--queue : Whether the job should be queued}';

Richiesta di Input Mancanti

Se il tuo comando contiene argomenti obbligatori, l’utente riceverà un messaggio di errore se non li fornisce. In alternativa, puoi configurare il tuo comando per richiedere automaticamente all’utente gli argomenti mancanti implementando l’interfaccia PromptsForMissingInput:

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\Contracts\Console\PromptsForMissingInput;

class SendEmails extends Command implements PromptsForMissingInput
{
    /**
     * Il nome e la firma del comando console.
     *
     * @var string
     */
    protected $signature = 'mail:send {user}';

    // ...
}

Se Laravel ha bisogno di raccogliere un argomento obbligatorio dall’utente, chiederà automaticamente all’utente l’argomento formulando intelligentemente la domanda usando il nome o la descrizione dell’argomento. Se desideri personalizzare la domanda utilizzata per raccogliere l’argomento obbligatorio, puoi implementare il metodo promptForMissingArgumentsUsing, restituendo un array di domande indicizzate per nome degli argomenti:

/**
 * Richiedi argomenti di input mancanti utilizzando le domande restituite.
 *
 * @return array<string, string>
 */
protected function promptForMissingArgumentsUsing(): array
{
    return [
        'user' => 'Quale ID utente dovrebbe ricevere la mail?',
    ];
}

Puoi anche fornire un testo segnaposto utilizzando una tupla contenente la domanda e il segnaposto:

return [
    'user' => ['Quale ID utente dovrebbe ricevere la mail?', 'Es. 123'],
];

Se desideri un controllo completo sulla richiesta, puoi fornire una closure che deve richiedere all’utente e restituire la sua risposta:

use App\Models\User;
use function Laravel\Prompts\search;

// ...

return [
    'user' => fn () => search(
        label: 'Cerca un utente:',
        placeholder: 'Es. Taylor Otwell',
        options: fn ($value) => strlen($value) > 0
            ? User::where('name', 'like', "%{$value}%")->pluck('name', 'id')->all()
            : []
    ),
];

La documentazione completa di Laravel Prompts include ulteriori informazioni sui prompt disponibili e sul loro utilizzo.

Se desideri richiedere all’utente di selezionare o inserire opzioni, puoi includere i prompt nel metodo handle del tuo comando. Tuttavia, se desideri richiedere all’utente solo quando sono stati anche automaticamente richiesti argomenti mancanti, puoi implementare il metodo afterPromptingForMissingArguments:

use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use function Laravel\Prompts\confirm;

// ...

/**
 * Esegui azioni dopo che all'utente sono stati richiesti argomenti mancanti.
 */
protected function afterPromptingForMissingArguments(InputInterface $input, OutputInterface $output): void
{
    $input->setOption('queue', confirm(
        label: 'Vuoi mettere in coda la mail?',
        default: $this->option('queue')
    ));
}

Input/Output dei Comandi

Recuperare gli input

Durante l’esecuzione del tuo comando, probabilmente avrai bisogno di accedere ai valori degli argomenti e delle opzioni accettati dal tuo comando. Per farlo, puoi usare i metodi argument e option. Se un argomento o un’opzione non esiste, verrà restituito null:

    /**
     * Esegue il comando console.
     */
    public function handle(): void
    {
        $userId = $this->argument('user');
    }

Se hai bisogno di recuperare tutti gli argomenti come un array, chiama il metodo arguments:

    $arguments = $this->arguments();

Le opzioni possono essere recuperate altrettanto facilmente come gli argomenti usando il metodo option. Per recuperare tutte le opzioni come un array, chiama il metodo options:

    // Recupera un'opzione specifica...
    $queueName = $this->option('queue');

    // Recupera tutte le opzioni come un array...
    $options = $this->options();

Richiesta di Input

Laravel Prompts è un pacchetto PHP per aggiungere moduli belli e user-friendly alle tue applicazioni da linea di comando, con funzionalità simili a quelle del browser tra cui testo segnaposto e validazione.

Oltre a mostrare output, puoi anche chiedere all’utente di fornire input durante l’esecuzione del tuo comando. Il metodo ask richiederà all’utente la domanda fornita, accetterà il loro input e poi restituirà l’input dell’utente al tuo comando:

    /**
     * Esegui il comando console.
     */
    public function handle(): void
    {
        $name = $this->ask('Qual è il tuo nome?');

        // ...
    }

Il metodo ask accetta anche un secondo argomento opzionale che specifica il valore predefinito che dovrebbe essere restituito se non viene fornito alcun input dall’utente:

    $name = $this->ask('Qual è il tuo nome?', 'Taylor');

Il metodo secret è simile a ask, ma l’input dell’utente non sarà visibile mentre digita nella console. Questo metodo è utile quando si richiedono informazioni sensibili come le password:

    $password = $this->secret('Qual è la password?');

Richiesta di Conferma

Se hai bisogno di chiedere all’utente una semplice conferma "sì o no", puoi usare il metodo confirm. Per impostazione predefinita, questo metodo restituisce false. Tuttavia, se l’utente inserisce y o yes in risposta al prompt, il metodo restituirà true.

if ($this->confirm('Do you wish to continue?')) {
    // ...
}

Se necessario, puoi specificare che il prompt di conferma dovrebbe restituire true di default passando true come secondo argomento al metodo confirm:

if ($this->confirm('Do you wish to continue?', true)) {
    // ...
}

Completamento Automatico

Il metodo anticipate può essere usato per fornire il completamento automatico delle possibili scelte. L’utente può comunque fornire qualsiasi risposta, indipendentemente dai suggerimenti di completamento automatico:

$name = $this->anticipate('What is your name?', ['Taylor', 'Dayle']);

In alternativa, puoi passare una closure come secondo argomento al metodo anticipate. La closure verrà chiamata ogni volta che l’utente digita un carattere di input. La closure deve accettare un parametro stringa contenente l’input dell’utente fino a quel momento e restituire un array di opzioni per il completamento automatico:

$name = $this->anticipate('What is your address?', function (string $input) {
    // Return auto-completion options...
});

Domande a scelta multipla

Se hai bisogno di fornire all’utente un insieme predefinito di opzioni quando fai una domanda, puoi usare il metodo choice. Puoi impostare l’indice dell’array del valore predefinito da restituire se nessuna opzione viene scelta passando l’indice come terzo argomento al metodo:

$name = $this->choice(
    'What is your name?',
    ['Taylor', 'Dayle'],
    $defaultIndex
);

Inoltre, il metodo choice accetta argomenti opzionali quarto e quinto per determinare il numero massimo di tentativi per selezionare una risposta valida e se sono consentite selezioni multiple:

$name = $this->choice(
    'What is your name?',
    ['Taylor', 'Dayle'],
    $defaultIndex,
    $maxAttempts = null,
    $allowMultipleSelections = false
);

Scrivere l’Output

Per inviare output alla console, puoi usare i metodi line, info, comment, question, warn ed error. Ciascuno di questi metodi utilizzerà i colori ANSI appropriati per il loro scopo. Ad esempio, mostriamo alcune informazioni generali all’utente. Tipicamente, il metodo info mostrerà nella console del testo colorato di verde:

    /**
     * Esegui il comando console.
     */
    public function handle(): void
    {
        // ...

        $this->info('Il comando è stato eseguito con successo!');
    }

Per visualizzare un messaggio di errore, usa il metodo error. Il testo del messaggio di errore viene solitamente mostrato in rosso:

    $this->error('Qualcosa è andato storto!');

Puoi usare il metodo line per mostrare testo semplice, senza colori:

    $this->line('Mostra questo sullo schermo');

Puoi usare il metodo newLine per visualizzare una linea vuota:

    // Scrivi una singola linea vuota...
    $this->newLine();

    // Scrivi tre linee vuote...
    $this->newLine(3);

Tabelle

Il metodo table facilita la formattazione corretta di più righe e colonne di dati. Tutto ciò che devi fare è fornire i nomi delle colonne e i dati della tabella, e Laravel calcolerà automaticamente la larghezza e l’altezza appropriate della tabella per te:

use App\Models\User;

$this->table(
    ['Name', 'Email'],
    User::all(['name', 'email'])->toArray()
);

Barre di Progresso

Per attività di lunga durata, può essere utile mostrare una barra di progresso che informa gli utenti su quanto l’attività è completata. Utilizzando il metodo withProgressBar, Laravel mostrerà una barra di progresso e ne avanzerà il progresso ad ogni iterazione su un valore iterabile specificato:

use App\Models\User;

$users = $this->withProgressBar(User::all(), function (User $user) {
    $this->performTask($user);
});

A volte, potresti aver bisogno di un controllo più manuale su come la barra di progresso avanza. Innanzitutto, definisci il numero totale di passaggi che il processo eseguirà. Poi, avanza la barra di progresso dopo aver elaborato ogni elemento:

$users = App\Models\User::all();

$bar = $this->output->createProgressBar(count($users));

$bar->start();

foreach ($users as $user) {
    $this->performTask($user);

    $bar->advance();
}

$bar->finish();

Per opzioni più avanzate, consulta la documentazione del componente Symfony Progress Bar.

Registrazione dei Comandi

Per impostazione predefinita, Laravel registra automaticamente tutti i comandi nella directory app/Console/Commands. Tuttavia, puoi istruire Laravel a scansionare altre directory per i comandi Artisan utilizzando il metodo withCommands nel file bootstrap/app.php della tua applicazione:

->withCommands([
    __DIR__.'/../app/Domain/Orders/Commands',
])

Se necessario, puoi anche registrare manualmente i comandi fornendo il nome della classe del comando al metodo withCommands:

use App\Domain\Orders\Commands\SendEmails;

->withCommands([
    SendEmails::class,
])

Quando Artisan si avvia, tutti i comandi nella tua applicazione saranno risolti dal service container e registrati con Artisan.

Esecuzione programmatica dei comandi

A volte potresti voler eseguire un comando Artisan al di fuori della CLI. Ad esempio, potresti voler eseguire un comando Artisan da una route o da un controller. Puoi usare il metodo call sulla façade Artisan per realizzarlo. Il metodo call accetta come primo argomento il nome della firma del comando o il nome della classe, e come secondo argomento un array di parametri del comando. Verrà restituito il codice di uscita:

use Illuminate\Support\Facades\Artisan;

Route::post('/user/{user}/mail', function (string $user) {
    $exitCode = Artisan::call('mail:send', [
        'user' => $user, '--queue' => 'default'
    ]);

    // ...
});

In alternativa, puoi passare l’intero comando Artisan al metodo call come stringa:

Artisan::call('mail:send 1 --queue=default');

Passare valori array

Se il tuo comando definisce un’opzione che accetta un array, puoi passare un array di valori a quell’opzione:

use Illuminate\Support\Facades\Artisan;

Route::post('/mail', function () {
    $exitCode = Artisan::call('mail:send', [
        '--id' => [5, 13]
    ]);
});

Passare Valori Booleani

Se devi specificare il valore di un’opzione che non accetta valori stringa, come il flag --force nel comando migrate:refresh, dovresti passare true o false come valore dell’opzione:

$exitCode = Artisan::call('migrate:refresh', [
    '--force' => true,
]);

Messa in coda dei comandi Artisan

Usando il metodo queue sulla facciata Artisan, puoi mettere in coda i comandi Artisan in modo che vengano elaborati in background dai tuoi queue worker. Prima di utilizzare questo metodo, assicurati di aver configurato la tua coda ed eseguire un listener della coda:

use Illuminate\Support\Facades\Artisan;

Route::post('/user/{user}/mail', function (string $user) {
    Artisan::queue('mail:send', [
        'user' => $user, '--queue' => 'default'
    ]);

    // ...
});

Usando i metodi onConnection e onQueue, puoi specificare la connessione o la coda a cui deve essere inviato il comando Artisan:

Artisan::queue('mail:send', [
    'user' => 1, '--queue' => 'default'
])->onConnection('redis')->onQueue('commands');

Eseguire Comandi da Altri Comandi

A volte potresti voler eseguire altri comandi da un comando Artisan esistente. Puoi farlo usando il metodo call. Questo metodo accetta il nome del comando e un array di argomenti/opzioni del comando:

/**
 * Esegui il comando della console.
 */
public function handle(): void
{
    $this->call('mail:send', [
        'user' => 1, '--queue' => 'default'
    ]);

    // ...
}

Se desideri eseguire un altro comando della console e sopprimere tutta la sua uscita, puoi usare il metodo callSilently. Il metodo callSilently ha la stessa firma del metodo call:

$this->callSilently('mail:send', [
    'user' => 1, '--queue' => 'default'
]);

Gestione dei segnali

Come saprai, i sistemi operativi permettono di inviare segnali ai processi in esecuzione. Ad esempio, il segnale SIGTERM è il modo in cui i sistemi operativi chiedono a un programma di terminare. Se desideri ascoltare i segnali nei tuoi comandi di console Artisan ed eseguire del codice quando si verificano, puoi utilizzare il metodo trap:

/**
 * Esegui il comando della console.
 */
public function handle(): void
{
    $this->trap(SIGTERM, fn () => $this->shouldKeepRunning = false);

    while ($this->shouldKeepRunning) {
        // ...
    }
}

Per ascoltare più segnali contemporaneamente, puoi fornire un array di segnali al metodo trap:

$this->trap([SIGTERM, SIGQUIT], function (int $signal) {
    $this->shouldKeepRunning = false;

    dump($signal); // SIGTERM / SIGQUIT
});

Personalizzazione degli Stub

I comandi make della console Artisan vengono usati per creare vari tipi di classi, come controller, job, migration e test. Queste classi sono generate usando file "stub" che vengono riempiti con valori in base al tuo input. Tuttavia, potresti voler fare piccole modifiche ai file generati da Artisan. Per questo, puoi usare il comando stub:publish per pubblicare gli stub più comuni nella tua applicazione e così personalizzarli:

php artisan stub:publish

Gli stub pubblicati si troveranno nella directory stubs nella radice della tua applicazione. Qualsiasi modifica apporti a questi stub sarà riflessa quando generi le relative classi usando i comandi make di Artisan.

Eventi

Artisan emette tre eventi quando esegue comandi: Illuminate\Console\Events\ArtisanStarting, Illuminate\Console\Events\CommandStarting e Illuminate\Console\Events\CommandFinished. L’evento ArtisanStarting viene emesso subito quando Artisan inizia a funzionare. Successivamente, l’evento CommandStarting viene emesso immediatamente prima che un comando venga eseguito. Infine, l’evento CommandFinished viene emesso una volta che un comando ha terminato l’esecuzione.

Lascia un commento

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *