alazhar/joomla_test
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
alazhar
2020-01-02 22:20:31 +07:00
commit 10eb3340ad
5753 changed files with 631345 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

248
libraries/joomla/cache/storage/apc.php vendored Normal file
View File

@ -0,0 +1,248 @@
<?php
/**
* @package Joomla.Platform
* @subpackage Cache
*
* @copyright Copyright (C) 2005 - 2013 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
defined('JPATH_PLATFORM') or die;
/**
* APC cache storage handler
*
* @package Joomla.Platform
* @subpackage Cache
* @see http://php.net/manual/en/book.apc.php
* @since 11.1
*/
class JCacheStorageApc extends JCacheStorage
{
/**
* Get cached data from APC by id and group
*
* @param string $id The cache data id
* @param string $group The cache data group
* @param boolean $checkTime True to verify cache time expiration threshold
*
* @return mixed Boolean False on failure or a cached data string
*
* @since 11.1
*/
public function get($id, $group, $checkTime = true)
{
$cache_id = $this->_getCacheId($id, $group);
return apc_fetch($cache_id);
}
/**
* Get all cached data
*
* @return array data
*
* @since 11.1
*/
public function getAll()
{
parent::getAll();
$allinfo = apc_cache_info('user');
$keys = $allinfo['cache_list'];
$secret = $this->_hash;
$data = array();
foreach ($keys as $key)
{
$name = $key['info'];
$namearr = explode('-', $name);
if ($namearr !== false && $namearr[0] == $secret && $namearr[1] == 'cache')
{
$group = $namearr[2];
if (!isset($data[$group]))
{
$item = new JCacheStorageHelper($group);
}
else
{
$item = $data[$group];
}
$item->updateSize($key['mem_size'] / 1024);
$data[$group] = $item;
}
}
return $data;
}
/**
* Store the data to APC by id and group
*
* @param string $id The cache data id
* @param string $group The cache data group
* @param string $data The data to store in cache
*
* @return boolean True on success, false otherwise
*
* @since 11.1
*/
public function store($id, $group, $data)
{
$cache_id = $this->_getCacheId($id, $group);
return apc_store($cache_id, $data, $this->_lifetime);
}
/**
* Remove a cached data entry by id and group
*
* @param string $id The cache data id
* @param string $group The cache data group
*
* @return boolean True on success, false otherwise
*
* @since 11.1
*/
public function remove($id, $group)
{
$cache_id = $this->_getCacheId($id, $group);
return apc_delete($cache_id);
}
/**
* Clean cache for a group given a mode.
*
* group mode : cleans all cache in the group
* notgroup mode : cleans all cache not in the group
*
* @param string $group The cache data group
* @param string $mode The mode for cleaning cache [group|notgroup]
*
* @return boolean True on success, false otherwise
*
* @since 11.1
*/
public function clean($group, $mode = null)
{
$allinfo = apc_cache_info('user');
$keys = $allinfo['cache_list'];
$secret = $this->_hash;
foreach ($keys as $key)
{
if (strpos($key['info'], $secret . '-cache-' . $group . '-') === 0 xor $mode != 'group')
{
apc_delete($key['info']);
}
}
return true;
}
/**
* Force garbage collect expired cache data as items are removed only on fetch!
*
* @return boolean True on success, false otherwise.
*
* @since 11.1
*/
public function gc()
{
$allinfo = apc_cache_info('user');
$keys = $allinfo['cache_list'];
$secret = $this->_hash;
foreach ($keys as $key)
{
if (strpos($key['info'], $secret . '-cache-'))
{
apc_fetch($key['info']);
}
}
}
/**
* Test to see if the cache storage is available.
*
* @return boolean True on success, false otherwise.
*
* @since 12.1
*/
public static function isSupported()
{
return extension_loaded('apc');
}
/**
* Lock cached item - override parent as this is more efficient
*
* @param string $id The cache data id
* @param string $group The cache data group
* @param integer $locktime Cached item max lock time
*
* @return object Properties are lock and locklooped
*
* @since 11.1
*/
public function lock($id, $group, $locktime)
{
$returning = new stdClass;
$returning->locklooped = false;
$looptime = $locktime * 10;
$cache_id = $this->_getCacheId($id, $group) . '_lock';
$data_lock = apc_add($cache_id, 1, $locktime);
if ($data_lock === false)
{
$lock_counter = 0;
// Loop until you find that the lock has been released.
// That implies that data get from other thread has finished
while ($data_lock === false)
{
if ($lock_counter > $looptime)
{
$returning->locked = false;
$returning->locklooped = true;
break;
}
usleep(100);
$data_lock = apc_add($cache_id, 1, $locktime);
$lock_counter++;
}
}
$returning->locked = $data_lock;
return $returning;
}
/**
* Unlock cached item - override parent for cacheid compatibility with lock
*
* @param string $id The cache data id
* @param string $group The cache data group
*
* @return boolean True on success, false otherwise.
*
* @since 11.1
*/
public function unlock($id, $group = null)
{
$cache_id = $this->_getCacheId($id, $group) . '_lock';
$unlock = apc_delete($cache_id);
return $unlock;
}
}

336
libraries/joomla/cache/storage/cachelite.php vendored Normal file
View File

