SeparateProcessExecutor::handle() - Code Metrics - Inspection of "Implemented retry-exectution for specific handler..." - php-task/TaskBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( cfc46b...5a6c91 )

by Thomas

created 2017-08-22 12:56 UTC

SeparateProcessExecutor::handle() A

↳ Parent: SeparateProcessExecutor

Complexity

Conditions	2
Paths	2

Size

Total Lines	11
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	2

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	11
ccs	6
cts	6
cp	1
rs	9.4285
cc	2
eloc	6
nc	2
nop	1
crap	2

<?php

/*
 * This file is part of php-task library.
 *
 * (c) php-task
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Task\TaskBundle\Executor;

use Task\Execution\TaskExecutionInterface;
use Task\Executor\ExecutorInterface;
use Task\Executor\FailedException;
use Task\Executor\RetryTaskHandlerInterface;
use Task\Handler\TaskHandlerFactoryInterface;
use Task\Storage\TaskExecutionRepositoryInterface;

/**
 * Uses a separate process to start the executions via console-command.
 */
class SeparateProcessExecutor implements ExecutorInterface
{
    /**
     * @var TaskHandlerFactoryInterface
     */
    private $handlerFactory;

    /**
     * @var TaskExecutionRepositoryInterface
     */
    private $executionRepository;

    /**
     * @var ExecutionProcessFactory
     */
    private $processFactory;

    /**
     * @param TaskHandlerFactoryInterface $handlerFactory
     * @param TaskExecutionRepositoryInterface $executionRepository
     * @param ExecutionProcessFactory $processFactory
     */
    public function __construct(
        TaskHandlerFactoryInterface $handlerFactory,
        TaskExecutionRepositoryInterface $executionRepository,
        ExecutionProcessFactory $processFactory
    ) {
        $this->handlerFactory = $handlerFactory;
        $this->executionRepository = $executionRepository;
        $this->processFactory = $processFactory;
    }

    /**
     * {@inheritdoc}
     */
    public function execute(TaskExecutionInterface $execution)
    {
        $attempts = $this->getMaximumAttempts($execution->getHandlerClass());
        $lastException = null;

        for ($attempt = 0; $attempt < $attempts; ++$attempt) {
            try {
                return $this->handle($execution);
            } catch (FailedException $exception) {
                throw $exception;
            } catch (SeparateProcessException $exception) {
                if ($execution->getAttempts() < $attempts) {
                    $execution->incrementAttempts();
                    $this->executionRepository->save($execution);
                }

                $lastException = $exception;
            }
        }

        // maximum attempts to pass executions are reached
        throw new FailedException($lastException);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
    }

    /**
     * Returns maximum attempts for specified handler.
     *
     * @param string $handlerClass
     *
     * @return int
     */
    private function getMaximumAttempts($handlerClass)
    {
        $handler = $this->handlerFactory->create($handlerClass);
        if (!$handler instanceof RetryTaskHandlerInterface) {
            return 1;
        }

        return $handler->getMaximumAttempts();
    }

    /**
     * Handle execution by using console-command.
     *
     * @param TaskExecutionInterface $execution
     *
     * @return string
     *
     * @throws FailedException
     * @throws SeparateProcessException
     */
    private function handle(TaskExecutionInterface $execution)
    {
        $process = $this->processFactory->create($execution->getUuid());
        $process->run();

        if (!$process->isSuccessful()) {
            throw $this->createException($process->getErrorOutput());
        }

        return $process->getOutput();
    }

    /**
     * Create the correct exception.
     *
     * FailedException for failed executions.
     * SeparateProcessExceptions for any exception during execution.
     *
     * @param string $errorOutput
     *
     * @return FailedException|SeparateProcessException
     */
    private function createException($errorOutput)
    {
        if (strpos($errorOutput, FailedException::class) !== 0) {
            return new SeparateProcessException($errorOutput);
        }

        $errorOutput = trim(str_replace(FailedException::class, '', $errorOutput));

        return new FailedException(new SeparateProcessException($errorOutput));
    }
}


