Consola Artisan

• Introducción
  • Tinker (REPL)
• Escribiendo Comandos
  • Generando Comandos
  • Estructura del Comando
  • Comandos Closure
  • Comandos Aislables
• Definiendo Expectativas de Entrada
  • Argumentos
  • Opciones
  • Arrays de Entrada
  • Descripciones de Entrada
  • Solicitando Entrada Faltante
• Entrada/Salida de Comandos
  • Recuperando Entrada
  • Solicitando Entrada
  • Escribiendo Salida
• Registrando Comandos
• Ejecutando Comandos Programáticamente
  • Llamando Comandos desde Otros Comandos
• Manejo de Señales
• Personalización de Stubs
• Eventos

#Introducción

Artisan es la interfaz de línea de comandos incluida con Laravel. Artisan se encuentra en la raíz de su aplicación como el script artisan y proporciona una serie de comandos útiles que pueden ayudarle mientras construye su aplicación. Para ver una lista de todos los comandos Artisan disponibles, puede usar el comando list:

php artisan list

Cada comando también incluye una pantalla de "ayuda" que muestra y describe los argumentos y opciones disponibles del comando. Para ver una pantalla de ayuda, anteponga el nombre del comando con help:

php artisan help migrate

#Laravel Sail

Si está utilizando Laravel Sail como su entorno de desarrollo local, recuerde usar la línea de comandos sail para invocar comandos Artisan. Sail ejecutará sus comandos Artisan dentro de los contenedores Docker de su aplicación:

./vendor/bin/sail artisan list

#Tinker (REPL)

Laravel Tinker es un REPL potente para el framework Laravel, impulsado por el paquete PsySH.

#Instalación

Todas las aplicaciones Laravel incluyen Tinker por defecto. Sin embargo, puede instalar Tinker usando Composer si lo ha eliminado previamente de su aplicación:

composer require laravel/tinker

#Uso

Tinker le permite interactuar con toda su aplicación Laravel desde la línea de comandos, incluyendo sus modelos Eloquent, jobs, eventos y más. Para entrar al entorno Tinker, ejecute el comando Artisan tinker:

php artisan tinker

Puede publicar el archivo de configuración de Tinker usando el comando vendor:publish:

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

#Lista de Comandos Permitidos

Tinker utiliza una lista de "permitidos" para determinar qué comandos Artisan pueden ejecutarse dentro de su shell. Por defecto, puede ejecutar los comandos clear-compiled, down, env, inspire, migrate, optimize y up. Si desea permitir más comandos, puede agregarlos al arreglo commands en su archivo de configuración tinker.php:

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

#Clases que No Deben Ser Alias

Normalmente, Tinker crea alias automáticamente para las clases a medida que interactúa con ellas. Sin embargo, puede que desee nunca crear alias para algunas clases. Puede lograr esto listando las clases en el arreglo dont_alias de su archivo de configuración tinker.php:

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

#Escribiendo Comandos

Además de los comandos proporcionados con Artisan, puede crear sus propios comandos personalizados. Los comandos se almacenan típicamente en el directorio app/Console/Commands; sin embargo, puede elegir su propia ubicación siempre que sus comandos puedan ser cargados por Composer.

#Generando Comandos

Para crear un nuevo comando, puede usar el comando Artisan make:command. Este comando creará una nueva clase de comando en el directorio app/Console/Commands. No se preocupe si este directorio no existe en su aplicación: se creará la primera vez que ejecute el comando Artisan make:command:

php artisan make:command SendEmails

#Estructura del Comando

Después de generar su comando, debe definir valores apropiados para las propiedades signature y description de la clase. Estas propiedades se usarán al mostrar su comando en la pantalla list. La propiedad signature también le permite definir las expectativas de entrada de su comando. El método handle será llamado cuando su comando se ejecute. Puede colocar la lógica de su comando en este método.

Veamos un ejemplo de comando. Note que podemos solicitar cualquier dependencia que necesitemos a través del método handle del comando. El service container de Laravel inyectará automáticamente todas las dependencias que estén tipeadas en la firma de este método:

<?php

namespace App\Console\Commands;

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

