vendor/tedivm/stash/src/Stash/Driver/FileSystem.php line 171

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Stash package.
  5.  *
  6.  * (c) Robert Hafner <tedivm@tedivm.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Stash\Driver;
  14. use Stash;
  15. use Stash\Driver\FileSystem\NativeEncoder;
  16. use Stash\Driver\FileSystem\EncoderInterface;
  17. use Stash\Utilities;
  18. use Stash\Exception\LogicException;
  19. use Stash\Exception\RuntimeException;
  21. /**
  22.  * StashFileSystem stores cache objects in the filesystem as native php, making the process of retrieving stored data
  23.  * as performance intensive as including a file. Since the data is stored as php this module can see performance
  24.  * benefits from php opcode caches like APC and xcache.
  25.  *
  26.  * @package Stash
  27.  * @author  Robert Hafner <tedivm@tedivm.com>
  28.  */
  29. class FileSystem extends AbstractDriver
  30. {
  31.     /**
  32.      * This is the path to the file which will be used to store the cached item. It is based off of the key.
  33.      *
  34.      * @var string
  35.      */
  36.     protected $path;
  38.     /**
  39.      * This is the array passed from the main Cache class, which needs to be saved
  40.      *
  41.      * @var array
  42.      */
  43.     protected $data;
  45.     /**
  46.      * This function stores the path information generated by the makePath function so that it does not have to be
  47.      * calculated each time the driver is called. This only stores path information, it does not store the data to be
  48.      * cached.
  49.      *
  50.      * @var array
  51.      */
  52.     protected $memStore = array();
  54.     /**
  55.      * The limit of keys to store in memory.
  56.      *
  57.      * @var int
  58.      */
  59.     protected $memStoreLimit;
  61.     /**
  62.      * This is the base path for the cache items to be saved in. This defaults to a directory in the tmp directory (as
  63.      * defined by the configuration) called 'stash_', which it will create if needed.
  64.      *
  65.      * @var string
  66.      */
  67.     protected $cachePath;
  69.     /**
  70.      * Permissions to use for new files.
  71.      *
  72.      * @var
  73.      */
  74.     protected $filePermissions;
  76.     /**
  77.      * Permissions to use for new directories.
  78.      *
  79.      * @var
  80.      */
  81.     protected $dirPermissions;
  83.     /**
  84.      * The level of directories each key will have. This is used to reduce the number of files or directories
  85.      * in a single directory to get past various filesystem limits.
  86.      *
  87.      * @var
  88.      */
  89.     protected $directorySplit;
  91.     /**
  92.      * The hashing algorithm used to normalize keys into filesystem safe values. The only reason this gets changed is
  93.      * to lower the path length for windows systems.
  94.      *
  95.      * @var
  96.      */
  97.     protected $keyHashFunction;
  99.     /**
  100.      * Is this driver disabled.
  101.      *
  102.      * @var bool
  103.      */
  104.     protected $disabled = false;
  106.     /**
  107.      * @var \Stash\Driver\FileSystem\EncoderInterface
  108.      */
  109.     protected $encoder;
  111.     /**
  112.      * {@inheritdoc}
  113.      */
  114.     public function getDefaultOptions()
  115.     {
  116.         return array(
  117.             'filePermissions' => 0660,
  118.             'dirPermissions' => 0770,
  119.             'dirSplit' => 2,
  120.             'memKeyLimit' => 20,
  121.             'keyHashFunction' => 'md5',
  122.         );
  123.     }
  125.     /**
  126.      * Requests a list of options.
  127.      *
  128.      * @param array $options
  129.      *
  130.      * @throws \Stash\Exception\RuntimeException
  131.      */
  132.     protected function setOptions(array $options = array())
  133.     {
  134.         $options += $this->getDefaultOptions();
  135.         if (!isset($options['path'])) {
  136.             $options['path'] = Utilities::getBaseDirectory($this);
  137.         }
  139.         $this->cachePath = rtrim($options['path'], '\\/') . DIRECTORY_SEPARATOR;
  140.         $this->filePermissions = $options['filePermissions'];
  141.         $this->dirPermissions = $options['dirPermissions'];
  142.         $this->directorySplit = max((int) $options['dirSplit'], 1);
  143.         $this->memStoreLimit = max((int) $options['memKeyLimit'], 0);
  145.         if (is_callable($options['keyHashFunction'])) {
  146.             $this->keyHashFunction = $options['keyHashFunction'];
  147.         } else {
  148.             throw new RuntimeException('Key Hash Function is not callable');
  149.         }
  151.         if (isset($options['encoder'])) {
  152.             $encoder = $options['encoder'];
  153.             if (is_object($encoder)) {
  154.                 if (!($encoder instanceof EncoderInterface)) {
  155.                     throw new RuntimeException('Encoder object must implement EncoderInterface');
  156.                 }
  157.                 $this->encoder = new $encoder;
  158.             } else {
  159.                 $encoderInterface = 'Stash\Driver\FileSystem\EncoderInterface';
  160.                 $encoderClass = 'Stash\Driver\FileSystem\\' . $encoder . 'Encoder';
  161.                 if (class_exists($encoder) && in_array($encoderInterface, class_implements($encoder))) {
  162.                     $this->encoder = new $encoder();
  163.                 } elseif (class_exists($encoderClass) && in_array($encoderInterface, class_implements($encoderClass))) {
  164.                     $this->encoder = new $encoderClass();
  165.                 } else {
  166.                     throw new RuntimeException('Invalid Encoder: ' . $encoder);
  167.                 }
  168.             }
  169.         }
  171.         Utilities::checkFileSystemPermissions($this->cachePath, $this->dirPermissions);
  172.     }
  174.     /**
  175.      * Converts a key array into a key string.
  176.      *
  177.      * @param  array  $key
  178.      * @return string
  179.      */
  180.     protected function makeKeyString($key)
  181.     {
  182.         $keyString = '';
  183.         foreach ($key as $group) {
  184.             $keyString .= $group . '/';
  185.         }
  187.         return $keyString;
  188.     }
  190.     /**
  191.      * This function retrieves the data from the file. If the file does not exist, or is currently being written to, it
  192.      * will return false. If the file is already being written to, this instance of the driver gets disabled so as not
  193.      * to have a bunch of writes get queued up when a cache item fails to hit.
  194.      *
  195.      * {@inheritdoc}
  196.      *
  197.      * @return bool
  198.      */
  199.     public function getData($key)
  200.     {
  201.         return $this->getEncoder()->deserialize($this->makePath($key));
  202.     }
  204.     /**
  205.      * This function takes the data and stores it to the path specified. If the directory leading up to the path does
  206.      * not exist, it creates it.
  207.      *
  208.      * {@inheritdoc}
  209.      */
  210.     public function storeData($key, $data, $expiration)
  211.     {
  212.         $path = $this->makePath($key);
  214.         // MAX_PATH is 260 - http://msdn.microsoft.com/en-us/library/aa365247(VS.85).aspx
  215.         if (strlen($path) > 259 &&  stripos(PHP_OS, 'WIN') === 0) {
  216.             throw new Stash\Exception\WindowsPathMaxLengthException();
  217.         }
  219.         if (!file_exists($path)) {
  220.             if (!is_dir(dirname($path))) {
  221.                 if (!@mkdir(dirname($path), $this->dirPermissions, true)) {
  222.                     return false;
  223.                 }
  224.             }
  226.             if (!(touch($path) && chmod($path, $this->filePermissions))) {
  227.                 return false;
  228.             }
  229.         }
  231.         $storeString = $this->getEncoder()->serialize($this->makeKeyString($key), $data, $expiration);
  232.         $result = file_put_contents($path, $storeString, LOCK_EX);
  234.         // If opcache is switched on, it will try to cache the PHP data file
  235.         // The new php opcode caching system only revalidates against the source files once every few seconds,
  236.         // so some changes will not be caught.
  237.         // This fix immediately invalidates that opcode cache after a file is written,
  238.         // so that future includes are not using the stale opcode cached file.
  239.         if (function_exists('opcache_invalidate')) {
  240.             opcache_invalidate($path, true);
  241.         }
  243.         return false !== $result;
  244.     }
  246.     /**
  247.      * This function takes in an array of strings (the key) and uses them to create a path to save the cache item to.
  248.      * It starts with the cachePath (or a new 'cache' directory in the config temp directory) and then uses each element
  249.      * of the array as a directory (after putting the element through md5(), which was the most efficient way to make
  250.      * sure it was filesystem safe). The last element of the array gets a php extension attached to it.
  251.      *
  252.      * @param  array                           $key Null arguments return the base directory.
  253.      * @throws \Stash\Exception\LogicException
  254.      * @return string
  255.      */
  256.     protected function makePath($key = null)
  257.     {
  258.         if (!isset($this->cachePath)) {
  259.             throw new LogicException('Unable to load system without a base path.');
  260.         }
  262.         $basePath = $this->cachePath;
  264.         if (!is_array($key) || count($key) == 0) {
  265.             return $basePath;
  266.         }
  268.         // When I profiled this compared to the "implode" function, this was much faster. This is probably due to the
  269.         // small size of the arrays and the overhead from function calls. This may seem like a ridiculous
  270.         // micro-optimization, but I only did it after profiling the code with xdebug and noticing a legitimate
  271.         // difference, most likely due to the number of times this function can get called in a scripts.
  272.         // Please don't look at me like that.
  273.         $memkey = '';
  274.         foreach ($key as $group) {
  275.             $memkey .= str_replace('#', ':', $group) . '#';
  276.         }
  278.         if (isset($this->memStore['keys'][$memkey])) {
  279.             return $this->memStore['keys'][$memkey];
  280.         } else {
  281.             $path = $basePath;
  282.             $key = Utilities::normalizeKeys($key, $this->keyHashFunction);
  284.             foreach ($key as $value) {
  285.                 if (strpos($value, '@') === 0) {
  286.                     $path .= substr($value, 1) . DIRECTORY_SEPARATOR;
  287.                     continue;
  288.                 }
  290.                 $sLen = strlen($value);
  291.                 $len = floor($sLen / $this->directorySplit);
  292.                 for ($i = 0; $i < $this->directorySplit; $i++) {
  293.                     $start = $len * $i;
  294.                     if ($i == $this->directorySplit) {
  295.                         $len = $sLen - $start;
  296.                     }
  297.                     $path .= substr($value, $start, $len) . DIRECTORY_SEPARATOR;
  298.                 }
  299.             }
  301.             $path = rtrim($path, DIRECTORY_SEPARATOR) . $this->getEncoder()->getExtension();
  302.             $this->memStore['keys'][$memkey] = $path;
  304.             // in most cases the key will be used almost immediately or not at all, so it doesn't need to grow too large
  305.             if (count($this->memStore['keys']) > $this->memStoreLimit) {
  306.                 foreach (array_rand($this->memStore['keys'], ceil($this->memStoreLimit / 2) + 1) as $empty) {
  307.                     unset($this->memStore['keys'][$empty]);
  308.                 }
  309.             }
  311.             return $path;
  312.         }
  313.     }
  315.     /**
  316.      * This function clears the data from a key. If a key points to both a directory and a file, both are erased. If
  317.      * passed null, the entire cache directory is removed.
  318.      *
  319.      * {@inheritdoc}
  320.      */
  321.     public function clear($key = null)
  322.     {
  323.         $path = $this->makePath($key);
  324.         if (is_file($path)) {
  325.             $return = true;
  326.             unlink($path);
  327.         }
  329.         $extension = $this->getEncoder()->getExtension();
  330.         if (strpos($path, $extension) !== false) {
  331.             $path = substr($path, 0, -(strlen($extension)));
  332.         }
  334.         if (is_dir($path)) {
  335.             return Utilities::deleteRecursive($path, true);
  336.         }
  338.         return isset($return);
  339.     }
  341.     /**
  342.      * Cleans out the cache directory by removing all stale cache files and empty directories.
  343.      *
  344.      * {@inheritdoc}
  345.      */
  346.     public function purge()
  347.     {
  348.         $startTime = time();
  349.         $filePath = $this->makePath();
  351.         $directoryIt = new \RecursiveDirectoryIterator($filePath);
  353.         foreach (new \RecursiveIteratorIterator($directoryIt, \RecursiveIteratorIterator::CHILD_FIRST) as $file) {
  354.             $filename = $file->getPathname();
  355.             if ($file->isDir()) {
  356.                 $dirFiles = scandir($file->getPathname());
  357.                 if ($dirFiles && count($dirFiles) == 2) {
  358.                     $filename = rtrim($filename, '/.');
  360.                     if (file_exists(($filename))) {
  361.                         rmdir($filename);
  362.                     }
  363.                 }
  364.                 unset($dirFiles);
  365.                 continue;
  366.             }
  368.             if (!file_exists($filename)) {
  369.                 continue;
  370.             }
  372.             $data = $this->getEncoder()->deserialize($filename);
  374.             if (is_numeric($data['expiration']) && $data['expiration'] <= $startTime) {
  375.                 unlink($filename);
  376.             }
  377.         }
  378.         unset($directoryIt);
  380.         return true;
  381.     }
  383.     protected function getEncoder()
  384.     {
  385.         if (!isset($this->encoder)) {
  386.             $this->encoder = new \Stash\Driver\FileSystem\NativeEncoder();
  387.         }
  389.         return $this->encoder;
  390.     }
  392.     /**
  393.      * {@inheritdoc}
  394.      */
  395.     public function isPersistent()
  396.     {
  397.         return true;
  398.     }
  399. }