eZ\Publish\Core\MVC\Symfony\Cache\Http\LocationAwareStore

Complexity

Total Complexity

30

Size/Duplication

Total Lines	236
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	setFilesystem()	0	4	1
A	getFilesystem()	0	8	2
A	generateContentDigest()	0	9	2
B	getPath()	0	38	7
B	purgeByRequest()	0	33	10
A	purgeAllContent()	0	4	1
A	purgeLocation()	0	32	3
A	getLocationCacheLockName()	0	6	2
A	getLocationCacheDir()	0	9	2

<?php

/**
 * File containing the LocationAwareStore class.
 *
 * @copyright Copyright (C) eZ Systems AS. All rights reserved.
 * @license For full copyright and license information view LICENSE file distributed with this source code.
 */
namespace eZ\Publish\Core\MVC\Symfony\Cache\Http;

use Symfony\Component\HttpKernel\HttpCache\Store;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\Filesystem\Exception\IOException;

/**
 * LocationAwareStore implements all the logic for storing cache metadata regarding locations.
 */
class LocationAwareStore extends Store implements ContentPurger
{
    const LOCATION_CACHE_DIR = 'ezlocation';
    const LOCATION_STALE_CACHE_DIR = 'ezlocation_stale';

    /**
     * @var \Symfony\Component\Filesystem\Filesystem
     */
    private $fs;

    /**
     * Injects a Filesystem instance
     * For unit tests only.
     *
     * @internal
     *
     * @param \Symfony\Component\Filesystem\Filesystem $fs
     */
    public function setFilesystem(Filesystem $fs)
    {
        $this->fs = $fs;
    }

    /**
     * @return \Symfony\Component\Filesystem\Filesystem
     */
    public function getFilesystem()
    {
        if (!isset($this->fs)) {
            $this->fs = new Filesystem();
        }

        return $this->fs;
    }

    /**
     * Injects eZ Publish specific information in the content digest if needed.
     * X-Location-Id response header is set in the ViewController.
     *
     * @see \eZ\Publish\Core\MVC\Symfony\Controller\Content\ViewController::viewLocation()
     *
     * @param \Symfony\Component\HttpFoundation\Response $response
     *
     * @return string
     */
    protected function generateContentDigest(Response $response)
    {
        $digest = parent::generateContentDigest($response);
        if (!$response->headers->has('X-Location-Id')) {
            return $digest;
        }

        return static::LOCATION_CACHE_DIR . "/{$response->headers->get('X-Location-Id')}/$digest";
    }

    /**
     * Returns the right path where cache is being stored.
     * Will detect if $key is eZ Publish specific.
     *
     * @param string $key
     *
     * @return string
     */
    public function getPath($key)
    {
        if (strpos($key, static::LOCATION_CACHE_DIR) === false) {
            return parent::getPath($key);
        }

        $prefix = '';
        if (($pos = strrpos($key, DIRECTORY_SEPARATOR)) !== false) {
            $prefix = substr($key, 0, $pos) . DIRECTORY_SEPARATOR;
            $key = substr($key, $pos + 1);

            list($locationCacheDir, $locationId) = explode(DIRECTORY_SEPARATOR, $prefix);
            unset($locationCacheDir);
            // If cache purge is in progress, serve stale cache instead of regular cache.
            // We first check for a global cache purge, then for the current location.
            foreach ([$this->getLocationCacheLockName(), $this->getLocationCacheLockName($locationId)] as $cacheLockFile) {
                if (is_file($cacheLockFile)) {
                    if (function_exists('posix_kill')) {
                        // Check if purge process is still running. If not, remove the lock file to unblock future cache purge
                        if (!posix_kill(file_get_contents($cacheLockFile), 0)) {
                            $fs = $this->getFilesystem();
                            $fs->remove([$cacheLockFile, $this->getLocationCacheDir($locationId)]);
                            goto returnCachePath;
                        }
                    }

                    $prefix = str_replace(static::LOCATION_CACHE_DIR, static::LOCATION_STALE_CACHE_DIR, $prefix);
                }
            }
        }

        returnCachePath:
        return $this->root . DIRECTORY_SEPARATOR . $prefix .
           substr($key, 0, 2) . DIRECTORY_SEPARATOR .
           substr($key, 2, 2) . DIRECTORY_SEPARATOR .
           substr($key, 4, 2) . DIRECTORY_SEPARATOR .
           substr($key, 6);
    }

