Очереди

Подключения или очереди

Перед изучением очередей Laravel важно понимать различие между «подключениями» и «очередями». В вашем файле настроек config/queue.php есть параметр connections, который определяет конкретное подключение к сервису очередей, такому как Amazon SQS, Beanstalk или Redis. Но у любого подключения может быть несколько «очередей», которые можно представить в виде отдельных стеков или наборов задач в очереди.

Обратите внимание, в каждом примере настройки подключения в файле queue есть атрибут queue. Это та очередь, в которую будут помещаться задачи при отправке по данному подключению. Другими словами, если вы отправляете задачу без явного указания очереди, задача будет помещена в очередь, заданную в атрибуте queue в настройках подключения:

// Эта задача отправлена в очередь по умолчанию...
dispatch(new Job);

// Эта задача отправлена в очередь "emails"...
dispatch((new Job)->onQueue('emails'));

Для некоторых приложений нет необходимости помещать задачи в несколько очередей, для них достаточно иметь одну простую очередь. Иметь несколько очередей особенно полезно для приложений, в которых необходимо разделение обрабатываемых задач по сегментам или приоритетам. Обработчик очереди Laravel позволяет вам указывать какие задачи имеют больший приоритет. Например, если вы отправите задачу в очередь high, то можете запустить обработчик, который даст им больший приоритет при выполнении:

shphp artisan queue:work --queue=high,default

Redis

Для использования драйвера очереди redis вам надо настроить подключение к базе данных Redis в файле config/database.php.

Если ваше подключение к очереди Redis использует Redis Cluster, имена ваших очередей должны содержать хештег ключа. Это необходимо, чтобы убедиться в том, что все ключи Redis для данной очереди помещены в один хеш-слот:

conf'redis' => [
  'driver' => 'redis',
  'connection' => 'default',
  'queue' => '{default}',
  'retry_after' => 90,
],

shphp artisan make:job SendReminderEmail

shphp artisan make:job SendReminderEmail --queued

shphp artisan make:command SendEmail --queued

В этом примере мы представим, что создаём сервис публикации подкастов, и нам надо обрабатывать загружаемые файлы подкастов перед их публикацией:

<?php

namespace App\Jobs;

use App\Podcast;
use App\AudioProcessor;
use Illuminate\Bus\Queueable;
use Illuminate\Queue\SerializesModels;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Contracts\Queue\ShouldQueue;

class ProcessPodcast implements ShouldQueue
{
  use InteractsWithQueue, Queueable, SerializesModels;

  protected $podcast;

  /**
   * Создание нового экземпляра задачи.
   *
   * @param  Podcast  $podcast
   * @return void
   */
  public function __construct(Podcast $podcast)
  {
    $this->podcast = $podcast;
  }

  /**
   * Выполнение задачи.
   *
   * @param  AudioProcessor  $processor
   * @return void
   */
  public function handle(AudioProcessor $processor)
  {
    // Обработка загруженного подкаста...
  }
}

Если вы хотите, чтобы у команды был отдельный класс-обработчик, вам надо добавить ключ sh--handler в команду shmake:command:

shphp artisan make:command SendEmail --queued --handler

Бинарные данные, такие как сырое содержимое изображения, должны быть пропущены через функцию PHPbase64_encode() перед отправкой в задачу для очереди. Иначе задача может быть неправильно сериализована в JSON при помещении в очередь.

Ручной выпуск задач

Если вы хотите «отпустить» задачу вручную, то типаж InteractsWithQueue, который уже включён в ваш сгенерированный класс задачи, предоставляет доступ к методу задачи PHPrelease(). Этот метод принимает один аргумент — число секунд, через которое задача станет снова доступной:

public function handle(Mailer $mailer)
{
  if (condition) {
    $this->release(10);
  }
}

Проверка числа попыток запуска

Как уже было сказано, при возникновении исключения при выполнении задачи она будет автоматически возвращена в очередь. Вы можете проверить число сделанных попыток выполнения задачи при помощи метода PHPattempts():

