QueueWorkBatchCommand::runJob() - Code Metrics - DNXLabs/laravel-queue-aws-batch - Measure and Improve Code Quality continuously with Scrutinizer

QueueWorkBatchCommand::runJob() A
last analyzed 2021-03-19 03:50 UTC

↳ Parent: QueueWorkBatchCommand

Complexity

Conditions	4
Paths	3

Size

Total Lines	26
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	20

Importance

Changes

Metric	Value
eloc	12
c	0
b	0
f	0
dl	0
loc	26
ccs	0
cts	12
cp	0
rs	9.8666
cc	4
nc	3
nop	0
crap	20

<?php
/**
 * Laravel Queue for AWS Batch.
 *
 * @author    Luke Waite <[email protected]>
 * @copyright 2017 Luke Waite
 * @license   http://www.opensource.org/licenses/mit-license.php MIT
 *
 * @link      https://github.com/dnxlabs/laravel-queue-aws-batch
 */

namespace DNXLabs\LaravelQueueAwsBatch\Console;

use Illuminate\Container\Container;
use Illuminate\Contracts\Cache\Repository;
use Illuminate\Foundation\Exceptions\Handler;
use Illuminate\Queue\Console\WorkCommand;
use Illuminate\Queue\QueueManager;
use Illuminate\Queue\Worker;
use Illuminate\Queue\WorkerOptions;
use DNXLabs\LaravelQueueAwsBatch\Exceptions\JobNotFoundException;
use DNXLabs\LaravelQueueAwsBatch\Exceptions\UnsupportedException;
use DNXLabs\LaravelQueueAwsBatch\Queues\BatchQueue;
use Symfony\Component\Debug\Exception\FatalThrowableError;

class QueueWorkBatchCommand extends WorkCommand
{
    protected $name = 'queue:work-batch';

    protected $description = 'Run a Job for the AWS Batch queue';

    protected $signature = 'queue:work-batch
                            {job_id : The job id in the database}
                            {connection? : The name of the queue connection to work}
                            {--memory=128 : The memory limit in megabytes}
                            {--timeout=60 : The number of seconds a child process can run}
                            {--tries=0 : Number of times to attempt a job before logging it failed}
                            {--force : Force the worker to run even in maintenance mode}
                            {--queue= : The names of the queues to work}
                            {--once : Only process the next job on the queue}
                            {--stop-when-empty : Stop when the queue is empty}';


    protected $manager;
    protected $exceptions;

    public function __construct(QueueManager $manager, Worker $worker, Handler $exceptions)
    {
        parent::__construct($worker, Container::getInstance()->make(Repository::class));
        $this->manager = $manager;
        $this->exceptions = $exceptions;
    }

    public function handle()
    {
        $this->listenForEvents();

        try {
            $this->runJob();
        } catch (\Exception $e) {
            $this->exceptions->report($e);
            throw $e;
        } catch (\Throwable $e) {
            $this->exceptions->report(new FatalThrowableError($e));
            $this->exceptions->report(/** @scrutinizer ignore-deprecated */ new FatalThrowableError($e));
            throw $e;
        }
    }

    // TOOD: Refactor out the logic here into an extension of the Worker class
    protected function runJob()
    {
        $connectionName = $connection = $this->argument('connection') ?: $this->laravel['config']['queue.default'];

        $jobId = $this->argument('job_id');

        /** @var BatchQueue $connection */
        $connection = $this->manager->connection($connectionName);
        $connection = $this->manager->connection(/** @scrutinizer ignore-type */ $connectionName);

        if (!$connection instanceof BatchQueue) {

            throw new UnsupportedException('queue:work-batch can only be run on batch queues');
        }

        $job = $connection->getJobById($jobId, $connectionName);
        $job = $connection->getJobById($jobId, $connectionName);

        // If we're able to pull a job off of the stack, we will process it and
        // then immediately return back out.
        if (!is_null($job)) {
            return $this->worker->process(
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
                $this->manager->getName($connectionName),
                $this->manager->getName(/** @scrutinizer ignore-type */ $connectionName),
                $job,
                $this->gatherWorkerOptions()
            );
        }

        // If we hit this point, we haven't processed our job
        throw new JobNotFoundException('No job was returned');
    }

    /**
     * Gather all of the queue worker options as a single object.
     *
     * @return \Illuminate\Queue\WorkerOptions
     */
    protected function gatherWorkerOptions()
    {
        return new WorkerOptions(
            0, // delay
            $this->option('memory'),
            $this->option('timeout'),
            0, // sleep
            $this->option('tries'),
            false, // force
            $this->option('stop-when-empty')
            /** @scrutinizer ignore-type */ $this->option('stop-when-empty')
        );
    }
}


DNXLabs / laravel-queue-aws-batch

QueueWorkBatchCommand::runJob() A last analyzed 2021-03-19 03:50 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

QueueWorkBatchCommand::runJob() A
last analyzed 2021-03-19 03:50 UTC