Resque - Code Metrics - mpclarkson/resque-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Resque B
last analyzed 2016-08-03 19:39 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	345
Duplicated Lines	19.13 %

Coupling/Cohesion

Components	2
Dependencies	11

Importance

Changes	4
Bugs	1	Features	1

Metric	Value
wmc	43
c	4
b	1
f	1
lcom	2
cbo	11
dl	66
loc	345
rs	8.3157

24 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	setPrefix()	0	4	1
A	setGlobalRetryStrategy()	0	4	1
A	setJobRetryStrategy()	0	4	1
A	getRedisConfiguration()	0	4	1
A	setRedisConfiguration()	0	11	2
B	enqueueOnce()	0	15	5
A	enqueue()	0	16	3
A	attachRetryStrategy()	0	13	4
A	enqueueAt()	12	12	2
A	enqueueIn()	12	12	2
A	removedDelayed()	10	10	2
A	removeFromTimestamp()	10	10	2
A	getQueues()	0	6	1
A	getQueue()	0	4	1
A	getWorkers()	0	6	1
A	getWorker()	0	10	2
A	pruneDeadWorkers()	0	6	1
A	getFirstDelayedJobTimestamp()	0	9	2
A	getDelayedJobTimestamps()	0	12	2
A	getNumberOfDelayedJobs()	0	4	1
A	getJobsForTimestamp()	10	10	2
A	clearQueue()	0	7	1
A	getFailedJobs()	12	12	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Resque often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Resque, and based on these observations, apply Extract Interface, too.

<?php

namespace Mpclarkson\ResqueBundle;

use Psr\Log\NullLogger;

/**
 * Class Resque
 * @package Mpclarkson\ResqueBundle
 */
class Resque implements EnqueueInterface
{
    /**
     * @var array
     */
    private $kernelOptions;

    /**
     * @var array
     */
    private $redisConfiguration;

    /**
     * @var array
     */
    private $globalRetryStrategy = [];

    /**
     * @var array
     */
    private $jobRetryStrategy = [];

    /**
     * Resque constructor.
     * @param array $kernelOptions
     */
    public function __construct(array $kernelOptions)
    {
        $this->kernelOptions = $kernelOptions;
    }

    /**
     * @param $prefix
     */
    public function setPrefix($prefix)
    {
        \Resque_Redis::prefix($prefix);
    }

    /**
     * @param $strategy
     */
    public function setGlobalRetryStrategy($strategy)
    {
        $this->globalRetryStrategy = $strategy;
    }

    /**
     * @param $strategy
     */
    public function setJobRetryStrategy($strategy)
    {
        $this->jobRetryStrategy = $strategy;
    }

    /**
     * @return array
     */
    public function getRedisConfiguration()
    {
        return $this->redisConfiguration;
    }

    /**
     * @param $host
     * @param $port
     * @param $database
     */
    public function setRedisConfiguration($host, $port, $database)
    {
        $this->redisConfiguration = [
            'host'     => $host,
            'port'     => $port,
            'database' => $database,
        ];
        $host = substr($host, 0, 1) == '/' ? $host : $host . ':' . $port;

        \Resque::setBackend($host, $database);
    }

    /**
     * @param Job $job
     * @param bool $trackStatus
     * @return null|\Resque_Job_Status
     */
    public function enqueueOnce(Job $job, $trackStatus = FALSE)
    {
        $queue = new Queue($job->queue);
        $jobs = $queue->getJobs();

        foreach ($jobs AS $j) {
            if ($j->job->payload['class'] == get_class($job)) {
                if (count(array_intersect($j->args, $job->args)) == count($job->args)) {
                    return ($trackStatus) ? $j->job->payload['id'] : NULL;
                }
            }
        }

        return $this->enqueue($job, $trackStatus);
    }

