MSlwk\ReactPhpPlayground\Console\Command\StartCliReportingService

Complexity

Total Complexity

7

Size/Duplication

Total Lines	138
Duplicated Lines	28.26 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	17	17	1
A	configure()	0	10	1
A	execute()	13	13	1
A	startProcesses()	9	9	2
A	createProcessDefinition()	0	9	1
A	getFullCommand()	0	9	1

<?php
declare(strict_types=1);

/**
 * File: StartCliReportingService.php
 *
 * @author      Maciej Sławik <maciekslawik@gmail.com>
 * Github:      https://github.com/maciejslawik
 */

namespace MSlwk\ReactPhpPlayground\Console\Command;

use MSlwk\ReactPhpPlayground\Api\ChunkSizeCalculatorInterface;
use MSlwk\ReactPhpPlayground\Api\CustomerIdsProviderInterface;
use MSlwk\ReactPhpPlayground\Api\TimerInterface;
use MSlwk\ReactPhpPlayground\Model\Adapter\ReactPHP\ProcessFactory;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Magento\Framework\Serialize\Serializer\Json;
use React\EventLoop\Factory;

/**
 * Class StartCliReportingService
 * @package MSlwk\ReactPhpPlayground\Console\Command
 */
class StartCliReportingService extends Command
{
    const COMMAND_NAME = 'mslwk:cli-reporting-start';
    const COMMAND_DESCRIPTION = 'Start asynchronous CLI reporting service';
    const ARGUMENT_NUMBER_OF_THREADS = 'threads';

    /**
     * @var TimerInterface
     */
    private $timer;

    /**
     * @var CustomerIdsProviderInterface
     */
    private $customerIdsProvider;

    /**
     * @var LoopInterface
     */
    private $loop;

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

    /**
     * @var Json
     */
    private $jsonHandler;

    /**
     * @var ChunkSizeCalculatorInterface
     */
    private $chunkSizeCalculator;

    /**
     * StartCliReportingService constructor.
     * @param TimerInterface $timer
     * @param CustomerIdsProviderInterface $customerIdsProvider
     * @param Factory $loopFactory
     * @param ProcessFactory $processFactory
     * @param Json $jsonHandler
     * @param ChunkSizeCalculatorInterface $chunkSizeCalculator
     * @param null $name
     */
    public function __construct(

This method seems to be duplicated in your project.

        TimerInterface $timer,
        CustomerIdsProviderInterface $customerIdsProvider,
        Factory $loopFactory,
        ProcessFactory $processFactory,
        Json $jsonHandler,
        ChunkSizeCalculatorInterface $chunkSizeCalculator,
        $name = null
    ) {
        parent::__construct($name);
        $this->timer = $timer;
        $this->customerIdsProvider = $customerIdsProvider;
        $this->loop = $loopFactory::create();

It seems like $loopFactory::create() of type object<React\EventLoop\LoopInterface> is incompatible with the declared type object<MSlwk\ReactPhpPlayground\Console\Command\LoopInterface> of property $loop.

        $this->processFactory = $processFactory;
        $this->jsonHandler = $jsonHandler;
        $this->chunkSizeCalculator = $chunkSizeCalculator;
    }

    /**
     * {@inheritdoc}
     */
    protected function configure()
    {
        $this->setName(self::COMMAND_NAME)
            ->setDescription(self::COMMAND_DESCRIPTION)
            ->addArgument(
                self::ARGUMENT_NUMBER_OF_THREADS,
                InputArgument::REQUIRED,
                'Number of threads for running the export process'
            );
    }

    /**
     * @param InputInterface $input
     * @param OutputInterface $output
     * @return void
     */
    protected function execute(InputInterface $input, OutputInterface $output)

This method seems to be duplicated in your project.

    {
        $numberOfThreads = (int)$input->getArgument(self::ARGUMENT_NUMBER_OF_THREADS);
        $customerIds = $this->customerIdsProvider->getCustomerIds();

        $this->timer->startTimer();

        $this->startProcesses($customerIds, $numberOfThreads);

        $this->timer->stopTimer();

        $output->writeln("<info>Process finished after {$this->timer->getExecutionTimeInSeconds()} seconds</info>");
    }

    /**
     * @param int[] $customerIds
     * @param int $numberOfThreads
     */
    protected function startProcesses(array $customerIds, int $numberOfThreads): void

This method seems to be duplicated in your project.

    {
        $chunkSize = $this->chunkSizeCalculator->calculateChunkSize($customerIds, $numberOfThreads);
        $threadedCustomerIds = array_chunk($customerIds, $chunkSize);
        foreach ($threadedCustomerIds as $customerIdsForSingleThread) {
            $this->createProcessDefinition($this->getFullCommand($customerIdsForSingleThread));
        }
        $this->loop->run();
    }

    /**
     * @param string $command
     */
    protected function createProcessDefinition(string $command): void
    {
        $reactProcess = $this->processFactory->create($command);
        $reactProcess->start($this->loop);

        $reactProcess->stdout->on('data', function ($chunk) {
            echo $chunk;
        });
    }

    /**
     * @param int[] $customerIds
     * @return string
     */
    protected function getFullCommand(array $customerIds): string
    {
        return sprintf(
            ' %s/bin/magento %s %s',
            BP,
            GenerateReports::COMMAND_NAME,
            $this->jsonHandler->serialize($customerIds)
        );
    }
}