-
-
Notifications
You must be signed in to change notification settings - Fork 9.4k
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
feature #18823 [Cache] Add PhpArrayAdapter to use shared memory on PH…
…P 7.0 (tgalopin) This PR was merged into the 3.2-dev branch. Discussion ---------- [Cache] Add PhpArrayAdapter to use shared memory on PHP 7.0 | Q | A | ------------- | --- | Branch? | master | Bug fix? | no | New feature? | yes | BC breaks? | no | Deprecations? | no | Tests pass? | WIP | Fixed tickets | - | License | MIT | Doc PR | - Depends on #18825 This PR aims to implement a Symfony Cache adapter able to build files optimized for OPCache memory storage. Any kind of static data that can be warmed up is a candidate for OPcache storage. This PR is limited to the implementation of the Adapter. It's usage in the annotations caching system is implemented in the PR #18533. The aim is also to use this adapter in other contexts (validator, serializer, ...). Commits ------- 28a40d2 [Cache] Add PhpArrayAdapter to use shared memory on PHP 7.0+
- Loading branch information
Showing
3 changed files
with
538 additions
and
0 deletions.
There are no files selected for viewing
358 changes: 358 additions & 0 deletions
358
src/Symfony/Component/Cache/Adapter/PhpArrayAdapter.php
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,358 @@ | ||
<?php | ||
|
||
/* | ||
* This file is part of the Symfony package. | ||
* | ||
* (c) Fabien Potencier <fabien@symfony.com> | ||
* | ||
* For the full copyright and license information, please view the LICENSE | ||
* file that was distributed with this source code. | ||
*/ | ||
|
||
namespace Symfony\Component\Cache\Adapter; | ||
|
||
use Psr\Cache\CacheItemInterface; | ||
use Psr\Cache\CacheItemPoolInterface; | ||
use Symfony\Component\Cache\CacheItem; | ||
use Symfony\Component\Cache\Exception\InvalidArgumentException; | ||
|
||
/** | ||
* Caches items at warm up time using a PHP array that is stored in shared memory by OPCache since PHP 7.0. | ||
* Warmed up items are read-only and run-time discovered items are cached using a fallback adapter. | ||
* | ||
* @author Titouan Galopin <galopintitouan@gmail.com> | ||
* @author Nicolas Grekas <p@tchwork.com> | ||
*/ | ||
class PhpArrayAdapter implements AdapterInterface | ||
{ | ||
private $file; | ||
private $values; | ||
private $createCacheItem; | ||
private $fallbackPool; | ||
|
||
/** | ||
* @param string $file The PHP file were values are cached | ||
* @param AdapterInterface $fallbackPool A pool to fallback on when an item is not hit | ||
*/ | ||
public function __construct($file, AdapterInterface $fallbackPool) | ||
{ | ||
$this->file = $file; | ||
$this->fallbackPool = $fallbackPool; | ||
$this->createCacheItem = \Closure::bind( | ||
function ($key, $value) { | ||
$item = new CacheItem(); | ||
$item->key = $key; | ||
$item->value = $value; | ||
$item->isHit = true; | ||
|
||
return $item; | ||
}, | ||
null, | ||
CacheItem::class | ||
); | ||
} | ||
|
||
/** | ||
* This adapter should only be used on PHP 7.0+ to take advantage of how PHP | ||
* stores arrays in its latest versions. This factory method decorates the given | ||
* fallback pool with this adapter only if the current PHP version is supported. | ||
* | ||
* @param string $file The PHP file were values are cached | ||
* | ||
* @return CacheItemPoolInterface | ||
*/ | ||
public static function create($file, CacheItemPoolInterface $fallbackPool) | ||
{ | ||
// Shared memory is available in PHP 7.0+ with OPCache enabled and in HHVM | ||
if ((PHP_VERSION_ID >= 70000 && ini_get('opcache.enable')) || defined('HHVM_VERSION')) { | ||
if (!$fallbackPool instanceof AdapterInterface) { | ||
$fallbackPool = new ProxyAdapter($fallbackPool); | ||
} | ||
|
||
return new static($file, $fallbackPool); | ||
} | ||
|
||
return $fallbackPool; | ||
} | ||
|
||
/** | ||
* Store an array of cached values. | ||
* | ||
* @param array $values The cached values | ||
*/ | ||
public function warmUp(array $values) | ||
{ | ||
if (file_exists($this->file)) { | ||
if (!is_file($this->file)) { | ||
throw new InvalidArgumentException(sprintf('Cache path exists and is not a file: %s.', $this->file)); | ||
} | ||
|
||
if (!is_writable($this->file)) { | ||
throw new InvalidArgumentException(sprintf('Cache file is not writable: %s.', $this->file)); | ||
} | ||
} else { | ||
$directory = dirname($this->file); | ||
|
||
if (!is_dir($directory) && !@mkdir($directory, 0777, true)) { | ||
throw new InvalidArgumentException(sprintf('Cache directory does not exist and cannot be created: %s.', $directory)); | ||
} | ||
|
||
if (!is_writable($directory)) { | ||
throw new InvalidArgumentException(sprintf('Cache directory is not writable: %s.', $directory)); | ||
} | ||
} | ||
|
||
$dump = <<<'EOF' | ||
<?php | ||
// This file has been auto-generated by the Symfony Cache Component. | ||
return array( | ||
|
||
|
||
EOF; | ||
|
||
foreach ($values as $key => $value) { | ||
CacheItem::validateKey(is_int($key) ? (string) $key : $key); | ||
|
||
if (null === $value || is_object($value)) { | ||
try { | ||
$value = serialize($value); | ||
} catch (\Exception $e) { | ||
throw new InvalidArgumentException(sprintf('Cache key "%s" has non-serializable %s value.', $key, get_class($value)), 0, $e); | ||
} | ||
} elseif (is_array($value)) { | ||
try { | ||
$serialized = serialize($value); | ||
$unserialized = unserialize($serialized); | ||
} catch (\Exception $e) { | ||
throw new InvalidArgumentException(sprintf('Cache key "%s" has non-serializable array value.', $key), 0, $e); | ||
} | ||
// Store arrays serialized if they contain any objects or references | ||
if ($unserialized !== $value || (false !== strpos($serialized, ';R:') && preg_match('/;R:[1-9]/', $serialized))) { | ||
$value = $serialized; | ||
} | ||
} elseif (is_string($value)) { | ||
// Serialize strings if they could be confused with serialized objects or arrays | ||
if ('N;' === $value || (isset($value[2]) && ':' === $value[1])) { | ||
$value = serialize($value); | ||
} | ||
} elseif (!is_scalar($value)) { | ||
throw new InvalidArgumentException(sprintf('Cache key "%s" has non-serializable %s value.', $key, gettype($value))); | ||
} | ||
|
||
$dump .= var_export($key, true).' => '.var_export($value, true).",\n"; | ||
} | ||
|
||
$dump .= "\n);\n"; | ||
$dump = str_replace("' . \"\\0\" . '", "\0", $dump); | ||
|
||
$tmpFile = uniqid($this->file); | ||
|
||
file_put_contents($tmpFile, $dump); | ||
@chmod($tmpFile, 0666); | ||
unset($serialized, $unserialized, $value, $dump); | ||
|
||
@rename($tmpFile, $this->file); | ||
|
||
$this->values = (include $this->file) ?: array(); | ||
} | ||
|
||
/** | ||
* {@inheritdoc} | ||
*/ | ||
public function getItem($key) | ||
{ | ||
if (null === $this->values) { | ||
$this->initialize(); | ||
} | ||
|
||
if (!is_string($key)) { | ||
throw new InvalidArgumentException(sprintf('Cache key must be string, "%s" given.', is_object($key) ? get_class($key) : gettype($key))); | ||
} | ||
|
||
if (!isset($this->values[$key])) { | ||
return $this->fallbackPool->getItem($key); | ||
} | ||
|
||
$value = $this->values[$key]; | ||
|
||
if ('N;' === $value) { | ||
$value = null; | ||
} elseif (is_string($value) && isset($value[2]) && ':' === $value[1]) { | ||
$value = unserialize($value); | ||
} | ||
|
||
$f = $this->createCacheItem; | ||
|
||
return $f($key, $value); | ||
} | ||
|
||
/** | ||
* {@inheritdoc} | ||
*/ | ||
public function getItems(array $keys = array()) | ||
{ | ||
if (null === $this->values) { | ||
$this->initialize(); | ||
} | ||
|
||
foreach ($keys as $key) { | ||
if (!is_string($key)) { | ||
throw new InvalidArgumentException(sprintf('Cache key must be string, "%s" given.', is_object($key) ? get_class($key) : gettype($key))); | ||
} | ||
} | ||
|
||
return $this->generateItems($keys); | ||
} | ||
|
||
/** | ||
* {@inheritdoc} | ||
*/ | ||
public function hasItem($key) | ||
{ | ||
if (null === $this->values) { | ||
$this->initialize(); | ||
} | ||
|
||
if (!is_string($key)) { | ||
throw new InvalidArgumentException(sprintf('Cache key must be string, "%s" given.', is_object($key) ? get_class($key) : gettype($key))); | ||
} | ||
|
||
return isset($this->values[$key]) || $this->fallbackPool->hasItem($key); | ||
} | ||
|
||
/** | ||
* {@inheritdoc} | ||
*/ | ||
public function clear() | ||
{ | ||
$this->values = array(); | ||
|
||
$cleared = @unlink($this->file) || !file_exists($this->file); | ||
|
||
return $this->fallbackPool->clear() && $cleared; | ||
} | ||
|
||
/** | ||
* {@inheritdoc} | ||
*/ | ||
public function deleteItem($key) | ||
{ | ||
if (null === $this->values) { | ||
$this->initialize(); | ||
} | ||
|
||
if (!is_string($key)) { | ||
throw new InvalidArgumentException(sprintf('Cache key must be string, "%s" given.', is_object($key) ? get_class($key) : gettype($key))); | ||
} | ||
|
||
return !isset($this->values[$key]) && $this->fallbackPool->deleteItem($key); | ||
} | ||
|
||
/** | ||
* {@inheritdoc} | ||
*/ | ||
public function deleteItems(array $keys) | ||
{ | ||
if (null === $this->values) { | ||
$this->initialize(); | ||
} | ||
|
||
$deleted = true; | ||
$fallbackKeys = array(); | ||
|
||
foreach ($keys as $key) { | ||
if (!is_string($key)) { | ||
throw new InvalidArgumentException(sprintf('Cache key must be string, "%s" given.', is_object($key) ? get_class($key) : gettype($key))); | ||
} | ||
|
||
if (isset($this->values[$key])) { | ||
$deleted = false; | ||
} else { | ||
$fallbackKeys[] = $key; | ||
} | ||
} | ||
|
||
if ($fallbackKeys) { | ||
$deleted = $this->fallbackPool->deleteItems($fallbackKeys) && $deleted; | ||
} | ||
|
||
return $deleted; | ||
} | ||
|
||
/** | ||
* {@inheritdoc} | ||
*/ | ||
public function save(CacheItemInterface $item) | ||
{ | ||
if (null === $this->values) { | ||
$this->initialize(); | ||
} | ||
|
||
return !isset($this->values[$item->getKey()]) && $this->fallbackPool->save($item); | ||
} | ||
|
||
/** | ||
* {@inheritdoc} | ||
*/ | ||
public function saveDeferred(CacheItemInterface $item) | ||
{ | ||
if (null === $this->values) { | ||
$this->initialize(); | ||
} | ||
|
||
return !isset($this->values[$item->getKey()]) && $this->fallbackPool->saveDeferred($item); | ||
} | ||
|
||
/** | ||
* {@inheritdoc} | ||
*/ | ||
public function commit() | ||
{ | ||
return $this->fallbackPool->commit(); | ||
} | ||
|
||
/** | ||
* Load the cache file. | ||
*/ | ||
private function initialize() | ||
{ | ||
$this->values = @(include $this->file) ?: array(); | ||
} | ||
|
||
/** | ||
* Generator for items. | ||
* | ||
* @param array $keys | ||
* | ||
* @return \Generator | ||
*/ | ||
private function generateItems(array $keys) | ||
{ | ||
$f = $this->createCacheItem; | ||
$fallbackKeys = array(); | ||
|
||
foreach ($keys as $key) { | ||
if (isset($this->values[$key])) { | ||
$value = $this->values[$key]; | ||
|
||
if ('N;' === $value) { | ||
$value = null; | ||
} elseif (is_string($value) && isset($value[2]) && ':' === $value[1]) { | ||
$value = unserialize($value); | ||
} | ||
|
||
yield $key => $f($key, $value); | ||
} else { | ||
$fallbackKeys[] = $key; | ||
} | ||
} | ||
|
||
if ($fallbackKeys) { | ||
foreach ($this->fallbackPool->getItems($fallbackKeys) as $key => $item) { | ||
yield $key => $item; | ||
} | ||
} | ||
} | ||
} |
Oops, something went wrong.