1		<?php
2
3		/*
4		* This file is part of php-task library.
5		*
6		* (c) php-task
7		*
8		* This source file is subject to the MIT license that is bundled
9		* with this source code in the file LICENSE.
10		*/
11
12		namespace Task\TaskBundle\Executor;
13
14		use Task\Execution\TaskExecutionInterface;
15		use Task\Executor\ExecutorInterface;
16		use Task\Executor\FailedException;
17		use Task\Executor\RetryTaskHandlerInterface;
18		use Task\Handler\TaskHandlerFactoryInterface;
19		use Task\Storage\TaskExecutionRepositoryInterface;
20
21		/**
22		* Uses a separate process to start the executions via console-command.
23		*/
24		class SeparateProcessExecutor implements ExecutorInterface
25		{
26		/**
27		* @var TaskHandlerFactoryInterface
28		*/
29		private $handlerFactory;
30
31		/**
32		* @var TaskExecutionRepositoryInterface
33		*/
34		private $executionRepository;
35
36		/**
37		* @var ExecutionProcessFactory
38		*/
39		private $processFactory;
40
41		/**
42		* @param TaskHandlerFactoryInterface $handlerFactory
43		* @param TaskExecutionRepositoryInterface $executionRepository
44		* @param ExecutionProcessFactory $processFactory
45		*/
46	18	public function __construct(
47		TaskHandlerFactoryInterface $handlerFactory,
48		TaskExecutionRepositoryInterface $executionRepository,
49		ExecutionProcessFactory $processFactory
50		) {
51	18	$this->handlerFactory = $handlerFactory;
52	18	$this->executionRepository = $executionRepository;
53	18	$this->processFactory = $processFactory;
54	18	}
55
56		/**
57		* {@inheritdoc}
58		*/
59	7	public function execute(TaskExecutionInterface $execution)
60		{
61	7	$attempts = $this->getMaximumAttempts($execution->getHandlerClass());
62	7	$lastException = null;
63
64	7	for ($attempt = 0; $attempt < $attempts; ++$attempt) {
65		try {
66	7	return $this->handle($execution);
67	5	} catch (FailedException $exception) {
68	2	throw $exception;
69	3	} catch (SeparateProcessException $exception) {
70	3	if ($execution->getAttempts() < $attempts) {
71	1	$execution->incrementAttempts();
72	1	$this->executionRepository->save($execution);
73	1	}
74
75	3	$lastException = $exception;
76		}
77	3	}
78
79		// maximum attempts to pass executions are reached
80	3	throw new FailedException($lastException);
		0 ignored issues – show Bug introduced 2017-08-18 11:57 UTC by Report Bug Copy Issue Report It seems like `$lastException` defined by `null` on line `62` can be `null`; however, `Task\Executor\FailedException::__construct()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
81		}
82
83		/**
84		* Returns maximum attempts for specified handler.
85		*
86		* @param string $handlerClass
87		*
88		* @return int
89		*/
90	7	private function getMaximumAttempts($handlerClass)
91		{
92	7	$handler = $this->handlerFactory->create($handlerClass);
93	7	if (!$handler instanceof RetryTaskHandlerInterface) {
94	5	return 1;
95		}
96
97	2	return $handler->getMaximumAttempts();
98		}
99
100		/**
101		* Handle execution by using console-command.
102		*
103		* @param TaskExecutionInterface $execution
104		*
105		* @return string
106		*
107		* @throws FailedException
108		* @throws SeparateProcessException
109		*/
110	7	private function handle(TaskExecutionInterface $execution)
111		{
112	7	$process = $this->processFactory->create($execution->getUuid());
113	7	$process->run();
114
115	7	if (!$process->isSuccessful()) {
116	5	throw $this->createException($process->getErrorOutput());
117		}
118
119	2	return $process->getOutput();
120		}
121
122		/**
123		* Create the correct exception.
124		*
125		* FailedException for failed executions.
126		* SeparateProcessExceptions for any exception during execution.
127		*
128		* @param string $errorOutput
129		*
130		* @return FailedException\|SeparateProcessException
131		*/
132	5	private function createException($errorOutput)
133		{
134	5	if (strpos($errorOutput, FailedException::class) !== 0) {
135	3	return new SeparateProcessException($errorOutput);
136		}
137
138	2	$errorOutput = trim(str_replace(FailedException::class, '', $errorOutput));
139
140	2	return new FailedException(new SeparateProcessException($errorOutput));
141		}
142		}
143

php-task / TaskBundle

Push — master ( cfc46b...5a6c91 )

SeparateProcessExecutor::handle() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like