LukeWaite\LaravelQueueAwsBatch\Console\QueueWorkBatchCommand

Complexity

Total Complexity

8

Size/Duplication

Total Lines	83
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

0%

Importance

Changes	3
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	fire()	0	14	3
B	runJob()	0	27	3
A	gatherWorkerOptions()	0	8	1

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

namespace LukeWaite\LaravelQueueAwsBatch\Console;

use Illuminate\Console\Command;
use Illuminate\Foundation\Exceptions\Handler;
use Illuminate\Queue\Console\WorkCommand;
use Illuminate\Queue\QueueManager;
use Illuminate\Queue\Worker;
use Illuminate\Queue\WorkerOptions;
use LukeWaite\LaravelQueueAwsBatch\Exceptions\JobNotFoundException;
use LukeWaite\LaravelQueueAwsBatch\Exceptions\UnsupportedException;
use LukeWaite\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 {connection} {job_id} {--tries=}';

45% of this comment could be valid code. Did you maybe forget this after debugging?

    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}';


    protected $manager;
    protected $exceptions;

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

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

        try {
            $this->runJob();
        } catch (\Exception $e) {
            $this->exceptions->report($e);
            throw $e;
        } catch (\Throwable $e) {

The class Throwable does not exist. Did you forget a USE statement, or did you not list all dependencies?

            $this->exceptions->report(new FatalThrowableError($e));
            throw $e;
        }
    }

    // TOOD: Refactor out the logic here into an extension of the Worker class
    protected function runJob()
    {
        $connectionName = $this->argument('connection');
        $jobId = $this->argument('job_id');

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

It seems like $connectionName defined by $this->argument('connection') on line 68 can also be of type array; however, Illuminate\Queue\QueueManager::connection() does only seem to accept string|null, maybe add an additional type check?

        if (!$connection instanceof BatchQueue) {
            throw new UnsupportedException('queue:work-batch can only be run on batch queues');
        }

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

The call to BatchQueue::getJobById() has too many arguments starting with $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(
                $this->manager->getName($connectionName),

It seems like $connectionName defined by $this->argument('connection') on line 68 can also be of type array; however, Illuminate\Queue\QueueManager::getName() does only seem to accept string|null, maybe add an additional type check?

                $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, $this->option('memory'),

$this->option('memory') is of type string|array, but the function expects a integer.

            $this->option('timeout'), 0,

$this->option('timeout') is of type string|array, but the function expects a integer.

            $this->option('tries'), false

$this->option('tries') is of type string|array, but the function expects a integer.

        );
    }
}