<?php
/**
* Copyright 2018 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
namespace Google\Auth\Cache;
use Psr\Cache\CacheItemInterface;
use Psr\Cache\CacheItemPoolInterface;
use SysvSemaphore;
use SysvSharedMemory;
/**
* SystemV shared memory based CacheItemPool implementation.
*
* This CacheItemPool implementation can be used among multiple processes, but
* it doesn't provide any locking mechanism. If multiple processes write to
* this ItemPool, you have to avoid race condition manually in your code.
*/
class SysVCacheItemPool implements CacheItemPoolInterface
{
const VAR_KEY = 1;
const DEFAULT_PROJ = 'A';
const DEFAULT_SEM_PROJ = 'B';
const DEFAULT_MEMSIZE = 10000;
const DEFAULT_PERM = 0600;
/**
* @var int
*/
private $sysvKey;
/**
* @var CacheItemInterface[]
*/
private $items;
/**
* @var CacheItemInterface[]
*/
private $deferredItems;
/**
* @var array<mixed>
*/
private $options;
/**
* @var bool
*/
private $hasLoadedItems = false;
/**
* @var SysvSemaphore|false
*/
private SysvSemaphore|false $semId = false;
/**
* Maintain the process which is currently holding the semaphore to prevent deadlock.
*
* @var int|null
*/
private ?int $lockOwnerPid = null;
/**
* Create a SystemV shared memory based CacheItemPool.
*
* @param array<mixed> $options {
* [optional] Configuration options.
*
* @type int $variableKey The variable key for getting the data from the shared memory. **Defaults to** 1.
* @type string $proj The project identifier for ftok. This needs to be a one character string.
* **Defaults to** 'A'.
* @type string $semProj The project identifier for ftok to provide to `sem_get`. This needs to be a one
* character string.
* **Defaults to** 'B'.
* @type int $memsize The memory size in bytes for shm_attach. **Defaults to** 10000.
* @type int $perm The permission for shm_attach. **Defaults to** 0600.
* }
*/
public function __construct($options = [])
{
if (!extension_loaded('sysvshm')) {
throw new \RuntimeException(
'sysvshm extension is required to use this ItemPool'
);
}
$this->options = $options + [
'variableKey' => self::VAR_KEY,
'proj' => self::DEFAULT_PROJ,
'semProj' => self::DEFAULT_SEM_PROJ,
'memsize' => self::DEFAULT_MEMSIZE,
'perm' => self::DEFAULT_PERM
];
$this->items = [];
$this->deferredItems = [];
$this->sysvKey = ftok(__FILE__, $this->options['proj']);
// gracefully handle when `sysvsem` isn't loaded
// @TODO(v2): throw an exception when the extension isn't loaded
if (extension_loaded('sysvsem')) {
$semKey = ftok(__FILE__, $this->options['semProj']);
$this->semId = sem_get($semKey, 1, $this->options['perm'], true);
}
}
/**
* @param mixed $key
* @return CacheItemInterface
*/
public function getItem($key): CacheItemInterface
{
$this->loadItems();
return current($this->getItems([$key])); // @phpstan-ignore-line
}
/**
* @param array<mixed> $keys
* @return iterable<CacheItemInterface>
*/
public function getItems(array $keys = []): iterable
{
$this->loadItems();
$items = [];
foreach ($keys as $key) {
$items[$key] = $this->hasItem($key) ?
clone $this->items[$key] :
new TypedItem($key);
}
return $items;
}
/**
* {@inheritdoc}
*/
public function hasItem($key): bool
{
$this->loadItems();
return isset($this->items[$key]) && $this->items[$key]->isHit();
}
/**
* {@inheritdoc}
*/
public function clear(): bool
{
if (!$this->acquireLock()) {
return false;
}
$this->items = [];
$this->deferredItems = [];
$ret = $this->saveCurrentItems();
$this->resetShm();
$this->releaseLock();
return $ret;
}
/**
* {@inheritdoc}
*/
public function deleteItem($key): bool
{
return $this->deleteItems([$key]);
}
/**
* {@inheritdoc}
*/
public function deleteItems(array $keys): bool
{
if (!$this->acquireLock()) {
return false;
}
if (!$this->hasLoadedItems) {
$this->loadItems();
}
foreach ($keys as $key) {
unset($this->items[$key]);
}
$ret = $this->saveCurrentItems();
$this->resetShm();
$this->releaseLock();
return $ret;
}
/**
* {@inheritdoc}
*/
public function save(CacheItemInterface $item): bool
{
if (!$this->acquireLock()) {
return false;
}
if (!$this->hasLoadedItems) {
$this->loadItems();
}
$this->items[$item->getKey()] = $item;
$ret = $this->saveCurrentItems();
$this->releaseLock();
return $ret;
}
/**
* {@inheritdoc}
*/
public function saveDeferred(CacheItemInterface $item): bool
{
$this->deferredItems[$item->getKey()] = $item;
return true;
}
/**
* {@inheritdoc}
*/
public function commit(): bool
{
if (!$this->acquireLock()) {
return false;
}
foreach ($this->deferredItems as $item) {
if ($this->save($item) === false) {
$this->releaseLock();
return false;
}
}
$this->deferredItems = [];
$this->releaseLock();
return true;
}
/**
* Save the current items.
*
* @return bool true when success, false upon failure
*/
private function saveCurrentItems()
{
if (!$this->acquireLock()) {
return false;
}
if (false !== $shmid = $this->attachShm()) {
$success = shm_put_var(
$shmid,
$this->options['variableKey'],
$this->items
);
shm_detach($shmid);
$this->releaseLock();
return $success;
}
$this->releaseLock();
return false;
}
/**
* Load the items from the shared memory.
*
* @return bool true when success, false upon failure
*/
private function loadItems()
{
if (!$this->acquireLock()) {
return false;
}
if (false !== $shmid = $this->attachShm()) {
$data = @shm_get_var($shmid, $this->options['variableKey']);
$this->items = $data ?: [];
shm_detach($shmid);
$this->hasLoadedItems = true;
$this->releaseLock();
return true;
}
$this->releaseLock();
return false;
}
private function acquireLock(): bool
{
if ($this->semId === false) {
// if `sysvsem` isn't loaded, or if `sem_get` fails, return true
// this ensures BC with previous versions of the auth library.
// @TODO consider better handling when `sem_get` fails.
return true;
}
$currentPid = getmypid();
if ($this->lockOwnerPid === $currentPid) {
// We already have the lock
return true;
}
if (sem_acquire($this->semId)) {
$this->lockOwnerPid = (int) $currentPid;
return true;
}
return false;
}
private function releaseLock(): bool
{
if ($this->semId === false || $this->lockOwnerPid !== getmypid()) {
return true;
}
$this->lockOwnerPid = null;
return sem_release($this->semId);
}
private function resetShm(): void
{
// Remove the shared memory segment and semaphore when clearing the cache
$shmid = @shm_attach($this->sysvKey);
if ($shmid !== false) {
@shm_remove($shmid);
@shm_detach($shmid);
}
}
private function attachShm(): SysvSharedMemory|false
{
return shm_attach(
$this->sysvKey,
$this->options['memsize'],
$this->options['perm']
);
}
}