AbstractInMemoryHandler::getMultipleCacheValues() - Code Metrics - Inspection of "Align AbstractHandler::getMultipleCacheItems with..." - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — inmemory-abstract-trait ( 124d36 )

by André

created 2019-03-21 12:55 UTC

AbstractInMemoryHandler::getMultipleCacheValues() B

↳ Parent: AbstractInMemoryHandler

Complexity

Conditions	7
Paths	13

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	7
nc	13
nop	6
dl	0
loc	53
rs	8.0921
c	0
b	0
f	0

How to fix Long Method

<?php

/**
 * File containing the AbstractInMemoryHandler.
 *
 * @copyright Copyright (C) eZ Systems AS. All rights reserved.
 * @license For full copyright and license information view LICENSE file distributed with this source code.
 */
namespace eZ\Publish\Core\Persistence\Cache;

use eZ\Publish\Core\Persistence\Cache\InMemory\InMemoryCache;
use eZ\Publish\SPI\Persistence\Handler as PersistenceHandler;
use Symfony\Component\Cache\Adapter\TagAwareAdapterInterface;

/**
 * Class AbstractInMemoryHandler.
 *
 * Abstract handler for use in other Persistence Cache Handlers.
 */
abstract class AbstractInMemoryHandler
{
    use AbstractTrait {
        getMultipleCacheValues as getMultipleCacheValuesWithoutInMemoryCache;
    }

    /**
     * NOTE: $cache and $inMemory is private in order to abstract interactions across both,
     *       and be able to optimize this later without affecting all classes extending this.
     *
     * @var \Symfony\Component\Cache\Adapter\TagAwareAdapterInterface
     */
    private $cache;

    /**
     * @var \eZ\Publish\SPI\Persistence\Handler
     */
    protected $persistenceHandler;

    /**
     * @var \eZ\Publish\Core\Persistence\Cache\InMemory\InMemoryCache
     */
    private $inMemory;

    /**
     * Setups current handler with everything needed.
     *
     * @param \Symfony\Component\Cache\Adapter\TagAwareAdapterInterface $cache
     * @param \eZ\Publish\SPI\Persistence\Handler $persistenceHandler
     * @param \eZ\Publish\Core\Persistence\Cache\PersistenceLogger $logger
     * @param \eZ\Publish\Core\Persistence\Cache\InMemory\InMemoryCache $inMemory
     */
    public function __construct(
        TagAwareAdapterInterface $cache,
        PersistenceHandler $persistenceHandler,
        PersistenceLogger $logger,
        InMemoryCache $inMemory
    ) {
        $this->cache = $cache;
        $this->persistenceHandler = $persistenceHandler;
        $this->logger = $logger;
        $this->inMemory = $inMemory;

        $this->init();
    }

    /**
     * Function to initialize handler without having to overload __construct().
     */
    abstract protected function init(): void;

    /**
     * Load one cache item from cache and loggs the hits / misses.
     *
     * Load items from in-memory cache, symfony cache pool or backend in that order.
     * If not cached the returned objects will be placed in cache.
     *
     * @param int|string $id
     * @param string $keyPrefix E.g "ez-content-"
     * @param callable $backendLoader Function for loading missing objects, gets array with missing id's as argument,
     *                                expects return value to be array with id as key. Missing items should be missing.
     * @param callable $cacheTagger Gets cache object as argument, return array of cache tags.
     * @param callable $cacheIndexes Gets cache object as argument, return array of cache keys.
     * @param string $keySuffix Optional, e.g "-by-identifier"
     *
     * @return object
     */
    final protected function getCacheValue(
        $id,
        string $keyPrefix,
        callable $backendLoader,
        callable $cacheTagger,
        callable $cacheIndexes,
        string $keySuffix = ''
    ) {
        $key = $keyPrefix . $id . $keySuffix;
        // In-memory
        if ($object = $this->inMemory->get($key)) {
            $this->logger->logCacheHit([$id], 3, true);

            return $object;
        }

        // Cache pool
        $cacheItem = $this->cache->getItem($key);
        if ($cacheItem->isHit()) {

            $this->logger->logCacheHit([$id], 3);
            $this->inMemory->setMulti([$object = $cacheItem->get()], $cacheIndexes);

            return $object;
        }

        // Backend
        $object = $backendLoader($id);
        $this->inMemory->setMulti([$object], $cacheIndexes);
        $this->logger->logCacheMiss([$id], 3);
        $this->cache->save(
            $cacheItem
                ->set($object)
                ->tag($cacheTagger($object))
        );

        return $object;
    }