class SendEmails extends Command
{
    /**
     * El nombre y la firma del comando de consola.
     *
     * @var string
     */
    protected $signature = 'mail:send {user}';

    /**
     * La descripción del comando de consola.
     *
     * @var string
     */
    protected $description = 'Enviar un correo de marketing a un usuario';

    /**
     * Ejecutar el comando de consola.
     */
    public function handle(DripEmailer $drip): void
    {
        $drip->send(User::find($this->argument('user')));
    }
}

#Comandos Closure

Los comandos basados en closures ofrecen una alternativa a definir comandos de consola como clases. De la misma manera que los closures de rutas son una alternativa a los controladores, piense en los comandos closure como una alternativa a las clases de comando. Dentro del método commands de su archivo app/Console/Kernel.php, Laravel carga el archivo routes/console.php:

/**
 * Registrar los comandos basados en closure para la aplicación.
 */
protected function commands(): void
{
    require base_path('routes/console.php');
}

Aunque este archivo no define rutas HTTP, define puntos de entrada basados en consola (rutas) para su aplicación. Dentro de este archivo, puede definir todos sus comandos de consola basados en closure usando el método Artisan::command. El método command acepta dos argumentos: la firma del comando y un closure que recibe los argumentos y opciones del comando:

Artisan::command('mail:send {user}', function (string $user) {
    $this->info("¡Enviando correo a: {$user}!");
});

El closure está ligado a la instancia subyacente del comando, por lo que tiene acceso completo a todos los métodos helper que normalmente podría usar en una clase de comando completa.

#Inyección de Dependencias con Type-Hinting

Además de recibir los argumentos y opciones de su comando, los closures de comando también pueden type-hintar dependencias adicionales que desea resolver desde el 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));
});

#Descripciones para Comandos Closure

Al definir un comando basado en closure, puede usar el método purpose para agregar una descripción al comando. Esta descripción se mostrará cuando ejecute los comandos php artisan list o php artisan help:

Artisan::command('mail:send {user}', function (string $user) {
    // ...
})->purpose('Enviar un correo de marketing a un usuario');

#Comandos Aislables

A veces puede querer asegurarse de que solo una instancia de un comando se ejecute a la vez. Para lograr esto, puede implementar la interfaz Illuminate\Contracts\Console\Isolatable en su clase de comando:

<?php

namespace App\Console\Commands;

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

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

Cuando un comando está marcado como Isolatable, Laravel agregará automáticamente una opción --isolated al comando. Cuando el comando se invoca con esa opción, Laravel se asegurará de que no haya otras instancias de ese comando ya ejecutándose. Laravel logra esto intentando adquirir un bloqueo atómico usando el driver de caché predeterminado de su aplicación. Si otras instancias del comando están ejecutándose, el comando no se ejecutará; sin embargo, el comando aún saldrá con un código de estado de salida exitoso:

php artisan mail:send 1 --isolated

Si desea especificar el código de estado de salida que el comando debe devolver si no puede ejecutarse, puede proporcionar el código deseado a través de la opción isolated:

php artisan mail:send 1 --isolated=12

#ID del Bloqueo

Por defecto, Laravel usará el nombre del comando para generar la clave de cadena que se usa para adquirir el bloqueo atómico en la caché de su aplicación. Sin embargo, puede personalizar esta clave definiendo un método isolatableId en su clase de comando Artisan, permitiéndole integrar los argumentos u opciones del comando en la clave:

/**
 * Obtener el ID aislable para el comando.
 */
public function isolatableId(): string
{
    return $this->argument('user');
}

#Tiempo de Expiración del Bloqueo

Por defecto, los bloqueos de aislamiento expiran después de que el comando termina. O, si el comando se interrumpe y no puede terminar, el bloqueo expirará después de una hora. Sin embargo, puede ajustar el tiempo de expiración del bloqueo definiendo un método isolationLockExpiresAt en su comando:

use DateTimeInterface;
use DateInterval;

/**
 * Determinar cuándo expira un bloqueo de aislamiento para el comando.
 */
public function isolationLockExpiresAt(): DateTimeInterface|DateInterval
{
    return now()->addMinutes(5);
}