@ -0,0 +1,336 @@
<?php
/**
* @package Joomla.Platform
* @subpackage Cache
*
* @copyright Copyright (C) 2005 - 2013 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
defined('JPATH_PLATFORM') or die;
/**
* Cache lite storage handler
*
* @package Joomla.Platform
* @subpackage Cache
* @see http://pear.php.net/package/Cache_Lite/
* @since 11.1
*/
class JCacheStorageCachelite extends JCacheStorage
{
/**
* @var object
* @since 11.1
*/
protected static $CacheLiteInstance = null;
/**
* @var
* @since 11.1
*/
protected $_root;
/**
* Constructor
*
* @param array $options Optional parameters.
*
* @since 11.1
*/
public function __construct($options = array())
{
parent::__construct($options);
$this->_root = $options['cachebase'];
$cloptions = array(
'cacheDir' => $this->_root . '/',
'lifeTime' => $this->_lifetime,
'fileLocking' => $this->_locking,
'automaticCleaningFactor' => isset($options['autoclean']) ? $options['autoclean'] : 200,
'fileNameProtection' => false,
'hashedDirectoryLevel' => 0,
'caching' => $options['caching']);
if (self::$CacheLiteInstance === null)
{
$this->initCache($cloptions);
}
}
/**
* Instantiates the appropriate CacheLite object.
* Only initializes the engine if it does not already exist.
* Note this is a protected method
*
* @param array $cloptions optional parameters
*
* @return object
*
* @since 11.1
*/
protected function initCache($cloptions)
{
require_once 'Cache/Lite.php';
self::$CacheLiteInstance = new Cache_Lite($cloptions);
return self::$CacheLiteInstance;
}
/**
* Get cached data from a file by id and group
*
* @param string $id The cache data id.
* @param string $group The cache data group.
* @param boolean $checkTime True to verify cache time expiration threshold.
*
* @return mixed Boolean false on failure or a cached data string.
*
* @since 11.1
*/
public function get($id, $group, $checkTime = true)
{
self::$CacheLiteInstance->setOption('cacheDir', $this->_root . '/' . $group . '/');
$this->_getCacheId($id, $group);
$data = self::$CacheLiteInstance->get($this->rawname, $group);
return $data;
}
/**
* Get all cached data
*
* @return array
*
* @since 11.1
*/
public function getAll()
{
parent::getAll();
$path = $this->_root;
$folders = new DirectoryIterator($path);
$data = array();
foreach ($folders as $folder)
{
if (!$folder->isDir() || $folder->isDot())
{
continue;
}
$foldername = $folder->getFilename();
$files = new DirectoryIterator($path . '/' . $foldername);
$item = new JCacheStorageHelper($foldername);
foreach ($files as $file)
{
if (!$file->isFile())
{
continue;
}
$filename = $file->getFilename();
$item->updateSize(filesize($path . '/' . $foldername . '/' . $filename) / 1024);
}
$data[$foldername] = $item;
}
return $data;
}
/**
* Store the data to a file by id and group
*
* @param string $id The cache data id.
* @param string $group The cache data group.
* @param string $data The data to store in cache.
*
* @return boolean True on success, false otherwise
*
* @since 11.1
*/
public function store($id, $group, $data)
{
$dir = $this->_root . '/' . $group;
// If the folder doesn't exist try to create it
if (!is_dir($dir))
{
// Make sure the index file is there
$indexFile = $dir . '/index.html';
@mkdir($dir) && file_put_contents($indexFile, '<!DOCTYPE html><title></title>');
}
// Make sure the folder exists
if (!is_dir($dir))
{
return false;
}
self::$CacheLiteInstance->setOption('cacheDir', $this->_root . '/' . $group . '/');
$this->_getCacheId($id, $group);
$success = self::$CacheLiteInstance->save($data, $this->rawname, $group);
if ($success == true)
{
return $success;
}
else
{
return false;
}
}
/**
* Remove a cached data file by id and group
*
* @param string $id The cache data id
* @param string $group The cache data group
*
* @return boolean True on success, false otherwise
*
* @since 11.1
*/
public function remove($id, $group)
{
self::$CacheLiteInstance->setOption('cacheDir', $this->_root . '/' . $group . '/');
$this->_getCacheId($id, $group);
$success = self::$CacheLiteInstance->remove($this->rawname, $group);
if ($success == true)
{
return $success;
}
else
{
return false;
}
}
/**
* Clean cache for a group given a mode.
*
* @param string $group The cache data group.
* @param string $mode The mode for cleaning cache [group|notgroup].
* group mode : cleans all cache in the group
* notgroup mode : cleans all cache not in the group
*
* @return boolean True on success, false otherwise.
*
* @since 11.1
*/
public function clean($group, $mode = null)
{
jimport('joomla.filesystem.folder');
switch ($mode)
{
case 'notgroup':
$clmode = 'notingroup';
$success = self::$CacheLiteInstance->clean($group, $clmode);
break;
case 'group':
if (is_dir($this->_root . '/' . $group))
{
$clmode = $group;
self::$CacheLiteInstance->setOption('cacheDir', $this->_root . '/' . $group . '/');
$success = self::$CacheLiteInstance->clean($group, $clmode);
JFolder::delete($this->_root . '/' . $group);
}
else
{
$success = true;
}
break;
default:
if (is_dir($this->_root . '/' . $group))
{
$clmode = $group;
self::$CacheLiteInstance->setOption('cacheDir', $this->_root . '/' . $group . '/');
$success = self::$CacheLiteInstance->clean($group, $clmode);
}
else
{
$success = true;
}
break;
}
if ($success == true)
{
return $success;
}
else
{
return false;
}
}
/**
* Garbage collect expired cache data
*
* @return boolean True on success, false otherwise.
*
* @since 11.1
*/
public function gc()
{
$result = true;
self::$CacheLiteInstance->setOption('automaticCleaningFactor', 1);
self::$CacheLiteInstance->setOption('hashedDirectoryLevel', 1);
$success1 = self::$CacheLiteInstance->_cleanDir($this->_root . '/', false, 'old');
if (!($dh = opendir($this->_root . '/')))
{
return false;
}
while ($file = readdir($dh))
{
if (($file != '.') && ($file != '..') && ($file != '.svn'))
{
$file2 = $this->_root . '/' . $file;
if (is_dir($file2))
{
$result = ($result && (self::$CacheLiteInstance->_cleanDir($file2 . '/', false, 'old')));
}
}
}
$success = ($success1 && $result);
return $success;
}
/**
* Test to see if the cache storage is available.
*
* @return boolean True on success, false otherwise.
*
* @since 12.1
*/
public static function isSupported()
{
@include_once 'Cache/Lite.php';
if (class_exists('Cache_Lite'))
{
return true;
}
else
{
return false;
}
}
}

689
libraries/joomla/cache/storage/file.php vendored Normal file
View File

