EdmondsCommerce\DoctrineStaticMeta\Entity\Savers\AbstractBulkProcess

Complexity

Total Complexity

24

Size/Duplication

Total Lines	162
Duplicated Lines	0 %

Test Coverage

Coverage

60.2%

Importance

Changes	2
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	prepareEntitiesForBulkUpdate()	0	7	2
A	endBulkProcess()	0	13	3
A	addEntitiesToSave()	0	10	2
A	addEntityToSave()	0	7	2
A	setSecondsToPauseBetweenSaves()	0	3	1
A	pauseBetweenSaves()	0	6	2
A	__destruct()	0	7	4
A	startBulkProcess()	0	7	1
A	setChunkSize()	0	5	1
A	__construct()	0	4	1
A	bulkSaveIfChunkBigEnough()	0	7	2
A	getChunkSize()	0	3	1
A	freeResources()	0	9	2

<?php declare(strict_types=1);

namespace EdmondsCommerce\DoctrineStaticMeta\Entity\Savers;

use Doctrine\ORM\EntityManagerInterface;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Interfaces\EntityInterface;

abstract class AbstractBulkProcess
{
    /**
     * @var EntityManagerInterface
     */
    protected $entityManager;

    protected $entitiesToSave = [];

    protected $chunkSize = 1000;

    /**
     * @var float
     */
    protected $secondsToPauseBetweenSaves = 0.0;

    /**
     * @var bool
     */
    private $gcWasEnabled;

    private $started = false;
    private $ended   = false;

    public function __construct(EntityManagerInterface $entityManager)
    {
        $this->entityManager = $entityManager;
        $this->gcWasEnabled  = gc_enabled();
    }

    public function __destruct()
    {
        if (true === $this->started && false === $this->ended) {
            if (!$this->entityManager->isOpen()) {
                throw new \RuntimeException('Error in ' . __METHOD__ . ': Entity Manager has been closed');
            }
            $this->endBulkProcess();
        }
    }

    public function endBulkProcess(): void
    {
        $this->started = false;
        $this->ended   = true;

        if ([] !== $this->entitiesToSave) {
            $this->doSave();
            $this->freeResources();
        }
        if (false === $this->gcWasEnabled) {
            return;
        }
        gc_enable();
    }

    abstract protected function doSave(): void;

    protected function freeResources()
    {
        gc_enable();
        foreach ($this->entitiesToSave as $entity) {
            $this->entityManager->detach($entity);
        }
        $this->entitiesToSave = [];
        gc_collect_cycles();
        gc_disable();
    }

    public function addEntityToSave(EntityInterface $entity)
    {
        if (false === $this->started) {
            $this->startBulkProcess();
        }
        $this->entitiesToSave[] = $entity;
        $this->bulkSaveIfChunkBigEnough();
    }

    public function startBulkProcess(): self
    {
        gc_disable();
        $this->started = true;
        $this->ended   = false;

        return $this;
    }

    protected function bulkSaveIfChunkBigEnough()
    {
        $size = count($this->entitiesToSave);
        if ($size >= $this->chunkSize) {
            $this->doSave();
            $this->freeResources();
            $this->pauseBetweenSaves();

        }
    }

    /**
     * If configured, we will pause between starting another round of saves
     */
    private function pauseBetweenSaves(): void
    {
        if (0 >= $this->secondsToPauseBetweenSaves) {
            return;
        }
        usleep((int)$this->secondsToPauseBetweenSaves * 1000000);
    }

    /**
     * This will prevent any notification on changed properties
     *
     * @param array|EntityInterface[] $entities
     *
     * @return $this
     */
    public function prepareEntitiesForBulkUpdate(array $entities)
    {
        foreach ($entities as $entity) {
            $entity->removePropertyChangedListeners();
        }

        return $this;
    }

    public function addEntitiesToSave(array $entities)
    {
        $entitiesToSaveBackup = $this->entitiesToSave;
        $chunks               = array_chunk($entities, $this->chunkSize, true);
        foreach ($chunks as $chunk) {
            $this->entitiesToSave = $chunk;
            $this->bulkSaveIfChunkBigEnough();
        }
        $this->entitiesToSave = array_merge($this->entitiesToSave, $entitiesToSaveBackup);
        $this->bulkSaveIfChunkBigEnough();
    }

    /**
     * @return int
     */
    public function getChunkSize(): int
    {
        return $this->chunkSize;
    }

    /**
     * @param int $chunkSize
     *
     * @return $this
     */
    public function setChunkSize(int $chunkSize): self
    {
        $this->chunkSize = $chunkSize;

        return $this;
    }

    /**
     * @param float $secondsToPauseBetweenSaves
     */
    public function setSecondsToPauseBetweenSaves(float $secondsToPauseBetweenSaves): void
    {
        $this->secondsToPauseBetweenSaves = $secondsToPauseBetweenSaves;
    }
}