RetryableJobManager::retryableSaveHistory()

Completed

Pull Request — master (#30)

by Matthew

created 2018-01-13 19:28 UTC

↳ Parent: RetryableJobManager

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	1
ccs	0
cts	0
cp	0
c	0
b	0
f	0
nc	1

<?php

namespace Dtc\QueueBundle\Manager;

use Dtc\QueueBundle\Model\BaseJob;
use Dtc\QueueBundle\Model\RetryableJob;
use Dtc\QueueBundle\Model\Job;
use Dtc\QueueBundle\Model\JobTiming;

abstract class RetryableJobManager extends AbstractJobManager
{
    protected $defaultMaxRetries;
    protected $defaultMaxFailures;
    protected $defaultMaxExceptions;

    protected $autoRetryOnFailure;
    protected $autoRetryOnException;

    abstract protected function retryableSave(RetryableJob $job);

    /**
     * @param RetryableJob $job
     * @param $retry bool
     *
     * @return
     */
    abstract protected function retryableSaveHistory(RetryableJob $job, $retry);

    public function save(Job $job)
    {
        if (!$job instanceof RetryableJob) {
            throw new \InvalidArgumentException('Job is not instanceof '.RetryableJob::class);
        }

        if (!$job->getId()) {
            $this->setBaseRetryableJobDefaults($job);
        }
        $this->recordTiming($job);
        $job->setUpdatedAt(new \DateTime());

        return $this->retryableSave($job);
    }

    /**
     * @return bool true if retry
     *
     * @param bool $retry true if the job was retried, false if not
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     */
    public function saveHistory(Job $job)
    {
        if (!$job instanceof RetryableJob) {
            throw new \InvalidArgumentException('job not instance of '.RetryableJob::class);
        }

        switch ($job->getStatus()) {
            case BaseJob::STATUS_FAILURE:
                return $this->retryableSaveHistory($job, $this->updateJobFailure($job));
            case BaseJob::STATUS_EXCEPTION:
                return $this->retryableSaveHistory($job, $this->updateJobException($job));
        }

        return $this->retryableSaveHistory($job, false);
    }

    private function updateJobException(RetryableJob $job)
    {
        return $this->updateJobMax($job, 'Exceptions', RetryableJob::STATUS_MAX_EXCEPTIONS, $this->autoRetryOnException);
    }

    protected function updateJobMax(RetryableJob $job, $type, $maxStatus, $autoRetry)
    {
        $setMethod = 'set'.$type;
        $getMethod = 'get'.$type;
        $getMax = 'getMax'.$type;
        $job->$setMethod(intval($job->$getMethod()) + 1);
        if (!$this->updateMaxStatus($job, $maxStatus, $job->$getMax(), $job->$getMethod()) &&
            !$this->updateMaxStatus($job, RetryableJob::STATUS_MAX_RETRIES, $job->getMaxRetries(), $job->getRetries())) {

            if ($autoRetry) {
                return $this->resetRetryableJob($job);
            }
        }

        return false;
    }

    private function updateJobFailure(RetryableJob $job)
    {
        return $this->updateJobMax($job, 'Failures', RetryableJob::STATUS_MAX_FAILURES, $this->autoRetryOnFailure);
    }

    /**
     * Determine if we've hit a max retry condition.
     *
     * @param RetryableJob $job
     * @param $status
     * @param null $max
     * @param int  $count
     *
     * @return bool
     */
    protected function updateMaxStatus(RetryableJob $job, $status, $max = null, $count = 0)
    {
        if (null !== $max && $count >= $max) {
            $job->setStatus($status);

            return true;
        }

        return false;
    }

    protected function resetRetryableJob(RetryableJob $job)
    {
        if ($this->resetJob($job)) {
            $this->getJobTimingManager()->recordTiming(JobTiming::STATUS_INSERT);

            return true;
        }

        return false;
    }

    /**
     * @param RetryableJob $retryableJob
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     *
     * @return bool true if the job was successfully "reset", i.e. re-queued
     */
    abstract protected function resetJob(RetryableJob $job);

    protected function setBaseRetryableJobDefaults(RetryableJob $job)
    {
        if (null === $job->getMaxExceptions()) {
            $job->setMaxExceptions($this->defaultMaxExceptions);
        }

        if (null === $job->getMaxRetries()) {
            $job->setMaxRetries($this->defaultMaxRetries);
        }

        if (null === $job->getMaxFailures()) {
            $job->setMaxFailures($this->defaultMaxFailures);
        }

        if (null === $job->getCrcHash()) {
            $hashValues = array(get_class($job), $job->getMethod(), $job->getWorkerName(), $job->getArgs());
            $crcHash = hash('sha256', serialize($hashValues));
            $job->setCrcHash($crcHash);
        }
    }

    /**
     * @return int|null
     */
    public function getDefaultMaxRetries()
    {
        return $this->defaultMaxRetries;
    }

    /**
     * @param int|null $defaultMaxRetry
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     */
    public function setDefaultMaxRetries($defaultMaxRetries)
    {
        $this->defaultMaxRetries = $defaultMaxRetries;
    }

    /**
     * @return int|null
     */
    public function getDefaultMaxFailures()
    {
        return $this->defaultMaxFailures;
    }

    /**
     * @param int|null $defaultMaxFailure
/**
 * @param array $germany
 * @param array $ireland
 */
function finale($germany, $island) {
    return "2:1";
}
     */
    public function setDefaultMaxFailures($defaultMaxFailures)
    {
        $this->defaultMaxFailures = $defaultMaxFailures;
    }

    /**
     * @return bool
     */
    public function getAutoRetryOnFailure()
    {
        return $this->autoRetryOnFailure;
    }

    /**
     * @param bool $autoRetryOnFailure
     */
    public function setAutoRetryOnFailure($autoRetryOnFailure)
    {
        $this->autoRetryOnFailure = $autoRetryOnFailure;
    }

    /**
     * @return bool
     */
    public function getAutoRetryOnException()
    {
        return $this->autoRetryOnException;
    }

    /**
     * @param bool $autoRetryOnException
     */
    public function setAutoRetryOnException($autoRetryOnException)
    {
        $this->autoRetryOnException = $autoRetryOnException;
    }

    /**
     * @return int|null
     */
    public function getDefaultMaxExceptions()
    {
        return $this->defaultMaxExceptions;
    }

    /**
     * @param int|null $defaultMaxException
/**
 * @param array $germany
 * @param array $ireland
 */
function finale($germany, $island) {
    return "2:1";
}
     */
    public function setDefaultMaxExceptions($defaultMaxExceptions)
    {
        $this->defaultMaxExceptions = $defaultMaxExceptions;
    }

    protected function recordTiming(Job $job)
    {
        $status = JobTiming::STATUS_INSERT;
        if ($job->getWhenAt() && $job->getWhenAt() > (new \DateTime())) {
            $status = JobTiming::STATUS_INSERT_DELAYED;
        }

        $this->getJobTimingManager()->recordTiming($status);
    }
}


1		<?php
2
3		namespace Dtc\QueueBundle\Manager;
4
5		use Dtc\QueueBundle\Model\BaseJob;
6		use Dtc\QueueBundle\Model\RetryableJob;
7		use Dtc\QueueBundle\Model\Job;
8		use Dtc\QueueBundle\Model\JobTiming;
9
10		abstract class RetryableJobManager extends AbstractJobManager
11		{
12		protected $defaultMaxRetries;
13		protected $defaultMaxFailures;
14		protected $defaultMaxExceptions;
15
16		protected $autoRetryOnFailure;
17		protected $autoRetryOnException;
18
19		abstract protected function retryableSave(RetryableJob $job);
20
21		/**
22		* @param RetryableJob $job
23		* @param $retry bool
24		*
25		* @return
26		*/
27		abstract protected function retryableSaveHistory(RetryableJob $job, $retry);
28
29	74	public function save(Job $job)
30		{
31	74	if (!$job instanceof RetryableJob) {
32	3	throw new \InvalidArgumentException('Job is not instanceof '.RetryableJob::class);
33		}
34
35	74	if (!$job->getId()) {
36	74	$this->setBaseRetryableJobDefaults($job);
37		}
38	74	$this->recordTiming($job);
39	74	$job->setUpdatedAt(new \DateTime());
40
41	74	return $this->retryableSave($job);
42		}
43
44		/**
45		* @return bool true if retry
46		*
47		* @param bool $retry true if the job was retried, false if not
		0 ignored issues – show Bug introduced 2018-01-07 01:22 UTC by Report Bug Copy Issue Report There is no parameter named `$retry`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
48		*/
49	20	public function saveHistory(Job $job)
50		{
51	20	if (!$job instanceof RetryableJob) {
52	3	throw new \InvalidArgumentException('job not instance of '.RetryableJob::class);
53		}
54
55	20	switch ($job->getStatus()) {
56	20	case BaseJob::STATUS_FAILURE:
57	9	return $this->retryableSaveHistory($job, $this->updateJobFailure($job));
58	11	case BaseJob::STATUS_EXCEPTION:
59	6	return $this->retryableSaveHistory($job, $this->updateJobException($job));
60		}
61
62	5	return $this->retryableSaveHistory($job, false);
63		}
64
65	6	private function updateJobException(RetryableJob $job)
66		{
67	6	return $this->updateJobMax($job, 'Exceptions', RetryableJob::STATUS_MAX_EXCEPTIONS, $this->autoRetryOnException);
68		}
69
70	17	protected function updateJobMax(RetryableJob $job, $type, $maxStatus, $autoRetry)
71		{
72	17	$setMethod = 'set'.$type;
73	17	$getMethod = 'get'.$type;
74	17	$getMax = 'getMax'.$type;
75	17	$job->$setMethod(intval($job->$getMethod()) + 1);
76	17	if (!$this->updateMaxStatus($job, $maxStatus, $job->$getMax(), $job->$getMethod()) &&
77	17	!$this->updateMaxStatus($job, RetryableJob::STATUS_MAX_RETRIES, $job->getMaxRetries(), $job->getRetries())) {
		0 ignored issues – show Bug introduced 2018-01-07 01:22 UTC by Report Bug Copy Issue Report It seems like `$job->getMaxRetries()` targeting `Dtc\QueueBundle\Model\Re...bleJob::getMaxRetries()` can also be of type `integer`; however, `Dtc\QueueBundle\Manager\...ager::updateMaxStatus()` does only seem to accept `null`, maybe add an additional type check? This check looks at variables that are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history...
78	16	if ($autoRetry) {
79	14	return $this->resetRetryableJob($job);
80		}
81		}
82
83	17	return false;
84		}
85
86	9	private function updateJobFailure(RetryableJob $job)
87		{
88	9	return $this->updateJobMax($job, 'Failures', RetryableJob::STATUS_MAX_FAILURES, $this->autoRetryOnFailure);
89		}
90
91		/**
92		* Determine if we've hit a max retry condition.
93		*
94		* @param RetryableJob $job
95		* @param $status
96		* @param null $max
97		* @param int $count
98		*
99		* @return bool
100		*/
101	19	protected function updateMaxStatus(RetryableJob $job, $status, $max = null, $count = 0)
102		{
103	19	if (null !== $max && $count >= $max) {
104	17	$job->setStatus($status);
105
106	17	return true;
107		}
108
109	18	return false;
110		}
111
112	14	protected function resetRetryableJob(RetryableJob $job)
113		{
114	14	if ($this->resetJob($job)) {
115	14	$this->getJobTimingManager()->recordTiming(JobTiming::STATUS_INSERT);
116
117	14	return true;
118		}
119
120		return false;
121		}
122
123		/**
124		* @param RetryableJob $retryableJob
		0 ignored issues – show Bug introduced 2018-01-07 01:22 UTC by Report Bug Copy Issue Report There is no parameter named `$retryableJob`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
125		*
126		* @return bool true if the job was successfully "reset", i.e. re-queued
127		*/
128		abstract protected function resetJob(RetryableJob $job);
129
130	74	protected function setBaseRetryableJobDefaults(RetryableJob $job)
131		{
132	74	if (null === $job->getMaxExceptions()) {
133	43	$job->setMaxExceptions($this->defaultMaxExceptions);
134		}
135
136	74	if (null === $job->getMaxRetries()) {
137	43	$job->setMaxRetries($this->defaultMaxRetries);
138		}
139
140	74	if (null === $job->getMaxFailures()) {
141	43	$job->setMaxFailures($this->defaultMaxFailures);
142		}
143
144	74	if (null === $job->getCrcHash()) {
145	74	$hashValues = array(get_class($job), $job->getMethod(), $job->getWorkerName(), $job->getArgs());
146	74	$crcHash = hash('sha256', serialize($hashValues));
147	74	$job->setCrcHash($crcHash);
148		}
149	74	}
150
151		/**
152		* @return int\|null
153		*/
154		public function getDefaultMaxRetries()
155		{
156		return $this->defaultMaxRetries;
157		}
158
159		/**
160		* @param int\|null $defaultMaxRetry
		0 ignored issues – show Bug introduced 2018-01-07 01:22 UTC by Report Bug Copy Issue Report There is no parameter named `$defaultMaxRetry`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
161		*/
162		public function setDefaultMaxRetries($defaultMaxRetries)
163		{
164		$this->defaultMaxRetries = $defaultMaxRetries;
165		}
166
167		/**
168		* @return int\|null
169		*/
170		public function getDefaultMaxFailures()
171		{
172		return $this->defaultMaxFailures;
173		}
174
175		/**
176		* @param int\|null $defaultMaxFailure
		0 ignored issues – show Documentation introduced 2018-01-07 01:22 UTC by Report Bug Copy Issue Report There is no parameter named `$defaultMaxFailure`. Did you maybe mean `$defaultMaxFailures`? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. It has, however, found a similar but not annotated parameter which might be a good fit. Consider the following example. The parameter `$ireland` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $ireland */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was changed, but the annotation was not. Loading history...
177		*/
178		public function setDefaultMaxFailures($defaultMaxFailures)
179		{
180		$this->defaultMaxFailures = $defaultMaxFailures;
181		}
182
183		/**
184		* @return bool
185		*/
186		public function getAutoRetryOnFailure()
187		{
188		return $this->autoRetryOnFailure;
189		}
190
191		/**
192		* @param bool $autoRetryOnFailure
193		*/
194	12	public function setAutoRetryOnFailure($autoRetryOnFailure)
195		{
196	12	$this->autoRetryOnFailure = $autoRetryOnFailure;
197	12	}
198
199		/**
200		* @return bool
201		*/
202		public function getAutoRetryOnException()
203		{
204		return $this->autoRetryOnException;
205		}
206
207		/**
208		* @param bool $autoRetryOnException
209		*/
210	6	public function setAutoRetryOnException($autoRetryOnException)
211		{
212	6	$this->autoRetryOnException = $autoRetryOnException;
213	6	}
214
215		/**
216		* @return int\|null
217		*/
218		public function getDefaultMaxExceptions()
219		{
220		return $this->defaultMaxExceptions;
221		}
222
223		/**
224		* @param int\|null $defaultMaxException
		0 ignored issues – show Documentation introduced 2018-01-07 01:22 UTC by Report Bug Copy Issue Report There is no parameter named `$defaultMaxException`. Did you maybe mean `$defaultMaxExceptions`? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. It has, however, found a similar but not annotated parameter which might be a good fit. Consider the following example. The parameter `$ireland` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $ireland */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was changed, but the annotation was not. Loading history...
225		*/
226		public function setDefaultMaxExceptions($defaultMaxExceptions)
227		{
228		$this->defaultMaxExceptions = $defaultMaxExceptions;
229		}
230
231	74	protected function recordTiming(Job $job)
232		{
233	74	$status = JobTiming::STATUS_INSERT;
234	74	if ($job->getWhenAt() && $job->getWhenAt() > (new \DateTime())) {
235	2	$status = JobTiming::STATUS_INSERT_DELAYED;
236		}
237
238	74	$this->getJobTimingManager()->recordTiming($status);
239	74	}
240		}
241

mmucklo / DtcQueueBundle

Pull Request — master (#30)

RetryableJobManager::retryableSaveHistory()

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like