    /**
     * @param Job $job
     * @param bool $trackStatus
     * @return null|\Resque_Job_Status
     */
    public function enqueue(Job $job, $trackStatus = FALSE)
    {
        if ($job instanceof ContainerAwareJob) {
            $job->setKernelOptions($this->kernelOptions);
        }

        $this->attachRetryStrategy($job);

        $result = \Resque::enqueue($job->queue, \get_class($job), $job->args, $trackStatus);

        if ($trackStatus) {
            return new \Resque_Job_Status($result);
<?php

function getDate($date)
{
    if ($date !== null) {
        return new DateTime($date);
    }

    return false;
}
        }

        return NULL;
    }

    /**
     * Attach any applicable retry strategy to the job.
     *
     * @param Job $job
     */
    protected function attachRetryStrategy($job)
    {
        $class = get_class($job);

        if (isset($this->jobRetryStrategy[$class])) {
            if (count($this->jobRetryStrategy[$class])) {
                $job->args['resque.retry_strategy'] = $this->jobRetryStrategy[$class];
            }
            $job->args['resque.retry_strategy'] = $this->jobRetryStrategy[$class];
        } elseif (count($this->globalRetryStrategy)) {
            $job->args['resque.retry_strategy'] = $this->globalRetryStrategy;
        }
    }

    /**
     * @param $at
     * @param Job $job
     * @return null
     */
    public function enqueueAt($at, Job $job)

    {
        if ($job instanceof ContainerAwareJob) {
            $job->setKernelOptions($this->kernelOptions);
        }

        $this->attachRetryStrategy($job);

        \ResqueScheduler::enqueueAt($at, $job->queue, \get_class($job), $job->args);

        return NULL;
    }

    /**
     * @param $in
     * @param Job $job
     * @return null
     */
    public function enqueueIn($in, Job $job)

    {
        if ($job instanceof ContainerAwareJob) {
            $job->setKernelOptions($this->kernelOptions);
        }

        $this->attachRetryStrategy($job);

        \ResqueScheduler::enqueueIn($in, $job->queue, \get_class($job), $job->args);

        return NULL;
    }

    /**
     * @param Job $job
     * @return mixed
     */
    public function removedDelayed(Job $job)

    {
        if ($job instanceof ContainerAwareJob) {
            $job->setKernelOptions($this->kernelOptions);
        }

        $this->attachRetryStrategy($job);

        return \ResqueScheduler::removeDelayed($job->queue, \get_class($job), $job->args);
    }

    /**
     * @param $at
     * @param Job $job
     * @return mixed
     */
    public function removeFromTimestamp($at, Job $job)

    {
        if ($job instanceof ContainerAwareJob) {
            $job->setKernelOptions($this->kernelOptions);
        }

        $this->attachRetryStrategy($job);

        return \ResqueScheduler::removeDelayedJobFromTimestamp($at, $job->queue, \get_class($job), $job->args);
    }

    /**
     * @return array
     */
    public function getQueues()
    {
        return \array_map(function ($queue) {
            return new Queue($queue);
        }, \Resque::queues());
    }

    /**
     * @param $queue
     * @return Queue
     */
    public function getQueue($queue)
    {
        return new Queue($queue);
    }

    /**
     * @return array
     */
    public function getWorkers()
    {
        return \array_map(function ($worker) {
            return new Worker($worker);
        }, \Resque_Worker::all());
    }

    /**
     * @param $id
     * @return Worker|null
     */
    public function getWorker($id)
    {
        $worker = \Resque_Worker::find($id);

        if (!$worker) {
            return NULL;
        }

        return new Worker($worker);
    }

    /**
     * @todo - Clean this up, for now, prune dead workers, just in case
     */
    public function pruneDeadWorkers()
    {
        $worker = new \Resque_Worker('temp');
        $worker->setLogger(new NullLogger());
        $worker->pruneDeadWorkers();
    }

    /**
     * @return array|mixed
     */
    public function getFirstDelayedJobTimestamp()
    {
        $timestamps = $this->getDelayedJobTimestamps();
        if (count($timestamps) > 0) {
            return $timestamps[0];
        }

        return [NULL, 0];
    }

