2018-06-14 16:10:14 +01:00
|
|
|
<?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;
|
|
|
|
|
2019-04-03 10:22:52 +01:00
|
|
|
use Psr\Log\LoggerInterface;
|
2018-09-24 18:16:30 +01:00
|
|
|
use Symfony\Contracts\Cache\CacheInterface;
|
|
|
|
use Symfony\Contracts\Cache\ItemInterface;
|
2018-06-14 16:10:14 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* LockRegistry is used internally by existing adapters to protect against cache stampede.
|
|
|
|
*
|
|
|
|
* It does so by wrapping the computation of items in a pool of locks.
|
|
|
|
* Foreach each apps, there can be at most 20 concurrent processes that
|
|
|
|
* compute items at the same time and only one per cache-key.
|
|
|
|
*
|
|
|
|
* @author Nicolas Grekas <p@tchwork.com>
|
|
|
|
*/
|
2019-03-14 21:54:25 +00:00
|
|
|
final class LockRegistry
|
2018-06-14 16:10:14 +01:00
|
|
|
{
|
2019-01-16 20:35:37 +00:00
|
|
|
private static $openedFiles = [];
|
|
|
|
private static $lockedFiles = [];
|
2018-06-14 16:10:14 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* The number of items in this list controls the max number of concurrent processes.
|
|
|
|
*/
|
2019-01-16 20:35:37 +00:00
|
|
|
private static $files = [
|
2018-06-14 16:10:14 +01:00
|
|
|
__DIR__.\DIRECTORY_SEPARATOR.'Adapter'.\DIRECTORY_SEPARATOR.'AbstractAdapter.php',
|
|
|
|
__DIR__.\DIRECTORY_SEPARATOR.'Adapter'.\DIRECTORY_SEPARATOR.'AdapterInterface.php',
|
|
|
|
__DIR__.\DIRECTORY_SEPARATOR.'Adapter'.\DIRECTORY_SEPARATOR.'ApcuAdapter.php',
|
|
|
|
__DIR__.\DIRECTORY_SEPARATOR.'Adapter'.\DIRECTORY_SEPARATOR.'ArrayAdapter.php',
|
|
|
|
__DIR__.\DIRECTORY_SEPARATOR.'Adapter'.\DIRECTORY_SEPARATOR.'ChainAdapter.php',
|
|
|
|
__DIR__.\DIRECTORY_SEPARATOR.'Adapter'.\DIRECTORY_SEPARATOR.'DoctrineAdapter.php',
|
|
|
|
__DIR__.\DIRECTORY_SEPARATOR.'Adapter'.\DIRECTORY_SEPARATOR.'FilesystemAdapter.php',
|
|
|
|
__DIR__.\DIRECTORY_SEPARATOR.'Adapter'.\DIRECTORY_SEPARATOR.'MemcachedAdapter.php',
|
|
|
|
__DIR__.\DIRECTORY_SEPARATOR.'Adapter'.\DIRECTORY_SEPARATOR.'NullAdapter.php',
|
|
|
|
__DIR__.\DIRECTORY_SEPARATOR.'Adapter'.\DIRECTORY_SEPARATOR.'PdoAdapter.php',
|
|
|
|
__DIR__.\DIRECTORY_SEPARATOR.'Adapter'.\DIRECTORY_SEPARATOR.'PhpArrayAdapter.php',
|
|
|
|
__DIR__.\DIRECTORY_SEPARATOR.'Adapter'.\DIRECTORY_SEPARATOR.'PhpFilesAdapter.php',
|
|
|
|
__DIR__.\DIRECTORY_SEPARATOR.'Adapter'.\DIRECTORY_SEPARATOR.'ProxyAdapter.php',
|
2018-11-15 20:07:46 +00:00
|
|
|
__DIR__.\DIRECTORY_SEPARATOR.'Adapter'.\DIRECTORY_SEPARATOR.'Psr16Adapter.php',
|
2018-06-14 16:10:14 +01:00
|
|
|
__DIR__.\DIRECTORY_SEPARATOR.'Adapter'.\DIRECTORY_SEPARATOR.'RedisAdapter.php',
|
|
|
|
__DIR__.\DIRECTORY_SEPARATOR.'Adapter'.\DIRECTORY_SEPARATOR.'SimpleCacheAdapter.php',
|
|
|
|
__DIR__.\DIRECTORY_SEPARATOR.'Adapter'.\DIRECTORY_SEPARATOR.'TagAwareAdapter.php',
|
|
|
|
__DIR__.\DIRECTORY_SEPARATOR.'Adapter'.\DIRECTORY_SEPARATOR.'TagAwareAdapterInterface.php',
|
|
|
|
__DIR__.\DIRECTORY_SEPARATOR.'Adapter'.\DIRECTORY_SEPARATOR.'TraceableAdapter.php',
|
|
|
|
__DIR__.\DIRECTORY_SEPARATOR.'Adapter'.\DIRECTORY_SEPARATOR.'TraceableTagAwareAdapter.php',
|
2019-01-16 20:35:37 +00:00
|
|
|
];
|
2018-06-14 16:10:14 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Defines a set of existing files that will be used as keys to acquire locks.
|
|
|
|
*
|
|
|
|
* @return array The previously defined set of files
|
|
|
|
*/
|
|
|
|
public static function setFiles(array $files): array
|
|
|
|
{
|
|
|
|
$previousFiles = self::$files;
|
|
|
|
self::$files = $files;
|
|
|
|
|
2018-06-21 10:23:42 +01:00
|
|
|
foreach (self::$openedFiles as $file) {
|
|
|
|
if ($file) {
|
|
|
|
flock($file, LOCK_UN);
|
|
|
|
fclose($file);
|
|
|
|
}
|
2018-06-14 16:10:14 +01:00
|
|
|
}
|
2019-01-16 20:35:37 +00:00
|
|
|
self::$openedFiles = self::$lockedFiles = [];
|
2018-06-14 16:10:14 +01:00
|
|
|
|
|
|
|
return $previousFiles;
|
|
|
|
}
|
|
|
|
|
2019-04-03 10:22:52 +01:00
|
|
|
public static function compute(callable $callback, ItemInterface $item, bool &$save, CacheInterface $pool, \Closure $setMetadata = null, LoggerInterface $logger = null)
|
2018-06-14 16:10:14 +01:00
|
|
|
{
|
2018-09-24 18:16:30 +01:00
|
|
|
$key = self::$files ? crc32($item->getKey()) % \count(self::$files) : -1;
|
2018-06-14 16:10:14 +01:00
|
|
|
|
|
|
|
if ($key < 0 || (self::$lockedFiles[$key] ?? false) || !$lock = self::open($key)) {
|
2018-10-30 08:19:03 +00:00
|
|
|
return $callback($item, $save);
|
2018-06-14 16:10:14 +01:00
|
|
|
}
|
|
|
|
|
2018-10-30 08:19:03 +00:00
|
|
|
while (true) {
|
|
|
|
try {
|
|
|
|
// race to get the lock in non-blocking mode
|
|
|
|
if (flock($lock, LOCK_EX | LOCK_NB)) {
|
2019-04-03 10:22:52 +01:00
|
|
|
$logger && $logger->info('Lock acquired, now computing item "{key}"', ['key' => $item->getKey()]);
|
2018-10-30 08:19:03 +00:00
|
|
|
self::$lockedFiles[$key] = true;
|
2018-06-14 16:10:14 +01:00
|
|
|
|
2019-03-14 21:54:25 +00:00
|
|
|
$value = $callback($item, $save);
|
|
|
|
|
|
|
|
if ($save) {
|
|
|
|
if ($setMetadata) {
|
|
|
|
$setMetadata($item);
|
|
|
|
}
|
|
|
|
|
|
|
|
$pool->save($item->set($value));
|
|
|
|
$save = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return $value;
|
2018-10-30 08:19:03 +00:00
|
|
|
}
|
|
|
|
// if we failed the race, retry locking in blocking mode to wait for the winner
|
2019-04-03 10:22:52 +01:00
|
|
|
$logger && $logger->info('Item "{key}" is locked, waiting for it to be released', ['key' => $item->getKey()]);
|
2018-10-30 08:19:03 +00:00
|
|
|
flock($lock, LOCK_SH);
|
|
|
|
} finally {
|
|
|
|
flock($lock, LOCK_UN);
|
|
|
|
unset(self::$lockedFiles[$key]);
|
2018-06-14 16:10:14 +01:00
|
|
|
}
|
2018-10-30 08:19:03 +00:00
|
|
|
static $signalingException, $signalingCallback;
|
|
|
|
$signalingException = $signalingException ?? unserialize("O:9:\"Exception\":1:{s:16:\"\0Exception\0trace\";a:0:{}}");
|
|
|
|
$signalingCallback = $signalingCallback ?? function () use ($signalingException) { throw $signalingException; };
|
2018-06-14 16:10:14 +01:00
|
|
|
|
2018-10-30 08:19:03 +00:00
|
|
|
try {
|
|
|
|
$value = $pool->get($item->getKey(), $signalingCallback, 0);
|
2019-04-03 10:22:52 +01:00
|
|
|
$logger && $logger->info('Item "{key}" retrieved after lock was released', ['key' => $item->getKey()]);
|
2018-10-30 08:19:03 +00:00
|
|
|
$save = false;
|
|
|
|
|
|
|
|
return $value;
|
|
|
|
} catch (\Exception $e) {
|
|
|
|
if ($signalingException !== $e) {
|
|
|
|
throw $e;
|
|
|
|
}
|
2019-04-03 10:22:52 +01:00
|
|
|
$logger && $logger->info('Item "{key}" not found while lock was released, now retrying', ['key' => $item->getKey()]);
|
2018-10-30 08:19:03 +00:00
|
|
|
}
|
|
|
|
}
|
2018-06-14 16:10:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
private static function open(int $key)
|
|
|
|
{
|
2018-06-21 10:23:42 +01:00
|
|
|
if (null !== $h = self::$openedFiles[$key] ?? null) {
|
2018-06-14 16:10:14 +01:00
|
|
|
return $h;
|
|
|
|
}
|
2018-06-21 10:23:42 +01:00
|
|
|
set_error_handler(function () {});
|
|
|
|
try {
|
|
|
|
$h = fopen(self::$files[$key], 'r+');
|
|
|
|
} finally {
|
|
|
|
restore_error_handler();
|
2018-06-14 16:10:14 +01:00
|
|
|
}
|
2018-06-21 10:23:42 +01:00
|
|
|
|
2019-03-14 21:54:25 +00:00
|
|
|
return self::$openedFiles[$key] = $h ?: @fopen(self::$files[$key], 'r');
|
2018-06-14 16:10:14 +01:00
|
|
|
}
|
|
|
|
}
|