Блог

У меня есть два набора заданий:

• Set1: Задание A, задание B, задание C
• Набор 2: Задание D, задание E, задание F

Как я могу обработать все задания в Set1, а затем обработать задания в Set2?

Я попробовал связать задания в цепочку. Но цепочка заданий прекращает обработку заданий, если предыдущее задание выполнено с ошибкой. Я хочу обработать их все, даже если одно из них завершилось с ошибкой.

Он должен обрабатывать все задания в Set1(A, B, C), и процесс B и C не должен останавливаться, если процесс задания A завершился неудачей. Когда все задания из Set1 обработаны (независимо от того, завершились неудачей или успехом) Он должен забирать задания в Set2 для обработки.

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

Я не могу работать с отложенной отправкой, потому что время, затрачиваемое на обработку набора 1 заданий, варьируется очень сильно.

Теперь это можно сделать с помощью пакетной обработки заданий в Laravel 8.x:

 $batch = Bus::batch([
    new ImportCsv(1, 100),
    new ImportCsv(101, 200),
    new ImportCsv(201, 300),
    new ImportCsv(301, 400),
    new ImportCsv(401, 500),
])->then(function (Batch $batch) {
    // All jobs completed successfully...
})->catch(function (Batch $batch, Throwable $e) {
    // First batch job failure detected...
})->finally(function (Batch $batch) {
    // The batch has finished executing...
})->dispatch();
  

Цепочка заданий в Laravel основана на том факте, что она не будет выполнять следующие задания, если текущее не выполняется.

Вы можете использовать события. У каждого задания есть 2 метода handle() и failed() . Вы можете генерировать события либо при успешном выполнении задания, либо при сбое. Смотрите пример ниже :

Например :

 <?php

namespace AppJobs;

use Exception;
use AppSomething;
use IlluminateBusQueueable;
use IlluminateQueueSerializesModels;
use IlluminateQueueInteractsWithQueue;
use IlluminateContractsQueueShouldQueue;

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

    protected $something;

    /**
     * Create a new job instance.
     *
     * @param  Something $somethin
     * @return void
     */
    public function __construct(Something $something)
    {
        $this->something = $something;
    }

    /**
     * Execute the job.
     *
     * @param  AudioProcessor  $processor
     * @return void
     */
    public function handle()
    {
        // Execute Job on something
        event(new JobAHandled($something));
    }

    /**
     * The job failed to process.
     *
     * @param  Exception  $exception
     * @return void
     */
    public function failed(Exception $exception)
    {
        // Send user notification of failure, etc...
        event(new JobAFailed($something, $e));
    }
}
  

Теперь вы можете вызвать следующее задание, прослушав события JobAHandled и JobAFailed . Это даст вам контроль над тем, что даже если вы продолжаете выполнение следующего задания, вы знаете, что предыдущее задание завершилось неудачей. При необходимости вы можете зарегистрировать это.

Затем вы можете сделать то же самое для других заданий, независимо от набора, в котором оно находится.

Также убедитесь, что если вы попробуете выполнить задание, то дальнейшие задания будут выполнены снова, поскольку, учитывая ваш случай, событие failed также выполнит следующее задание.

Идея заключалась бы в создании задания JobSet и задания JobWorker.

Таким образом, набор заданий принимает ваш новый JobWorker («A»), JobWorker («B»), JobWorker («C») в качестве аргумента, а затем отправляет их все.

 dispatch(new JobSet(new JobWorker("A"), new JobWorker("B"), new JobWorker("C")));
  

и задание «Набор заданий» для вдохновения

 class JobSet implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    private $a;
    private $b;
    private $c;

    /**
     * Create a new job instance.
     *
     * @return void
     */
    public function __construct(JobWorker $a, JobWorker $b, JobWorker $c)
    {
        $this->a = $a;
        $this->b = $b;
        $this->c = $c;
    }

    /**
     * Execute the job.
     *
     * @return void
     */
    public function handle()
    {
        dispatch($this->a);
        dispatch($this->b);
        dispatch($this->c);
    }
}
  

Вы можете отправлять их в разные очереди:

 A::dispatch()->onQueue('set1');
B::dispatch()->onQueue('set1');
C::dispatch()->onQueue('set1');

D::dispatch()->onQueue('set2');
E::dispatch()->onQueue('set2');
F::dispatch()->onQueue('set2');
  

и запустите worker, который проверяет, что set1 пуст, прежде чем проверять set2:

 php artisan queue:work --queue=set1,set2
  

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

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

https://laravel.com/docs/5.8/queues#running-the-queue-worker

Редактировать:

Вы можете решить, что set1 задания от пользователя 2 задерживают set2 задания от пользователя 1, запустив больше рабочих.