@ -0,0 +1,689 @@
<?php
/**
* @package Joomla.Platform
* @subpackage Cache
*
* @copyright Copyright (C) 2005 - 2013 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
defined('JPATH_PLATFORM') or die;
/**
* File cache storage handler
*
* @package Joomla.Platform
* @subpackage Cache
* @since 11.1
*/
class JCacheStorageFile extends JCacheStorage
{
/**
* @var string
* @since 11.1
*/
protected $_root;
/**
* Constructor
*
* @param array $options Optional parameters
*
* @since 11.1
*/
public function __construct($options = array())
{
parent::__construct($options);
$this->_root = $options['cachebase'];
}
// NOTE: raw php calls are up to 100 times faster than JFile or JFolder
/**
* Get cached data from a file by id and group
*
* @param string $id The cache data id
* @param string $group The cache data group
* @param boolean $checkTime True to verify cache time expiration threshold
*
* @return mixed Boolean false on failure or a cached data string
*
* @since 11.1
*/
public function get($id, $group, $checkTime = true)
{
$data = false;
$path = $this->_getFilePath($id, $group);
if ($checkTime == false || ($checkTime == true && $this->_checkExpire($id, $group) === true))
{
if (file_exists($path))
{
$data = file_get_contents($path);
if ($data)
{
// Remove the initial die() statement
$data = str_replace('<?php die("Access Denied"); ?>#x#', '', $data);
}
}
return $data;
}
else
{
return false;
}
}
/**
* Get all cached data
*
* @return array The cached data
*
* @since 11.1
*/
public function getAll()
{
parent::getAll();
$path = $this->_root;
$folders = $this->_folders($path);
$data = array();
foreach ($folders as $folder)
{
$files = $this->_filesInFolder($path . '/' . $folder);
$item = new JCacheStorageHelper($folder);
foreach ($files as $file)
{
$item->updateSize(filesize($path . '/' . $folder . '/' . $file) / 1024);
}
$data[$folder] = $item;
}
return $data;
}
/**
* Store the data to a file by id and group
*
* @param string $id The cache data id
* @param string $group The cache data group
* @param string $data The data to store in cache
*
* @return boolean True on success, false otherwise
*
* @since 11.1
*/
public function store($id, $group, $data)
{
$written = false;
$path = $this->_getFilePath($id, $group);
$die = '<?php die("Access Denied"); ?>#x#';
// Prepend a die string
$data = $die . $data;
$_fileopen = @fopen($path, "wb");
if ($_fileopen)
{
$len = strlen($data);
@fwrite($_fileopen, $data, $len);
$written = true;
}
// Data integrity check
if ($written && ($data == file_get_contents($path)))
{
return true;
}
else
{
return false;
}
}
/**
* Remove a cached data file by id and group
*
* @param string $id The cache data id
* @param string $group The cache data group
*
* @return boolean True on success, false otherwise
*
* @since 11.1
*/
public function remove($id, $group)
{
$path = $this->_getFilePath($id, $group);
if (!@unlink($path))
{
return false;
}
return true;
}
/**
* Clean cache for a group given a mode.
*
* @param string $group The cache data group
* @param string $mode The mode for cleaning cache [group|notgroup]
* group mode : cleans all cache in the group
* notgroup mode : cleans all cache not in the group
*
* @return boolean True on success, false otherwise
*
* @since 11.1
*/
public function clean($group, $mode = null)
{
$return = true;
$folder = $group;
if (trim($folder) == '')
{
$mode = 'notgroup';
}
switch ($mode)
{
case 'notgroup':
$folders = $this->_folders($this->_root);
for ($i = 0, $n = count($folders); $i < $n; $i++)
{
if ($folders[$i] != $folder)
{
$return |= $this->_deleteFolder($this->_root . '/' . $folders[$i]);
}
}
break;
case 'group':
default:
if (is_dir($this->_root . '/' . $folder))
{
$return = $this->_deleteFolder($this->_root . '/' . $folder);
}
break;
}
return $return;
}
/**
* Garbage collect expired cache data
*
* @return boolean True on success, false otherwise.
*
* @since 11.1
*/
public function gc()
{
$result = true;
// Files older than lifeTime get deleted from cache
$files = $this->_filesInFolder($this->_root, '', true, true, array('.svn', 'CVS', '.DS_Store', '__MACOSX', 'index.html'));
foreach ($files as $file)
{
$time = @filemtime($file);
if (($time + $this->_lifetime) < $this->_now || empty($time))
{
$result |= @unlink($file);
}
}
return $result;
}
/**
* Test to see if the cache storage is available.
*
* @return boolean True on success, false otherwise.
*
* @since 12.1
*/
public static function isSupported()
{
$conf = JFactory::getConfig();
return is_writable($conf->get('cache_path', JPATH_CACHE));
}
/**
* Lock cached item
*
* @param string $id The cache data id
* @param string $group The cache data group
* @param integer $locktime Cached item max lock time
*
* @return boolean True on success, false otherwise.
*
* @since 11.1
*/
public function lock($id, $group, $locktime)
{
$returning = new stdClass;
$returning->locklooped = false;
$looptime = $locktime * 10;
$path = $this->_getFilePath($id, $group);
$_fileopen = @fopen($path, "r+b");
if ($_fileopen)
{
$data_lock = @flock($_fileopen, LOCK_EX);
}
else
{
$data_lock = false;
}
if ($data_lock === false)
{
$lock_counter = 0;
// Loop until you find that the lock has been released.
// That implies that data get from other thread has finished
while ($data_lock === false)
{
if ($lock_counter > $looptime)
{
$returning->locked = false;
$returning->locklooped = true;
break;
}
usleep(100);
$data_lock = @flock($_fileopen, LOCK_EX);
$lock_counter++;
}
}
$returning->locked = $data_lock;
return $returning;
}
/**
* Unlock cached item
*
* @param string $id The cache data id
* @param string $group The cache data group
*
* @return boolean True on success, false otherwise.
*
* @since 11.1
*/
public function unlock($id, $group = null)
{
$path = $this->_getFilePath($id, $group);
$_fileopen = @fopen($path, "r+b");
if ($_fileopen)
{
$ret = @flock($_fileopen, LOCK_UN);
@fclose($_fileopen);
}
return $ret;
}
/**
* Check to make sure cache is still valid, if not, delete it.
*
* @param string $id Cache key to expire.
* @param string $group The cache data group.
*
* @return boolean False if not valid
*
* @since 11.1
*/
protected function _checkExpire($id, $group)
{
$path = $this->_getFilePath($id, $group);
// Check prune period
if (file_exists($path))
{
$time = @filemtime($path);
if (($time + $this->_lifetime) < $this->_now || empty($time))
{
@unlink($path);
return false;
}
return true;
}
return false;
}
/**
* Get a cache file path from an id/group pair
*
* @param string $id The cache data id
* @param string $group The cache data group
*
* @return string The cache file path
*
* @since 11.1
*/
protected function _getFilePath($id, $group)
{
$name = $this->_getCacheId($id, $group);
$dir = $this->_root . '/' . $group;
// If the folder doesn't exist try to create it
if (!is_dir($dir))
{
// Make sure the index file is there
$indexFile = $dir . '/index.html';
@ mkdir($dir) && file_put_contents($indexFile, '<!DOCTYPE html><title></title>');
}
// Make sure the folder exists
if (!is_dir($dir))
{
return false;
}
return $dir . '/' . $name . '.php';
}
/**
* Quickly delete a folder of files
*
* @param string $path The path to the folder to delete.
*
* @return boolean True on success.
*
* @since 11.1
*/
protected function _deleteFolder($path)
{
// Sanity check
if (!$path || !is_dir($path) || empty($this->_root))
{
// Bad programmer! Bad Bad programmer!
JLog::add('JCacheStorageFile::_deleteFolder ' . JText::_('JLIB_FILESYSTEM_ERROR_DELETE_BASE_DIRECTORY'), JLog::WARNING, 'jerror');
return false;
}
$path = $this->_cleanPath($path);
// Check to make sure path is inside cache folder, we do not want to delete Joomla root!
$pos = strpos($path, $this->_cleanPath($this->_root));
if ($pos === false || $pos > 0)
{
JLog::add('JCacheStorageFile::_deleteFolder' . JText::sprintf('JLIB_FILESYSTEM_ERROR_PATH_IS_NOT_A_FOLDER', $path), JLog::WARNING, 'jerror');
return false;
}
// Remove all the files in folder if they exist; disable all filtering
$files = $this->_filesInFolder($path, '.', false, true, array(), array());
if (!empty($files) && !is_array($files))
{
if (@unlink($files) !== true)
{
return false;
}
}
elseif (!empty($files) && is_array($files))
{
foreach ($files as $file)
{
$file = $this->_cleanPath($file);
// In case of restricted permissions we zap it one way or the other
// as long as the owner is either the webserver or the ftp
if (@unlink($file))
{
// Do nothing
}
else
{
$filename = basename($file);
JLog::add('JCacheStorageFile::_deleteFolder' . JText::sprintf('JLIB_FILESYSTEM_DELETE_FAILED', $filename), JLog::WARNING, 'jerror');
return false;
}
}
}
// Remove sub-folders of folder; disable all filtering
$folders = $this->_folders($path, '.', false, true, array(), array());
foreach ($folders as $folder)
{
if (is_link($folder))
{
// Don't descend into linked directories, just delete the link.
if (@unlink($folder) !== true)
{
return false;
}
}
elseif ($this->_deleteFolder($folder) !== true)
{
return false;
}
}
// In case of restricted permissions we zap it one way or the other
// as long as the owner is either the webserver or the ftp
if (@rmdir($path))
{
$ret = true;
}
else
{
JLog::add('JCacheStorageFile::_deleteFolder' . JText::sprintf('JLIB_FILESYSTEM_ERROR_FOLDER_DELETE', $path), JLog::WARNING, 'jerror');
$ret = false;
}
return $ret;
}
/**
* Function to strip additional / or \ in a path name
*
* @param string $path The path to clean
* @param string $ds Directory separator (optional)
*
* @return string The cleaned path
*
* @since 11.1
*/
protected function _cleanPath($path, $ds = DIRECTORY_SEPARATOR)
{
$path = trim($path);
if (empty($path))
{
$path = $this->_root;
}
else
{
// Remove double slashes and backslahses and convert all slashes and backslashes to DIRECTORY_SEPARATOR
$path = preg_replace('#[/\\\\]+#', $ds, $path);
}
return $path;
}
/**
* Utility function to quickly read the files in a folder.
*
* @param string $path The path of the folder to read.
* @param string $filter A filter for file names.
* @param mixed $recurse True to recursively search into sub-folders, or an
* integer to specify the maximum depth.
* @param boolean $fullpath True to return the full path to the file.
* @param array $exclude Array with names of files which should not be shown in
* the result.
* @param array $excludefilter Array of folder names to exclude
*
* @return array Files in the given folder.
*
* @since 11.1
*/
protected function _filesInFolder($path, $filter = '.', $recurse = false, $fullpath = false
, $exclude = array('.svn', 'CVS', '.DS_Store', '__MACOSX'), $excludefilter = array('^\..*', '.*~'))
{
$arr = array();
// Check to make sure the path valid and clean
$path = $this->_cleanPath($path);
// Is the path a folder?
if (!is_dir($path))
{
JLog::add('JCacheStorageFile::_filesInFolder' . JText::sprintf('JLIB_FILESYSTEM_ERROR_PATH_IS_NOT_A_FOLDER', $path), JLog::WARNING, 'jerror');
return false;
}
// Read the source directory.
if (!($handle = @opendir($path)))
{
return $arr;
}
if (count($excludefilter))
{
$excludefilter = '/(' . implode('|', $excludefilter) . ')/';
}
else
{
$excludefilter = '';
}
while (($file = readdir($handle)) !== false)
{
if (($file != '.') && ($file != '..') && (!in_array($file, $exclude)) && (!$excludefilter || !preg_match($excludefilter, $file)))
{
$dir = $path . '/' . $file;
$isDir = is_dir($dir);
if ($isDir)
{
if ($recurse)
{
if (is_int($recurse))
{
$arr2 = $this->_filesInFolder($dir, $filter, $recurse - 1, $fullpath);
}
else
{
$arr2 = $this->_filesInFolder($dir, $filter, $recurse, $fullpath);
}
$arr = array_merge($arr, $arr2);
}
}
else
{
if (preg_match("/$filter/", $file))
{
if ($fullpath)
{
$arr[] = $path . '/' . $file;
}
else
{
$arr[] = $file;
}
}
}
}
}
closedir($handle);
return $arr;
}
/**
* Utility function to read the folders in a folder.
*
* @param string $path The path of the folder to read.
* @param string $filter A filter for folder names.
* @param mixed $recurse True to recursively search into sub-folders, or an integer to specify the maximum depth.
* @param boolean $fullpath True to return the full path to the folders.
* @param array $exclude Array with names of folders which should not be shown in the result.
* @param array $excludefilter Array with regular expressions matching folders which should not be shown in the result.
*
* @return array Folders in the given folder.
*
* @since 11.1
*/
protected function _folders($path, $filter = '.', $recurse = false, $fullpath = false
, $exclude = array('.svn', 'CVS', '.DS_Store', '__MACOSX'), $excludefilter = array('^\..*'))
{
$arr = array();
// Check to make sure the path valid and clean
$path = $this->_cleanPath($path);
// Is the path a folder?
if (!is_dir($path))
{
JLog::add('JCacheStorageFile::_folders' . JText::sprintf('JLIB_FILESYSTEM_ERROR_PATH_IS_NOT_A_FOLDER', $path), JLog::WARNING, 'jerror');
return false;
}
// Read the source directory
if (!($handle = @opendir($path)))
{
return $arr;
}
if (count($excludefilter))
{
$excludefilter_string = '/(' . implode('|', $excludefilter) . ')/';
}
else
{
$excludefilter_string = '';
}
while (($file = readdir($handle)) !== false)
{
if (($file != '.') && ($file != '..')
&& (!in_array($file, $exclude))
&& (empty($excludefilter_string) || !preg_match($excludefilter_string, $file)))
{
$dir = $path . '/' . $file;
$isDir = is_dir($dir);
if ($isDir)
{
// Removes filtered directories
if (preg_match("/$filter/", $file))
{
if ($fullpath)
{
$arr[] = $dir;
}
else
{
$arr[] = $file;
}
}
if ($recurse)
{
if (is_int($recurse))
{
$arr2 = $this->_folders($dir, $filter, $recurse - 1, $fullpath, $exclude, $excludefilter);
}
else
{
$arr2 = $this->_folders($dir, $filter, $recurse, $fullpath, $exclude, $excludefilter);
}
$arr = array_merge($arr, $arr2);
}
}
}
}
closedir($handle);
return $arr;
}
}

