Graviton\DocumentBundle\Service\CollectionCache

Complexity

Total Complexity

15

Size/Duplication

Total Lines	176
Duplicated Lines	13.07 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

72%

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	buildCacheKey()	0	4	1
A	getCollectionCacheTime()	0	7	2
A	getByRepository()	13	13	3
A	setByRepository()	10	10	2
A	updateOperationCheck()	0	13	2
A	addUpdateLock()	0	9	1
A	releaseUpdateLock()	0	14	2
A	setConfiguration()	0	4	1

<?php
/**
 * ExtReferenceConverter class file
 */

namespace Graviton\DocumentBundle\Service;

use Doctrine\Common\Cache\CacheProvider;
use Doctrine\ODM\MongoDB\DocumentRepository as Repository;
use Monolog\Logger;

/**
 * graviton.cache.collections

 * Collection Cache Service
 *
 *
 *
 * @author   List of contributors <https://github.com/libgraviton/graviton/graphs/contributors>
 * @license  https://opensource.org/licenses/MIT MIT License
 * @link     http://swisscom.ch
 */
class CollectionCache
{
    /** Prefix cache key */
    const BASE_KEY = 'CollectionCache';

    /** Prefix cache key */
    const BASE_UPDATE_KEY = 'CollectionUpdate';

    /** @var array  */
    private $config = [];

    /** @var CacheProvider */
    private $cache;

    /**
     * @var Logger
     */
    private $logger;

    /**
     * CollectionCache constructor.
     * @param CacheProvider $cache         Cache provider
     * @param Logger        $logger        Logger
     * @param array         $configuration Collections to be saved
     */
    public function __construct(
        CacheProvider $cache,
        Logger $logger,
        $configuration
    ) {
        $this->cache = $cache;
        $this->logger = $logger;
        $this->config = $configuration;
    }

    /**
     * Makes an id
     *
     * @param string $collection DB collection name
     * @param string $id         Object Identifier
     * @return string
     */
    private function buildCacheKey($collection, $id)
    {
        return self::BASE_KEY.'-'.preg_replace("/[^a-zA-Z0-9_-]+/", "-", $collection.'-'.$id);
    }

    /**
     * Time it should be in cache and if so should happen
     *
     * @param string $collection DB collection name
     * @return int
     */
    private function getCollectionCacheTime($collection)
    {
        if (array_key_exists($collection, $this->config)) {
            return (int) $this->config[$collection];
        }
        return 0;
    }

    /**
     * Return un cached object.
     *
     * @param Repository $repository DB Repository
     * @param string     $id         Queried is
     * @return object|false if no cache found
     */
    public function getByRepository(Repository $repository, $id)
    {
        $collection = $repository->getClassMetadata()->collection;
        if (!$this->getCollectionCacheTime($collection)) {
            return false;
        }
        $key = $this->buildCacheKey($collection, $id);

        if ($result = $this->cache->fetch($key)) {
            return $result;
        }
        return false;
    }

    /**
     * @param Repository $repository DB Repository
     * @param string     $serialized Serialised Object document
     * @param string     $id         Object document identifier
     * @return bool
     */
    public function setByRepository(Repository $repository, $serialized, $id)
    {
        $collection = $repository->getClassMetadata()->collection;
        if (!$time = $this->getCollectionCacheTime($collection)) {
            return false;
        }
        $key = $this->buildCacheKey($collection, $id);

        return $this->cache->save($key, $serialized, $time);
    }

    /**
     * Will sleep until previous operation has finished.
     * Default sleep time 10 seconds.
     * Loops by 1/4 second while there is a cache update lock
     *
     * @param Repository $repository Model repository
     * @param string     $id         Object identifier
     *
     * @return void
     */
    public function updateOperationCheck(Repository $repository, $id)
    {
        $collection = $repository->getClassMetadata()->collection;

        $key = self::BASE_UPDATE_KEY.'-'.$this->buildCacheKey($collection, $id);
        $this->logger->info("LOCK CHECK START = ".$collection.", id = ".$id. ", key=".$key);

        while ($this->cache->fetch($key)) {
            usleep(250000);
        }

        $this->logger->info("LOCK CHECK FINISHED = ".$collection.", id = ".$id. ", key=".$key);
    }

    /**
     * Will add update lock
     *
     * @param Repository $repository Model repository
     * @param string     $id         Object identifier
     * @param integer    $maxTime    Set timeout for lock
     *
     * @return bool
     */
    public function addUpdateLock(Repository $repository, $id, $maxTime = 10)
    {
        $collection = $repository->getClassMetadata()->collection;
        $key = self::BASE_UPDATE_KEY.'-'.$this->buildCacheKey($collection, $id);

        $this->logger->info("LOCK ADD = ".$collection.", id = ".$id. ", key=".$key);

        return $this->cache->save($key, true, $maxTime);
    }

    /**
     * Will remove lock if there was one.
     *
     * @param Repository $repository Model repository
     * @param string     $id         Object identifier
     *
     * @return void
     */
    public function releaseUpdateLock(Repository $repository, $id)
    {
        $collection = $repository->getClassMetadata()->collection;
        $baseKey = $this->buildCacheKey($collection, $id);
        $key = self::BASE_UPDATE_KEY.'-'.$baseKey;

        $this->cache->delete($key);

        $this->logger->info("LOCK RELEASE = ".$collection.", id = ".$id. ", key=".$key);

        if ($this->getCollectionCacheTime($collection)) {
            $this->cache->delete($baseKey);
        }
    }

    /**
     * Update cache if needed
     *
     * @param array $configuration configuration array
     * @return void
     */
    public function setConfiguration($configuration)
    {
        $this->config = $configuration;
    }
}