Console Artisan
Introdução
O Artisan é o interface de linha de comando incluído no Laravel. O Artisan está na raiz da sua aplicação como um script e fornece uma série de comandos úteis que podem ajudá-lo enquanto você constrói a sua aplicação. Para ver uma lista de todos os comandos disponíveis do Artisan, utilize o comando list
:
php artisan list
Todos os comandos incluem também uma tela de ajuda que descreve os argumentos e opções disponíveis. Para visualizar a tela de ajuda, anteceda o nome do comando com "help":
php artisan help migrate
Onde estão as instruções do Laravel Sail?
Se você estiver usando o Laravel Sail como seu ambiente de desenvolvimento local, lembre-se de usar a linha de comando sail
para invocar os comandos do Artisan. O Sail executará seus comandos do Artisan dentro dos containers Docker do aplicativo:
./vendor/bin/sail artisan list
Tinker (REPL)
O Laravel Tinker é um poderoso REPL para o framework Laravel, impulsionado pelo pacote PsySH.
Instalação
Todos os aplicativos do Laravel incluem o Tinker por padrão. No entanto, você pode instalar o Tinker usando o Composer se tiver removido o programa da sua aplicação previamente:
composer require laravel/tinker
Uso
O Tinker permite interagir com toda a aplicação do Laravel na linha de comando, incluindo modelos Eloquent, tarefas, eventos e muito mais. Para iniciar o ambiente do Tinker, execute a ordem de serviço "tinker":
php artisan tinker
Você pode publicar o arquivo de configuração do Tinker usando o comando vendor:publish
:
php artisan vendor:publish --provider="Laravel\Tinker\TinkerServiceProvider"
AVISO
A função de ajuda dispatch
e o método dispatch
na classe Dispatchable
dependem da coleta de lixo para colocar o trabalho na fila. Sendo assim, ao usar o tinker, você deve usar a função Bus::dispatch
ou Queue::push
para encaminhar trabalhos.
Lista de permissão
O Tinker utiliza uma lista de "permissões" para determinar quais comandos do Artisan podem ser executados na sua shell. Por padrão, você pode executar os comandos clear-compiled
, down
, env
, inspire
, migrate
, optimize
e up
. Se você deseja permitir mais comandos, é possível adicioná-los ao array commands
do seu arquivo de configuração tinker.php
:
'commands' => [
// App\Console\Commands\ExampleCommand::class,
],
Clases que não devem ser associadas
Normalmente, o Tinker atribui automaticamente nomes às classes conforme interage com elas no próprio Tinker. No entanto, você pode não querer atribuir nomes a algumas classes. Você pode fazer isso listando as classes no array dont_alias
do arquivo de configuração tinker.php
:
'dont_alias' => [
App\Models\User::class,
],
Comandos de escrita
Além dos comandos fornecidos com o Artisan, você pode criar seus próprios comandos personalizados. Geralmente, os comandos são armazenados no diretório app/Console/Commands
. No entanto, você é livre para escolher seu próprio local de armazenamento desde que seus comandos possam ser carregados pelo Composer.
Comandos de geração
Para criar um novo comando, você pode usar o comando do Artisan make:command
. Este comando irá criar uma nova classe de comando na pasta app/Console/Commands
. Não se preocupe se essa pasta não existir em sua aplicação - ela será criada na primeira vez que você executar o comando do Artisan make:command
:
php artisan make:command SendEmails
Estrutura de Comando
Depois de gerar seu comando, você deve definir valores apropriados para as propriedades signature
e description
da classe. Estas propriedades serão usadas ao exibir seu comando na tela list
. A propriedade signature
também permite que você defina expectativas de entrada do seu comando. O método handle
será chamado quando seu comando for executado. Você pode colocar sua lógica de comando nesse método.
Vamos dar uma olhada em um comando de exemplo. Note que podemos solicitar quaisquer dependências necessárias por meio do método handle
do comando. O contêiner [de serviços] Laravel ([conjunto de serviços)](/docs//container) injetará automaticamente todas as dependências indicadas no tipo em sua assinatura:
<?php
namespace App\Console\Commands;
use App\Models\User;
use App\Support\DripEmailer;
use Illuminate\Console\Command;
class SendEmails extends Command
{
/**
* The name and signature of the console command.
*
* @var string
*/
protected $signature = 'mail:send {user}';
/**
* The console command description.
*
* @var string
*/
protected $description = 'Send a marketing email to a user';
/**
* Execute the console command.
*/
public function handle(DripEmailer $drip): void
{
$drip->send(User::find($this->argument('user')));
}
}
[!NOTA] Para melhor reutilização de código, é uma boa prática manter os comandos da console leves e deixar que os serviços de aplicativo assegurem suas tarefas. No exemplo acima, observe que injetamos uma classe de serviço para executar a "tarefa pesada" de enviar os e-mails.
Códigos de saída
Se nada for retornado da função handle
e o comando executar-se bem, o comando sairá com um código de saída 0
, indicando sucesso. No entanto, a função handle
pode retornar opcionalmente um número inteiro para especificar manualmente o código de saída do comando:
$this->error('Something went wrong.');
return 1;
Se pretender "deixar de executar" o comando em qualquer método no contexto do comando, poderá utilizar o método fail. O método fail interrompe imediatamente a execução do comando e retorna um código de saída de 1:
$this->fail('Something went wrong.');
Comandos de encerramento
Os comandos baseados em closure fornecem uma alternativa para a definição de comandos do console como classes. Da mesma forma que os fechamentos de rotas são uma alternativa aos controladores, pense nos fechamentos de comando como uma alternativa às classes de comando.
Ainda que o arquivo routes/console.php
não defina rotas HTTP, ele define pontos de entrada baseados em console na sua aplicação. Nesse arquivo, você pode definir todos os seus comandos de console com base em closures usando o método Artisan::command
. O método command
aceita dois argumentos: a assinatura do comando e um closure que recebe os argumentos e as opções do comando:
Artisan::command('mail:send {user}', function (string $user) {
$this->info("Sending email to: {$user}!");
});
O fecho está associado à instância do comando subjacente, pelo que tem total acesso a todos os métodos de ajuda aos quais normalmente teria acesso numa classe de comando completa.
Tipos e dependências de indicação
Além de receber os argumentos e opções do comando, as regras de comandos também podem indicar dependências adicionais que você gostaria que fossem resolvidas pelo conjunto de serviços:
use App\Models\User;
use App\Support\DripEmailer;
Artisan::command('mail:send {user}', function (DripEmailer $drip, string $user) {
$drip->send(User::find($user));
});
Descrições do comando de fecho
Ao definir um comando baseado em closure é possível usar o método purpose
para adicionar uma descrição ao comando. Essa descrição será exibida quando você executar os comandos php artisan list
ou php artisan help
:
Artisan::command('mail:send {user}', function (string $user) {
// ...
})->purpose('Send a marketing email to a user');
Comandos isoláveis
[AVISO] Para usar esse recurso, seu aplicativo deve utilizar o driver de cache
memcached
,redis
,dynamodb
,database
,file
ouarray
como driver de cache padrão da sua aplicação. Além disso, todos os servidores devem se comunicar com o mesmo servidor central de cache.
Algumas vezes, você pode querer garantir que apenas uma única instância de um comando seja executada por vez. Para fazer isso, você pode implementar a interface Illuminate\Contracts\Console\Isolatable
em sua classe de comando:
<?php
namespace App\Console\Commands;
use Illuminate\Console\Command;
use Illuminate\Contracts\Console\Isolatable;
class SendEmails extends Command implements Isolatable
{
// ...
}
Quando um comando é marcado como Isolável
, o Laravel adicionará automaticamente uma opção --isolada
ao comando. Se esse comando for invocado com essa opção, o Laravel irá garantir que nenhuma outra instância do mesmo comando esteja em execução. Para fazer isso, o Laravel tenta adquirir um bloqueio atômico usando o driver de cache padrão da sua aplicação. Se outras instâncias do comando estiverem em execução, ele não será executado. No entanto, o comando ainda sairá com um código de status de saída bem-sucedido:
php artisan mail:send 1 --isolated
Se você desejar especificar o código de status da saída do comando que será retornado caso ele não seja capaz de executar, poderá fornecer a senha desejada através da opção isolated
:
php artisan mail:send 1 --isolated=12
Identificador de Bloqueio
Por padrão, o Laravel usará o nome do comando para gerar a chave de string que será usada para obter o bloqueio atômico no cache da sua aplicação. No entanto, você pode personalizar essa chave definindo um método isolatableId
na classe de comando Artisan, permitindo integrar os argumentos ou opções do comando à chave:
/**
* Get the isolatable ID for the command.
*/
public function isolatableId(): string
{
return $this->argument('user');
}
Hora de expiração do bloqueio
Por padrão, os bloqueios de isolamento são cancelados quando o comando estiver terminado. Caso o comando seja interrompido ou incapaz de ser executado, o bloqueio será cancelado após uma hora. No entanto, você pode ajustar esse tempo no seu comando ao definir um método isolationLockExpiresAt
:
use DateTimeInterface;
use DateInterval;
/**
* Determine when an isolation lock expires for the command.
*/
public function isolationLockExpiresAt(): DateTimeInterface|DateInterval
{
return now()->addMinutes(5);
}
Definindo as expetativas relativamente ao input
Na escrita de comandos de console é comum obter dados do usuário através de argumentos ou opções. O Laravel torna muito prático o definição da informação que você espera do usuário utilizando a propriedade signature
em seus comandos. A propriedade signature
permite definir o nome, argumentos e opções para um comando em um único formato sintático como um URL.
Argumentos
Todos os argumentos e opções fornecidos pelo usuário estão envoltos em aspas duplas. No exemplo a seguir, o comando define um único argumento obrigatório: user
.
/**
* The name and signature of the console command.
*
* @var string
*/
protected $signature = 'mail:send {user}';
Você também pode tornar os argumentos opcionais ou definir valores por padrão para eles:
// Optional argument...
'mail:send {user?}'
// Optional argument with default value...
'mail:send {user=foo}'
Opções
Opções, assim como argumentos, são outra forma de entrada do usuário. As opções têm um prefixo de dois traços (-) quando fornecidas pela linha de comando. Existem dois tipos de opção: as que recebem um valor e aquelas que não o fazem. As opções que não recebem um valor servem como "interruptor" booleano. Vamos examinar um exemplo desse tipo de opção:
/**
* The name and signature of the console command.
*
* @var string
*/
protected $signature = 'mail:send {user} {--queue}';
Neste exemplo, a opção --queue
pode ser especificada ao chamar o comando Artisan. Se esta opção for passada, o valor da opção será true
. Caso contrário, o valor será false
:
php artisan mail:send 1 --queue
Opções com valores
Vamos agora analisar uma opção que espera um valor. Se o usuário tiver de especificar um valor para uma opção, deve sufixá-la com um sinal de igual (=):
/**
* The name and signature of the console command.
*
* @var string
*/
protected $signature = 'mail:send {user} {--queue=}';
Neste exemplo, o usuário pode passar um valor para essa opção da seguinte maneira. Se não especificada ao invocar o comando, sua opção será null
(nulo):
php artisan mail:send 1 --queue=default
Você pode atribuir valores por padrão para opções ao especificar o valor padrão após o nome da opção. Se nenhum valor de opção for passado pelo usuário, será utilizado o valor padrão:
'mail:send {user} {--queue=default}'
Atalhos de opções
Para atribuir um atalho ao definir uma opção, pode especificá-la antes do nome da mesma e utilizar o caractere "|" como separador para separar o atalho do nome completo da opção:
'mail:send {user} {--Q|queue}'
Quando você inicia o comando em seu terminal, os atalhos de opção devem ser precedidos por um hífen simples e não deve haver nenhum caractere =
incluído ao especificar o valor da opção:
php artisan mail:send 1 -Qdefault
Matrizes de Entrada
Se desejar definir um argumento ou opção com vários valores esperados, pode utilizar o caractere *
. Primeiro, vamos ver um exemplo que especifica tal argumento:
'mail:send {user*}'
Ao chamar este método, os argumentos 'user' podem ser passados na linha de comando. Por exemplo, o seguinte comando definirá o valor do 'user' como um array com valores '1' e '2':
php artisan mail:send 1 2
Este caractere asterisco (*) pode ser combinado com uma definição opcional de argumento para permitir zero ou mais instâncias de um argumento.
'mail:send {user?*}'
Opções de Matriz
Quando você definir uma opção que espera vários valores de entrada, cada valor da opção passado ao comando deve ser prefixado com o nome da opção.
'mail:send {--id=*}'
É possível invocar esse comando ao passar vários argumentos --id
:
php artisan mail:send --id=1 --id=2
Descrições do input
Você pode atribuir descrições para os argumentos e opções de entrada, separando o nome do argumento da descrição usando um ponto. Se você precisar de um pouco de espaço extra para definir seu comando, sinta-se à vontade para espalhar a definição em várias linhas:
/**
* 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}';
Pedido de informações em falta
Se o seu comando contiver argumentos obrigatórios, o usuário receberá uma mensagem de erro quando estes não forem fornecidos. Como alternativa, pode configurar o comando para solicitar automaticamente ao utilizador os dados quando forem faltar argumentos obrigatórios ao implementar a interface PromptsForMissingInput
:
<?php
namespace App\Console\Commands;
use Illuminate\Console\Command;
use Illuminate\Contracts\Console\PromptsForMissingInput;
class SendEmails extends Command implements PromptsForMissingInput
{
/**
* The name and signature of the console command.
*
* @var string
*/
protected $signature = 'mail:send {user}';
// ...
}
Se o Laravel precisar coletar um argumento requerido do usuário, ele irá pedir automaticamente ao usuário pelo argumento utilizando uma frase inteligente contendo o nome ou descrição do argumento. Caso você queira personalizar a pergunta usada para coleta do argumento requerido, poderá implementar o método promptForMissingArgumentsUsing
, retornando um array de perguntas, com as informações dos nomes dos argumentos:
/**
* Prompt for missing input arguments using the returned questions.
*
* @return array<string, string>
*/
protected function promptForMissingArgumentsUsing(): array
{
return [
'user' => 'Which user ID should receive the mail?',
];
}
Você também poderá inserir um texto de substituição usando uma sequência contendo a pergunta e seu texto de substituição:
return [
'user' => ['Which user ID should receive the mail?', 'E.g. 123'],
];
Se você desejar ter controle total sobre o prompt, poderá fornecer um closure que deverá solicitar ao usuário uma resposta e retornar o valor dela:
use App\Models\User;
use function Laravel\Prompts\search;
// ...
return [
'user' => fn () => search(
label: 'Search for a user:',
placeholder: 'E.g. Taylor Otwell',
options: fn ($value) => strlen($value) > 0
? User::where('name', 'like', "%{$value}%")->pluck('name', 'id')->all()
: []
),
];
[!AVERTISSEMENDO] A documentação abrangente de [Pedidos Laravel] (https://laravel.com/docs/5.8#prompts), inclui informações adicionais sobre os pedidos disponíveis e seu uso.
Se você quiser solicitar ao usuário que selecione ou introduza as opções [#options], pode incluir perguntas na ordem de execução do comando. No entanto, se você desejar solicitar somente quando houver sido automaticamente solicitado os argumentos faltantes, poderá implementar o método afterPromptingForMissingArguments
:
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use function Laravel\Prompts\confirm;
// ...
/**
* Perform actions after the user was prompted for missing arguments.
*/
protected function afterPromptingForMissingArguments(InputInterface $input, OutputInterface $output): void
{
$input->setOption('queue', confirm(
label: 'Would you like to queue the mail?',
default: $this->option('queue')
));
}
Entrada/Saída de comandos
Recuperando dados de entrada
Enquanto o comando estiver sendo executado, é provável que você precise acessar os valores dos argumentos e opções aceitos pelo comando. Para fazer isso, você pode usar os métodos argument
e option
. Se um argumento ou uma opção não existir, será retornado null
:
/**
* Execute the console command.
*/
public function handle(): void
{
$userId = $this->argument('user');
}
Se precisar recuperar todos os argumentos como um array
, use o método arguments
:
$arguments = $this->arguments();
As opções podem ser recuperadas da mesma forma que os argumentos usando o método option
. Para recuperar todas as opções como um array, chame o método options
:
// Retrieve a specific option...
$queueName = $this->option('queue');
// Retrieve all options as an array...
$options = $this->options();
Solicitar introdução
[!ATENÇÃO] O Prompt de Laravel é um pacote para adição de formulários bonitos e amigáveis ao seu aplicativo de linha de comando, com recursos semelhantes aos de um browser, incluindo texto-plano e validação.
Além de exibir a saída, você também pode pedir para o usuário fornecer entrada durante a execução do seu comando. O método ask
irá solicitar ao usuário uma pergunta específica e, em seguida, retornará a resposta dele ao seu comando:
/**
* Execute the console command.
*/
public function handle(): void
{
$name = $this->ask('What is your name?');
// ...
}
O método ask
também aceita um segundo argumento opcional, que especifica o valor padrão a ser retornado se nenhuma entrada do usuário for fornecida.
$name = $this->ask('What is your name?', 'Taylor');
O método secret
é semelhante ao ask
, mas a entrada do usuário não será exibida no momento da sua digitação na consola. Este método pode ser útil quando necessitar de informações confidenciais, como as senhas:
$password = $this->secret('What is the password?');
Pedir confirmação
Se necessário pedir ao usuário uma confirmação "sim/não", poderá utilizar a função confirm
. Por padrão, esta função retorna false
. Contudo, se o usuário inserir "y" ou "sim" como resposta à indicação, a função irá retornar true
.
if ($this->confirm('Do you wish to continue?')) {
// ...
}
Caso seja necessário, você pode especificar que o aviso de confirmação deve retornar true
por padrão ao passar true
como segundo argumento para o método confirm
:
if ($this->confirm('Do you wish to continue?', true)) {
// ...
}
Completamento automático
O método anticipate
pode ser usado para dar sugestões de respostas ao utilizador. O utilizador ainda pode fornecer qualquer resposta, independentemente das dicas de preenchimento automático:
$name = $this->anticipate('What is your name?', ['Taylor', 'Dayle']);
Como alternativa, você pode passar um closura como o segundo argumento ao método anticipate
. O closura será chamado a cada vez que o usuário digitar um caractere. O closura deve aceitar um parâmetro de tipo string contendo as entradas do usuário até agora e retornar um array de opções para auto-completar:
$name = $this->anticipate('What is your address?', function (string $input) {
// Return auto-completion options...
});
Perguntas de Escolha Múltipla
Se você precisar fornecer ao usuário um conjunto predefinido de opções quando fazer uma pergunta, poderá usar o método choice
. Pode definir o índice do array para a opção padrão a ser retornada se nenhuma opção for escolhida, passando o índice como o terceiro argumento ao método:
$name = $this->choice(
'What is your name?',
['Taylor', 'Dayle'],
$defaultIndex
);
Além disso, o método choice
aceita quatro e cinco argumentos opcionais para determinar o número máximo de tentativas para selecionar uma resposta válida e se permitem várias seleções:
$name = $this->choice(
'What is your name?',
['Taylor', 'Dayle'],
$defaultIndex,
$maxAttempts = null,
$allowMultipleSelections = false
);
Saída do script
Para enviar saída para a consola, pode utilizar os métodos line
, info
, comment
, question
, warn
e error
. Cada um destes métodos irá usar cores ANSI apropriadas para o seu objetivo. Por exemplo, vamos mostrar algumas informações gerais ao utilizador. Normalmente, o método info
irá mostrar na consola como texto colorido verde:
/**
* Execute the console command.
*/
public function handle(): void
{
// ...
$this->info('The command was successful!');
}
Para exibir uma mensagem de erro, utilize o método error
. O texto da mensagem de erro é exibido normalmente em vermelho:
$this->error('Something went wrong!');
Pode utilizar o método line
para apresentar um texto puro e não colorido:
$this->line('Display this on the screen');
Você pode usar o método newLine
para exibir uma nova linha em branco:
// Write a single blank line...
$this->newLine();
// Write three blank lines...
$this->newLine(3);
Tabelas
O método table
facilita o formatação correta de várias linhas/colunas de dados. Só é necessário indicar os nomes das colunas e os seus respectivos dados, sendo que o Laravel cuidará de tudo o mais. O Excel calculará automaticamente o comprimento e largura apropriados da tabela para você:
use App\Models\User;
$this->table(
['Name', 'Email'],
User::all(['name', 'email'])->toArray()
);
Barras de progresso
Para tarefas que demoram mais tempo, pode ser útil mostrar uma barra de progresso que informe os usuários do grau de conclusão da tarefa. Usando o método withProgressBar
, Laravel exibirá uma barra de progresso e avançará sua progressão para cada iteração sobre um determinado valor iterável:
use App\Models\User;
$users = $this->withProgressBar(User::all(), function (User $user) {
$this->performTask($user);
});
Às vezes, você pode precisar de mais controle manual sobre como um indicador de andamento é avançado. Primeiro defina o número total de etapas que o processo vai percorrer e depois avance o indicador de andamento após o processamento de cada item:
$users = App\Models\User::all();
$bar = $this->output->createProgressBar(count($users));
$bar->start();
foreach ($users as $user) {
$this->performTask($user);
$bar->advance();
}
$bar->finish();
Registo de comandos
Por padrão, o Laravel registra automaticamente todos os comandos na pasta app/Console/Commands
. No entanto, você pode instruir o Laravel a procurar por comandos da ArtiSan noutras pastas no arquivo bootstrap/app.php
do seu aplicativo usando o método withCommands
:
->withCommands([
__DIR__.'/../app/Domain/Orders/Commands',
])
Se necessário, também poderá registrar comandos manualmente fornecendo o nome da classe do comando ao método withCommands
:
use App\Domain\Orders\Commands\SendEmails;
->withCommands([
SendEmails::class,
])
Quando o comando "artisan" for executado, todos os comandos em sua aplicação serão resolvidos pelo conjunto de serviços e registrados no "Artisan".
Executando comandos de maneira programática
Por vezes pode pretender executar um comando Artisan fora da CLI. Por exemplo, pretende executar um comando Artisan a partir de uma rota ou controlador. Pode usar o método call
na faceta Artisan
para realizar isto. O método call
aceita como primeiro argumento o nome da assinatura do comando ou o nome da classe, e um array de parâmetros do comando como segundo argumento. O código de saída é retornado:
use Illuminate\Support\Facades\Artisan;
Route::post('/user/{user}/mail', function (string $user) {
$exitCode = Artisan::call('mail:send', [
'user' => $user, '--queue' => 'default'
]);
// ...
});
Como alternativa, você pode passar o comando completo do Artisan para o método call
, como uma cadeia de caracteres:
Artisan::call('mail:send 1 --queue=default');
Transmitir valores de matriz
Se o seu comando definir uma opção que aceite um conjunto de valores, poderá passar um conjunto destes para essa opção.
use Illuminate\Support\Facades\Artisan;
Route::post('/mail', function () {
$exitCode = Artisan::call('mail:send', [
'--id' => [5, 13]
]);
});
Transmitindo valores booleanos
Se você precisar especificar o valor de uma opção que não aceita valores de string, como a opção --force
no comando migrate:refresh
, você deve passar true
ou false
como o valor da opção:
$exitCode = Artisan::call('migrate:refresh', [
'--force' => true,
]);
Ordem de Funcionamento de Comandos Artesanais
Usando o método queue
da facade Artisan
, você pode até mesmo agendar comandos do Artisan
para serem processados no background pelos trabalhadores de filas. Antes de usar este método, certifique-se que você tenha configurado a fila e está executando um receptor da fila:
use Illuminate\Support\Facades\Artisan;
Route::post('/user/{user}/mail', function (string $user) {
Artisan::queue('mail:send', [
'user' => $user, '--queue' => 'default'
]);
// ...
});
Usando as funcionalidades onConnection
e onQueue
, pode especificar a conexão ou fila para onde o comando Artisan deverá ser enviado.
Artisan::queue('mail:send', [
'user' => 1, '--queue' => 'default'
])->onConnection('redis')->onQueue('commands');
Chamar comandos a partir de outros comandos
Às vezes, você pode querer chamar outros comandos de um comando existente no Artisan. Você pode fazer isso usando o método call
. Este método aceita o nome do comando e uma matriz de argumentos / opções para o comando:
/**
* Execute the console command.
*/
public function handle(): void
{
$this->call('mail:send', [
'user' => 1, '--queue' => 'default'
]);
// ...
}
Se você deseja chamar um comando de outra console e suprimir todo o seu conteúdo, poderá usar o método callSilently
. O método callSilently
possui a mesma assinatura do método call
:
$this->callSilently('mail:send', [
'user' => 1, '--queue' => 'default'
]);
Processamento de sinais
Como você provavelmente já sabe, os sistemas operacionais permitem o envio de sinais para processos em execução. Por exemplo, o sinal SIGTERM
é utilizado pelos sistemas operacionais para solicitar o término de um programa. Se você quiser ouvir sinais no seu comando Artisan console e executar código quando eles ocorrerem, pode usar o método trap
:
/**
* Execute the console command.
*/
public function handle(): void
{
$this->trap(SIGTERM, fn () => $this->shouldKeepRunning = false);
while ($this->shouldKeepRunning) {
// ...
}
}
Para ouvir vários sinais ao mesmo tempo, você pode passar uma matriz de sinais para o método trap
:
$this->trap([SIGTERM, SIGQUIT], function (int $signal) {
$this->shouldKeepRunning = false;
dump($signal); // SIGTERM / SIGQUIT
});
Personalização de stubs
Os comandos make
do console de artesão são utilizados para criar várias classes como controladores, tarefas, migrações e testes. Essas classes são geradas com base em arquivos "stub" que contêm valores baseados na sua entrada. No entanto, pode ser necessário fazer pequenas alterações nos arquivos gerados pelo Artisan. Para fazer isso, você pode usar o comando stub:publish
para publicar os stubs mais comuns em sua aplicação para que seja possível personalizá-los:
php artisan stub:publish
As stubs publicadas estarão localizadas dentro do diretório stubs
, na raiz de seu aplicativo. Todas as alterações feitas nessas stubs serão refletidas quando você gerar suas classes correspondentes usando os comandos do Artisan make
.
Eventos
O módulo Artisan envia três eventos ao executar comandos: Illuminate\Console\Events\ArtisanStarting
, Illuminate\Console\Events\CommandStarting
e Illuminate\Console\Events\CommandFinished
. O evento Illuminate\Console\Events\ArtisanStarting
é enviado imediatamente quando o módulo Artisan é iniciado. Em seguida, o evento Illuminate\Console\Events\CommandStarting
é enviado antes da execução de um comando e, por último, o evento Illuminate\Console\Events\CommandFinished
é enviado assim que um comando terminar a sua execução.