    /**
     * @return array
     */
    public function getDelayedJobTimestamps()
    {
        $timestamps = \Resque::redis()->zrange('delayed_queue_schedule', 0, -1);

        //TODO: find a more efficient way to do this
        $out = [];
        foreach ($timestamps as $timestamp) {
            $out[] = [$timestamp, \Resque::redis()->llen('delayed:' . $timestamp)];
        }

        return $out;
    }

    /**
     * @return mixed
     */
    public function getNumberOfDelayedJobs()
    {
        return \ResqueScheduler::getDelayedQueueScheduleSize();
    }

    /**
     * @param $timestamp
     * @return array
     */
    public function getJobsForTimestamp($timestamp)

    {
        $jobs = \Resque::redis()->lrange('delayed:' . $timestamp, 0, -1);
        $out = [];
        foreach ($jobs as $job) {
            $out[] = json_decode($job, TRUE);
        }

        return $out;
    }

    /**
     * @param $queue
     * @return int
     */
    public function clearQueue($queue)
    {
        $length = \Resque::redis()->llen('queue:' . $queue);
        \Resque::redis()->del('queue:' . $queue);

        return $length;
    }

    /**
     * @param int $start
     * @param int $count
     * @return array
     */
    public function getFailedJobs($start = -100, $count = 100)

    {
        $jobs = \Resque::redis()->lrange('failed', $start, $count);

        $result = [];

        foreach ($jobs as $job) {
            $result[] = new FailedJob(json_decode($job, TRUE));
        }

        return $result;
    }
}