#Definiendo Expectativas de Entrada

Al escribir comandos de consola, es común recopilar entrada del usuario a través de argumentos u opciones. Laravel facilita mucho definir la entrada que espera del usuario usando la propiedad signature en sus comandos. La propiedad signature le permite definir el nombre, argumentos y opciones para el comando en una sintaxis expresiva similar a rutas.

#Argumentos

Todos los argumentos y opciones proporcionados por el usuario están encerrados en llaves. En el siguiente ejemplo, el comando define un argumento requerido: user:

/**
 * El nombre y la firma del comando de consola.
 *
 * @var string
 */
protected $signature = 'mail:send {user}';

También puede hacer que los argumentos sean opcionales o definir valores predeterminados para los argumentos:

// Argumento opcional...
'mail:send {user?}'

// Argumento opcional con valor predeterminado...
'mail:send {user=foo}'

#Opciones

Las opciones, al igual que los argumentos, son otra forma de entrada del usuario. Las opciones se prefijan con dos guiones (--) cuando se proporcionan desde la línea de comandos. Hay dos tipos de opciones: las que reciben un valor y las que no. Las opciones que no reciben valor funcionan como un "interruptor" booleano. Veamos un ejemplo de este tipo de opción:

/**
 * El nombre y la firma del comando de consola.
 *
 * @var string
 */
protected $signature = 'mail:send {user} {--queue}';

En este ejemplo, el interruptor --queue puede especificarse al llamar al comando Artisan. Si se pasa el interruptor --queue, el valor de la opción será true. De lo contrario, el valor será false:

php artisan mail:send 1 --queue

#Opciones con Valores

A continuación, veamos una opción que espera un valor. Si el usuario debe especificar un valor para una opción, debe agregar un signo = al final del nombre de la opción:

/**
 * El nombre y la firma del comando de consola.
 *
 * @var string
 */
protected $signature = 'mail:send {user} {--queue=}';

En este ejemplo, el usuario puede pasar un valor para la opción así. Si la opción no se especifica al invocar el comando, su valor será null:

php artisan mail:send 1 --queue=default

Puede asignar valores predeterminados a las opciones especificando el valor predeterminado después del nombre de la opción. Si el usuario no pasa un valor para la opción, se usará el valor predeterminado:

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

#Atajos para Opciones

Para asignar un atajo al definir una opción, puede especificarlo antes del nombre de la opción y usar el carácter | como delimitador para separar el atajo del nombre completo de la opción:

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

Al invocar el comando en su terminal, los atajos de opciones deben prefijarse con un solo guion y no debe incluirse el carácter = al especificar un valor para la opción:

php artisan mail:send 1 -Qdefault

#Arrays de Entrada

Si desea definir argumentos u opciones que esperen múltiples valores de entrada, puede usar el carácter *. Primero, veamos un ejemplo que especifica tal argumento:

'mail:send {user*}'

Al llamar a este método, los argumentos user pueden pasarse en orden a la línea de comandos. Por ejemplo, el siguiente comando establecerá el valor de user como un array con 1 y 2 como sus valores:

php artisan mail:send 1 2

Este carácter * puede combinarse con una definición de argumento opcional para permitir cero o más instancias de un argumento:

'mail:send {user?*}'

#Arrays de Opciones

Al definir una opción que espera múltiples valores de entrada, cada valor de opción pasado al comando debe estar prefijado con el nombre de la opción:

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

Tal comando puede invocarse pasando múltiples argumentos --id:

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

#Descripciones de Entrada

Puede asignar descripciones a los argumentos y opciones de entrada separando el nombre del argumento de la descripción usando dos puntos. Si necesita un poco más de espacio para definir su comando, siéntase libre de extender la definición en varias líneas:

/**
 * El nombre y la firma del comando de consola.
 *
 * @var string
 */
protected $signature = 'mail:send
                        {user : El ID del usuario}
                        {--queue : Si el job debe ser encolado}';

#Solicitando Entrada Faltante

Si su comando contiene argumentos requeridos, el usuario recibirá un mensaje de error cuando no los proporcione. Alternativamente, puede configurar su comando para que solicite automáticamente al usuario cuando falten argumentos requeridos implementando la interfaz PromptsForMissingInput:

