2016-10-19 09:57:06 -04:00
|
|
|
<?php declare(strict_types=1);
|
2016-08-31 12:18:46 -04:00
|
|
|
/**
|
2016-09-05 16:43:37 -04:00
|
|
|
* Banker
|
2016-08-31 12:18:46 -04:00
|
|
|
*
|
2020-05-07 19:00:38 -04:00
|
|
|
* A Caching library implementing psr/cache (PSR 6) and psr/simple-cache (PSR 16)
|
2016-08-31 12:18:46 -04:00
|
|
|
*
|
2020-05-07 19:00:38 -04:00
|
|
|
* PHP version 7.4
|
2016-08-31 12:18:46 -04:00
|
|
|
*
|
2016-09-05 16:43:37 -04:00
|
|
|
* @package Banker
|
2016-08-31 12:18:46 -04:00
|
|
|
* @author Timothy J. Warren <tim@timshomepage.net>
|
2020-05-07 19:00:38 -04:00
|
|
|
* @copyright 2016 - 2020 Timothy J. Warren
|
2016-08-31 12:18:46 -04:00
|
|
|
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
2020-05-08 12:30:43 -04:00
|
|
|
* @version 3.1.0
|
2016-09-05 16:43:37 -04:00
|
|
|
* @link https://git.timshomepage.net/timw4mail/banker
|
2016-08-31 12:18:46 -04:00
|
|
|
*/
|
|
|
|
namespace Aviat\Banker;
|
|
|
|
|
2016-09-05 16:43:37 -04:00
|
|
|
use Aviat\Banker\Exception\InvalidArgumentException;
|
2016-10-19 09:57:06 -04:00
|
|
|
use Psr\Cache\{CacheItemInterface, CacheItemPoolInterface};
|
|
|
|
use Psr\Log\{LoggerAwareInterface, LoggerInterface};
|
2016-08-31 12:18:46 -04:00
|
|
|
|
2020-05-07 17:17:03 -04:00
|
|
|
use function is_string;
|
|
|
|
|
2016-08-31 12:18:46 -04:00
|
|
|
/**
|
|
|
|
* The main cache manager
|
|
|
|
*/
|
2018-11-15 16:37:50 -05:00
|
|
|
final class Pool implements CacheItemPoolInterface, LoggerAwareInterface {
|
2020-05-08 10:54:09 -04:00
|
|
|
use _Driver;
|
2016-09-06 17:03:43 -04:00
|
|
|
use LoggerTrait;
|
2016-08-31 12:18:46 -04:00
|
|
|
|
2016-09-05 16:43:37 -04:00
|
|
|
/**
|
|
|
|
* Cache Items to be saved
|
|
|
|
*
|
|
|
|
* @var array
|
|
|
|
*/
|
2020-05-07 17:17:03 -04:00
|
|
|
protected array $deferred = [];
|
2016-09-05 16:43:37 -04:00
|
|
|
|
2016-08-31 12:18:46 -04:00
|
|
|
/**
|
|
|
|
* Set up the cache backend
|
|
|
|
*
|
|
|
|
* @param array $config
|
2018-11-15 16:37:50 -05:00
|
|
|
* @param LoggerInterface $logger
|
2016-08-31 12:18:46 -04:00
|
|
|
*/
|
2018-11-15 16:37:50 -05:00
|
|
|
public function __construct(array $config, ?LoggerInterface $logger = NULL)
|
2016-08-31 12:18:46 -04:00
|
|
|
{
|
2016-09-05 16:43:37 -04:00
|
|
|
$this->driver = $this->loadDriver($config);
|
2016-09-06 20:57:24 -04:00
|
|
|
|
2018-11-15 16:37:50 -05:00
|
|
|
if ($logger !== NULL)
|
2016-09-06 17:03:43 -04:00
|
|
|
{
|
|
|
|
$this->setLogger($logger);
|
|
|
|
}
|
2016-08-31 12:18:46 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns a Cache Item representing the specified key.
|
|
|
|
*
|
|
|
|
* This method must always return a CacheItemInterface object, even in case of
|
|
|
|
* a cache miss. It MUST NOT return null.
|
|
|
|
*
|
|
|
|
* @param string $key
|
|
|
|
* The key for which to return the corresponding Cache Item.
|
|
|
|
*
|
|
|
|
* @throws InvalidArgumentException
|
|
|
|
* If the $key string is not a legal value a \Psr\Cache\InvalidArgumentException
|
|
|
|
* MUST be thrown.
|
|
|
|
*
|
|
|
|
* @return CacheItemInterface
|
|
|
|
* The corresponding Cache Item.
|
|
|
|
*/
|
2016-10-19 09:57:06 -04:00
|
|
|
public function getItem($key): CacheItemInterface
|
2016-08-31 12:18:46 -04:00
|
|
|
{
|
2020-05-08 10:54:09 -04:00
|
|
|
$this->validateKey($key);
|
2016-09-06 20:57:24 -04:00
|
|
|
|
2016-09-06 17:03:43 -04:00
|
|
|
// If a deferred item exists, return that
|
|
|
|
if (array_key_exists($key, $this->deferred))
|
|
|
|
{
|
|
|
|
return $this->deferred[$key];
|
2016-09-05 16:43:37 -04:00
|
|
|
}
|
|
|
|
|
2018-11-15 16:37:50 -05:00
|
|
|
return new Item($this->driver, $key);
|
2016-08-31 12:18:46 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns a traversable set of cache items.
|
|
|
|
*
|
|
|
|
* @param string[] $keys
|
|
|
|
* An indexed array of keys of items to retrieve.
|
|
|
|
*
|
|
|
|
* @throws InvalidArgumentException
|
|
|
|
* If any of the keys in $keys are not a legal value a \Psr\Cache\InvalidArgumentException
|
|
|
|
* MUST be thrown.
|
|
|
|
*
|
|
|
|
* @return array|\Traversable
|
|
|
|
* A traversable collection of Cache Items keyed by the cache keys of
|
|
|
|
* each item. A Cache item will be returned for each key, even if that
|
|
|
|
* key is not found. However, if no keys are specified then an empty
|
|
|
|
* traversable MUST be returned instead.
|
|
|
|
*/
|
|
|
|
public function getItems(array $keys = [])
|
|
|
|
{
|
2020-05-08 10:54:09 -04:00
|
|
|
$this->validateKeys($keys);
|
|
|
|
|
2016-09-06 17:03:43 -04:00
|
|
|
if (empty($keys))
|
|
|
|
{
|
|
|
|
return new ItemCollection([]);
|
|
|
|
}
|
2016-09-06 20:57:24 -04:00
|
|
|
|
2018-11-15 16:37:50 -05:00
|
|
|
// Get the set of items selected
|
|
|
|
$items = [];
|
2016-09-06 17:03:43 -04:00
|
|
|
foreach($keys as $key)
|
|
|
|
{
|
2018-11-15 16:37:50 -05:00
|
|
|
$items[$key] = array_key_exists($key, $this->deferred)
|
|
|
|
? $this->deferred[$key]
|
|
|
|
: new Item($this->driver, $key);
|
2016-09-05 16:43:37 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
return new ItemCollection($items);
|
2016-08-31 12:18:46 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Confirms if the cache contains specified cache item.
|
|
|
|
*
|
|
|
|
* Note: This method MAY avoid retrieving the cached value for performance reasons.
|
|
|
|
* This could result in a race condition with CacheItemInterface::get(). To avoid
|
|
|
|
* such situation use CacheItemInterface::isHit() instead.
|
|
|
|
*
|
|
|
|
* @param string $key
|
|
|
|
* The key for which to check existence.
|
|
|
|
*
|
|
|
|
* @throws InvalidArgumentException
|
|
|
|
* If the $key string is not a legal value a \Psr\Cache\InvalidArgumentException
|
|
|
|
* MUST be thrown.
|
|
|
|
*
|
|
|
|
* @return bool
|
|
|
|
* True if item exists in the cache, false otherwise.
|
|
|
|
*/
|
2018-11-15 16:37:50 -05:00
|
|
|
public function hasItem($key): bool
|
2016-08-31 12:18:46 -04:00
|
|
|
{
|
2020-05-08 10:54:09 -04:00
|
|
|
$this->validateKey($key);
|
2016-09-06 20:57:24 -04:00
|
|
|
|
2016-09-06 17:03:43 -04:00
|
|
|
// See if there are any deferred items
|
|
|
|
if (array_key_exists($key, $this->deferred))
|
|
|
|
{
|
|
|
|
return TRUE;
|
2016-09-05 16:43:37 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
return $this->driver->exists($key);
|
2016-08-31 12:18:46 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Deletes all items in the pool.
|
|
|
|
*
|
|
|
|
* @return bool
|
|
|
|
* True if the pool was successfully cleared. False if there was an error.
|
|
|
|
*/
|
2016-10-19 09:57:06 -04:00
|
|
|
public function clear(): bool
|
2016-08-31 12:18:46 -04:00
|
|
|
{
|
2016-09-05 16:43:37 -04:00
|
|
|
return $this->driver->flush();
|
2016-08-31 12:18:46 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Removes the item from the pool.
|
|
|
|
*
|
|
|
|
* @param string $key
|
|
|
|
* The key to delete.
|
|
|
|
*
|
|
|
|
* @throws InvalidArgumentException
|
|
|
|
* If the $key string is not a legal value a \Psr\Cache\InvalidArgumentException
|
|
|
|
* MUST be thrown.
|
|
|
|
*
|
|
|
|
* @return bool
|
|
|
|
* True if the item was successfully removed. False if there was an error.
|
|
|
|
*/
|
2016-10-19 09:57:06 -04:00
|
|
|
public function deleteItem($key): bool
|
2016-08-31 12:18:46 -04:00
|
|
|
{
|
2020-05-08 10:54:09 -04:00
|
|
|
$this->validateKey($key);
|
2016-09-05 16:43:37 -04:00
|
|
|
|
|
|
|
if ( ! $this->hasItem($key))
|
|
|
|
{
|
|
|
|
return FALSE;
|
|
|
|
}
|
2018-11-15 16:37:50 -05:00
|
|
|
|
|
|
|
return $this->driver->delete($key);
|
2016-08-31 12:18:46 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Removes multiple items from the pool.
|
|
|
|
*
|
|
|
|
* @param string[] $keys
|
|
|
|
* An array of keys that should be removed from the pool.
|
|
|
|
|
|
|
|
* @throws InvalidArgumentException
|
|
|
|
* If any of the keys in $keys are not a legal value a \Psr\Cache\InvalidArgumentException
|
|
|
|
* MUST be thrown.
|
|
|
|
*
|
|
|
|
* @return bool
|
|
|
|
* True if the items were successfully removed. False if there was an error.
|
|
|
|
*/
|
2016-10-19 09:57:06 -04:00
|
|
|
public function deleteItems(array $keys): bool
|
2016-08-31 12:18:46 -04:00
|
|
|
{
|
2020-05-08 10:54:09 -04:00
|
|
|
$this->validateKeys($keys);
|
2016-09-05 16:43:37 -04:00
|
|
|
|
|
|
|
return $this->driver->deleteMultiple($keys);
|
2016-08-31 12:18:46 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Persists a cache item immediately.
|
|
|
|
*
|
|
|
|
* @param CacheItemInterface $item
|
|
|
|
* The cache item to save.
|
|
|
|
*
|
|
|
|
* @return bool
|
|
|
|
* True if the item was successfully persisted. False if there was an error.
|
|
|
|
*/
|
2016-10-19 09:57:06 -04:00
|
|
|
public function save(CacheItemInterface $item): bool
|
2016-08-31 12:18:46 -04:00
|
|
|
{
|
2016-09-06 17:03:43 -04:00
|
|
|
return $item->save();
|
2016-08-31 12:18:46 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets a cache item to be persisted later.
|
|
|
|
*
|
|
|
|
* @param CacheItemInterface $item
|
|
|
|
* The cache item to save.
|
|
|
|
*
|
|
|
|
* @return bool
|
|
|
|
* False if the item could not be queued or if a commit was attempted and failed. True otherwise.
|
|
|
|
*/
|
2016-10-19 09:57:06 -04:00
|
|
|
public function saveDeferred(CacheItemInterface $item): bool
|
2016-08-31 12:18:46 -04:00
|
|
|
{
|
2018-11-15 16:37:50 -05:00
|
|
|
$key = $item->getKey();
|
|
|
|
$this->deferred[$key] = $item;
|
|
|
|
|
2016-09-06 17:03:43 -04:00
|
|
|
return TRUE;
|
2016-08-31 12:18:46 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Persists any deferred cache items.
|
|
|
|
*
|
|
|
|
* @return bool
|
|
|
|
* True if all not-yet-saved items were successfully saved or there were none. False otherwise.
|
|
|
|
*/
|
2016-10-19 09:57:06 -04:00
|
|
|
public function commit(): bool
|
2016-08-31 12:18:46 -04:00
|
|
|
{
|
2016-09-05 16:43:37 -04:00
|
|
|
if (empty($this->deferred))
|
|
|
|
{
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
$result = TRUE;
|
|
|
|
|
|
|
|
foreach($this->deferred as $item)
|
|
|
|
{
|
|
|
|
$result = $result && $this->save($item);
|
|
|
|
}
|
2016-09-06 20:57:24 -04:00
|
|
|
|
2016-09-06 17:03:43 -04:00
|
|
|
if ($result === TRUE)
|
|
|
|
{
|
|
|
|
$this->deferred = [];
|
|
|
|
}
|
2016-09-05 16:43:37 -04:00
|
|
|
|
|
|
|
return $result;
|
2016-08-31 12:18:46 -04:00
|
|
|
}
|
|
|
|
}
|