71
libraries/joomla/cache/storage/helper.php vendored Normal file
View File

@ -0,0 +1,71 @@
<?php
/**
* @package Joomla.Platform
* @subpackage Cache
*
* @copyright Copyright (C) 2005 - 2013 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
defined('JPATH_PLATFORM') or die;
/**
* Cache storage helper functions.
*
* @package Joomla.Platform
* @subpackage Cache
* @since 11.1
*/
class JCacheStorageHelper
{
/**
* Cache data group
*
* @var string
* @since 11.1
*/
public $group = '';
/**
* Cached item size
*
* @var string
* @since 11.1
*/
public $size = 0;
/**
* Counter
*
* @var integer
* @since 11.1
*/
public $count = 0;
/**
* Constructor
*
* @param string $group The cache data group
*
* @since 11.1
*/
public function __construct($group)
{
$this->group = $group;
}
/**
* Increase cache items count.
*
* @param string $size Cached item size
*
* @return void
*
* @since 11.1
*/
public function updateSize($size)
{
$this->size = number_format($this->size + $size, 2);
$this->count++;
}
}

1
libraries/joomla/cache/storage/index.html vendored Normal file
View File

@ -0,0 +1 @@
<!DOCTYPE html><title></title>

485
libraries/joomla/cache/storage/memcache.php vendored Normal file
View File