public function handle(Mailer $mailer)
{
  if ($this->attempts() > 3) {
    //
  }
}

Когда вы напишете класс вашей задачи, вы можете отправить её в очередь с помощью вспомогательного метода PHPdispatch(). Необходимо передать единственный аргумент — экземпляр задачи:

<?php

namespace App\Http\Controllers;

use App\Jobs\ProcessPodcast;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;

class PodcastController extends Controller
{
  /**
   * Сохранить новый подкаст.
   *
   * @param  Request  $request
   * @return Response
   */
  public function store(Request $request)
  {
    // Создать подкаст...

    dispatch(new ProcessPodcast($podcast));
  }
}

Вспомогательный метод PHPdispatch() — удобная, лаконичная, доступная глобально функция, а также её чрезвычайно просто тестировать. Узнайте больше из документации по тестированию.

Стандартный контроллер Laravel расположен в app/Http/Controllers/Controller.php и использует типаж DispatchesJobs. Этот типаж предоставляет несколько методов, позволяющих вам удобно помещать задачи в очередь. Например, метод PHPdispatch():

<?php

namespace App\Http\Controllers;

use App\User;
use Illuminate\Http\Request;
use App\Jobs\SendReminderEmail;
use App\Http\Controllers\Controller;

class UserController extends Controller
{
  /**
   * Послать уведомление по e-mail данному пользователю.
   *
   * @param  Request  $request
   * @param  int  $id
   * @return Response
   */
  public function sendReminderEmail(Request $request, $id)
  {
    $user = User::findOrFail($id);

    $this->dispatch(new SendReminderEmail($user));
  }
}

Типаж DispatchesJobs

Разумеется, иногда нужно отправить задачу из другого места вашего приложения — не из маршрута или контроллера. Для этого вы можете включить типаж DispatchesJobs в любой класс своего приложения, чтобы получить доступ к его различным методам отправки. Например, вот пример класса, использующего этот типаж:

<?php

namespace App;

use Illuminate\Foundation\Bus\DispatchesJobs;

class ExampleClass
{
  use DispatchesJobs;
}

Функция PHPdispatch()

Или, вы можете использовать глобальную функцию PHPdispatch():

Route::get('/job', function () {
  dispatch(new App\Jobs\PerformTask);

  return 'Готово!';
});

Для добавления новой задачи в очередь используйте метод PHPQueue::push():

Queue::push(new SendEmail($message));

В этом примере мы используем фасад Queue напрямую. Но обычно вы будете отправлять команды в очередь через командную шину. В этой статье мы продолжим использовать фасад Queue, но также коснёмся и командной шины, поскольку она используется и для отправки синхронных задач, и для отправки задач в очередь.

Сгенерированный обработчик будет помещён в App\Handlers\Commands и будет извлечён из IoC-контейнера.

Например, давайте укажем, что задача станет доступной для обработки через 10 минут после отправки в очередь:

<?php

namespace App\Http\Controllers;

use Carbon\Carbon;
use App\Jobs\ProcessPodcast;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;

class PodcastController extends Controller
{
  /**
   * Сохранить новый подкаст.
   *
   * @param  Request  $request
   * @return Response
   */
  public function store(Request $request)
  {
    // Создать подкаст...

    $job = (new ProcessPodcast($podcast))
                ->delay(Carbon::now()->addMinutes(10));

    dispatch($job);
  }
}

Например, вы захотите поместить в очередь задачу, которая отправляет пользователю e-mail через 5 минут после регистрации:

<?php

namespace App\Http\Controllers;

use App\User;
use Illuminate\Http\Request;
use App\Jobs\SendReminderEmail;
use App\Http\Controllers\Controller;

class UserController extends Controller
{
  /**
   * Отправить уведомление на e-mail данному пользователю.
   *
   * @param  Request  $request
   * @param  int  $id
   * @return Response
   */
  public function sendReminderEmail(Request $request, $id)
  {
    $user = User::findOrFail($id);

    $job = (new SendReminderEmail($user))->delay(60 * 5);

    $this->dispatch($job);
  }
}