    /**
     * Purges data from $request.
     * If X-Location-Id or X-Group-Location-Id header is present, the store will purge cache for given locationId or group of locationIds.
     * If not, regular purge by URI will occur.
     *
     * @param \Symfony\Component\HttpFoundation\Request $request
     *
     * @return bool True if purge was successful. False otherwise
     */
    public function purgeByRequest(Request $request)
    {
        if (!$request->headers->has('X-Location-Id') && !$request->headers->has('X-Group-Location-Id')) {
            return $this->purge($request->getUri());
        }

        // Purge everything
        $locationId = $request->headers->get('X-Location-Id');
        if ($locationId === '*' || $locationId === '.*') {
            return $this->purgeAllContent();
        }

        // Usage of X-Group-Location-Id is deprecated.
        if ($request->headers->has('X-Group-Location-Id')) {
            $aLocationId = explode('; ', $request->headers->get('X-Group-Location-Id'));
        } elseif ($locationId[0] === '(' && substr($locationId, -1) === ')') {
            // Equivalent to X-Group-Location-Id, using a simple Regexp:
            // (123|456|789) => Purge for #123, #456 and #789 location IDs.
            $aLocationId = explode('|', substr($locationId, 1, -1));
        } else {
            $aLocationId = [$locationId];
        }

        if (empty($aLocationId)) {
            return false;
        }

        foreach ($aLocationId as $locationId) {
            $this->purgeLocation($locationId);
        }

        return true;
    }

    /**
     * Purges all cached content.
     *
     * @return bool
     */
    public function purgeAllContent()
    {
        return $this->purgeLocation(null);
    }

    /**
     * Purges cache for $locationId.
     *
     * @param int|null $locationId. If null, all locations will be purged.

There is no parameter named $locationId.. Did you maybe mean $locationId?

     *
     * @return bool
     */
    private function purgeLocation($locationId)
    {
        $fs = $this->getFilesystem();
        $locationCacheDir = $this->getLocationCacheDir($locationId);
        if ($fs->exists($locationCacheDir)) {
            // 1. Copy cache files to stale cache dir
            // 2. Place a lock file indicating to use the stale cache
            // 3. Remove real cache dir
            // 4. Remove lock file
            // 5. Remove stale cache dir
            // Note that there is no need to remove the meta-file
            $staleCacheDir = str_replace(static::LOCATION_CACHE_DIR, static::LOCATION_STALE_CACHE_DIR, $locationCacheDir);
            $fs->mkdir($staleCacheDir);
            $fs->mirror($locationCacheDir, $staleCacheDir);
            $lockFile = $this->getLocationCacheLockName($locationId);
            file_put_contents($lockFile, getmypid());
            try {
                // array of removal is in reverse order on purpose since remove() starts from the end.
                $fs->remove([$staleCacheDir, $lockFile, $locationCacheDir]);

                return true;
            } catch (IOException $e) {
                // Log the error in the standard error log and at least try to remove the lock file
                error_log($e->getMessage());
                @unlink($lockFile);

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

                return false;
            }
        }

        return false;
    }

    /**
     * Returns cache lock name for $locationId.
     *
     * This method is public only for unit tests.
     * Use it only if you know what you are doing.
     *
     * @internal
     *
     * @param int $locationId. If null, will return a global cache lock name (purging all content)

There is no parameter named $locationId.. Did you maybe mean $locationId?

     *
     * @return string
     */
    public function getLocationCacheLockName($locationId = null)
    {
        $locationId = $locationId ?: 'all';

        return "$this->root/_ezloc_$locationId.purging";
    }

    /**
     * Returns cache dir for $locationId.
     *
     * This method is public only for unit tests.
     * Use it only if you know what you are doing.
     *
     * @internal
     *
     * @param int $locationId
     *
     * @return string
     */
    public function getLocationCacheDir($locationId = null)
    {
        $cacheDir = "$this->root/" . static::LOCATION_CACHE_DIR;
        if ($locationId) {

The expression $locationId of type integer|null is loosely compared to true; this is ambiguous if the integer can be zero. You might want to explicitly use !== null instead.

            $cacheDir .= "/$locationId";
        }

        return $cacheDir;
    }
}