Gendoria\CommandQueue\Worker\BaseWorker

Complexity

Total Complexity

11

Size/Duplication

Total Lines	154
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

100%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	2
A	process()	0	15	2
A	getProcessor()	0	6	1
A	setProcessorFactory()	0	4	1
	getSerializedCommandData()	0	1	?
A	beforeTranslateHook()	0	3	1
A	beforeGetProcessorHook()	0	3	1
A	beforeProcessHook()	0	3	1
A	afterProcessHook()	0	3	1
A	processorErrorHook()	0	3	1

<?php

namespace Gendoria\CommandQueue\Worker;

use Exception;
use Gendoria\CommandQueue\Command\CommandInterface;
use Gendoria\CommandQueue\CommandProcessor\CommandProcessorInterface;
use Gendoria\CommandQueue\ProcessorFactory\Exception\ProcessorNotFoundException;
use Gendoria\CommandQueue\ProcessorFactory\ProcessorFactoryInterface;
use Gendoria\CommandQueue\Serializer\Exception\UnserializeErrorException;
use Gendoria\CommandQueue\Serializer\SerializedCommandData;
use Gendoria\CommandQueue\Serializer\SerializerInterface;
use Gendoria\CommandQueue\Worker\Exception\ProcessorErrorException;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;

/**
 * Base command queue worker
 *
 * @author Tomasz Struczyński <t.struczynski@gmail.com>
 */
abstract class BaseWorker implements WorkerInterface
{

    /**
     * Processor factory instance.
     *
     * @var ProcessorFactoryInterface
     */
    protected $processorFactory;

    /**
     * Logger instance.
     *
     * @var LoggerInterface
     */
    protected $logger;
    
    /**
     * Serializer.
     * 
     * @var SerializerInterface
     */
    protected $serializer;

    /**
     * Class constructor.
     *
     * @param ProcessorFactoryInterface $processorFactory Command processor factory.
     * @param SerializerInterface       $serializer       Serializer.
     * @param LoggerInterface           $logger           Logger.
     */
    public function __construct(ProcessorFactoryInterface $processorFactory, SerializerInterface $serializer, LoggerInterface $logger = null)
    {
        $this->processorFactory = $processorFactory;
        $this->serializer = $serializer;
        $this->logger = $logger ? $logger : new NullLogger();
    }

    /**
     * 
     * @param mixed $commandData
     * @return void
     * 
     * @throws UnserializeErrorException Thrown, when translation process resulted in an error.
     * @throws ProcessorNotFoundException Thrown, when processor for given command has not been found.
     * @throws ProcessorErrorException Thrown, when processor resulted in an error.
     */
    public function process($commandData)
    {
        $this->beforeTranslateHook($commandData);
        $command = $this->serializer->unserialize($this->getSerializedCommandData($commandData));
        $this->beforeGetProcessorHook($command);
        $processor = $this->getProcessor($command);
        $this->beforeProcessHook($command, $processor);
        try {
            $processor->process($command);
        } catch (Exception $e) {
            $this->processorErrorHook($command, $processor, $e);
            throw new ProcessorErrorException($command, $processor, $e->getMessage(), $e->getCode(), $e);
        }
        $this->afterProcessHook($command, $processor);
    }

    /**
     * {@inheritdoc}
     */
    public function getProcessor(CommandInterface $command)
    {
        $processor = $this->processorFactory->getProcessor($command);
        $processor->setLogger($this->logger);
        return $processor;
    }
    
    /**
     * {@inheritdoc}
     */
    public function setProcessorFactory(ProcessorFactoryInterface $processorFactory)
    {
        $this->processorFactory = $processorFactory;
    }
    
    /**
     * Get serialized command data to use with translator.
     * 
     * @param mixed $commandData
     * @return SerializedCommandData
     * 
     * @throws UnserializeErrorException Thrown, when data could not have been translated to serialized command data.
     */
    abstract protected function getSerializedCommandData($commandData);
    
    /**
     * Hook called before command translation.
     * 
     * @param string $commandData
     * @return void
     * 
     * @codeCoverageIgnore
     */
    protected function beforeTranslateHook(&$commandData)
    {
    }
    
    /**
     * Hook called before getting processor for command.
     * 
     * @param CommandInterface $command
     * @return void
     * 
     * @codeCoverageIgnore
     */
    protected function beforeGetProcessorHook(CommandInterface $command)
    {
    }

    /**
     * Hook called before processing command.
     * 
     * @param CommandInterface $command
     * @return void
     * 
     * @codeCoverageIgnore
     */
    protected function beforeProcessHook(CommandInterface $command, CommandProcessorInterface $processor)
    {
    }
    
    /**
     * Hook called after successfull processing of command.
     * 
     * @param CommandInterface $command
     * @param CommandProcessorInterface $processor
     * @return void
     * 
     * @codeCoverageIgnore
     */
    protected function afterProcessHook(CommandInterface $command, CommandProcessorInterface $processor)
    {
    }
    
    /**
     * Hook called after successfull processing of command.
     * 
     * @param CommandInterface $command
     * @param CommandProcessorInterface $processor
     * @param Exception $e Exception thrown by processor.
     * @return void
     * 
     * @codeCoverageIgnore
     */
    protected function processorErrorHook(CommandInterface $command, CommandProcessorInterface $processor, Exception $e)
    {
    }    
}