@ -0,0 +1,485 @@
<?php
/**
* @package Joomla.Platform
* @subpackage Cache
*
* @copyright Copyright (C) 2005 - 2013 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
defined('JPATH_PLATFORM') or die;
/**
* Memcache cache storage handler
*
* @package Joomla.Platform
* @subpackage Cache
* @see http://php.net/manual/en/book.memcache.php
* @since 11.1
*/
class JCacheStorageMemcache extends JCacheStorage
{
/**
* @var Memcache
* @since 11.1
*/
protected static $_db = null;
/**
* @var boolean
* @since 11.1
*/
protected $_persistent = false;
/**
* @var
* @since 11.1
*/
protected $_compress = 0;
/**
* Constructor
*
* @param array $options Optional parameters.
*
* @since 11.1
*/
public function __construct($options = array())
{
parent::__construct($options);
if (self::$_db === null)
{
$this->getConnection();
}
}
/**
* Return memcache connection object
*
* @return object memcache connection object
*
* @since 11.1
* @throws RuntimeException
*/
protected function getConnection()
{
if ((extension_loaded('memcache') && class_exists('Memcache')) != true)
{
return false;
}
$config = JFactory::getConfig();
$this->_persistent = $config->get('memcache_persist', true);
$this->_compress = $config->get('memcache_compress', false) == false ? 0 : MEMCACHE_COMPRESSED;
/*
* This will be an array of loveliness
* @todo: multiple servers
* $servers = (isset($params['servers'])) ? $params['servers'] : array();
*/
$server = array();
$server['host'] = $config->get('memcache_server_host', 'localhost');
$server['port'] = $config->get('memcache_server_port', 11211);
// Create the memcache connection
self::$_db = new Memcache;
self::$_db->addServer($server['host'], $server['port'], $this->_persistent);
$memcachetest = @self::$_db->connect($server['host'], $server['port']);
if ($memcachetest == false)
{
throw new RuntimeException('Could not connect to memcache server', 404);
}
// Memcahed has no list keys, we do our own accounting, initialise key index
if (self::$_db->get($this->_hash . '-index') === false)
{
$empty = array();
self::$_db->set($this->_hash . '-index', $empty, $this->_compress, 0);
}
return;
}
/**
* Get cached data from memcache by id and group
*
* @param string $id The cache data id
* @param string $group The cache data group
* @param boolean $checkTime True to verify cache time expiration threshold
*
* @return mixed Boolean false on failure or a cached data string
*
* @since 11.1
*/
public function get($id, $group, $checkTime = true)
{
$cache_id = $this->_getCacheId($id, $group);
$back = self::$_db->get($cache_id);
return $back;
}
/**
* Get all cached data
*
* @return array data
*
* @since 11.1
*/
public function getAll()
{
parent::getAll();
$keys = self::$_db->get($this->_hash . '-index');
$secret = $this->_hash;
$data = array();
if (!empty($keys))
{
foreach ($keys as $key)
{
if (empty($key))
{
continue;
}
$namearr = explode('-', $key->name);
if ($namearr !== false && $namearr[0] == $secret && $namearr[1] == 'cache')
{
$group = $namearr[2];
if (!isset($data[$group]))
{
$item = new JCacheStorageHelper($group);
}
else
{
$item = $data[$group];
}
$item->updateSize($key->size / 1024);
$data[$group] = $item;
}
}
}
return $data;
}
/**
* Store the data to memcache by id and group
*
* @param string $id The cache data id
* @param string $group The cache data group
* @param string $data The data to store in cache
*
* @return boolean True on success, false otherwise
*
* @since 11.1
*/
public function store($id, $group, $data)
{
$cache_id = $this->_getCacheId($id, $group);
if (!$this->lockindex())
{
return false;
}
$index = self::$_db->get($this->_hash . '-index');
if ($index === false)
{
$index = array();
}
$tmparr = new stdClass;
$tmparr->name = $cache_id;
$tmparr->size = strlen($data);
$config = JFactory::getConfig();
$lifetime = (int) $config->get('cachetime', 15);
if ($this->_lifetime == $lifetime)
{
$this->_lifetime = $lifetime * 60;
}
$index[] = $tmparr;
self::$_db->replace($this->_hash . '-index', $index, 0, 0);
$this->unlockindex();
// Prevent double writes, write only if it doesn't exist else replace
if (!self::$_db->replace($cache_id, $data, $this->_compress, $this->_lifetime))
{
self::$_db->set($cache_id, $data, $this->_compress, $this->_lifetime);
}
return true;
}
/**
* Remove a cached data entry by id and group
*
* @param string $id The cache data id
* @param string $group The cache data group
*
* @return boolean True on success, false otherwise
*
* @since 11.1
*/
public function remove($id, $group)
{
$cache_id = $this->_getCacheId($id, $group);
if (!$this->lockindex())
{
return false;
}
$index = self::$_db->get($this->_hash . '-index');
if ($index === false)
{
$index = array();
}
foreach ($index as $key => $value)
{
if ($value->name == $cache_id)
{
unset($index[$key]);
}
break;
}
self::$_db->replace($this->_hash . '-index', $index, 0, 0);
$this->unlockindex();
return self::$_db->delete($cache_id);
}
/**
* Clean cache for a group given a mode.
*
* @param string $group The cache data group
* @param string $mode The mode for cleaning cache [group|notgroup]
* group mode : cleans all cache in the group
* notgroup mode : cleans all cache not in the group
*
* @return boolean True on success, false otherwise
*
* @since 11.1
*/
public function clean($group, $mode = null)
{
if (!$this->lockindex())
{
return false;
}
$index = self::$_db->get($this->_hash . '-index');
if ($index === false)
{
$index = array();
}
$secret = $this->_hash;
foreach ($index as $key => $value)
{
if (strpos($value->name, $secret . '-cache-' . $group . '-') === 0 xor $mode != 'group')
{
self::$_db->delete($value->name, 0);
unset($index[$key]);
}
}
self::$_db->replace($this->_hash . '-index', $index, 0, 0);
$this->unlockindex();
return true;
}
/**
* Test to see if the cache storage is available.
*
* @return boolean True on success, false otherwise.
*
* @since 12.1
*/
public static function isSupported()
{
if ((extension_loaded('memcache') && class_exists('Memcache')) != true)
{
return false;
}
$config = JFactory::getConfig();
$host = $config->get('memcache_server_host', 'localhost');
$port = $config->get('memcache_server_port', 11211);
$memcache = new Memcache;
$memcachetest = @$memcache->connect($host, $port);
if (!$memcachetest)
{
return false;
}
else
{
return true;
}
}
/**
* Lock cached item - override parent as this is more efficient
*
* @param string $id The cache data id
* @param string $group The cache data group
* @param integer $locktime Cached item max lock time
*
* @return boolean True on success, false otherwise.
*
* @since 11.1
*/
public function lock($id, $group, $locktime)
{
$returning = new stdClass;
$returning->locklooped = false;
$looptime = $locktime * 10;
$cache_id = $this->_getCacheId($id, $group);
if (!$this->lockindex())
{
return false;
}
$index = self::$_db->get($this->_hash . '-index');
if ($index === false)
{
$index = array();
}
$tmparr = new stdClass;
$tmparr->name = $cache_id;
$tmparr->size = 1;
$index[] = $tmparr;
self::$_db->replace($this->_hash . '-index', $index, 0, 0);
$this->unlockindex();
$data_lock = self::$_db->add($cache_id . '_lock', 1, false, $locktime);
if ($data_lock === false)
{
$lock_counter = 0;
// Loop until you find that the lock has been released.
// That implies that data get from other thread has finished
while ($data_lock === false)
{
if ($lock_counter > $looptime)
{
$returning->locked = false;
$returning->locklooped = true;
break;
}
usleep(100);
$data_lock = self::$_db->add($cache_id . '_lock', 1, false, $locktime);
$lock_counter++;
}
}
$returning->locked = $data_lock;
return $returning;
}
/**
* Unlock cached item - override parent for cacheid compatibility with lock
*
* @param string $id The cache data id
* @param string $group The cache data group
*
* @return boolean True on success, false otherwise.
*
* @since 11.1
*/
public function unlock($id, $group = null)
{
$cache_id = $this->_getCacheId($id, $group) . '_lock';
if (!$this->lockindex())
{
return false;
}
$index = self::$_db->get($this->_hash . '-index');
if ($index === false)
{
$index = array();
}
foreach ($index as $key => $value)
{
if ($value->name == $cache_id)
{
unset($index[$key]);
}
break;
}
self::$_db->replace($this->_hash . '-index', $index, 0, 0);
$this->unlockindex();
return self::$_db->delete($cache_id);
}
/**
* Lock cache index
*
* @return boolean True on success, false otherwise.
*
* @since 11.1
*/
protected function lockindex()
{
$looptime = 300;
$data_lock = self::$_db->add($this->_hash . '-index_lock', 1, false, 30);
if ($data_lock === false)
{
$lock_counter = 0;
// Loop until you find that the lock has been released. that implies that data get from other thread has finished
while ($data_lock === false)
{
if ($lock_counter > $looptime)
{
return false;
break;
}
usleep(100);
$data_lock = self::$_db->add($this->_hash . '-index_lock', 1, false, 30);
$lock_counter++;
}
}
return true;
}
/**
* Unlock cache index
*
* @return boolean True on success, false otherwise.
*
* @since 11.1
*/
protected function unlockindex()
{
return self::$_db->delete($this->_hash . '-index_lock');
}
}

