vendor/zendframework/zend-cache/src/Storage/Adapter/FilesystemOptions.php

   1 <?php
   2 /**
   3  * @see       https://github.com/zendframework/zend-cache for the canonical source repository
   4  * @copyright Copyright (c) 2005-2018 Zend Technologies USA Inc. (https://www.zend.com)
   5  * @license   https://github.com/zendframework/zend-cache/blob/master/LICENSE.md New BSD License
   6  */
   7
   8 namespace Zend\Cache\Storage\Adapter;
   9
  10 use Traversable;
  11 use Zend\Cache\Exception;
  12
  13 /**
  14  * These are options specific to the Filesystem adapter
  15  */
  16 class FilesystemOptions extends AdapterOptions
  17 {
  18     /**
  19      * Directory to store cache files
  20      *
  21      * @var null|string The cache directory
  22      *                  or NULL for the systems temporary directory
  23      */
  24     protected $cacheDir = null;
  25
  26     /**
  27      * Call clearstatcache enabled?
  28      *
  29      * @var bool
  30      */
  31     protected $clearStatCache = true;
  32
  33     /**
  34      * How much sub-directaries should be created?
  35      *
  36      * @var int
  37      */
  38     protected $dirLevel = 1;
  39
  40     /**
  41      * Permission creating new directories
  42      *
  43      * @var false|int
  44      */
  45     protected $dirPermission = 0700;
  46
  47     /**
  48      * Lock files on writing
  49      *
  50      * @var bool
  51      */
  52     protected $fileLocking = true;
  53
  54     /**
  55      * Permission creating new files
  56      *
  57      * @var false|int
  58      */
  59     protected $filePermission = 0600;
  60
  61     /**
  62      * Overwrite default key pattern
  63      *
  64      * Defined in AdapterOptions
  65      *
  66      * @var string
  67      */
  68     protected $keyPattern = '/^[a-z0-9_\+\-]*$/Di';
  69
  70     /**
  71      * Namespace separator
  72      *
  73      * @var string
  74      */
  75     protected $namespaceSeparator = '-';
  76
  77     /**
  78      * Don't get 'fileatime' as 'atime' on metadata
  79      *
  80      * @var bool
  81      */
  82     protected $noAtime = true;
  83
  84     /**
  85      * Don't get 'filectime' as 'ctime' on metadata
  86      *
  87      * @var bool
  88      */
  89     protected $noCtime = true;
  90
  91     /**
  92      * Umask to create files and directories
  93      *
  94      * @var false|int
  95      */
  96     protected $umask = false;
  97
  98     /**
  99      * Suffix for cache files
 100      *
 101      * @var string
 102      */
 103     protected $suffix = 'dat';
 104
 105     /**
 106      * Suffix for tag files
 107      *
 108      * @var string
 109      */
 110     protected $tagSuffix = 'tag';
 111
 112     /**
 113      * Constructor
 114      *
 115      * @param  array|Traversable|null $options
 116      * @return FilesystemOptions
 117      * @throws Exception\InvalidArgumentException
 118      */
 119     public function __construct($options = null)
 120     {
 121         // disable file/directory permissions by default on windows systems
 122         if (strtoupper(substr(PHP_OS, 0, 3)) == 'WIN') {
 123             $this->filePermission = false;
 124             $this->dirPermission = false;
 125         }
 126
 127         parent::__construct($options);
 128     }
 129
 130     /**
 131      * Set cache dir
 132      *
 133      * @param  string $cacheDir
 134      * @return FilesystemOptions Provides a fluent interface
 135      * @throws Exception\InvalidArgumentException
 136      */
 137     public function setCacheDir($cacheDir)
 138     {
 139         if ($cacheDir !== null) {
 140             if (! is_dir($cacheDir)) {
 141                 throw new Exception\InvalidArgumentException(
 142                     "Cache directory '{$cacheDir}' not found or not a directory"
 143                 );
 144             } elseif (! is_writable($cacheDir)) {
 145                 throw new Exception\InvalidArgumentException(
 146                     "Cache directory '{$cacheDir}' not writable"
 147                 );
 148             } elseif (! is_readable($cacheDir)) {
 149                 throw new Exception\InvalidArgumentException(
 150                     "Cache directory '{$cacheDir}' not readable"
 151                 );
 152             }
 153
 154             $cacheDir = rtrim(realpath($cacheDir), DIRECTORY_SEPARATOR);
 155         } else {
 156             $cacheDir = sys_get_temp_dir();
 157         }
 158
 159         $this->triggerOptionEvent('cache_dir', $cacheDir);
 160         $this->cacheDir = $cacheDir;
 161         return $this;
 162     }
 163
 164     /**
 165      * Get cache dir
 166      *
 167      * @return null|string
 168      */
 169     public function getCacheDir()
 170     {
 171         if ($this->cacheDir === null) {
 172             $this->setCacheDir(null);
 173         }
 174
 175         return $this->cacheDir;
 176     }
 177
 178     /**
 179      * Set clear stat cache
 180      *
 181      * @param  bool $clearStatCache
 182      * @return FilesystemOptions Provides a fluent interface
 183      */
 184     public function setClearStatCache($clearStatCache)
 185     {
 186         $clearStatCache = (bool) $clearStatCache;
 187         $this->triggerOptionEvent('clear_stat_cache', $clearStatCache);
 188         $this->clearStatCache = $clearStatCache;
 189         return $this;
 190     }
 191
 192     /**
 193      * Get clear stat cache
 194      *
 195      * @return bool
 196      */
 197     public function getClearStatCache()
 198     {
 199         return $this->clearStatCache;
 200     }
 201
 202     /**
 203      * Set dir level
 204      *
 205      * @param  int $dirLevel
 206      * @return FilesystemOptions Provides a fluent interface
 207      * @throws Exception\InvalidArgumentException
 208      */
 209     public function setDirLevel($dirLevel)
 210     {
 211         $dirLevel = (int) $dirLevel;
 212         if ($dirLevel < 0 || $dirLevel > 16) {
 213             throw new Exception\InvalidArgumentException(
 214                 "Directory level '{$dirLevel}' must be between 0 and 16"
 215             );
 216         }
 217         $this->triggerOptionEvent('dir_level', $dirLevel);
 218         $this->dirLevel = $dirLevel;
 219         return $this;
 220     }
 221
 222     /**
 223      * Get dir level
 224      *
 225      * @return int
 226      */
 227     public function getDirLevel()
 228     {
 229         return $this->dirLevel;
 230     }
 231
 232     /**
 233      * Set permission to create directories on unix systems
 234      *
 235      * @param false|string|int $dirPermission FALSE to disable explicit permission or an octal number
 236      * @return FilesystemOptions Provides a fluent interface
 237      * @see setUmask
 238      * @see setFilePermission
 239      * @link http://php.net/manual/function.chmod.php
 240      */
 241     public function setDirPermission($dirPermission)
 242     {
 243         if ($dirPermission !== false) {
 244             if (is_string($dirPermission)) {
 245                 $dirPermission = octdec($dirPermission);
 246             } else {
 247                 $dirPermission = (int) $dirPermission;
 248             }
 249
 250             // validate
 251             if (($dirPermission & 0700) != 0700) {
 252                 throw new Exception\InvalidArgumentException(
 253                     'Invalid directory permission: need permission to execute, read and write by owner'
 254                 );
 255             }
 256         }
 257
 258         if ($this->dirPermission !== $dirPermission) {
 259             $this->triggerOptionEvent('dir_permission', $dirPermission);
 260             $this->dirPermission = $dirPermission;
 261         }
 262
 263         return $this;
 264     }
 265
 266     /**
 267      * Get permission to create directories on unix systems
 268      *
 269      * @return false|int
 270      */
 271     public function getDirPermission()
 272     {
 273         return $this->dirPermission;
 274     }
 275
 276     /**
 277      * Set file locking
 278      *
 279      * @param  bool $fileLocking
 280      * @return FilesystemOptions Provides a fluent interface
 281      */
 282     public function setFileLocking($fileLocking)
 283     {
 284         $fileLocking = (bool) $fileLocking;
 285         $this->triggerOptionEvent('file_locking', $fileLocking);
 286         $this->fileLocking = $fileLocking;
 287         return $this;
 288     }
 289
 290     /**
 291      * Get file locking
 292      *
 293      * @return bool
 294      */
 295     public function getFileLocking()
 296     {
 297         return $this->fileLocking;
 298     }
 299
 300     /**
 301      * Set permission to create files on unix systems
 302      *
 303      * @param false|string|int $filePermission FALSE to disable explicit permission or an octal number
 304      * @return FilesystemOptions Provides a fluent interface
 305      * @see setUmask
 306      * @see setDirPermission
 307      * @link http://php.net/manual/function.chmod.php
 308      */
 309     public function setFilePermission($filePermission)
 310     {
 311         if ($filePermission !== false) {
 312             if (is_string($filePermission)) {
 313                 $filePermission = octdec($filePermission);
 314             } else {
 315                 $filePermission = (int) $filePermission;
 316             }
 317
 318             // validate
 319             if (($filePermission & 0600) != 0600) {
 320                 throw new Exception\InvalidArgumentException(
 321                     'Invalid file permission: need permission to read and write by owner'
 322                 );
 323             } elseif ($filePermission & 0111) {
 324                 throw new Exception\InvalidArgumentException(
 325                     "Invalid file permission: Cache files shoudn't be executable"
 326                 );
 327             }
 328         }
 329
 330         if ($this->filePermission !== $filePermission) {
 331             $this->triggerOptionEvent('file_permission', $filePermission);
 332             $this->filePermission = $filePermission;
 333         }
 334
 335         return $this;
 336     }
 337
 338     /**
 339      * Get permission to create files on unix systems
 340      *
 341      * @return false|int
 342      */
 343     public function getFilePermission()
 344     {
 345         return $this->filePermission;
 346     }
 347
 348     /**
 349      * Set namespace separator
 350      *
 351      * @param  string $namespaceSeparator
 352      * @return FilesystemOptions Provides a fluent interface
 353      */
 354     public function setNamespaceSeparator($namespaceSeparator)
 355     {
 356         $namespaceSeparator = (string) $namespaceSeparator;
 357         $this->triggerOptionEvent('namespace_separator', $namespaceSeparator);
 358         $this->namespaceSeparator = $namespaceSeparator;
 359         return $this;
 360     }
 361
 362     /**
 363      * Get namespace separator
 364      *
 365      * @return string
 366      */
 367     public function getNamespaceSeparator()
 368     {
 369         return $this->namespaceSeparator;
 370     }
 371
 372     /**
 373      * Set no atime
 374      *
 375      * @param  bool $noAtime
 376      * @return FilesystemOptions Provides a fluent interface
 377      */
 378     public function setNoAtime($noAtime)
 379     {
 380         $noAtime = (bool) $noAtime;
 381         $this->triggerOptionEvent('no_atime', $noAtime);
 382         $this->noAtime = $noAtime;
 383         return $this;
 384     }
 385
 386     /**
 387      * Get no atime
 388      *
 389      * @return bool
 390      */
 391     public function getNoAtime()
 392     {
 393         return $this->noAtime;
 394     }
 395
 396     /**
 397      * Set no ctime
 398      *
 399      * @param  bool $noCtime
 400      * @return FilesystemOptions
 401      */
 402     public function setNoCtime($noCtime)
 403     {
 404         $noCtime = (bool) $noCtime;
 405         $this->triggerOptionEvent('no_ctime', $noCtime);
 406         $this->noCtime = $noCtime;
 407         return $this;
 408     }
 409
 410     /**
 411      * Get no ctime
 412      *
 413      * @return bool
 414      */
 415     public function getNoCtime()
 416     {
 417         return $this->noCtime;
 418     }
 419
 420     /**
 421      * Set the umask to create files and directories on unix systems
 422      *
 423      * Note: On multithreaded webservers it's better to explicit set file and dir permission.
 424      *
 425      * @param false|string|int $umask FALSE to disable umask or an octal number
 426      * @return FilesystemOptions
 427      * @see setFilePermission
 428      * @see setDirPermission
 429      * @link http://php.net/manual/function.umask.php
 430      * @link http://en.wikipedia.org/wiki/Umask
 431      */
 432     public function setUmask($umask)
 433     {
 434         if ($umask !== false) {
 435             if (is_string($umask)) {
 436                 $umask = octdec($umask);
 437             } else {
 438                 $umask = (int) $umask;
 439             }
 440
 441             // validate
 442             if ($umask & 0700) {
 443                 throw new Exception\InvalidArgumentException(
 444                     'Invalid umask: need permission to execute, read and write by owner'
 445                 );
 446             }
 447
 448             // normalize
 449             $umask = $umask & ~0002;
 450         }
 451
 452         if ($this->umask !== $umask) {
 453             $this->triggerOptionEvent('umask', $umask);
 454             $this->umask = $umask;
 455         }
 456
 457         return $this;
 458     }
 459
 460     /**
 461      * Get the umask to create files and directories on unix systems
 462      *
 463      * @return false|int
 464      */
 465     public function getUmask()
 466     {
 467         return $this->umask;
 468     }
 469
 470     /**
 471      * Get the suffix for cache files
 472      *
 473      * @return string
 474      */
 475     public function getSuffix()
 476     {
 477         return $this->suffix;
 478     }
 479
 480     /**
 481      * Set the suffix for cache files
 482      *
 483      * @param string $suffix
 484      */
 485     public function setSuffix($suffix)
 486     {
 487         $this->suffix = $suffix;
 488         return $this;
 489     }
 490
 491     /**
 492      * Get the suffix for tag files
 493      *
 494      * @return the $tagSuffix
 495      */
 496     public function getTagSuffix()
 497     {
 498         return $this->tagSuffix;
 499     }
 500
 501     /**
 502      * Set the suffix for cache files
 503      *
 504      * @param string $tagSuffix
 505      */
 506     public function setTagSuffix($tagSuffix)
 507     {
 508         $this->tagSuffix = $tagSuffix;
 509         return $this;
 510     }
 511 }