<?php

namespace App\Console\Commands;

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

class SendEmails extends Command implements PromptsForMissingInput
{
    /**
     * El nombre y la firma del comando de consola.
     *
     * @var string
     */
    protected $signature = 'mail:send {user}';

    // ...
}

Si Laravel necesita recopilar un argumento requerido del usuario, automáticamente le preguntará al usuario por el argumento formulando la pregunta inteligentemente usando el nombre o la descripción del argumento. Si desea personalizar la pregunta usada para recopilar el argumento requerido, puede implementar el método promptForMissingArgumentsUsing, devolviendo un array de preguntas indexado por los nombres de los argumentos:

/**
 * Solicitar argumentos de entrada faltantes usando las preguntas devueltas.
 *
 * @return array
 */
protected function promptForMissingArgumentsUsing()
{
    return [
        'user' => '¿Qué ID de usuario debe recibir el correo?',
    ];
}

También puede proporcionar texto de marcador de posición usando una tupla que contenga la pregunta y el marcador de posición:

return [
    'user' => ['¿Qué ID de usuario debe recibir el correo?', 'Ej. 123'],
];

Si desea control total sobre el prompt, puede proporcionar un closure que debe solicitar al usuario y devolver su respuesta:

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

// ...

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

La documentación completa de Laravel Prompts incluye información adicional sobre los prompts disponibles y su uso.

Si desea solicitar al usuario que seleccione o ingrese opciones, puede incluir prompts en el método handle de su comando. Sin embargo, si solo desea solicitar al usuario cuando también se le haya solicitado automáticamente por argumentos faltantes, puede implementar el método afterPromptingForMissingArguments:

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

// ...

/**
 * Realizar acciones después de que el usuario fue solicitado por argumentos faltantes.
 *
 * @param  \Symfony\Component\Console\Input\InputInterface  $input
 * @param  \Symfony\Component\Console\Output\OutputInterface  $output
 * @return void
 */
protected function afterPromptingForMissingArguments(InputInterface $input, OutputInterface $output)
{
    $input->setOption('queue', confirm(
        label: '¿Desea encolar el correo?',
        default: $this->option('queue')
    ));
}

#Entrada/Salida de Comandos

#Recuperando Entrada

Mientras su comando se ejecuta, probablemente necesitará acceder a los valores de los argumentos y opciones aceptados por su comando. Para hacerlo, puede usar los métodos argument y option. Si un argumento u opción no existe, se devolverá null:

/**
 * Ejecutar el comando de consola.
 */
public function handle(): void
{
    $userId = $this->argument('user');
}

Si necesita recuperar todos los argumentos como un array, llame al método arguments:

$arguments = $this->arguments();

Las opciones pueden recuperarse tan fácilmente como los argumentos usando el método option. Para recuperar todas las opciones como un array, llame al método options:

// Recuperar una opción específica...
$queueName = $this->option('queue');

// Recuperar todas las opciones como un array...
$options = $this->options();

#Solicitando Entrada

Además de mostrar salida, también puede pedir al usuario que proporcione entrada durante la ejecución de su comando. El método ask solicitará al usuario con la pregunta dada, aceptará su entrada y luego devolverá la entrada del usuario a su comando:

/**
 * Ejecutar el comando de consola.
 */
public function handle(): void
{
    $name = $this->ask('¿Cuál es su nombre?');

    // ...
}

El método ask también acepta un segundo argumento opcional que especifica el valor predeterminado que debe devolverse si no se proporciona entrada del usuario:

$name = $this->ask('¿Cuál es su nombre?', 'Taylor');

El método secret es similar a ask, pero la entrada del usuario no será visible mientras escribe en la consola. Este método es útil cuando se solicita información sensible como contraseñas:

$password = $this->secret('¿Cuál es la contraseña?');

#Preguntando por Confirmación

Si necesita pedir al usuario una simple confirmación de "sí o no", puede usar el método confirm. Por defecto, este método devolverá false. Sin embargo, si el usuario ingresa y o yes en respuesta al prompt, el método devolverá true.

