File Manager

Editing: SysVCacheItemPool.php

<?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']
        );
    }
}

⬅ Back