    /**
     * Load list of objects of some type and loggs the hits / misses.
     *
     * Load items from in-memory cache, symfony cache pool or backend in that order.
     * If not cached the returned objects will be placed in cache.
     *
     * @param string $key
     * @param callable $backendLoader Function for loading ALL objects, value is cached as-is.
     * @param callable $cacheTagger Gets cache object as argument, return array of cache tags.
     * @param callable $cacheIndexes Gets cache object as argument, return array of cache keys.
     * @param callable $listTags Optional, global tags for the list cache.
     * @param array $arguments Optional, arguments when parnt method takes arguments that key varies on.
     *
     * @return object
     */
    final protected function getListCacheValue(
        string $key,
        callable $backendLoader,
        callable $cacheTagger,
        callable $cacheIndexes,
        callable $listTags = null,
        array $arguments = []
    ) {
        // In-memory
        if ($objects = $this->inMemory->get($key)) {
            $this->logger->logCacheHit($arguments, 3, true);

            return $objects;
        }

        // Cache pool
        $cacheItem = $this->cache->getItem($key);
        if ($cacheItem->isHit()) {

            $this->logger->logCacheHit($arguments, 3);
            $this->inMemory->setMulti($objects = $cacheItem->get(), $cacheIndexes, $key);

            return $objects;
        }

        // Backend
        $objects = $backendLoader();
        $this->inMemory->setMulti($objects, $cacheIndexes, $key);
        $this->logger->logCacheMiss($arguments, 3);

        if ($listTags !== null) {
            $tagSet = [$listTags()];
        } else {
            $tagSet = [[]];
        }

        foreach ($objects as $object) {
            $tagSet[] = $cacheTagger($object);
        }

        $this->cache->save(
            $cacheItem
                ->set($objects)
                ->tag(array_unique(array_merge(...$tagSet)))
        );

        return $objects;
    }

    /**
     * Load several cache items from cache and loggs the hits / misses.
     *
     * Load items from in-memory cache, symfony cache pool or backend in that order.
     * If not cached the returned objects will be placed in cache.
     *
     * Cache items must be stored with a key in the following format "${keyPrefix}${id}", like "ez-content-info-${id}",
     * in order for this method to be able to prefix key on id's and also extract key prefix afterwards.
     *
     * @param array $ids
     * @param string $keyPrefix E.g "ez-content-"
     * @param callable $backendLoader Function for loading missing objects, gets array with missing id's as argument,
     *                                expects return value to be array with id as key. Missing items should be missing.
     * @param callable $cacheTagger Gets cache object as argument, return array of cache tags.
     * @param callable $cacheIndexes Gets cache object as argument, return array of cache keys.
     * @param string $keySuffix Optional, e.g "-by-identifier"
     *
     * @return array
     */
    final protected function getMultipleCacheValues(
        array $ids,
        string $keyPrefix,
        callable $backendLoader,
        callable $cacheTagger,
        callable $cacheIndexes,
        string $keySuffix = ''
    ): array {
        if (empty($ids)) {
            return [];
        }

        // Generate unique cache keys and check if in-memory
        $list = [];
        foreach (\array_unique($ids) as $id) {
            if ($object = $this->inMemory->get($keyPrefix . $id . $keySuffix)) {
                $list[$id] = $object;
            } else {
                $list[$id] = null;
                $misses[] = $id;
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
            }
        }

        // No in-memory misses
        if (empty($misses)) {
            $this->logger->logCacheHit($ids, 3, true);

            return $list;
        }

        $loaded = $this->getMultipleCacheValuesWithoutInMemoryCache(
            $misses,
            $keyPrefix,
            $backendLoader,
            $cacheTagger,
            $keySuffix
        );

        foreach ($misses as $id) {
            if (isset($loaded[$id])) {
                $list[$id] = $loaded[$id];
            } else {
                // not found
                unset($list[$id]);
            }
        }

        // save cache to memory
        $this->inMemory->setMulti($loaded, $cacheIndexes);
        unset($loaded);

        return $list;
    }