В этом примере мы указали, что задача в очереди должна быть отложена на 5 минут до того, как станет доступной обработчикам.

Вы можете добиться этого, используя метод PHPQueue::later():

$date = Carbon::now()->addMinutes(15);

Queue::later($date, new SendEmail($message));

В этом примере мы используем библиотеку для работы со временем Carbon, чтобы указать необходимое время задержки для задачи. Другой вариант — передать необходимое число секунд для задержки.

Вы можете задать очередь, в которую следует посылать задачу:

Queue::pushOn('emails', new SendEmail($message));

Передача одинаковых данных в несколько задач

Если вам надо передать одинаковые данные в несколько задач в очереди, вы можете использовать метод PHPQueue::bulk():

Queue::bulk([new SendEmail($message), new AnotherCommand]);

Указание подключения к очереди для задачи

Если вы работаете с несколькими подключениями к очередям, то можете указать, в какое из них надо поместить задачу. Для этого служит метод PHPonConnection() на экземпляре задачи:

Само собой, вы можете сцепить методы PHPonConnection() и PHPonQueue(), чтобы указать подключение и очередь для задачи:

$job = (new ProcessPodcast($podcast))
                ->onConnection('sqs')
                ->onQueue('processing');

Запуск обработчика очереди

Laravel содержит обработчик очереди, который обрабатывает новые задачи при поступлении в очередь. Вы можете запустить его Artisan-командой shqueue:work. Запомните, команда shqueue:work будет выполняться, пока вы не остановите её вручную или закроете свой терминал:

shphp artisan queue:work

Чтобы процесс shqueue:work выполнялся в фоне постоянно, используйте монитор процессов, такой как Supervisor, для проверки, что обработчик очереди не остановился.

Запомните, обработчики очереди — долгоживущие процессы, и они хранят в памяти состояние загруженного приложения. Поэтому они не заметят изменения в вашем коде, сделанные после их запуска. Поэтому в процессе развёртывания не забудьте перезапустить обработчиков очереди.

Указание подключения и очереди

Также вы можете указать, какое подключение должен использовать обработчик очереди. Имя подключения передаётся команде shwork и должно соответствовать одному из подключений, определённых в файле config/queue.php:

shphp artisan queue:work redis

Можно ещё точнее настроить обработчика очереди, указав для него конкретные очереди в данном подключении. Например, если все ваши email-сообщения обрабатываются в очереди emails в подключении redis, вы можете выполнить такую команду для запуска обработчика только для этой очереди:

shphp artisan queue:work redis --queue=emails

Освобождение ресурсов

Демоны-обработчики очереди не «перезагружают» фреймворк перед обработкой каждой задачи. Поэтому вам надо освобождать все тяжёлые ресурсы после завершения каждой задачи. Например, если вы выполняете обработку изображения с помощью библиотеки GD, то после завершения обработки вам надо освободить память с помощью PHPimagedestroy.

Приоритеты очередей

Иногда бывает необходимо организовать обработку очередей по их приоритетам. Например, в файле config/queue.php вы можете задать очередь low как очередь по умолчанию для подключения redis. При этом при необходимости вы можете помещать задачу в очередь high вот так:

dispatch((new Job)->onQueue('high'));

Чтобы запустить обработчика, который сначала проверит, что обработаны все задачи из очереди high, и только потом продолжит обрабатывать задачи из очереди low, передайте в команду sh список очередей через запятую:

shphp artisan queue:work --queue=high,low

Обработчики очереди и развёртывание

Поскольку обработчики очереди — долгоживущие процессы, они не подхватят изменения в вашем коде, пока не будут перезапущены. Поэтому простейший способ развернуть приложение с обработчиками очереди — перезапустить обработчиков во время процесса развёртывания. Вы можете мягко перезапустить всех своих обработчиков командой shqueue:restart:

shphp artisan queue:restart

Эта команда заставит обработчиков очереди мягко «умереть» после завершения ими текущей задачи, поэтому ни одна существующая задаче не будет потеряна. Поскольку обработчики очереди умрут при выполнении команды shqueue:restart, вам надо запустить менеджер процессов, такой как Supervisor, для автоматического перезапуска обработчиков очереди.

Окончание срока задачи и таймауты

Окончание срока задачи

В файле config/queue.php для каждого подключения определён параметр retry_after. Этот параметр указывает, сколько секунд подключение должно ждать, прежде чем заново приступить к обрабатываемой задаче. Например, если значение retry_after равно 90, то задача будет возвращена назад в очередь, если пробудет в обработке 90 секунд и не будет удалена. Обычно для retry_after лучше задать значение равное максимальному разумному количеству секунд, которое потребуется задачам для выполнения.

Единственное подключение, у которого нет значения retry_after, — Amazon SQS. SQS пробует выполнить задачу заново исходя из стандартного таймаута видимости, который настраивается в консоли AWS.

Таймауты обработчиков

Artisan-команда shqueue:work имеет параметр sh--timeout. Этот параметр указывает, сколько должен ждать главный процесс обработки очередей Laravel, прежде чем уничтожить дочернего обработчика очереди, выполняющего задачу. Дочерний процесс обработки очереди может «зависнуть» по разным причинам, таким как внешний HTTP-вызов, который не отвечает. Параметр sh--timeout удаляет зависнувшие процессы, превысившие указанный лимит времени:

shphp artisan queue:work --timeout=60

Параметр retry_after в настройках и параметр командной строки sh--timeout разные, но работают совместно для проверки, что задачи не потерялись, и что задачи выполняются успешно только один раз.

Значение sh--timeout должно быть всегда по крайней мере на несколько секунд меньше значения retry_after в настройках. Таким образом обработчик, выполняющий данную задачу, будет всегда убиваться до повторной попытки выполнения задачи. Если ваш параметр sh--timeout имеет значение больше значения retry_after, ваши задачи могут выполниться дважды.

Длительность паузы обработчика

Пока в очереди доступны задачи, обработчик будет выполнять их без задержки между ними. С помощью параметра shsleep можно задать время, на которое будет «засыпать» обработчик, если нет новых задач:

shphp artisan queue:work --sleep=3

Получение задач из запросов

Очень часто переменные HTTP-запросов переносятся в задачи. Поэтому вместо того, чтобы заставлять вас делать это вручную для каждого запроса, Laravel предоставляет несколько вспомогательных методов. Давайте посмотрим на метод PHPdispatchFrom() типажа DispatchesJobs. По умолчанию этот типаж включён в базовый класс контроллера Laravel:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Http\Controllers\Controller;

class CommerceController extends Controller
{
  /**
   * Обработка данного заказа.
   *
   * @param  Request  $request
   * @param  int  $id
   * @return Response
   */
  public function processOrder(Request $request, $id)
  {
    // Обработка запроса...

    $this->dispatchFrom('App\Jobs\ProcessOrder', $request);
  }
}

Этот метод проверит конструктор класса данной задачи и извлечёт переменные из HTTP-запроса (или любого другого объекта ArrayAccess) для заполнения необходимых параметров конструктора задачи. Поэтому, если класс нашей задачи принимает в конструкторе переменную productId, то шина задач попытается получить параметр productId из HTTP-запроса.

Вы также можете передать массив третьим аргументом метода PHPdispatchFrom(). Этот массив будет использован для заполнения тех параметров, которых нет в запросе:

$this->dispatchFrom('App\Jobs\ProcessOrder', $request, [
    'taxPercentage' => 20,
]);

Добавление замыканий в очередь

Вы можете помещать в очередь и функции-замыкания. Это очень удобно для простых, быстрых задач, выполняющихся в очереди.