489
libraries/joomla/cache/storage/memcached.php vendored Normal file
View File

@ -0,0 +1,489 @@
<?php
/**
* @package Joomla.Platform
* @subpackage Cache
*
* @copyright Copyright (C) 2005 - 2013 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
defined('JPATH_PLATFORM') or die;
/**
* Memcached cache storage handler
*
* @package Joomla.Platform
* @subpackage Cache
* @see http://php.net/manual/en/book.memcached.php
* @since 12.1
*/
class JCacheStorageMemcached extends JCacheStorage
{
/**
* @var Memcached
* @since 12.1
*/
protected static $_db = null;
/**
* @var boolean
* @since 12.1
*/
protected $_persistent = false;
/**
* @var
* @since 12.1
*/
protected $_compress = 0;
/**
* Constructor
*
* @param array $options Optional parameters.
*
* @since 12.1
*/
public function __construct($options = array())
{
parent::__construct($options);
if (self::$_db === null)
{
$this->getConnection();
}
}
/**
* Return memcached connection object
*
* @return object memcached connection object
*
* @since 12.1
* @throws RuntimeException
*/
protected function getConnection()
{
if ((extension_loaded('memcached') && class_exists('Memcached')) != true)
{
return false;
}
$config = JFactory::getConfig();
$this->_persistent = $config->get('memcache_persist', true);
$this->_compress = $config->get('memcache_compress', false) == false ? 0 : Memcached::OPT_COMPRESSION;
/*
* This will be an array of loveliness
* @todo: multiple servers
* $servers = (isset($params['servers'])) ? $params['servers'] : array();
*/
$server = array();
$server['host'] = $config->get('memcache_server_host', 'localhost');
$server['port'] = $config->get('memcache_server_port', 11211);
// Create the memcache connection
if ($this->_persistent)
{
$session = JFactory::getSession();
self::$_db = new Memcached($session->getId());
}
else
{
self::$_db = new Memcached;
}
$memcachedtest = self::$_db->addServer($server['host'], $server['port']);
if ($memcachedtest == false)
{
throw new RuntimeException('Could not connect to memcached server', 404);
}
self::$_db->setOption(Memcached::OPT_COMPRESSION, $this->_compress);
// Memcached has no list keys, we do our own accounting, initialise key index
if (self::$_db->get($this->_hash . '-index') === false)
{
$empty = array();
self::$_db->set($this->_hash . '-index', $empty, 0);
}
return;
}
/**
* Get cached data from memcached by id and group
*
* @param string $id The cache data id
* @param string $group The cache data group
* @param boolean $checkTime True to verify cache time expiration threshold
*
* @return mixed Boolean false on failure or a cached data string
*
* @since 12.1
*/
public function get($id, $group, $checkTime = true)
{
$cache_id = $this->_getCacheId($id, $group);
$back = self::$_db->get($cache_id);
return $back;
}
/**
* Get all cached data
*
* @return array data
*
* @since 12.1
*/
public function getAll()
{
parent::getAll();
$keys = self::$_db->get($this->_hash . '-index');
$secret = $this->_hash;
$data = array();
if (!empty($keys) && is_array($keys))
{
foreach ($keys as $key)
{
if (empty($key))
{
continue;
}
$namearr = explode('-', $key->name);
if ($namearr !== false && $namearr[0] == $secret && $namearr[1] == 'cache')
{
$group = $namearr[2];
if (!isset($data[$group]))
{
$item = new JCacheStorageHelper($group);
}
else
{
$item = $data[$group];
}
$item->updateSize($key->size / 1024);
$data[$group] = $item;
}
}
}
return $data;
}
/**
* Store the data to memcached by id and group
*
* @param string $id The cache data id
* @param string $group The cache data group
* @param string $data The data to store in cache
*
* @return boolean True on success, false otherwise
*
* @since 12.1
*/
public function store($id, $group, $data)
{
$cache_id = $this->_getCacheId($id, $group);
if (!$this->lockindex())
{
return false;
}
$index = self::$_db->get($this->_hash . '-index');
if ($index === false)
{
$index = array();
}
$tmparr = new stdClass;
$tmparr->name = $cache_id;
$tmparr->size = strlen($data);
$index[] = $tmparr;
self::$_db->replace($this->_hash . '-index', $index, 0);
$this->unlockindex();
// Prevent double writes, write only if it doesn't exist else replace
if (!self::$_db->replace($cache_id, $data, $this->_lifetime))
{
self::$_db->set($cache_id, $data, $this->_lifetime);
}
return true;
}
/**
* Remove a cached data entry by id and group
*
* @param string $id The cache data id
* @param string $group The cache data group
*
* @return boolean True on success, false otherwise
*
* @since 12.1
*/
public function remove($id, $group)
{
$cache_id = $this->_getCacheId($id, $group);
if (!$this->lockindex())
{
return false;
}
$index = self::$_db->get($this->_hash . '-index');
if ($index === false)
{
$index = array();
}
foreach ($index as $key => $value)
{
if ($value->name == $cache_id)
{
unset($index[$key]);
}
break;
}
self::$_db->replace($this->_hash . '-index', $index, 0);
$this->unlockindex();
return self::$_db->delete($cache_id);
}
/**
* Clean cache for a group given a mode.
*
* @param string $group The cache data group
* @param string $mode The mode for cleaning cache [group|notgroup]
* group mode : cleans all cache in the group
* notgroup mode : cleans all cache not in the group
*
* @return boolean True on success, false otherwise
*
* @since 12.1
*/
public function clean($group, $mode = null)
{
if (!$this->lockindex())
{
return false;
}
$index = self::$_db->get($this->_hash . '-index');
if ($index === false)
{
$index = array();
}
$secret = $this->_hash;
foreach ($index as $key => $value)
{
if (strpos($value->name, $secret . '-cache-' . $group . '-') === 0 xor $mode != 'group')
{
self::$_db->delete($value->name, 0);
unset($index[$key]);
}
}
self::$_db->replace($this->_hash . '-index', $index, 0);
$this->unlockindex();
return true;
}
/**
* Test to see if the cache storage is available.
*
* @return boolean True on success, false otherwise.
*
* @since 12.1
*/
public static function isSupported()
{
if ((extension_loaded('memcached') && class_exists('Memcached')) != true)
{
return false;
}
$config = JFactory::getConfig();
$host = $config->get('memcache_server_host', 'localhost');
$port = $config->get('memcache_server_port', 11211);
$memcached = new Memcached;
$memcachedtest = @$memcached->addServer($host, $port);
if (!$memcachedtest)
{
return false;
}
else
{
return true;
}
}
/**
* Lock cached item - override parent as this is more efficient
*
* @param string $id The cache data id
* @param string $group The cache data group
* @param integer $locktime Cached item max lock time
*
* @return boolean True on success, false otherwise.
*
* @since 12.1
*/
public function lock($id, $group, $locktime)
{
$returning = new stdClass;
$returning->locklooped = false;
$looptime = $locktime * 10;
$cache_id = $this->_getCacheId($id, $group);
if (!$this->lockindex())
{
return false;
}
$index = self::$_db->get($this->_hash . '-index');
if ($index === false)
{
$index = array();
}
$tmparr = new stdClass;
$tmparr->name = $cache_id;
$tmparr->size = 1;
$index[] = $tmparr;
self::$_db->replace($this->_hash . '-index', $index, 0);
$this->unlockindex();
$data_lock = self::$_db->add($cache_id . '_lock', 1, $locktime);
if ($data_lock === false)
{
$lock_counter = 0;
// Loop until you find that the lock has been released.
// That implies that data get from other thread has finished
while ($data_lock === false)
{
if ($lock_counter > $looptime)
{
$returning->locked = false;
$returning->locklooped = true;
break;
}
usleep(100);
$data_lock = self::$_db->add($cache_id . '_lock', 1, $locktime);
$lock_counter++;
}
}
$returning->locked = $data_lock;
return $returning;
}
/**
* Unlock cached item - override parent for cacheid compatibility with lock
*
* @param string $id The cache data id
* @param string $group The cache data group
*
* @return boolean True on success, false otherwise.
*
* @since 12.1
*/
public function unlock($id, $group = null)
{
$cache_id = $this->_getCacheId($id, $group) . '_lock';
if (!$this->lockindex())
{
return false;
}
$index = self::$_db->get($this->_hash . '-index');
if ($index === false)
{
$index = array();
}
foreach ($index as $key => $value)
{
if ($value->name == $cache_id)
{
unset($index[$key]);
}
break;
}
self::$_db->replace($this->_hash . '-index', $index, 0);
$this->unlockindex();
return self::$_db->delete($cache_id);
}
/**
* Lock cache index
*
* @return boolean True on success, false otherwise.
*
* @since 12.1
*/
protected function lockindex()
{
$looptime = 300;
$data_lock = self::$_db->add($this->_hash . '-index_lock', 1, 30);
if ($data_lock === false)
{
$lock_counter = 0;
// Loop until you find that the lock has been released. that implies that data get from other thread has finished
while ($data_lock === false)
{
if ($lock_counter > $looptime)
{
return false;
break;
}
usleep(100);
$data_lock = self::$_db->add($this->_hash . '-index_lock', 1, 30);
$lock_counter++;
}
}
return true;
}
/**
* Unlock cache index
*
* @return boolean True on success, false otherwise.
*
* @since 12.1
*/
protected function unlockindex()
{
return self::$_db->delete($this->_hash . '-index_lock');
}
}