if ($this->confirm('¿Desea continuar?')) {
    // ...
}

Si es necesario, puede especificar que el prompt de confirmación devuelva true por defecto pasando true como segundo argumento al método confirm:

if ($this->confirm('¿Desea continuar?', true)) {
    // ...
}

#Autocompletado

El método anticipate puede usarse para proporcionar autocompletado para posibles opciones. El usuario aún puede proporcionar cualquier respuesta, independientemente de las sugerencias de autocompletado:

$name = $this->anticipate('¿Cuál es su nombre?', ['Taylor', 'Dayle']);

Alternativamente, puede pasar un closure como segundo argumento al método anticipate. El closure será llamado cada vez que el usuario escriba un carácter de entrada. El closure debe aceptar un parámetro string que contenga la entrada del usuario hasta el momento, y devolver un array de opciones para autocompletado:

$name = $this->anticipate('¿Cuál es su dirección?', function (string $input) {
    // Devolver opciones de autocompletado...
});

#Preguntas de Elección Múltiple

Si necesita darle al usuario un conjunto predefinido de opciones al hacer una pregunta, puede usar el método choice. Puede establecer el índice del array del valor predeterminado que se devolverá si no se elige ninguna opción pasando el índice como tercer argumento al método:

$name = $this->choice(
    '¿Cuál es su nombre?',
    ['Taylor', 'Dayle'],
    $defaultIndex
);

Además, el método choice acepta argumentos opcionales cuarto y quinto para determinar el número máximo de intentos para seleccionar una respuesta válida y si se permiten selecciones múltiples:

$name = $this->choice(
    '¿Cuál es su nombre?',
    ['Taylor', 'Dayle'],
    $defaultIndex,
    $maxAttempts = null,
    $allowMultipleSelections = false
);

#Escribiendo Salida

Para enviar salida a la consola, puede usar los métodos line, info, comment, question, warn y error. Cada uno de estos métodos usará colores ANSI apropiados para su propósito. Por ejemplo, mostremos información general al usuario. Típicamente, el método info mostrará texto en color verde en la consola:

/**
 * Ejecutar el comando de consola.
 */
public function handle(): void
{
    // ...

    $this->info('¡El comando fue exitoso!');
}

Para mostrar un mensaje de error, use el método error. El texto de mensajes de error típicamente se muestra en rojo:

$this->error('¡Algo salió mal!');

Puede usar el método line para mostrar texto plano, sin color:

$this->line('Mostrar esto en la pantalla');

Puede usar el método newLine para mostrar una línea en blanco:

// Escribir una línea en blanco...
$this->newLine();

// Escribir tres líneas en blanco...
$this->newLine(3);

#Tablas

El método table facilita formatear correctamente múltiples filas / columnas de datos. Solo necesita proporcionar los nombres de las columnas y los datos para la tabla, y Laravel calculará automáticamente el ancho y alto apropiados de la tabla:

use App\Models\User;

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

#Barras de Progreso

Para tareas de larga duración, puede ser útil mostrar una barra de progreso que informe a los usuarios qué tan completa está la tarea. Usando el método withProgressBar, Laravel mostrará una barra de progreso y avanzará su progreso por cada iteración sobre un valor iterable dado:

use App\Models\User;

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

A veces, puede necesitar un control más manual sobre cómo se avanza una barra de progreso. Primero, defina el número total de pasos que el proceso iterará. Luego, avance la barra de progreso después de procesar cada 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();

#Registrando Comandos

Todos sus comandos de consola se registran dentro de la clase App\Console\Kernel de su aplicación, que es el "kernel de consola" de su aplicación. Dentro del método commands de esta clase, verá una llamada al método load del kernel. El método load escaneará el directorio app/Console/Commands y registrará automáticamente cada comando que contenga con Artisan. Incluso puede hacer llamadas adicionales al método load para escanear otros directorios en busca de comandos Artisan:

/**
 * Registrar los comandos para la aplicación.
 */
protected function commands(): void
{
    $this->load(__DIR__.'/Commands');
    $this->load(__DIR__.'/../Domain/Orders/Commands');

    // ...
}