    /**
     * Delete cache by keys.
     *
     * @param array $keys
     */
    final protected function deleteCache(array $keys): void
    {
        if (empty($keys)) {
            return;
        }

        $this->inMemory->deleteMulti($keys);
        $this->cache->deleteItems($keys);
    }

    /**
     * Invalidate cache by tags.
     *
     * @param array $tags
     */
    final protected function invalidateCache(array $tags): void
    {
        if (empty($tags)) {
            return;
        }

        $this->inMemory->clear();
        $this->cache->invalidateTags($tags);
    }

    /**
     * Clear ALL cache.
     *
     * Only use this in extname situations, or for isolation in tests.
     */
    final protected function clearCache(): void
    {
        $this->inMemory->clear();
        $this->cache->clear();
    }
}


1		<?php
2
3		/**
4		* File containing the AbstractInMemoryHandler.
5		*
6		* @copyright Copyright (C) eZ Systems AS. All rights reserved.
7		* @license For full copyright and license information view LICENSE file distributed with this source code.
8		*/
9		namespace eZ\Publish\Core\Persistence\Cache;
10
11		use eZ\Publish\Core\Persistence\Cache\InMemory\InMemoryCache;
12		use eZ\Publish\SPI\Persistence\Handler as PersistenceHandler;
13		use Symfony\Component\Cache\Adapter\TagAwareAdapterInterface;
14
15		/**
16		* Class AbstractInMemoryHandler.
17		*
18		* Abstract handler for use in other Persistence Cache Handlers.
19		*/
20		abstract class AbstractInMemoryHandler
21		{
22		use AbstractTrait {
23		getMultipleCacheValues as getMultipleCacheValuesWithoutInMemoryCache;
24		}
25
26		/**
27		* NOTE: $cache and $inMemory is private in order to abstract interactions across both,
28		* and be able to optimize this later without affecting all classes extending this.
29		*
30		* @var \Symfony\Component\Cache\Adapter\TagAwareAdapterInterface
31		*/
32		private $cache;
33
34		/**
35		* @var \eZ\Publish\SPI\Persistence\Handler
36		*/
37		protected $persistenceHandler;
38
39		/**
40		* @var \eZ\Publish\Core\Persistence\Cache\InMemory\InMemoryCache
41		*/
42		private $inMemory;
43
44		/**
45		* Setups current handler with everything needed.
46		*
47		* @param \Symfony\Component\Cache\Adapter\TagAwareAdapterInterface $cache
48		* @param \eZ\Publish\SPI\Persistence\Handler $persistenceHandler
49		* @param \eZ\Publish\Core\Persistence\Cache\PersistenceLogger $logger
50		* @param \eZ\Publish\Core\Persistence\Cache\InMemory\InMemoryCache $inMemory
51		*/
52		public function __construct(
53		TagAwareAdapterInterface $cache,
54		PersistenceHandler $persistenceHandler,
55		PersistenceLogger $logger,
56		InMemoryCache $inMemory
57		) {
58		$this->cache = $cache;
59		$this->persistenceHandler = $persistenceHandler;
60		$this->logger = $logger;
61		$this->inMemory = $inMemory;
62
63		$this->init();
64		}
65
66		/**
67		* Function to initialize handler without having to overload __construct().
68		*/
69		abstract protected function init(): void;
70
71		/**
72		* Load one cache item from cache and loggs the hits / misses.
73		*
74		* Load items from in-memory cache, symfony cache pool or backend in that order.
75		* If not cached the returned objects will be placed in cache.
76		*
77		* @param int\|string $id
78		* @param string $keyPrefix E.g "ez-content-"
79		* @param callable $backendLoader Function for loading missing objects, gets array with missing id's as argument,
80		* expects return value to be array with id as key. Missing items should be missing.
81		* @param callable $cacheTagger Gets cache object as argument, return array of cache tags.
82		* @param callable $cacheIndexes Gets cache object as argument, return array of cache keys.
83		* @param string $keySuffix Optional, e.g "-by-identifier"
84		*
85		* @return object
86		*/
87		final protected function getCacheValue(
88		$id,
89		string $keyPrefix,
90		callable $backendLoader,
91		callable $cacheTagger,
92		callable $cacheIndexes,
93		string $keySuffix = ''
94		) {
95		$key = $keyPrefix . $id . $keySuffix;
96		// In-memory
97		if ($object = $this->inMemory->get($key)) {
98		$this->logger->logCacheHit([$id], 3, true);
99
100		return $object;
101		}
102
103		// Cache pool
104		$cacheItem = $this->cache->getItem($key);
105	View Code Duplication	if ($cacheItem->isHit()) {
		0 ignored issues – show Duplication introduced 2019-03-01 16:41 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
106		$this->logger->logCacheHit([$id], 3);
107		$this->inMemory->setMulti([$object = $cacheItem->get()], $cacheIndexes);
108
109		return $object;
110		}
111
112		// Backend
113		$object = $backendLoader($id);
114		$this->inMemory->setMulti([$object], $cacheIndexes);
115		$this->logger->logCacheMiss([$id], 3);
116		$this->cache->save(
117		$cacheItem
118		->set($object)
119		->tag($cacheTagger($object))
120		);
121
122		return $object;
123		}
124
125		/**
126		* Load list of objects of some type and loggs the hits / misses.
127		*
128		* Load items from in-memory cache, symfony cache pool or backend in that order.
129		* If not cached the returned objects will be placed in cache.
130		*
131		* @param string $key
132		* @param callable $backendLoader Function for loading ALL objects, value is cached as-is.
133		* @param callable $cacheTagger Gets cache object as argument, return array of cache tags.
134		* @param callable $cacheIndexes Gets cache object as argument, return array of cache keys.
135		* @param callable $listTags Optional, global tags for the list cache.
136		* @param array $arguments Optional, arguments when parnt method takes arguments that key varies on.
137		*
138		* @return object
139		*/
140		final protected function getListCacheValue(
141		string $key,
142		callable $backendLoader,
143		callable $cacheTagger,
144		callable $cacheIndexes,
145		callable $listTags = null,
146		array $arguments = []
147		) {
148		// In-memory
149		if ($objects = $this->inMemory->get($key)) {
150		$this->logger->logCacheHit($arguments, 3, true);
151
152		return $objects;
153		}
154
155		// Cache pool
156		$cacheItem = $this->cache->getItem($key);
157	View Code Duplication	if ($cacheItem->isHit()) {
		0 ignored issues – show Duplication introduced 2019-03-01 16:41 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
158		$this->logger->logCacheHit($arguments, 3);
159		$this->inMemory->setMulti($objects = $cacheItem->get(), $cacheIndexes, $key);
160
161		return $objects;
162		}
163
164		// Backend
165		$objects = $backendLoader();
166		$this->inMemory->setMulti($objects, $cacheIndexes, $key);
167		$this->logger->logCacheMiss($arguments, 3);
168
169		if ($listTags !== null) {
170		$tagSet = [$listTags()];
171		} else {
172		$tagSet = [[]];
173		}
174
175		foreach ($objects as $object) {
176		$tagSet[] = $cacheTagger($object);
177		}
178
179		$this->cache->save(
180		$cacheItem
181		->set($objects)
182		->tag(array_unique(array_merge(...$tagSet)))
183		);
184
185		return $objects;
186		}
187
188		/**
189		* Load several cache items from cache and loggs the hits / misses.
190		*
191		* Load items from in-memory cache, symfony cache pool or backend in that order.
192		* If not cached the returned objects will be placed in cache.
193		*
194		* Cache items must be stored with a key in the following format "${keyPrefix}${id}", like "ez-content-info-${id}",
195		* in order for this method to be able to prefix key on id's and also extract key prefix afterwards.
196		*
197		* @param array $ids
198		* @param string $keyPrefix E.g "ez-content-"
199		* @param callable $backendLoader Function for loading missing objects, gets array with missing id's as argument,
200		* expects return value to be array with id as key. Missing items should be missing.
201		* @param callable $cacheTagger Gets cache object as argument, return array of cache tags.
202		* @param callable $cacheIndexes Gets cache object as argument, return array of cache keys.
203		* @param string $keySuffix Optional, e.g "-by-identifier"
204		*
205		* @return array
206		*/
207		final protected function getMultipleCacheValues(
208		array $ids,
209		string $keyPrefix,
210		callable $backendLoader,
211		callable $cacheTagger,
212		callable $cacheIndexes,
213		string $keySuffix = ''
214		): array {
215		if (empty($ids)) {
216		return [];
217		}
218
219		// Generate unique cache keys and check if in-memory
220		$list = [];
221		foreach (\array_unique($ids) as $id) {
222		if ($object = $this->inMemory->get($keyPrefix . $id . $keySuffix)) {
223		$list[$id] = $object;
224		} else {
225		$list[$id] = null;
226		$misses[] = $id;
		0 ignored issues – show Coding Style Comprehensibility introduced 2019-03-21 13:20 UTC by Report Bug Copy Issue Report `$misses` was never initialized. Although not strictly required by PHP, it is generally a good practice to add `$misses = array();` before regardless. Adding an explicit array definition is generally preferable to implicit array definition as it guarantees a stable state of the code. Let’s take a look at an example: foreach ($collection as $item) { $myArray['foo'] = $item->getFoo(); if ($item->hasBar()) { $myArray['bar'] = $item->getBar(); } // do something with $myArray } As you can see in this example, the array `$myArray` is initialized the first time when the foreach loop is entered. You can also see that the value of the `bar` key is only written conditionally; thus, its value might result from a previous iteration. This might or might not be intended. To make your intention clear, your code more readible and to avoid accidental bugs, we recommend to add an explicit initialization `$myArray = array()` either outside or inside the foreach loop. Loading history...
227		}
228		}
229
230		// No in-memory misses
231		if (empty($misses)) {
232		$this->logger->logCacheHit($ids, 3, true);
233
234		return $list;
235		}
236
237		$loaded = $this->getMultipleCacheValuesWithoutInMemoryCache(
238		$misses,
239		$keyPrefix,
240		$backendLoader,
241		$cacheTagger,
242		$keySuffix
243		);
244
245		foreach ($misses as $id) {
246		if (isset($loaded[$id])) {
247		$list[$id] = $loaded[$id];
248		} else {
249		// not found
250		unset($list[$id]);
251		}
252		}
253
254		// save cache to memory
255		$this->inMemory->setMulti($loaded, $cacheIndexes);
256		unset($loaded);
257
258		return $list;
259		}
260
261		/**
262		* Delete cache by keys.
263		*
264		* @param array $keys
265		*/
266		final protected function deleteCache(array $keys): void
267		{
268		if (empty($keys)) {
269		return;
270		}
271
272		$this->inMemory->deleteMulti($keys);
273		$this->cache->deleteItems($keys);
274		}
275
276		/**
277		* Invalidate cache by tags.
278		*
279		* @param array $tags
280		*/
281		final protected function invalidateCache(array $tags): void
282		{
283		if (empty($tags)) {
284		return;
285		}
286
287		$this->inMemory->clear();
288		$this->cache->invalidateTags($tags);
289		}
290
291		/**
292		* Clear ALL cache.
293		*
294		* Only use this in extname situations, or for isolation in tests.
295		*/
296		final protected function clearCache(): void
297		{
298		$this->inMemory->clear();
299		$this->cache->clear();
300		}
301		}
302

ezsystems / ezpublish-kernel

Push — inmemory-abstract-trait ( 124d36 )

AbstractInMemoryHandler::getMultipleCacheValues() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like