1		<?php
2
3		namespace Mpclarkson\ResqueBundle;
4
5		use Psr\Log\NullLogger;
6
7		/**
8		* Class Resque
9		* @package Mpclarkson\ResqueBundle
10		*/
11		class Resque implements EnqueueInterface
12		{
13		/**
14		* @var array
15		*/
16		private $kernelOptions;
17
18		/**
19		* @var array
20		*/
21		private $redisConfiguration;
22
23		/**
24		* @var array
25		*/
26		private $globalRetryStrategy = [];
27
28		/**
29		* @var array
30		*/
31		private $jobRetryStrategy = [];
32
33		/**
34		* Resque constructor.
35		* @param array $kernelOptions
36		*/
37		public function __construct(array $kernelOptions)
38		{
39		$this->kernelOptions = $kernelOptions;
40		}
41
42		/**
43		* @param $prefix
44		*/
45		public function setPrefix($prefix)
46		{
47		\Resque_Redis::prefix($prefix);
48		}
49
50		/**
51		* @param $strategy
52		*/
53		public function setGlobalRetryStrategy($strategy)
54		{
55		$this->globalRetryStrategy = $strategy;
56		}
57
58		/**
59		* @param $strategy
60		*/
61		public function setJobRetryStrategy($strategy)
62		{
63		$this->jobRetryStrategy = $strategy;
64		}
65
66		/**
67		* @return array
68		*/
69		public function getRedisConfiguration()
70		{
71		return $this->redisConfiguration;
72		}
73
74		/**
75		* @param $host
76		* @param $port
77		* @param $database
78		*/
79		public function setRedisConfiguration($host, $port, $database)
80		{
81		$this->redisConfiguration = [
82		'host' => $host,
83		'port' => $port,
84		'database' => $database,
85		];
86		$host = substr($host, 0, 1) == '/' ? $host : $host . ':' . $port;
87
88		\Resque::setBackend($host, $database);
89		}
90
91		/**
92		* @param Job $job
93		* @param bool $trackStatus
94		* @return null\|\Resque_Job_Status
95		*/
96		public function enqueueOnce(Job $job, $trackStatus = FALSE)
97		{
98		$queue = new Queue($job->queue);
99		$jobs = $queue->getJobs();
100
101		foreach ($jobs AS $j) {
102		if ($j->job->payload['class'] == get_class($job)) {
103		if (count(array_intersect($j->args, $job->args)) == count($job->args)) {
104		return ($trackStatus) ? $j->job->payload['id'] : NULL;
105		}
106		}
107		}
108
109		return $this->enqueue($job, $trackStatus);
110		}
111
112		/**
113		* @param Job $job
114		* @param bool $trackStatus
115		* @return null\|\Resque_Job_Status
116		*/
117		public function enqueue(Job $job, $trackStatus = FALSE)
118		{
119		if ($job instanceof ContainerAwareJob) {
120		$job->setKernelOptions($this->kernelOptions);
121		}
122
123		$this->attachRetryStrategy($job);
124
125		$result = \Resque::enqueue($job->queue, \get_class($job), $job->args, $trackStatus);
126
127		if ($trackStatus) {
128		return new \Resque_Job_Status($result);
		0 ignored issues – show Security Bug introduced 2016-07-13 05:27 UTC by Report Bug Copy Issue Report It seems like `$result` defined by `\Resque::enqueue($job->q...ob->args, $trackStatus)` on line `125` can also be of type `false`; however, `Resque_Job_Status::__construct()` does only seem to accept `string`, did you maybe forget to handle an error condition? This check looks for type mismatches where the missing type is `false`. This is usually indicative of an error condtion. Consider the follow example <?php function getDate($date) { if ($date !== null) { return new DateTime($date); } return false; } This function either returns a new `DateTime` object or false, if there was an error. This is a typical pattern in PHP programming to show that an error has occurred without raising an exception. The calling code should check for this returned `false` before passing on the value to another function or method that may not be able to handle a `false`. Loading history...
129		}
130
131		return NULL;
132		}
133
134		/**
135		* Attach any applicable retry strategy to the job.
136		*
137		* @param Job $job
138		*/
139		protected function attachRetryStrategy($job)
140		{
141		$class = get_class($job);
142
143		if (isset($this->jobRetryStrategy[$class])) {
144		if (count($this->jobRetryStrategy[$class])) {
145		$job->args['resque.retry_strategy'] = $this->jobRetryStrategy[$class];
146		}
147		$job->args['resque.retry_strategy'] = $this->jobRetryStrategy[$class];
148		} elseif (count($this->globalRetryStrategy)) {
149		$job->args['resque.retry_strategy'] = $this->globalRetryStrategy;
150		}
151		}
152
153		/**
154		* @param $at
155		* @param Job $job
156		* @return null
157		*/
158	View Code Duplication	public function enqueueAt($at, Job $job)
		0 ignored issues – show Duplication introduced 2016-07-13 05:27 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
159		{
160		if ($job instanceof ContainerAwareJob) {
161		$job->setKernelOptions($this->kernelOptions);
162		}
163
164		$this->attachRetryStrategy($job);
165
166		\ResqueScheduler::enqueueAt($at, $job->queue, \get_class($job), $job->args);
167
168		return NULL;
169		}
170
171		/**
172		* @param $in
173		* @param Job $job
174		* @return null
175		*/
176	View Code Duplication	public function enqueueIn($in, Job $job)
		0 ignored issues – show Duplication introduced 2016-07-13 05:27 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
177		{
178		if ($job instanceof ContainerAwareJob) {
179		$job->setKernelOptions($this->kernelOptions);
180		}
181
182		$this->attachRetryStrategy($job);
183
184		\ResqueScheduler::enqueueIn($in, $job->queue, \get_class($job), $job->args);
185
186		return NULL;
187		}
188
189		/**
190		* @param Job $job
191		* @return mixed
192		*/
193	View Code Duplication	public function removedDelayed(Job $job)
		0 ignored issues – show Duplication introduced 2016-07-13 05:27 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
194		{
195		if ($job instanceof ContainerAwareJob) {
196		$job->setKernelOptions($this->kernelOptions);
197		}
198
199		$this->attachRetryStrategy($job);
200
201		return \ResqueScheduler::removeDelayed($job->queue, \get_class($job), $job->args);
202		}
203
204		/**
205		* @param $at
206		* @param Job $job
207		* @return mixed
208		*/
209	View Code Duplication	public function removeFromTimestamp($at, Job $job)
		0 ignored issues – show Duplication introduced 2016-07-13 05:27 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
210		{
211		if ($job instanceof ContainerAwareJob) {
212		$job->setKernelOptions($this->kernelOptions);
213		}
214
215		$this->attachRetryStrategy($job);
216
217		return \ResqueScheduler::removeDelayedJobFromTimestamp($at, $job->queue, \get_class($job), $job->args);
218		}
219
220		/**
221		* @return array
222		*/
223		public function getQueues()
224		{
225		return \array_map(function ($queue) {
226		return new Queue($queue);
227		}, \Resque::queues());
228		}
229
230		/**
231		* @param $queue
232		* @return Queue
233		*/
234		public function getQueue($queue)
235		{
236		return new Queue($queue);
237		}
238
239		/**
240		* @return array
241		*/
242		public function getWorkers()
243		{
244		return \array_map(function ($worker) {
245		return new Worker($worker);
246		}, \Resque_Worker::all());
247		}
248
249		/**
250		* @param $id
251		* @return Worker\|null
252		*/
253		public function getWorker($id)
254		{
255		$worker = \Resque_Worker::find($id);
256
257		if (!$worker) {
258		return NULL;
259		}
260
261		return new Worker($worker);
262		}
263
264		/**
265		* @todo - Clean this up, for now, prune dead workers, just in case
266		*/
267		public function pruneDeadWorkers()
268		{
269		$worker = new \Resque_Worker('temp');
270		$worker->setLogger(new NullLogger());
271		$worker->pruneDeadWorkers();
272		}
273
274		/**
275		* @return array\|mixed
276		*/
277		public function getFirstDelayedJobTimestamp()
278		{
279		$timestamps = $this->getDelayedJobTimestamps();
280		if (count($timestamps) > 0) {
281		return $timestamps[0];
282		}
283
284		return [NULL, 0];
285		}
286
287		/**
288		* @return array
289		*/
290		public function getDelayedJobTimestamps()
291		{
292		$timestamps = \Resque::redis()->zrange('delayed_queue_schedule', 0, -1);
293
294		//TODO: find a more efficient way to do this
295		$out = [];
296		foreach ($timestamps as $timestamp) {
297		$out[] = [$timestamp, \Resque::redis()->llen('delayed:' . $timestamp)];
298		}
299
300		return $out;
301		}
302
303		/**
304		* @return mixed
305		*/
306		public function getNumberOfDelayedJobs()
307		{
308		return \ResqueScheduler::getDelayedQueueScheduleSize();
309		}
310
311		/**
312		* @param $timestamp
313		* @return array
314		*/
315	View Code Duplication	public function getJobsForTimestamp($timestamp)
		0 ignored issues – show Duplication introduced 2016-07-13 05:27 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
316		{
317		$jobs = \Resque::redis()->lrange('delayed:' . $timestamp, 0, -1);
318		$out = [];
319		foreach ($jobs as $job) {
320		$out[] = json_decode($job, TRUE);
321		}
322
323		return $out;
324		}
325
326		/**
327		* @param $queue
328		* @return int
329		*/
330		public function clearQueue($queue)
331		{
332		$length = \Resque::redis()->llen('queue:' . $queue);
333		\Resque::redis()->del('queue:' . $queue);
334
335		return $length;
336		}
337
338		/**
339		* @param int $start
340		* @param int $count
341		* @return array
342		*/
343	View Code Duplication	public function getFailedJobs($start = -100, $count = 100)
		0 ignored issues – show Duplication introduced 2016-07-13 05:27 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
344		{
345		$jobs = \Resque::redis()->lrange('failed', $start, $count);
346
347		$result = [];
348
349		foreach ($jobs as $job) {
350		$result[] = new FailedJob(json_decode($job, TRUE));
351		}
352
353		return $result;
354		}
355		}
356

mpclarkson / resque-bundle

Resque B last analyzed 2016-08-03 19:39 UTC