Si es necesario, puede registrar comandos manualmente agregando el nombre de la clase del comando a una propiedad $commands dentro de su clase App\Console\Kernel. Si esta propiedad no está definida en su kernel, debe definirla manualmente. Cuando Artisan se inicia, todos los comandos listados en esta propiedad serán resueltos por el service container y registrados con Artisan:

protected $commands = [
    Commands\SendEmails::class
];

#Ejecutando Comandos Programáticamente

A veces puede querer ejecutar un comando Artisan fuera del CLI. Por ejemplo, puede querer ejecutar un comando Artisan desde una ruta o controlador. Puede usar el método call en el facade Artisan para lograr esto. El método call acepta como primer argumento el nombre de la firma del comando o el nombre de la clase, y como segundo argumento un array de parámetros del comando. Se devolverá el código de salida:

use Illuminate\Support\Facades\Artisan;

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

    // ...
});

Alternativamente, puede pasar el comando Artisan completo al método call como una cadena:

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

#Pasando Valores en Array

Si su comando define una opción que acepta un array, puede pasar un array de valores a esa opción:

use Illuminate\Support\Facades\Artisan;

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

#Pasando Valores Booleanos

Si necesita especificar el valor de una opción que no acepta valores string, como la bandera --force en el comando migrate:refresh, debe pasar true o false como valor de la opción:

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

#Encolando Comandos Artisan

Usando el método queue en el facade Artisan, incluso puede encolar comandos Artisan para que sean procesados en segundo plano por sus trabajadores de cola. Antes de usar este método, asegúrese de haber configurado su cola y estar ejecutando un listener de cola:

use Illuminate\Support\Facades\Artisan;

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

    // ...
});

Usando los métodos onConnection y onQueue, puede especificar la conexión o cola a la que debe enviarse el comando Artisan:

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

#Llamando Comandos desde Otros Comandos

A veces puede querer llamar a otros comandos desde un comando Artisan existente. Puede hacerlo usando el método call. Este método call acepta el nombre del comando y un array de argumentos / opciones del comando:

/**
 * Ejecutar el comando de consola.
 */
public function handle(): void
{
    $this->call('mail:send', [
        'user' => 1, '--queue' => 'default'
    ]);

    // ...
}

Si desea llamar a otro comando de consola y suprimir toda su salida, puede usar el método callSilently. El método callSilently tiene la misma firma que el método call:

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

#Manejo de Señales

Como sabrá, los sistemas operativos permiten enviar señales a procesos en ejecución. Por ejemplo, la señal SIGTERM es cómo los sistemas operativos piden a un programa que termine. Si desea escuchar señales en sus comandos Artisan y ejecutar código cuando ocurran, puede usar el método trap:

/**
 * Ejecutar el comando de consola.
 */
public function handle(): void
{
    $this->trap(SIGTERM, fn () => $this->shouldKeepRunning = false);

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

Para escuchar múltiples señales a la vez, puede proporcionar un array de señales al método trap:

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

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

#Personalización de Stubs

Los comandos make de la consola Artisan se usan para crear una variedad de clases, como controladores, jobs, migraciones y pruebas. Estas clases se generan usando archivos "stub" que se llenan con valores basados en su entrada. Sin embargo, puede que quiera hacer pequeños cambios a los archivos generados por Artisan. Para lograr esto, puede usar el comando stub:publish para publicar los stubs más comunes en su aplicación y así personalizarlos:

php artisan stub:publish

Los stubs publicados estarán ubicados dentro de un directorio stubs en la raíz de su aplicación. Cualquier cambio que haga en estos stubs se reflejará cuando genere sus clases correspondientes usando los comandos make de Artisan.

#Eventos

Artisan despacha tres eventos al ejecutar comandos: Illuminate\Console\Events\ArtisanStarting, Illuminate\Console\Events\CommandStarting y Illuminate\Console\Events\CommandFinished. El evento ArtisanStarting se despacha inmediatamente cuando Artisan comienza a ejecutarse. Luego, el evento CommandStarting se despacha justo antes de que un comando se ejecute. Finalmente, el evento CommandFinished se despacha una vez que un comando termina su ejecución.