194
libraries/joomla/cache/storage/wincache.php vendored Normal file
View File

@ -0,0 +1,194 @@
<?php
/**
* @package Joomla.Platform
* @subpackage Cache
*
* @copyright Copyright (C) 2005 - 2013 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
defined('JPATH_PLATFORM') or die;
/**
* WINCACHE cache storage handler
*
* @package Joomla.Platform
* @subpackage Cache
* @see http://php.net/manual/en/book.wincache.php
* @since 11.1
*/
class JCacheStorageWincache extends JCacheStorage
{
/**
* Constructor
*
* @param array $options Optional parameters.
*
* @since 11.1
*/
public function __construct($options = array())
{
parent::__construct($options);
}
/**
* Get cached data from WINCACHE by id and group
*
* @param string $id The cache data id
* @param string $group The cache data group
* @param boolean $checkTime True to verify cache time expiration threshold
*
* @return mixed Boolean false on failure or a cached data string
*
* @since 11.1
*/
public function get($id, $group, $checkTime = true)
{
$cache_id = $this->_getCacheId($id, $group);
$cache_content = wincache_ucache_get($cache_id);
return $cache_content;
}
/**
* Get all cached data
*
* @return array data
*
* @since 11.1
*/
public function getAll()
{
parent::getAll();
$allinfo = wincache_ucache_info();
$keys = $allinfo['cache_entries'];
$secret = $this->_hash;
$data = array();
foreach ($keys as $key)
{
$name = $key['key_name'];
$namearr = explode('-', $name);
if ($namearr !== false && $namearr[0] == $secret && $namearr[1] == 'cache')
{
$group = $namearr[2];
if (!isset($data[$group]))
{
$item = new JCacheStorageHelper($group);
}
else
{
$item = $data[$group];
}
if (isset($key['value_size']))
{
$item->updateSize($key['value_size'] / 1024);
}
else
{
// Dummy, WINCACHE version is too low.
$item->updateSize(1);
}
$data[$group] = $item;
}
}
return $data;
}
/**
* Store the data to WINCACHE by id and group
*
* @param string $id The cache data id
* @param string $group The cache data group
* @param string $data The data to store in cache
*
* @return boolean True on success, false otherwise
*
* @since 11.1
*/
public function store($id, $group, $data)
{
$cache_id = $this->_getCacheId($id, $group);
return wincache_ucache_set($cache_id, $data, $this->_lifetime);
}
/**
* Remove a cached data entry by id and group
*
* @param string $id The cache data id
* @param string $group The cache data group
*
* @return boolean True on success, false otherwise
*
* @since 11.1
*/
public function remove($id, $group)
{
$cache_id = $this->_getCacheId($id, $group);
return wincache_ucache_delete($cache_id);
}
/**
* Clean cache for a group given a mode.
*
* @param string $group The cache data group
* @param string $mode The mode for cleaning cache [group|notgroup]
* group mode : cleans all cache in the group
* notgroup mode : cleans all cache not in the group
*
* @return boolean True on success, false otherwise
*
* @since 11.1
*/
public function clean($group, $mode = null)
{
$allinfo = wincache_ucache_info();
$keys = $allinfo['cache_entries'];
$secret = $this->_hash;
foreach ($keys as $key)
{
if (strpos($key['key_name'], $secret . '-cache-' . $group . '-') === 0 xor $mode != 'group')
{
wincache_ucache_delete($key['key_name']);
}
}
return true;
}
/**
* Force garbage collect expired cache data as items are removed only on get/add/delete/info etc
*
* @return boolean True on success, false otherwise.
*
* @since 11.1
*/
public function gc()
{
$allinfo = wincache_ucache_info();
$keys = $allinfo['cache_entries'];
$secret = $this->_hash;
foreach ($keys as $key)
{
if (strpos($key['key_name'], $secret . '-cache-'))
{
wincache_ucache_get($key['key_name']);
}
}
}
/**
* Test to see if the cache storage is available.
*
* @return boolean True on success, false otherwise.
*
* @since 12.1
*/
public static function isSupported()
{
$test = extension_loaded('wincache') && function_exists('wincache_ucache_get') && !strcmp(ini_get('wincache.ucenabled'), '1');
return $test;
}
}