Добавление замыкания в очередь

Queue::push(function($job) use ($id)
{
  Account::delete($id);

  $job->delete();
});

Вместо того, чтобы делать объекты доступными для замыканий в очереди через директиву PHPuse, передавайте первичные ключи и повторно извлекайте связанные модели из вашей задачи в очереди. Это часто позволяет избежать неожиданного поведения при сериализации.

При использовании push-очередей Iron.io будьте особенно внимательны при добавлении замыканий. Конечная точка выполнения, получающая ваше сообщение, должна проверить входящую последовательность-ключ, чтобы удостовериться, что запрос действительно исходит от Iron.io. Например, ваша конечная push-точка может иметь адрес вида https://yourapp.com/queue/receive?token=SecretToken — где значение token можно проверять перед собственно обработкой задачи.

Запуск Supervisor

После создания файла настроек вы можете обновить конфигурацию Supervisor и запустить процесс при помощи следующих команд:

shsudo supervisorctl reread

sudo supervisorctl update

sudo supervisorctl start laravel-worker:*

Уборка после проваленных задач

Вы можете определить метод PHPfailed() прямо в классе задачи, это позволит вам выполнять уборку после данной конкретной задачи при возникновении ошибки. Это идеальное место для отправки предупреждения вашим пользователям или для отмены всех действий, выполненных задачей. Исключение PHPException, приведшее к провалу задачи, будет передано в метод PHPfailed():

<?php

namespace App\Jobs;

use Exception;
use App\Podcast;
use App\AudioProcessor;
use Illuminate\Bus\Queueable;
use Illuminate\Queue\SerializesModels;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Contracts\Queue\ShouldQueue;

class ProcessPodcast implements ShouldQueue
{
  use InteractsWithQueue, Queueable, SerializesModels;

  protected $podcast;

  /**
   * Создать новый экземпляр задачи.
   *
   * @param  Podcast  $podcast
   * @return void
   */
  public function __construct(Podcast $podcast)
  {
    $this->podcast = $podcast;
  }

  /**
   * Выполнить задачу.
   *
   * @param  AudioProcessor  $processor
   * @return void
   */
  public function handle(AudioProcessor $processor)
  {
    // Обработка загруженного подкаста...
  }

  /**
   * Ошибка выполнения задачи.
   *
   * @param  Exception  $exception
   * @return void
   */
  public function failed(Exception $exception)
  {
    // Отправить пользователю уведомление об ошибке, и т.п. ...
  }
}

Метод PHPfailed() класса задачи

Для более точного контроля, вы можете определить метод PHPfailed() непосредственно в классе задачи, это позволит выполнять специфичное для задачи действие при возникновении ошибки:

<?php

namespace App\Jobs;

use App\Jobs\Job;
use Illuminate\Contracts\Mail\Mailer;
use Illuminate\Queue\SerializesModels;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Contracts\Queue\ShouldQueue;

//для версии 5.1 и ранее:
//use Illuminate\Contracts\Bus\SelfHandling;
//
//class SendReminderEmail extends Job implements SelfHandling, ShouldQueue

class SendReminderEmail extends Job implements ShouldQueue
{
  use InteractsWithQueue, SerializesModels;

  /**
   * Выполнение задачи.
   *
   * @param  Mailer  $mailer
   * @return void
   */
  public function handle(Mailer $mailer)
  {
    //
  }

  /**
   * Обработка ошибки задачи.
   *
   * @return void
   */
  public function failed()
  {
    // Вызывается при ошибке в задаче...
  }
}

Если задача не само-обрабатываемая, а имеет отдельный класс-обработчик, то метод PHPfailed() должен быть определён именно там.

Методы PHPbefore() и PHPafter() фасада Queue позволяют указать обратные вызовы, которые будут выполнены до выполнения задачи или после успешного выполнения задачи. Эти обратные вызовы — отличная возможность для выполнения дополнительного журналирования или увеличения статистики для панели управления. Обычно эти методы вызываются из сервис-провайдера. Например, мы можем использовать AppServiceProvider, который включён в Laravel:

<?php

namespace App\Providers;

use Illuminate\Support\Facades\Queue;
use Illuminate\Support\ServiceProvider;
use Illuminate\Queue\Events\JobProcessed;
use Illuminate\Queue\Events\JobProcessing;

class AppServiceProvider extends ServiceProvider
{
  /**
   * Начальная загрузка всех сервисов приложения.
   *
   * @return void
   */
  public function boot()
  {
    Queue::before(function (JobProcessing $event) {
      // $event->connectionName
      // $event->job
      // $event->job->payload()
    });

    Queue::after(function (JobProcessed $event) {
      // $event->connectionName
      // $event->job
      // $event->job->payload()
    });
  }

  /**
   * Регистрация сервис-провайдера.
   *
   * @return void
   */
  public function register()
  {
    //
  }
    }

С помощью метода PHPlooping() фасада Queue вы можете указать обратные вызовы, которые будут выполнены перед тем, как обработчик попытается получить задачу из очереди. Например, вы можете зарегистрировать замыкание для отката всех транзакций, которые были оставлены открытыми предыдущей проваленной задачей:

Queue::looping(function () {
  while (DB::transactionLevel() > 0) {
    DB::rollBack();
  }
});

События выполнения задачи

Методы PHPQueue::before() и PHPQueue::after() позволяют зарегистрировать обратный вызов, который будет выполнен до выполнения задачи или после успешного выполнения задачи. Обратные вызовы — отличная возможность для выполнения дополнительного журналирования, помещения в очередь последующей задачи, или увеличения статистики для панели управления. Например, мы можем прикрепить обратный вызов к этому событию из AppServiceProvider, который включён в Laravel:

<?php

namespace App\Providers;

use Queue;
use Illuminate\Support\ServiceProvider;
//для версии 5.2 и выше:
use Illuminate\Queue\Events\JobProcessed;

class AppServiceProvider extends ServiceProvider
{
  /**
   * Начальная загрузка всех сервисов приложения.
   *
   * @return void
   */
  public function boot()
  {
    //для версии 5.2 и выше:
    Queue::after(function (JobProcessed $event) {
      // $event->connectionName
      // $event->job
      // $event->data

    //для версии 5.1 и ранее:
    //Queue::after(function ($connection, $job, $data) {
    //  //
    });
  }

  /**
   * Регистрация сервис-провайдера.
   *
   * @return void
   */
  public function register()
  {
    //
  }
}

Запуск слушателя очереди

Запуск слушателя очереди

Laravel включает в себя Artisan-команду, которая будет выполнять новые задачи по мере их поступления. Вы можете запустить слушателя командой shqueue:listen:

shphp artisan queue:listen

Вы также можете указать, какое именно соединение должно прослушиваться:

shphp artisan queue:listen connection-name

shphp artisan queue:listen connection

Заметьте, что когда это задание запущено, оно будет продолжать работать, пока вы не остановите его вручную. Вы можете использовать монитор процессов, такой как Supervisor, чтобы удостовериться, что задание продолжает работать.

Приоритеты очереди

Вы можете передать команде shlisten список подключений к очереди через запятую, чтобы задать приоритеты для очереди:

shphp artisan queue:listen --queue=high,low

В этом примере задачи из подключения high-connection всегда будут обрабатывать перед задачами из low-connection.

Указание времени на выполнение задачи

Кроме этого вы можете указать число секунд, в течение которых будет выполняться каждая задача:

shphp artisan queue:listen --timeout=60

Указание перерыва между задачами

Также вы можете задать число секунд ожидания перед проверкой наличия новых задач в очереди:

shphp artisan queue:listen --sleep=5

Обратите внимание, что очередь «засыпает» только тогда, когда в ней нет задач. Если задачи есть, очередь будет продолжать обрабатывать их без перерыва.

Обработка только первой задачи в очереди

