moodle/moodle
3
0
Fork 0
mirror of https://github.com/moodle/moodle.git synced 2025-08-05 08:56:36 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Revert "MDL-41106 cache: several fixes for the session cache."

Browse source 
This reverts commit 4973a0cb41.
This reverts commit e3d9d02381.
This reverts commit b4aba7cac2.
This commit is contained in:
Damyon Wiese 2013-08-19 15:33:46 +08:00
parent ab97bc0a1e
commit 07173cac05
4 changed files with 151 additions and 359 deletions
Download patch file Download diff file Expand all files Collapse all files

323
cache/classes/loaders.php vendored
View file

@ -271,7 +271,7 @@ class cache implements cache_loader {
* In advanced cases an array may be useful such as in situations requiring the multi-key functionality. * In advanced cases an array may be useful such as in situations requiring the multi-key functionality.
* @param int $strictness One of IGNORE_MISSING | MUST_EXIST * @param int $strictness One of IGNORE_MISSING | MUST_EXIST
* @return mixed|false The data from the cache or false if the key did not exist within the cache. * @return mixed|false The data from the cache or false if the key did not exist within the cache.
* @throws coding_exception * @throws moodle_exception
*/ */
public function get($key, $strictness = IGNORE_MISSING) { public function get($key, $strictness = IGNORE_MISSING) {
// 1. Parse the key. // 1. Parse the key.
@ -329,7 +329,7 @@ class cache implements cache_loader {
} }
// 5. Validate strictness. // 5. Validate strictness.
if ($strictness === MUST_EXIST && $result === false) { if ($strictness === MUST_EXIST && $result === false) {
throw new coding_exception('Requested key did not exist in any cache stores and could not be loaded.'); throw new moodle_exception('Requested key did not exist in any cache stores and could not be loaded.');
} }
// 6. Set it to the store if we got it from the loader/datasource. // 6. Set it to the store if we got it from the loader/datasource.
if ($setaftervalidation) { if ($setaftervalidation) {
@ -363,7 +363,7 @@ class cache implements cache_loader {
* @return array An array of key value pairs for the items that could be retrieved from the cache. * @return array An array of key value pairs for the items that could be retrieved from the cache.
* If MUST_EXIST was used and not all keys existed within the cache then an exception will be thrown. * If MUST_EXIST was used and not all keys existed within the cache then an exception will be thrown.
* Otherwise any key that did not exist will have a data value of false within the results. * Otherwise any key that did not exist will have a data value of false within the results.
* @throws coding_exception * @throws moodle_exception
*/ */
public function get_many(array $keys, $strictness = IGNORE_MISSING) { public function get_many(array $keys, $strictness = IGNORE_MISSING) {
@ -420,7 +420,7 @@ class cache implements cache_loader {
$missingkeys = array(); $missingkeys = array();
foreach ($result as $key => $value) { foreach ($result as $key => $value) {
if ($value === false) { if ($value === false) {
$missingkeys[] = $parsedkeys[$key]; $missingkeys[] = ($usingloader) ? $key : $parsedkeys[$key];
} }
} }
if (!empty($missingkeys)) { if (!empty($missingkeys)) {
@ -430,9 +430,11 @@ class cache implements cache_loader {
$resultmissing = $this->datasource->load_many_for_cache($missingkeys); $resultmissing = $this->datasource->load_many_for_cache($missingkeys);
} }
foreach ($resultmissing as $key => $value) { foreach ($resultmissing as $key => $value) {
$result[$keysparsed[$key]] = $value; $pkey = ($usingloader) ? $key : $keysparsed[$key];
$realkey = ($usingloader) ? $parsedkeys[$key] : $key;
$result[$pkey] = $value;
if ($value !== false) { if ($value !== false) {
$this->set($key, $value); $this->set($realkey, $value);
} }
} }
unset($resultmissing); unset($resultmissing);
@ -451,7 +453,7 @@ class cache implements cache_loader {
if ($strictness === MUST_EXIST) { if ($strictness === MUST_EXIST) {
foreach ($keys as $key) { foreach ($keys as $key) {
if (!array_key_exists($key, $fullresult)) { if (!array_key_exists($key, $fullresult)) {
throw new coding_exception('Not all the requested keys existed within the cache stores.'); throw new moodle_exception('Not all the requested keys existed within the cache stores.');
} }
} }
} }
@ -481,11 +483,6 @@ class cache implements cache_loader {
if ($this->perfdebug) { if ($this->perfdebug) {
cache_helper::record_cache_set($this->storetype, $this->definition->get_id()); cache_helper::record_cache_set($this->storetype, $this->definition->get_id());
} }
if ($this->loader !== false) {
// We have a loader available set it there as well.
// We have to let the loader do its own parsing of data as it may be unique.
$this->loader->set($key, $data);
}
if (is_object($data) && $data instanceof cacheable_object) { if (is_object($data) && $data instanceof cacheable_object) {
$data = new cache_cached_object($data); $data = new cache_cached_object($data);
} else if (!is_scalar($data)) { } else if (!is_scalar($data)) {
@ -509,7 +506,6 @@ class cache implements cache_loader {
* Removes references where required. * Removes references where required.
* *
* @param stdClass|array $data * @param stdClass|array $data
* @return mixed What ever was put in but without any references.
*/ */
protected function unref($data) { protected function unref($data) {
if ($this->definition->uses_simple_data()) { if ($this->definition->uses_simple_data()) {
@ -597,11 +593,6 @@ class cache implements cache_loader {
* ... if they care that is. * ... if they care that is.
*/ */
public function set_many(array $keyvaluearray) { public function set_many(array $keyvaluearray) {
if ($this->loader !== false) {
// We have a loader available set it there as well.
// We have to let the loader do its own parsing of data as it may be unique.
$this->loader->set_many($keyvaluearray);
}
$data = array(); $data = array();
$simulatettl = $this->has_a_ttl() && !$this->store_supports_native_ttl(); $simulatettl = $this->has_a_ttl() && !$this->store_supports_native_ttl();
$usepersistcache = $this->is_using_persist_cache(); $usepersistcache = $this->is_using_persist_cache();
@ -867,7 +858,7 @@ class cache implements cache_loader {
* Returns the loader associated with this instance. * Returns the loader associated with this instance.
* *
* @since 2.4.4 * @since 2.4.4
* @return cache|false * @return cache_loader|false
*/ */
protected function get_loader() { protected function get_loader() {
return $this->loader; return $this->loader;
@ -1349,6 +1340,7 @@ class cache_application extends cache implements cache_loader_with_locking {
* @param string|int $key The key for the data being requested. * @param string|int $key The key for the data being requested.
* @param int $strictness One of IGNORE_MISSING | MUST_EXIST * @param int $strictness One of IGNORE_MISSING | MUST_EXIST
* @return mixed|false The data from the cache or false if the key did not exist within the cache. * @return mixed|false The data from the cache or false if the key did not exist within the cache.
* @throws moodle_exception
*/ */
public function get($key, $strictness = IGNORE_MISSING) { public function get($key, $strictness = IGNORE_MISSING) {
if ($this->requirelockingread && $this->check_lock_state($key) === false) { if ($this->requirelockingread && $this->check_lock_state($key) === false) {
@ -1372,7 +1364,7 @@ class cache_application extends cache implements cache_loader_with_locking {
* @return array An array of key value pairs for the items that could be retrieved from the cache. * @return array An array of key value pairs for the items that could be retrieved from the cache.
* If MUST_EXIST was used and not all keys existed within the cache then an exception will be thrown. * If MUST_EXIST was used and not all keys existed within the cache then an exception will be thrown.
* Otherwise any key that did not exist will have a data value of false within the results. * Otherwise any key that did not exist will have a data value of false within the results.
* @throws coding_exception * @throws moodle_exception
*/ */
public function get_many(array $keys, $strictness = IGNORE_MISSING) { public function get_many(array $keys, $strictness = IGNORE_MISSING) {
if ($this->requirelockingread) { if ($this->requirelockingread) {
@ -1466,7 +1458,6 @@ class cache_application extends cache implements cache_loader_with_locking {
* @todo we should support locking in the session as well. Should be pretty simple to set up. * @todo we should support locking in the session as well. Should be pretty simple to set up.
* *
* @internal don't use me directly. * @internal don't use me directly.
* @method cache_store|cache_is_searchable get_store() Returns the cache store which must implement both cache_is_searchable.
* *
* @package core * @package core
* @category cache * @category cache
@ -1503,11 +1494,6 @@ class cache_session extends cache {
*/ */
const KEY_PREFIX = 'sess_'; const KEY_PREFIX = 'sess_';
/**
* This is the key used to track last access.
*/
const LASTACCESS = '__lastaccess__';
/** /**
* Override the cache::construct method. * Override the cache::construct method.
* *
@ -1521,15 +1507,12 @@ class cache_session extends cache {
* @param cache_definition $definition * @param cache_definition $definition
* @param cache_store $store * @param cache_store $store
* @param cache_loader|cache_data_source $loader * @param cache_loader|cache_data_source $loader
* @return void
*/ */
public function __construct(cache_definition $definition, cache_store $store, $loader = null) { public function __construct(cache_definition $definition, cache_store $store, $loader = null) {
// First up copy the loadeduserid to the current user id. // First up copy the loadeduserid to the current user id.
$this->currentuserid = self::$loadeduserid; $this->currentuserid = self::$loadeduserid;
parent::__construct($definition, $store, $loader); parent::__construct($definition, $store, $loader);
// This will trigger check tracked user. If this gets removed a call to that will need to be added here in its place.
$this->set(self::LASTACCESS, cache::now());
if ($definition->has_invalidation_events()) { if ($definition->has_invalidation_events()) {
$lastinvalidation = $this->get('lastsessioninvalidation'); $lastinvalidation = $this->get('lastsessioninvalidation');
if ($lastinvalidation === false) { if ($lastinvalidation === false) {
@ -1578,21 +1561,6 @@ class cache_session extends cache {
} }
} }
/**
* Sets the session id for the loader.
*/
protected function set_session_id() {
$this->sessionid = preg_replace('#[^a-zA-Z0-9_]#', '_', session_id());
}
/**
* Returns the prefix used for all keys.
* @return string
*/
protected function get_key_prefix() {
return 'u'.$this->currentuserid.'_'.$this->sessionid;
}
/** /**
* Parses the key turning it into a string (or array is required) suitable to be passed to the cache store. * Parses the key turning it into a string (or array is required) suitable to be passed to the cache store.
* *
@ -1605,18 +1573,17 @@ class cache_session extends cache {
* @return string|array String unless the store supports multi-identifiers in which case an array if returned. * @return string|array String unless the store supports multi-identifiers in which case an array if returned.
*/ */
protected function parse_key($key) { protected function parse_key($key) {
$prefix = $this->get_key_prefix(); if ($key === 'lastaccess') {
if ($key === self::LASTACCESS) { $key = '__lastaccess__';
return $key.$prefix;
} }
return $prefix.'_'.parent::parse_key($key); return 'sess_'.parent::parse_key($key);
} }
/** /**
* Check that this cache instance is tracking the current user. * Check that this cache instance is tracking the current user.
*/ */
protected function check_tracked_user() { protected function check_tracked_user() {
if (isset($_SESSION['USER']->id) && $_SESSION['USER']->id !== null) { if (isset($_SESSION['USER']->id)) {
// Get the id of the current user. // Get the id of the current user.
$new = $_SESSION['USER']->id; $new = $_SESSION['USER']->id;
} else { } else {
@ -1630,25 +1597,55 @@ class cache_session extends cache {
// This way we don't bloat the session. // This way we don't bloat the session.
$this->purge(); $this->purge();
// Update the session id just in case! // Update the session id just in case!
$this->set_session_id(); $this->sessionid = session_id();
} }
self::$loadeduserid = $new; self::$loadeduserid = $new;
$this->currentuserid = $new; $this->currentuserid = $new;
} else if ($new !== $this->currentuserid) { } else if ($new !== $this->currentuserid) {
// The current user matches the loaded user but not the user last used by this cache. // The current user matches the loaded user but not the user last used by this cache.
$this->purge_current_user(); $this->purge();
$this->currentuserid = $new; $this->currentuserid = $new;
// Update the session id just in case! // Update the session id just in case!
$this->set_session_id(); $this->sessionid = session_id();
} }
} }
/** /**
* Purges the session cache of all data belonging to the current user. * Gets the session data.
*
* @param bool $force If true the session data will be loaded from the store again.
* @return array An array of session data.
*/ */
public function purge_current_user() { protected function get_session_data($force = false) {
$keys = $this->get_store()->find_all($this->get_key_prefix()); if ($this->sessionid === null) {
$this->get_store()->delete_many($keys); $this->sessionid = session_id();
}
if (is_array($this->session) && !$force) {
return $this->session;
}
$session = parent::get($this->sessionid);
if ($session === false) {
$session = array();
}
// We have to write here to ensure that the lastaccess time is recorded.
// And also in order to ensure the session entry exists as when we save it on __destruct
// $CFG is likely to have already been destroyed.
$this->save_session($session);
return $this->session;
}
/**
* Saves the session data.
*
* This function also updates the last access time.
*
* @param array $session
* @return bool
*/
protected function save_session(array $session) {
$session['lastaccess'] = time();
$this->session = $session;
return parent::set($this->sessionid, $this->session);
} }
/** /**
@ -1659,7 +1656,7 @@ class cache_session extends cache {
* In advanced cases an array may be useful such as in situations requiring the multi-key functionality. * In advanced cases an array may be useful such as in situations requiring the multi-key functionality.
* @param int $strictness One of IGNORE_MISSING | MUST_EXIST * @param int $strictness One of IGNORE_MISSING | MUST_EXIST
* @return mixed|false The data from the cache or false if the key did not exist within the cache. * @return mixed|false The data from the cache or false if the key did not exist within the cache.
* @throws coding_exception * @throws moodle_exception
*/ */
public function get($key, $strictness = IGNORE_MISSING) { public function get($key, $strictness = IGNORE_MISSING) {
// Check the tracked user. // Check the tracked user.
@ -1667,8 +1664,10 @@ class cache_session extends cache {
// 2. Parse the key. // 2. Parse the key.
$parsedkey = $this->parse_key($key); $parsedkey = $this->parse_key($key);
// 3. Get it from the store. // 3. Get it from the store.
$result = $this->get_store()->get($parsedkey); $result = false;
if ($result !== false) { $session = $this->get_session_data();
if (array_key_exists($parsedkey, $session)) {
$result = $session[$parsedkey];
if ($result instanceof cache_ttl_wrapper) { if ($result instanceof cache_ttl_wrapper) {
if ($result->has_expired()) { if ($result->has_expired()) {
$this->get_store()->delete($parsedkey); $this->get_store()->delete($parsedkey);
@ -1682,9 +1681,10 @@ class cache_session extends cache {
} }
} }
// 4. Load if from the loader/datasource if we don't already have it. // 4. Load if from the loader/datasource if we don't already have it.
$setaftervalidation = false;
if ($result === false) { if ($result === false) {
if ($this->perfdebug) { if ($this->perfdebug) {
cache_helper::record_cache_miss($this->storetype, $this->get_definition()->get_id()); cache_helper::record_cache_miss('**static session**', $this->get_definition()->get_id());
} }
if ($this->get_loader() !== false) { if ($this->get_loader() !== false) {
// We must pass the original (unparsed) key to the next loader in the chain. // We must pass the original (unparsed) key to the next loader in the chain.
@ -1694,18 +1694,19 @@ class cache_session extends cache {
} else if ($this->get_datasource() !== false) { } else if ($this->get_datasource() !== false) {
$result = $this->get_datasource()->load_for_cache($key); $result = $this->get_datasource()->load_for_cache($key);
} }
// 5. Set it to the store if we got it from the loader/datasource. $setaftervalidation = ($result !== false);
if ($result !== false) {
$this->set($key, $result);
}
} else if ($this->perfdebug) { } else if ($this->perfdebug) {
cache_helper::record_cache_hit($this->storetype, $this->get_definition()->get_id()); cache_helper::record_cache_hit('**static session**', $this->get_definition()->get_id());
} }
// 5. Validate strictness. // 5. Validate strictness.
if ($strictness === MUST_EXIST && $result === false) { if ($strictness === MUST_EXIST && $result === false) {
throw new coding_exception('Requested key did not exist in any cache stores and could not be loaded.'); throw new moodle_exception('Requested key did not exist in any cache stores and could not be loaded.');
} }
// 6. Make sure we don't pass back anything that could be a reference. // 6. Set it to the store if we got it from the loader/datasource.
if ($setaftervalidation) {
$this->set($key, $result);
}
// 7. Make sure we don't pass back anything that could be a reference.
// We don't want people modifying the data in the cache. // We don't want people modifying the data in the cache.
if (!is_scalar($result)) { if (!is_scalar($result)) {
// If data is an object it will be a reference. // If data is an object it will be a reference.
@ -1736,14 +1737,8 @@ class cache_session extends cache {
*/ */
public function set($key, $data) { public function set($key, $data) {
$this->check_tracked_user(); $this->check_tracked_user();
$loader = $this->get_loader();
if ($loader !== false) {
// We have a loader available set it there as well.
// We have to let the loader do its own parsing of data as it may be unique.
$loader->set($key, $data);
}
if ($this->perfdebug) { if ($this->perfdebug) {
cache_helper::record_cache_set($this->storetype, $this->get_definition()->get_id()); cache_helper::record_cache_set('**static session**', $this->get_definition()->get_id());
} }
if (is_object($data) && $data instanceof cacheable_object) { if (is_object($data) && $data instanceof cacheable_object) {
$data = new cache_cached_object($data); $data = new cache_cached_object($data);
@ -1755,10 +1750,12 @@ class cache_session extends cache {
$data = $this->unref($data); $data = $this->unref($data);
} }
// We dont' support native TTL here as we consolidate data for sessions. // We dont' support native TTL here as we consolidate data for sessions.
if ($this->has_a_ttl() && !$this->store_supports_native_ttl()) { if ($this->has_a_ttl()) {
$data = new cache_ttl_wrapper($data, $this->get_definition()->get_ttl()); $data = new cache_ttl_wrapper($data, $this->get_definition()->get_ttl());
} }
return $this->get_store()->set($this->parse_key($key), $data); $session = $this->get_session_data();
$session[$this->parse_key($key)] = $data;
return $this->save_session($session);
} }
/** /**
@ -1770,12 +1767,15 @@ class cache_session extends cache {
* @return bool True of success, false otherwise. * @return bool True of success, false otherwise.
*/ */
public function delete($key, $recurse = true) { public function delete($key, $recurse = true) {
$this->check_tracked_user();
$parsedkey = $this->parse_key($key); $parsedkey = $this->parse_key($key);
if ($recurse && $this->get_loader() !== false) { if ($recurse && $this->get_loader() !== false) {
// Delete from the bottom of the stack first. // Delete from the bottom of the stack first.
$this->get_loader()->delete($key, $recurse); $this->get_loader()->delete($key, $recurse);
} }
return $this->get_store()->delete($parsedkey); $session = $this->get_session_data();
unset($session[$parsedkey]);
return $this->save_session($session);
} }
/** /**
@ -1794,72 +1794,15 @@ class cache_session extends cache {
* @return array An array of key value pairs for the items that could be retrieved from the cache. * @return array An array of key value pairs for the items that could be retrieved from the cache.
* If MUST_EXIST was used and not all keys existed within the cache then an exception will be thrown. * If MUST_EXIST was used and not all keys existed within the cache then an exception will be thrown.
* Otherwise any key that did not exist will have a data value of false within the results. * Otherwise any key that did not exist will have a data value of false within the results.
* @throws coding_exception * @throws moodle_exception
*/ */
public function get_many(array $keys, $strictness = IGNORE_MISSING) { public function get_many(array $keys, $strictness = IGNORE_MISSING) {
$this->check_tracked_user(); $this->check_tracked_user();
$parsedkeys = array();
$keymap = array();
foreach ($keys as $key) {
$parsedkey = $this->parse_key($key);
$parsedkeys[$key] = $parsedkey;
$keymap[$parsedkey] = $key;
}
$result = $this->get_store()->get_many($parsedkeys);
$return = array(); $return = array();
$missingkeys = array(); foreach ($keys as $key) {
$hasmissingkeys = false; $return[$key] = $this->get($key, $strictness);
foreach ($result as $parsedkey => $value) {
$key = $keymap[$parsedkey];
if ($value instanceof cache_ttl_wrapper) {
/* @var cache_ttl_wrapper $value */
if ($value->has_expired()) {
$this->delete($keymap[$parsedkey]);
$value = false;
} else {
$value = $value->data;
} }
}
if ($value instanceof cache_cached_object) {
/* @var cache_cached_object $value */
$value = $value->restore_object();
}
$return[$key] = $value;
if ($value === false) {
$hasmissingkeys = true;
$missingkeys[$parsedkey] = $key;
}
}
if ($hasmissingkeys) {
// We've got missing keys - we've got to check any loaders or data sources.
$loader = $this->get_loader();
$datasource = $this->get_datasource();
if ($loader !== false) {
foreach ($loader->get_many($missingkeys) as $key => $value) {
if ($value !== false) {
$return[$key] = $value;
unset($missingkeys[$parsedkeys[$key]]);
}
}
}
$hasmissingkeys = count($missingkeys) > 0;
if ($datasource !== false && $hasmissingkeys) {
// We're still missing keys but we've got a datasource.
foreach ($datasource->load_many_for_cache($missingkeys) as $key => $value) {
if ($value !== false) {
$return[$key] = $value;
unset($missingkeys[$parsedkeys[$key]]);
}
}
$hasmissingkeys = count($missingkeys) > 0;
}
}
if ($hasmissingkeys && $strictness === MUST_EXIST) {
throw new coding_exception('Requested key did not exist in any cache stores and could not be loaded.');
}
return $return; return $return;
} }
/** /**
@ -1871,12 +1814,18 @@ class cache_session extends cache {
* @return int The number of items successfully deleted. * @return int The number of items successfully deleted.
*/ */
public function delete_many(array $keys, $recurse = true) { public function delete_many(array $keys, $recurse = true) {
$this->check_tracked_user();
$parsedkeys = array_map(array($this, 'parse_key'), $keys); $parsedkeys = array_map(array($this, 'parse_key'), $keys);
if ($recurse && $this->get_loader() !== false) { if ($recurse && $this->get_loader() !== false) {
// Delete from the bottom of the stack first. // Delete from the bottom of the stack first.
$this->get_loader()->delete_many($keys, $recurse); $this->get_loader()->delete_many($keys, $recurse);
} }
return $this->get_store()->delete_many($parsedkeys); $session = $this->get_session_data();
foreach ($parsedkeys as $parsedkey) {
unset($session[$parsedkey]);
}
$this->save_session($session);
return count($keys);
} }
/** /**
@ -1904,15 +1853,8 @@ class cache_session extends cache {
*/ */
public function set_many(array $keyvaluearray) { public function set_many(array $keyvaluearray) {
$this->check_tracked_user(); $this->check_tracked_user();
$loader = $this->get_loader(); $session = $this->get_session_data();
if ($loader !== false) { $simulatettl = $this->has_a_ttl();
// We have a loader available set it there as well.
// We have to let the loader do its own parsing of data as it may be unique.
$loader->set_many($keyvaluearray);
}
$data = array();
$definitionid = $this->get_definition()->get_ttl();
$simulatettl = $this->has_a_ttl() && !$this->store_supports_native_ttl();
foreach ($keyvaluearray as $key => $value) { foreach ($keyvaluearray as $key => $value) {
if (is_object($value) && $value instanceof cacheable_object) { if (is_object($value) && $value instanceof cacheable_object) {
$value = new cache_cached_object($value); $value = new cache_cached_object($value);
@ -1924,17 +1866,16 @@ class cache_session extends cache {
$value = $this->unref($value); $value = $this->unref($value);
} }
if ($simulatettl) { if ($simulatettl) {
$value = new cache_ttl_wrapper($value, $definitionid); $value = new cache_ttl_wrapper($value, $this->get_definition()->get_ttl());
} }
$data[$key] = array( $parsedkey = $this->parse_key($key);
'key' => $this->parse_key($key), $session[$parsedkey] = $value;
'value' => $value
);
} }
if ($this->perfdebug) { if ($this->perfdebug) {
cache_helper::record_cache_set($this->storetype, $definitionid); cache_helper::record_cache_set($this->storetype, $this->get_definition()->get_id());
} }
return $this->get_store()->set_many($data); $this->save_session($session);
return count($keyvaluearray);
} }
/** /**
@ -1943,9 +1884,13 @@ class cache_session extends cache {
* @return bool True on success, false otherwise * @return bool True on success, false otherwise
*/ */
public function purge() { public function purge() {
$this->get_store()->purge(); // 1. Purge the session object.
$this->session = array();
// 2. Delete the record for this users session from the store.
$this->get_store()->delete($this->sessionid);
// 3. Optionally purge any stacked loaders in the same way.
if ($this->get_loader()) { if ($this->get_loader()) {
$this->get_loader()->purge(); $this->get_loader()->delete($this->sessionid);
} }
return true; return true;
} }
@ -1974,27 +1919,21 @@ class cache_session extends cache {
public function has($key, $tryloadifpossible = false) { public function has($key, $tryloadifpossible = false) {
$this->check_tracked_user(); $this->check_tracked_user();
$parsedkey = $this->parse_key($key); $parsedkey = $this->parse_key($key);
$store = $this->get_store(); $session = $this->get_session_data();
if ($this->has_a_ttl() && !$this->store_supports_native_ttl()) { $has = false;
if ($this->has_a_ttl()) {
// The data has a TTL and the store doesn't support it natively. // The data has a TTL and the store doesn't support it natively.
// We must fetch the data and expect a ttl wrapper. // We must fetch the data and expect a ttl wrapper.
$data = $store->get($parsedkey); if (array_key_exists($parsedkey, $session)) {
$data = $session[$parsedkey];
$has = ($data instanceof cache_ttl_wrapper && !$data->has_expired()); $has = ($data instanceof cache_ttl_wrapper && !$data->has_expired());
} else if (!$this->store_supports_key_awareness()) { }
// The store doesn't support key awareness, get the data and check it manually... puke.
// Either no TTL is set of the store supports its handling natively.
$data = $store->get($parsedkey);
$has = ($data !== false);
} else { } else {
// The store supports key awareness, this is easy! $has = array_key_exists($parsedkey, $session);
// Either no TTL is set of the store supports its handling natively.
/* @var cache_store|cache_is_key_aware $store */
$has = $store->has($parsedkey);
} }
if (!$has && $tryloadifpossible) { if (!$has && $tryloadifpossible) {
$result = null;
if ($this->get_loader() !== false) { if ($this->get_loader() !== false) {
$result = $this->get_loader()->get($parsedkey); $result = $this->get_loader()->get($key);
} else if ($this->get_datasource() !== null) { } else if ($this->get_datasource() !== null) {
$result = $this->get_datasource()->load_for_cache($key); $result = $this->get_datasource()->load_for_cache($key);
} }
@ -2021,19 +1960,26 @@ class cache_session extends cache {
*/ */
public function has_all(array $keys) { public function has_all(array $keys) {
$this->check_tracked_user(); $this->check_tracked_user();
if (($this->has_a_ttl() && !$this->store_supports_native_ttl()) || !$this->store_supports_key_awareness()) { $session = $this->get_session_data();
foreach ($keys as $key) { foreach ($keys as $key) {
if (!$this->has($key)) { $has = false;
$parsedkey = $this->parse_key($key);
if ($this->has_a_ttl()) {
// The data has a TTL and the store doesn't support it natively.
// We must fetch the data and expect a ttl wrapper.
if (array_key_exists($parsedkey, $session)) {
$data = $session[$parsedkey];
$has = ($data instanceof cache_ttl_wrapper && !$data->has_expired());
}
} else {
$has = array_key_exists($parsedkey, $session);
}
if (!$has) {
return false; return false;
} }
} }
return true; return true;
} }
// The cache must be key aware and if support native ttl if it a ttl is set.
/* @var cache_store|cache_is_key_aware $store */
$store = $this->get_store();
return $store->has_all(array_map(array($this, 'parse_key'), $keys));
}
/** /**
* Test if a cache has at least one of the given keys. * Test if a cache has at least one of the given keys.
@ -2049,18 +1995,27 @@ class cache_session extends cache {
* @return bool True if the cache has at least one of the given keys * @return bool True if the cache has at least one of the given keys
*/ */
public function has_any(array $keys) { public function has_any(array $keys) {
if (($this->has_a_ttl() && !$this->store_supports_native_ttl()) || !$this->store_supports_key_awareness()) { $this->check_tracked_user();
$session = $this->get_session_data();
foreach ($keys as $key) { foreach ($keys as $key) {
if ($this->has($key)) { $has = false;
$parsedkey = $this->parse_key($key);
if ($this->has_a_ttl()) {
// The data has a TTL and the store doesn't support it natively.
// We must fetch the data and expect a ttl wrapper.
if (array_key_exists($parsedkey, $session)) {
$data = $session[$parsedkey];
$has = ($data instanceof cache_ttl_wrapper && !$data->has_expired());
}
} else {
$has = array_key_exists($parsedkey, $session);
}
if ($has) {
return true; return true;
} }
} }
return false; return false;
} }
/* @var cache_store|cache_is_key_aware $store */
$store = $this->get_store();
return $store->has_any(array_map(array($this, 'parse_key'), $keys));
}
/** /**
* The session loader never uses the persist cache. * The session loader never uses the persist cache.

68
cache/stores/session/lib.php vendored
View file

@ -190,9 +190,8 @@ class cachestore_session extends session_data_store implements cache_is_key_awar
*/ */
public function initialise(cache_definition $definition) { public function initialise(cache_definition $definition) {
$this->storeid = $definition->generate_definition_hash(); $this->storeid = $definition->generate_definition_hash();
$this->store = &self::register_store_id($this->name.'-'.$definition->get_id()); $this->store = &self::register_store_id($definition->get_id());
$this->ttl = $definition->get_ttl(); $this->ttl = $definition->get_ttl();
$this->check_ttl();
} }
/** /**
@ -220,13 +219,10 @@ class cachestore_session extends session_data_store implements cache_is_key_awar
*/ */
public function get($key) { public function get($key) {
if (isset($this->store[$key])) { if (isset($this->store[$key])) {
if ($this->ttl === 0) { if ($this->ttl == 0) {
return $this->store[$key][0]; return $this->store[$key][0];
} else if ($this->store[$key][1] >= (cache::now() - $this->ttl)) { } else if ($this->store[$key][1] >= (cache::now() - $this->ttl)) {
return $this->store[$key][0]; return $this->store[$key][0];
} else {
// Element is present but has expired.
$this->check_ttl();
} }
} }
return false; return false;
@ -243,12 +239,10 @@ class cachestore_session extends session_data_store implements cache_is_key_awar
*/ */
public function get_many($keys) { public function get_many($keys) {
$return = array(); $return = array();
$maxtime = 0;
if ($this->ttl != 0) { if ($this->ttl != 0) {
$maxtime = cache::now() - $this->ttl; $maxtime = cache::now() - $this->ttl;
} }
$hasexpiredelements = false;
foreach ($keys as $key) { foreach ($keys as $key) {
$return[$key] = false; $return[$key] = false;
if (isset($this->store[$key])) { if (isset($this->store[$key])) {
@ -256,15 +250,9 @@ class cachestore_session extends session_data_store implements cache_is_key_awar
$return[$key] = $this->store[$key][0]; $return[$key] = $this->store[$key][0];
} else if ($this->store[$key][1] >= $maxtime) { } else if ($this->store[$key][1] >= $maxtime) {
$return[$key] = $this->store[$key][0]; $return[$key] = $this->store[$key][0];
} else {
$hasexpiredelements = true;
} }
} }
} }
if ($hasexpiredelements) {
// There are some elements that are present but have expired.
$this->check_ttl();
}
return $return; return $return;
} }
@ -276,8 +264,8 @@ class cachestore_session extends session_data_store implements cache_is_key_awar
* @return bool True if the operation was a success false otherwise. * @return bool True if the operation was a success false otherwise.
*/ */
public function set($key, $data) { public function set($key, $data) {
if ($this->ttl === 0) { if ($this->ttl == 0) {
$this->store[$key] = array($data, 0); $this->store[$key][0] = $data;
} else { } else {
$this->store[$key] = array($data, cache::now()); $this->store[$key] = array($data, cache::now());
} }
@ -295,14 +283,8 @@ class cachestore_session extends session_data_store implements cache_is_key_awar
public function set_many(array $keyvaluearray) { public function set_many(array $keyvaluearray) {
$count = 0; $count = 0;
foreach ($keyvaluearray as $pair) { foreach ($keyvaluearray as $pair) {
$key = $pair['key']; $this->set($pair['key'], $pair['value']);
$data = $pair['value'];
$count++; $count++;
if ($this->ttl === 0) {
$this->store[$key] = array($data, 0);
} else {
$this->store[$key] = array($data, cache::now());
}
} }
return $count; return $count;
} }
@ -331,7 +313,6 @@ class cachestore_session extends session_data_store implements cache_is_key_awar
* @return bool * @return bool
*/ */
public function has_all(array $keys) { public function has_all(array $keys) {
$maxtime = 0;
if ($this->ttl != 0) { if ($this->ttl != 0) {
$maxtime = cache::now() - $this->ttl; $maxtime = cache::now() - $this->ttl;
} }
@ -354,7 +335,6 @@ class cachestore_session extends session_data_store implements cache_is_key_awar
* @return bool * @return bool
*/ */
public function has_any(array $keys) { public function has_any(array $keys) {
$maxtime = 0;
if ($this->ttl != 0) { if ($this->ttl != 0) {
$maxtime = cache::now() - $this->ttl; $maxtime = cache::now() - $this->ttl;
} }
@ -374,9 +354,6 @@ class cachestore_session extends session_data_store implements cache_is_key_awar
* @return bool Returns true if the operation was a success, false otherwise. * @return bool Returns true if the operation was a success, false otherwise.
*/ */
public function delete($key) { public function delete($key) {
if (!isset($this->store[$key])) {
return false;
}
unset($this->store[$key]); unset($this->store[$key]);
return true; return true;
} }
@ -388,7 +365,6 @@ class cachestore_session extends session_data_store implements cache_is_key_awar
* @return int The number of items successfully deleted. * @return int The number of items successfully deleted.
*/ */
public function delete_many(array $keys) { public function delete_many(array $keys) {
// The number of items that have been successfully deleted.
$count = 0; $count = 0;
foreach ($keys as $key) { foreach ($keys as $key) {
unset($this->store[$key]); unset($this->store[$key]);
@ -444,37 +420,12 @@ class cachestore_session extends session_data_store implements cache_is_key_awar
return $this->name; return $this->name;
} }
/**
* Removes expired elements.
* @return int number of removed elements
*/
protected function check_ttl() {
if ($this->ttl === 0) {
return 0;
}
$maxtime = cache::now() - $this->ttl;
$count = 0;
for ($value = reset($this->store); $value !== false; $value = next($this->store)) {
if ($value[1] >= $maxtime) {
// We know that elements are sorted by ttl so no need to continue.
break;
}
$count++;
}
if ($count) {
// Remove first $count elements as they are expired.
$this->store = array_slice($this->store, $count, null, true);
}
return $count;
}
/** /**
* Finds all of the keys being stored in the cache store instance. * Finds all of the keys being stored in the cache store instance.
* *
* @return array * @return array
*/ */
public function find_all() { public function find_all() {
$this->check_ttl();
return array_keys($this->store); return array_keys($this->store);
} }
@ -482,7 +433,6 @@ class cachestore_session extends session_data_store implements cache_is_key_awar
* Finds all of the keys whose keys start with the given prefix. * Finds all of the keys whose keys start with the given prefix.
* *
* @param string $prefix * @param string $prefix
* @return array An array of keys.
*/ */
public function find_by_prefix($prefix) { public function find_by_prefix($prefix) {
$return = array(); $return = array();
@ -493,12 +443,4 @@ class cachestore_session extends session_data_store implements cache_is_key_awar
} }
return $return; return $return;
} }
/**
* This store supports native TTL handling.
* @return bool
*/
public function store_supports_native_ttl() {
return true;
}
} }

91
cache/tests/cache_test.php vendored
View file

@ -1109,9 +1109,9 @@ class cache_phpunit_tests extends advanced_testcase {
} }
/** /**
* Test that multiple application loaders work ok. * Test that multiple loaders work ok.
*/ */
public function test_multiple_application_loaders() { public function test_multiple_loaders() {
$instance = cache_config_phpunittest::instance(true); $instance = cache_config_phpunittest::instance(true);
$instance->phpunit_add_file_store('phpunittest1'); $instance->phpunit_add_file_store('phpunittest1');
$instance->phpunit_add_file_store('phpunittest2'); $instance->phpunit_add_file_store('phpunittest2');
@ -1156,93 +1156,6 @@ class cache_phpunit_tests extends advanced_testcase {
$this->assertFalse($result['a']); $this->assertFalse($result['a']);
$this->assertEquals('B', $result['b']); $this->assertEquals('B', $result['b']);
$this->assertFalse($result['c']); $this->assertFalse($result['c']);
// Test non-recursive deletes.
$this->assertTrue($cache->set('test', 'test'));
$this->assertSame('test', $cache->get('test'));
$this->assertTrue($cache->delete('test', false));
// We should still have it on a deeper loader.
$this->assertSame('test', $cache->get('test'));
// Test non-recusive with many functions.
$this->assertSame(3, $cache->set_many(array(
'one' => 'one',
'two' => 'two',
'three' => 'three'
)));
$this->assertSame('one', $cache->get('one'));
$this->assertSame(array('two' => 'two', 'three' => 'three'), $cache->get_many(array('two', 'three')));
$this->assertSame(3, $cache->delete_many(array('one', 'two', 'three'), false));
$this->assertSame('one', $cache->get('one'));
$this->assertSame(array('two' => 'two', 'three' => 'three'), $cache->get_many(array('two', 'three')));
}
/**
* Test that multiple application loaders work ok.
*/
public function test_multiple_session_loaders() {
/* @var cache_config_phpunittest $instance */
$instance = cache_config_phpunittest::instance(true);
$instance->phpunit_add_session_store('phpunittest1');
$instance->phpunit_add_session_store('phpunittest2');
$instance->phpunit_add_definition('phpunit/multi_loader', array(
'mode' => cache_store::MODE_SESSION,
'component' => 'phpunit',
'area' => 'multi_loader'
));
$instance->phpunit_add_definition_mapping('phpunit/multi_loader', 'phpunittest1', 3);
$instance->phpunit_add_definition_mapping('phpunit/multi_loader', 'phpunittest2', 2);
$cache = cache::make('phpunit', 'multi_loader');
$this->assertInstanceOf('cache_session', $cache);
$this->assertFalse($cache->get('test'));
$this->assertTrue($cache->set('test', 'test'));
$this->assertEquals('test', $cache->get('test'));
$this->assertTrue($cache->delete('test'));
$this->assertFalse($cache->get('test'));
$this->assertTrue($cache->set('test', 'test'));
$this->assertTrue($cache->purge());
$this->assertFalse($cache->get('test'));
// Test the many commands.
$this->assertEquals(3, $cache->set_many(array('a' => 'A', 'b' => 'B', 'c' => 'C')));
$result = $cache->get_many(array('a', 'b', 'c'));
$this->assertInternalType('array', $result);
$this->assertCount(3, $result);
$this->assertArrayHasKey('a', $result);
$this->assertArrayHasKey('b', $result);
$this->assertArrayHasKey('c', $result);
$this->assertEquals('A', $result['a']);
$this->assertEquals('B', $result['b']);
$this->assertEquals('C', $result['c']);
$this->assertEquals($result, $cache->get_many(array('a', 'b', 'c')));
$this->assertEquals(2, $cache->delete_many(array('a', 'c')));
$result = $cache->get_many(array('a', 'b', 'c'));
$this->assertInternalType('array', $result);
$this->assertCount(3, $result);
$this->assertArrayHasKey('a', $result);
$this->assertArrayHasKey('b', $result);
$this->assertArrayHasKey('c', $result);
$this->assertFalse($result['a']);
$this->assertEquals('B', $result['b']);
$this->assertFalse($result['c']);
// Test non-recursive deletes.
$this->assertTrue($cache->set('test', 'test'));
$this->assertSame('test', $cache->get('test'));
$this->assertTrue($cache->delete('test', false));
// We should still have it on a deeper loader.
$this->assertSame('test', $cache->get('test'));
// Test non-recusive with many functions.
$this->assertSame(3, $cache->set_many(array(
'one' => 'one',
'two' => 'two',
'three' => 'three'
)));
$this->assertSame('one', $cache->get('one'));
$this->assertSame(array('two' => 'two', 'three' => 'three'), $cache->get_many(array('two', 'three')));
$this->assertSame(3, $cache->delete_many(array('one', 'two', 'three'), false));
$this->assertSame('one', $cache->get('one'));
$this->assertSame(array('two' => 'two', 'three' => 'three'), $cache->get_many(array('two', 'three')));
} }
/** /**

18
cache/tests/fixtures/lib.php vendored
View file

@ -86,24 +86,6 @@ class cache_config_phpunittest extends cache_config_writer {
); );
} }
/**
* Forcefully adds a session store.
*
* @param string $name
*/
public function phpunit_add_session_store($name) {
$this->configstores[$name] = array(
'name' => $name,
'plugin' => 'session',
'configuration' => array(),
'features' => 14,
'modes' => 2,
'default' => true,
'class' => 'cachestore_session',
'lock' => 'cachelock_file_default',
);
}
/** /**
* Forcefully injects a definition => store mapping. * Forcefully injects a definition => store mapping.
* *