InMemoryList\Infrastructure\Persistance\ApcuRepository

Complexity

Total Complexity

43

Size/Duplication

Total Lines	379
Duplicated Lines	0 %

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	getHeaders()	0	3	1
A	flush()	0	3	1
A	getStatistics()	0	3	1
A	getIndex()	0	11	4
A	updateElement()	0	36	5
A	exists()	0	5	1
A	updateTtl()	0	40	5
B	create()	0	51	9
A	findListByUuid()	0	10	3
A	deleteElement()	0	34	4
A	addOrUpdateListToIndex()	0	26	4
A	pushElement()	0	37	4
A	removeListFromIndex()	0	9	1

<?php
/**
 * This file is part of the Simple EventStore Manager package.
 *
 * (c) Mauro Cassani<https://github.com/mauretto78>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace InMemoryList\Infrastructure\Persistance;

use InMemoryList\Domain\Helper\ListElementConsistencyChecker;
use InMemoryList\Domain\Model\Contracts\ListRepositoryInterface;
use InMemoryList\Domain\Model\Exceptions\ListElementNotConsistentException;
use InMemoryList\Domain\Model\ListCollection;
use InMemoryList\Domain\Model\ListElement;
use InMemoryList\Domain\Model\ListElementUuid;
use InMemoryList\Infrastructure\Persistance\Exceptions\ListAlreadyExistsException;
use InMemoryList\Infrastructure\Persistance\Exceptions\ListDoesNotExistsException;

class ApcuRepository extends AbstractRepository implements ListRepositoryInterface
{
    /**
     * @param ListCollection $list
     * @param null           $ttl

Are you sure the doc-type for parameter $ttl is correct as it would always require null to be passed?

     * @param null           $chunkSize

Are you sure the doc-type for parameter $chunkSize is correct as it would always require null to be passed?

     *
     * @return mixed
     *
     * @throws ListAlreadyExistsException
     */
    public function create(ListCollection $list, $ttl = null, $chunkSize = null)
    {
        // check if list already exists in memory
        $listUuid = (string) $list->getUuid();
        if ($this->existsListInIndex($listUuid) && $this->exists($listUuid)) {
            throw new ListAlreadyExistsException('List '.$list->getUuid().' already exists in memory.');
        }

        if (!$chunkSize && !is_int($chunkSize)) {

$chunkSize is of type null, thus it always evaluated to false.

The condition is_int($chunkSize) is always false.

            $chunkSize = self::CHUNKSIZE;
        }

        // create arrayOfElements
        $arrayOfElements = [];

        /** @var ListElement $element */
        foreach ($list->getElements() as $element) {
            $arrayOfElements[(string) $element->getUuid()] = $element->getBody();
        }

        // persist in memory array in chunks
        $arrayChunks = array_chunk($arrayOfElements, $chunkSize, true);
        foreach ($arrayChunks as $chunkNumber => $item) {
            $arrayToPersist = [];
            foreach ($item as $key => $element) {
                $arrayToPersist[$key] = $element;
            }

            apcu_store(
                (string) $list->getUuid().self::SEPARATOR.'chunk-'.($chunkNumber + 1),
                $arrayToPersist,
                $ttl
            );
        }

        // set headers
        if ($list->getHeaders()) {
            apcu_store(
                (string) $list->getUuid().self::SEPARATOR.self::HEADERS,
                $list->getHeaders(),
                $ttl
            );
        }

        // add list to index
        $this->addOrUpdateListToIndex(
            (string) $listUuid,
            (int) count($list->getElements()),
            (int) count($arrayChunks),
            (int) $chunkSize,
            $ttl
        );
    }

    /**
     * @param $listUuid
     * @param $elementUuid
     *
     * @return mixed
     */
    public function deleteElement($listUuid, $elementUuid)
    {
        $numberOfChunks = $this->getNumberOfChunks($listUuid);
        $chunkSize = $this->getChunkSize($listUuid);

        for ($i = 1; $i <= $numberOfChunks; ++$i) {
            $chunkNumber = $listUuid.self::SEPARATOR.self::CHUNK.'-'.$i;
            $chunk = apcu_fetch($chunkNumber);

            if (array_key_exists($elementUuid, $chunk)) {
                // delete elements from chunk
                unset($chunk[(string) $elementUuid]);
                apcu_delete($chunkNumber);
                apcu_store($chunkNumber, $chunk);

                // update list index
                $prevIndex = $this->getIndex($listUuid);
                $this->addOrUpdateListToIndex(
                    $listUuid,
                    ($prevIndex['size'] - 1),
                    $numberOfChunks,
                    $chunkSize,
                    $prevIndex['ttl']
                );

                // delete headers if counter = 0
                $counter = $this->getCounter($listUuid);
                $headersKey = $listUuid.self::SEPARATOR.self::HEADERS;

                if ($counter === 0) {
                    apcu_delete($headersKey);
                }

                break;
            }
        }
    }

    /**
     * @param $listUuid
     *
     * @return bool
     */
    public function exists($listUuid)
    {
        $listFirstChunk = apcu_fetch($listUuid.self::SEPARATOR.self::CHUNK.'-1');

        return isset($listFirstChunk);
    }

    /**
     * @param $listUuid
     *
     * @return mixed
     */
    public function findListByUuid($listUuid)
    {
        $collection = (apcu_fetch($listUuid.self::SEPARATOR.self::CHUNK.'-1')) ?: [];
        $numberOfChunks = $this->getNumberOfChunks($listUuid);

        for ($i = 2; $i <= $numberOfChunks; ++$i) {
            $collection = (array) array_merge($collection, apcu_fetch($listUuid.self::SEPARATOR.self::CHUNK.'-'.$i));
        }

        return (array) array_map('unserialize', $collection);
    }

    /**
     * @return mixed
     */
    public function flush()
    {
        apcu_clear_cache();
    }

    /**
     * @param $listUuid
     *
     * @return array
     */
    public function getHeaders($listUuid)
    {
        return apcu_fetch($listUuid.self::SEPARATOR.'headers');
    }

    /**
     * @param null $listUuid

Are you sure the doc-type for parameter $listUuid is correct as it would always require null to be passed?

     *
     * @return mixed
     */
    public function getIndex($listUuid = null)
    {
        $indexKey = ListRepositoryInterface::INDEX;
        $index = apcu_fetch($indexKey);
        $this->removeExpiredListsFromIndex($index);

        if ($listUuid) {

$listUuid is of type null, thus it always evaluated to false.

            return (isset($index[(string) $listUuid])) ? unserialize($index[(string) $listUuid]) : null;
        }

        return ($index) ? array_map('unserialize', $index) : [];
    }

    /**
     * @param $listUuid
     * @param $size
     * @param $numberOfChunks
     * @param $chunkSize
     * @param null $ttl

Are you sure the doc-type for parameter $ttl is correct as it would always require null to be passed?

     */
    private function addOrUpdateListToIndex($listUuid, $size, $numberOfChunks, $chunkSize, $ttl = null)
    {
        $indexKey = ListRepositoryInterface::INDEX;
        $indexArray = serialize([
            'uuid' => $listUuid,
            'created_on' => new \DateTimeImmutable(),
            'size' => $size,
            'chunks' => $numberOfChunks,
            'chunk-size' => $chunkSize,
            'headers' => $this->getHeaders($listUuid),
            'ttl' => $ttl,
        ]);

        $indexArrayToUpdate[(string) $listUuid] = $indexArray;

$indexArrayToUpdate was never initialized. Although not strictly required by PHP, it is generally a good practice to add $indexArrayToUpdate = array(); before regardless.

        $index = apcu_fetch((string) $indexKey);

        if ($this->existsListInIndex($listUuid) or is_array($index)) {
            $index[$listUuid] = $indexArray;
            $indexArrayToUpdate = $index;
            apcu_delete($indexKey);
        }

        apcu_store((string) $indexKey, $indexArrayToUpdate);

        if ($size === 0) {
            $this->removeListFromIndex($listUuid);
        }
    }

    /**
     * @return array
     */
    public function getStatistics()
    {
        return (array) apcu_cache_info();
    }

    /**
     * @param $listUuid
     * @param ListElement $listElement
     *
     * @throws ListElementNotConsistentException
     *
     * @return mixed
     */
    public function pushElement($listUuid, ListElement $listElement)
    {
        $elementUuid = $listElement->getUuid();
        $body = $listElement->getBody();

        if (!ListElementConsistencyChecker::isConsistent($listElement, $this->findListByUuid($listUuid))) {
            throw new ListElementNotConsistentException('Element '.(string) $listElement->getUuid().' is not consistent with list data.');
        }

        $numberOfChunks = $this->getNumberOfChunks($listUuid);
        $chunkSize = $this->getChunkSize($listUuid);
        $chunkNumber = $listUuid.self::SEPARATOR.self::CHUNK.'-'.$numberOfChunks;
        $ttl = ($this->getTtl($listUuid) > 0) ? $this->getTtl($listUuid) : null;

        if ($chunkSize - count(apcu_fetch($chunkNumber)) === 0) {
            ++$numberOfChunks;
            $chunkNumber = $listUuid.self::SEPARATOR.self::CHUNK.'-'.$numberOfChunks;
        }

        $chunkValues = apcu_fetch($chunkNumber);
        $chunkValues[(string) $elementUuid] = (string) $body;

        apcu_delete($chunkNumber);
        apcu_store(
            $chunkNumber,
            $chunkValues,
            $ttl
        );

        // update list index
        $prevIndex = $this->getIndex($listUuid);
        $this->addOrUpdateListToIndex(
            $listUuid,
            ($prevIndex['size'] + 1),
            $numberOfChunks,
            $chunkSize,
            $ttl

It seems like $ttl can also be of type integer; however, parameter $ttl of InMemoryList\Infrastructure\Persistance\ApcuRepository::addOrUpdateListToIndex() does only seem to accept null, maybe add an additional type check?

        );
    }

    /**
     * @param $listUuid
     *
     * @return mixed
     */
    public function removeListFromIndex($listUuid)
    {
        $indexKey = ListRepositoryInterface::INDEX;

        $index = apcu_fetch($indexKey);
        unset($index[(string) $listUuid]);

        apcu_delete($indexKey);
        apcu_store($indexKey, $index);
    }

    /**
     * @param $listUuid
     * @param $elementUuid
     * @param array $data
     *
     * @throws ListElementNotConsistentException
     *
     * @return mixed
     */
    public function updateElement($listUuid, $elementUuid, $data)
    {
        $numberOfChunks = $this->getNumberOfChunks($listUuid);
        $ttl = ($this->getTtl($listUuid) > 0) ? $this->getTtl($listUuid) : null;

        for ($i = 1; $i <= $numberOfChunks; ++$i) {
            $chunkNumber = $listUuid.self::SEPARATOR.self::CHUNK.'-'.$i;
            $chunk = apcu_fetch($chunkNumber);

            if (array_key_exists($elementUuid, $chunk)) {
                $listElement = $this->findElement(
                    (string) $listUuid,
                    (string) $elementUuid
                );

                $updatedElementBody = $this->updateListElementBody($listElement, $data);
                if (!ListElementConsistencyChecker::isConsistent($updatedElementBody, $this->findListByUuid($listUuid))) {
                    throw new ListElementNotConsistentException('Element '.(string) $elementUuid.' is not consistent with list data.');
                }

                $arrayOfElements = apcu_fetch($listUuid);
                $updatedElement = new ListElement(
                    new ListElementUuid($elementUuid),
                    $updatedElementBody
                );
                $body = $updatedElement->getBody();
                $arrayOfElements[(string) $elementUuid] = $body;

                apcu_delete($chunkNumber);
                apcu_store(
                    (string) $chunkNumber,
                    $arrayOfElements,
                    $ttl
                );

                break;
            }
        }
    }

    /**
     * @param $listUuid
     * @param null $ttl

Are you sure the doc-type for parameter $ttl is correct as it would always require null to be passed?

     *
     * @return mixed
     *
     * @throws ListDoesNotExistsException
     */
    public function updateTtl($listUuid, $ttl)
    {
        if (!$this->findListByUuid($listUuid)) {
            throw new ListDoesNotExistsException('List '.$listUuid.' does not exists in memory.');
        }

        $ttl = ($ttl > 0) ? $ttl : null;

        // update ttl of all chunks
        $numberOfChunks = $this->getNumberOfChunks($listUuid);
        for ($i = 1; $i <= $numberOfChunks; ++$i) {
            $chunkNumber = (string) $listUuid.self::SEPARATOR.self::CHUNK.'-'.$i;
            $storedListInChunk = apcu_fetch($chunkNumber);
            apcu_delete((string) $chunkNumber);
            apcu_store(
                (string) $chunkNumber,
                $storedListInChunk,
                $ttl
            );
        }

        // update ttl of headers array (if present)
        if ($this->getHeaders($listUuid)) {
            $headers = (string) $listUuid.self::SEPARATOR.self::HEADERS;
            $storedHeaders = apcu_fetch($headers);
            apcu_delete((string) $headers);
            apcu_store(
                (string) $headers,
                $storedHeaders,
                $ttl
            );
        }

        // update index
        $this->addOrUpdateListToIndex(
            (string) $listUuid,
            $this->getCounter((string) $listUuid),
            $this->getNumberOfChunks((string) $listUuid),
            $this->getChunkSize((string) $listUuid),
            $ttl
        );
    }
}