Для обработки только первой задачи можно использовать команду shqueue:work:

shphp artisan queue:work

Демон-обработчик очереди

Команда shqueue:work также имеет опцию sh--daemon для того, чтобы обработчик принудительно продолжал обрабатывать задачи без необходимости повторной загрузки фреймворка. Это приводит к значительному снижению использования CPU по сравнению с командой shqueue:listen.

Для запуска обработчика очереди в режиме демона используйте флаг sh--daemon:

shphp artisan queue:work connection-name --daemon

php artisan queue:work connection-name --daemon --sleep=3

php artisan queue:work connection-name --daemon --sleep=3 --tries=3

shphp artisan queue:work connection --daemon

php artisan queue:work connection --daemon --sleep=3

php artisan queue:work connection --daemon --sleep=3 --tries=3

Как видите, команда shqueue:work поддерживает те же самые опции, что и команда shqueue:listen. Для просмотра всех доступных опций используйте команду shphp artisan help queue:work.

Написание кода для демонов-обработчиков очереди

Демоны-обработчики очереди не перезапускают фреймворк перед обработкой каждой задачи. Поэтому нужно быть аккуратным при освобождении любых «тяжёлых» ресурсов до того, как закончится выполнение вашей задачи. Например, если вы обрабатываете изображение с помощью библиотеки GD, то после завершения обработки вам необходимо освобождать память с помощью PHPimagedestroy().

Также ваше соединение с БД может быть потеряно, когда оно используется демоном долгое время. Вы можете использовать метод PHPDB::reconnect(), для обеспечения «свежего» соединения.

Развёртывание с помощью демонов-обработчиков очереди

Поскольку демоны-обработчики очереди — длительные процессы, они не подхватывают изменения в коде без перезапуска. Поэтому простейший способ развернуть приложение, используя обработчики очереди, — перезапустить их во время выполнения скрипта развёртывания. Вы можете изящно перезапустить все обработчики, включив следующую команду в ваш скрипт для развёртывания:

shphp artisan queue:restart

Эта команда сообщит всем обработчикам очереди о необходимости «умереть» после завершения обработки их текущих задач, поэтому текущие задачи не пропадут. Не забывайте, что обработчики очереди умрут при выполнении команды shqueue:restart, поэтому необходимо запустить менеджер процессов, такой как Supervisor, который автоматически перезапустит обработчики задач.

Эта команда сообщит всем обработчикам очереди о необходимости перезапуска после завершения обработки их текущих задач, поэтому текущие задачи не пропадут.

Эта команда полагается на систему кэша для планирования перезапуска. По умолчанию APCu не работает для терминальных задач. Если вы используете APCu, добавьте confapc.enable_cli=1 в свою конфигурацию для APCu.

Push-очереди

Push-очереди дают вам доступ ко всем мощным возможностям, предоставляемым подсистемой очередей Laravel 5, без запуска демонов и фоновых слушателей. На текущий момент push-очереди поддерживает только драйвер Iron.io. Перед тем, как начать, создайте аккаунт и впишите его данные в config/queue.php.

Регистрация подписчика push-очереди

После этого вы можете использовать Artisan-команду shqueue:subscribe для регистрации URL конечной точки, которая будет получать добавляемые в очередь задачи:

shphp artisan queue:subscribe queue_name queue/receive

php artisan queue:subscribe queue_name http://foo.com/queue/receive

Теперь, когда вы войдёте в ваш профиль Iron.io, то увидите новую push-очередь и URL её подписки. Вы можете подписать любое число URL на одну очередь. Дальше создайте маршрут для вашей конечной точки queue/receive, и пусть он возвращает результат вызова метода PHPQueue::marshal():

Route::post('queue/receive', function()
{
  return Queue::marshal();
});

Этот метод позаботится о вызове нужного класса-обработчика задачи. Для помещения задач в push-очередь просто используйте всё тот же метод PHPQueue::push(), который работает и для обычных очередей.