209
libraries/joomla/cache/storage/xcache.php vendored Normal file
View File

@ -0,0 +1,209 @@
<?php
/**
* @package Joomla.Platform
* @subpackage Cache
*
* @copyright Copyright (C) 2005 - 2013 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
defined('JPATH_PLATFORM') or die;
/**
* XCache cache storage handler
*
* @package Joomla.Platform
* @subpackage Cache
* @link http://xcache.lighttpd.net/
* @since 11.1
*/
class JCacheStorageXcache extends JCacheStorage
{
/**
* Get cached data by id and group
*
* @param string $id The cache data id
* @param string $group The cache data group
* @param boolean $checkTime True to verify cache time expiration threshold
*
* @return mixed Boolean false on failure or a cached data string
*
* @since 11.1
*/
public function get($id, $group, $checkTime = true)
{
$cache_id = $this->_getCacheId($id, $group);
$cache_content = xcache_get($cache_id);
if ($cache_content === null)
{
return false;
}
return $cache_content;
}
/**
* Get all cached data
*
* This requires the php.ini setting xcache.admin.enable_auth = Off.
*
* @return array data
*
* @since 11.1
*/
public function getAll()
{
parent::getAll();
$allinfo = xcache_list(XC_TYPE_VAR, 0);
$keys = $allinfo['cache_list'];
$secret = $this->_hash;
$data = array();
foreach ($keys as $key)
{
$namearr = explode('-', $key['name']);
if ($namearr !== false && $namearr[0] == $secret && $namearr[1] == 'cache')
{
$group = $namearr[2];
if (!isset($data[$group]))
{
$item = new JCacheStorageHelper($group);
}
else
{
$item = $data[$group];
}
$item->updateSize($key['size'] / 1024);
$data[$group] = $item;
}
}
return $data;
}
/**
* Store the data by id and group
*
* @param string $id The cache data id
* @param string $group The cache data group
* @param string $data The data to store in cache
*
* @return boolean True on success, false otherwise
*
* @since 11.1
*/
public function store($id, $group, $data)
{
$cache_id = $this->_getCacheId($id, $group);
$store = xcache_set($cache_id, $data, $this->_lifetime);
return $store;
}
/**
* Remove a cached data entry by id and group
*
* @param string $id The cache data id
* @param string $group The cache data group
*
* @return boolean True on success, false otherwise
*
* @since 11.1
*/
public function remove($id, $group)
{
$cache_id = $this->_getCacheId($id, $group);
if (!xcache_isset($cache_id))
{
return true;
}
return xcache_unset($cache_id);
}
/**
* Clean cache for a group given a mode.
*
* This requires the php.ini setting xcache.admin.enable_auth = Off.
*
* @param string $group The cache data group
* @param string $mode The mode for cleaning cache [group|notgroup]
* group mode : cleans all cache in the group
* notgroup mode : cleans all cache not in the group
*
* @return boolean True on success, false otherwise
*
* @since 11.1
*/
public function clean($group, $mode = null)
{
$allinfo = xcache_list(XC_TYPE_VAR, 0);
$keys = $allinfo['cache_list'];
$secret = $this->_hash;
foreach ($keys as $key)
{
if (strpos($key['name'], $secret . '-cache-' . $group . '-') === 0 xor $mode != 'group')
{
xcache_unset($key['name']);
}
}
return true;
}
/**
* Garbage collect expired cache data
*
* This is a dummy, since xcache has built in garbage collector, turn it
* on in php.ini by changing default xcache.gc_interval setting from
* 0 to 3600 (=1 hour)
*
* @return boolean True on success, false otherwise.
*
* @since 11.1
*/
public function gc()
{
/*
$now = time();
$cachecount = xcache_count(XC_TYPE_VAR);
for ($i = 0; $i < $cachecount; $i ++) {
$allinfo = xcache_list(XC_TYPE_VAR, $i);
$keys = $allinfo ['cache_list'];
foreach($keys as $key) {
if (strstr($key['name'], $this->_hash)) {
if (($key['ctime'] + $this->_lifetime ) < $this->_now) xcache_unset($key['name']);
}
}
}
*/
return true;
}
/**
* Test to see if the cache storage is available.
*
* @return boolean True on success, false otherwise.
*
* @since 12.1
*/
public static function isSupported()
{
return (extension_loaded('xcache'));
}
}