3 +--------------------------------------------------------------------+
4 | Copyright CiviCRM LLC. All rights reserved. |
6 | This work is published under the GNU AGPLv3 license with some |
7 | permitted exceptions and without any warranty. For full license |
8 | and copyright information, see https://civicrm.org/licensing |
9 +--------------------------------------------------------------------+
13 * BAO object for civicrm_cache table.
15 * This is a database cache and is persisted across sessions. Typically we use
16 * this to store meta data (like profile fields, custom fields etc).
18 * The group_name column is used for grouping together all cache elements that logically belong to the same set.
19 * Thus all session cache entries are grouped under 'CiviCRM Session'. This allows us to delete all entries of
20 * a specific group if needed.
22 * The path column allows us to differentiate between items in that group. Thus for the session cache, the path is
23 * the unique form name for each form (per user)
25 class CRM_Core_BAO_Cache
extends CRM_Core_DAO_Cache
{
28 * When store session/form state, how long should the data be retained?
30 * Default is Two days: 2*24*60*60
32 * @var int, number of second
34 const DEFAULT_SESSION_TTL
= 172800;
39 * Format is ($cacheKey => $cacheValue)
43 public static $_cache = NULL;
46 * Retrieve an item from the DB cache.
48 * @param string $group
49 * (required) The group name of the item.
51 * (required) The path under which this item is stored.
52 * @param int $componentID
53 * The optional component ID (so componenets can share the same name space).
56 * The data if present in cache, else null
59 public static function &getItem($group, $path, $componentID = NULL) {
60 CRM_Core_Error
::deprecatedFunctionWarning(
61 'CRM_Core_BAO_Cache::getItem is deprecated and will be removed from core soon, use Civi::cache() facade or define cache group using hook_civicrm_container'
63 if (($adapter = CRM_Utils_Constant
::value('CIVICRM_BAO_CACHE_ADAPTER')) !== NULL) {
64 $value = $adapter::getItem($group, $path, $componentID);
68 if (self
::$_cache === NULL) {
72 $argString = "CRM_CT_{$group}_{$path}_{$componentID}";
73 if (!array_key_exists($argString, self
::$_cache)) {
74 $cache = CRM_Utils_Cache
::singleton();
75 $cleanKey = self
::cleanKey($argString);
76 self
::$_cache[$argString] = $cache->get($cleanKey);
77 if (self
::$_cache[$argString] === NULL) {
78 $table = self
::getTableName();
79 $where = self
::whereCache($group, $path, $componentID);
80 $rawData = CRM_Core_DAO
::singleValueQuery("SELECT data FROM $table WHERE $where");
81 $data = $rawData ? self
::decode($rawData) : NULL;
83 self
::$_cache[$argString] = $data;
85 // Do not cache 'null' as that is most likely a cache miss & we shouldn't then cache it.
86 $cache->set($cleanKey, self
::$_cache[$argString]);
90 return self
::$_cache[$argString];
94 * Retrieve all items in a group.
96 * @param string $group
97 * (required) The group name of the item.
98 * @param int $componentID
99 * The optional component ID (so componenets can share the same name space).
102 * The data if present in cache, else null
105 public static function &getItems($group, $componentID = NULL) {
106 CRM_Core_Error
::deprecatedFunctionWarning(
107 'CRM_Core_BAO_Cache::getItems is deprecated and will be removed from core soon, use Civi::cache() facade or define cache group using hook_civicrm_container'
109 if (($adapter = CRM_Utils_Constant
::value('CIVICRM_BAO_CACHE_ADAPTER')) !== NULL) {
110 return $adapter::getItems($group, $componentID);
113 if (self
::$_cache === NULL) {
117 $argString = "CRM_CT_CI_{$group}_{$componentID}";
118 if (!array_key_exists($argString, self
::$_cache)) {
119 $cache = CRM_Utils_Cache
::singleton();
120 $cleanKey = self
::cleanKey($argString);
121 self
::$_cache[$argString] = $cache->get($cleanKey);
122 if (!self
::$_cache[$argString]) {
123 $table = self
::getTableName();
124 $where = self
::whereCache($group, NULL, $componentID);
125 $dao = CRM_Core_DAO
::executeQuery("SELECT path, data FROM $table WHERE $where");
128 while ($dao->fetch()) {
129 $result[$dao->path
] = self
::decode($dao->data
);
132 self
::$_cache[$argString] = $result;
133 $cache->set($cleanKey, self
::$_cache[$argString]);
137 return self
::$_cache[$argString];
141 * Store an item in the DB cache.
143 * @param object $data
144 * (required) A reference to the data that will be serialized and stored.
145 * @param string $group
146 * (required) The group name of the item.
147 * @param string $path
148 * (required) The path under which this item is stored.
149 * @param int $componentID
150 * The optional component ID (so componenets can share the same name space).
152 * @throws CRM_Core_Exception
154 public static function setItem(&$data, $group, $path, $componentID = NULL) {
155 CRM_Core_Error
::deprecatedFunctionWarning(
156 'CRM_Core_BAO_Cache::setItem is deprecated and will be removed from core soon, use Civi::cache() facade or define cache group using hook_civicrm_container'
158 if (($adapter = CRM_Utils_Constant
::value('CIVICRM_BAO_CACHE_ADAPTER')) !== NULL) {
159 return $adapter::setItem($data, $group, $path, $componentID);
162 if (self
::$_cache === NULL) {
166 // get a lock so that multiple ajax requests on the same page
167 // dont trample on each other
169 $lock = Civi
::lockManager()->acquire("cache.{$group}_{$path}._{$componentID}");
170 if (!$lock->isAcquired()) {
171 throw new CRM_Core_Exception('Cannot acquire database lock');
174 $table = self
::getTableName();
175 $where = self
::whereCache($group, $path, $componentID);
176 $dataExists = CRM_Core_DAO
::singleValueQuery("SELECT COUNT(*) FROM $table WHERE {$where}");
177 // FIXME - Use SQL NOW() or CRM_Utils_Time?
178 $now = date('Y-m-d H:i:s');
179 $dataSerialized = self
::encode($data);
181 // This table has a wonky index, so we cannot use REPLACE or
182 // "INSERT ... ON DUPE". Instead, use SELECT+(INSERT|UPDATE).
184 $sql = "UPDATE $table SET data = %1, created_date = %2 WHERE {$where}";
186 1 => [$dataSerialized, 'String'],
187 2 => [$now, 'String'],
189 $dao = CRM_Core_DAO
::executeQuery($sql, $args, TRUE, NULL, FALSE, FALSE);
192 $insert = CRM_Utils_SQL_Insert
::into($table)
194 'group_name' => $group,
196 'component_id' => $componentID,
197 'data' => $dataSerialized,
198 'created_date' => $now,
200 $dao = CRM_Core_DAO
::executeQuery($insert->toSQL(), [], TRUE, NULL, FALSE, FALSE);
205 // cache coherency - refresh or remove dependent caches
207 $argString = "CRM_CT_{$group}_{$path}_{$componentID}";
208 $cache = CRM_Utils_Cache
::singleton();
209 $data = self
::decode($dataSerialized);
210 self
::$_cache[$argString] = $data;
211 $cache->set(self
::cleanKey($argString), $data);
213 $argString = "CRM_CT_CI_{$group}_{$componentID}";
214 unset(self
::$_cache[$argString]);
215 $cache->delete(self
::cleanKey($argString));
219 * Delete all the cache elements that belong to a group OR delete the entire cache if group is not specified.
221 * @param string $group
222 * The group name of the entries to be deleted.
223 * @param string $path
224 * Path of the item that needs to be deleted.
225 * @param bool $clearAll clear all caches
228 public static function deleteGroup($group = NULL, $path = NULL, $clearAll = TRUE) {
229 CRM_Core_Error
::deprecatedFunctionWarning(
230 'CRM_Core_BAO_Cache::deleteGroup is deprecated and will be removed from core soon, use Civi::cache() facade or define cache group using hook_civicrm_container'
232 if (($adapter = CRM_Utils_Constant
::value('CIVICRM_BAO_CACHE_ADAPTER')) !== NULL) {
233 return $adapter::deleteGroup($group, $path);
236 $table = self
::getTableName();
237 $where = self
::whereCache($group, $path, NULL);
238 CRM_Core_DAO
::executeQuery("DELETE FROM $table WHERE $where");
247 * Cleanup ACL and System Level caches
249 public static function resetCaches() {
250 // also reset ACL Cache
251 // @todo why is this called when CRM_Utils_System::flushCache() does it as well.
252 CRM_ACL_BAO_Cache
::resetCache();
254 // also reset memory cache if any
255 CRM_Utils_System
::flushCache();
259 * The next two functions are internal functions used to store and retrieve session from
260 * the database cache. This keeps the session to a limited size and allows us to
261 * create separate session scopes for each form in a tab
265 * This function takes entries from the session array and stores it in the cache.
267 * It also deletes the entries from the $_SESSION object (for a smaller session size)
269 * @param array $names
270 * Array of session values that should be persisted.
271 * This is either a form name + qfKey or just a form name
272 * (in the case of profile)
273 * @param bool $resetSession
274 * Should session state be reset on completion of DB store?.
276 public static function storeSessionToCache($names, $resetSession = TRUE) {
277 foreach ($names as $key => $sessionName) {
278 if (is_array($sessionName)) {
280 if (!empty($_SESSION[$sessionName[0]][$sessionName[1]])) {
281 $value = $_SESSION[$sessionName[0]][$sessionName[1]];
283 $key = "{$sessionName[0]}_{$sessionName[1]}";
284 Civi
::cache('session')->set($key, $value, self
::pickSessionTtl($key));
286 $_SESSION[$sessionName[0]][$sessionName[1]] = NULL;
287 unset($_SESSION[$sessionName[0]][$sessionName[1]]);
292 if (!empty($_SESSION[$sessionName])) {
293 $value = $_SESSION[$sessionName];
295 Civi
::cache('session')->set($sessionName, $value, self
::pickSessionTtl($sessionName));
297 $_SESSION[$sessionName] = NULL;
298 unset($_SESSION[$sessionName]);
306 /* Retrieve the session values from the cache and populate the $_SESSION array
308 * @param array $names
309 * Array of session values that should be persisted.
310 * This is either a form name + qfKey or just a form name
311 * (in the case of profile)
315 * Restore session from cache.
317 * @param string $names
319 public static function restoreSessionFromCache($names) {
320 foreach ($names as $key => $sessionName) {
321 if (is_array($sessionName)) {
322 $value = Civi
::cache('session')->get("{$sessionName[0]}_{$sessionName[1]}");
324 $_SESSION[$sessionName[0]][$sessionName[1]] = $value;
328 $value = Civi
::cache('session')->get($sessionName);
330 $_SESSION[$sessionName] = $value;
337 * Determine how long session-state should be retained.
339 * @param string $sessionKey
340 * Ex: '_CRM_Admin_Form_Preferences_Display_f1a5f232e3d850a29a7a4d4079d7c37b_4654_container'
341 * Ex: 'CiviCRM_CRM_Admin_Form_Preferences_Display_f1a5f232e3d850a29a7a4d4079d7c37b_4654'
345 protected static function pickSessionTtl($sessionKey) {
346 $secureSessionTimeoutMinutes = (int) Civi
::settings()->get('secure_cache_timeout_minutes');
347 if ($secureSessionTimeoutMinutes) {
348 $transactionPages = [
349 'CRM_Contribute_Controller_Contribution',
350 'CRM_Event_Controller_Registration',
352 foreach ($transactionPages as $transactionPage) {
353 if (strpos($sessionKey, $transactionPage) !== FALSE) {
354 return $secureSessionTimeoutMinutes * 60;
359 return self
::DEFAULT_SESSION_TTL
;
363 * Do periodic cleanup of the CiviCRM session table.
365 * Also delete all session cache entries which are a couple of days old.
366 * This keeps the session cache to a manageable size
367 * Delete Contribution page session caches more energetically.
369 * @param bool $session
371 * @param bool $prevNext
372 * @param bool $expired
374 public static function cleanup($session = FALSE, $table = FALSE, $prevNext = FALSE, $expired = FALSE) {
375 // clean up the session cache every $cacheCleanUpNumber probabilistically
376 $cleanUpNumber = 757;
378 // clean up all sessions older than $cacheTimeIntervalDays days
379 $timeIntervalDays = 2;
381 if (mt_rand(1, 100000) %
$cleanUpNumber == 0) {
382 $expired = $session = $table = $prevNext = TRUE;
385 if (!$session && !$table && !$prevNext && !$expired) {
390 // delete all PrevNext caches
391 Civi
::service('prevnext')->cleanup();
395 CRM_Core_Config
::clearTempTables($timeIntervalDays . ' day');
399 // Session caches are just regular caches, so they expire naturally per TTL.
404 $sql = "DELETE FROM civicrm_cache WHERE expired_date < %1";
406 1 => [date(CRM_Utils_Cache_SqlGroup
::TS_FMT
, CRM_Utils_Time
::getTimeRaw()), 'String'],
408 CRM_Core_DAO
::executeQuery($sql, $params);
413 * (Quasi-private) Encode an object/array/string/int as a string.
418 public static function encode($mixed) {
419 return base64_encode(serialize($mixed));
423 * (Quasi-private) Decode an object/array/string/int from a string.
428 public static function decode($string) {
429 // Upgrade support -- old records (serialize) always have this punctuation,
430 // and new records (base64) never do.
431 if (strpos($string, ':') !== FALSE ||
strpos($string, ';') !== FALSE) {
432 return unserialize($string);
435 return unserialize(base64_decode($string));
440 * Compose a SQL WHERE clause for the cache.
442 * Note: We need to use the cache during bootstrap, so we don't have
443 * full access to DAO services.
445 * @param string $group
446 * @param string|null $path
447 * Filter by path. If NULL, then return any paths.
448 * @param int|null $componentID
449 * Filter by component. If NULL, then look for explicitly NULL records.
452 protected static function whereCache($group, $path, $componentID) {
454 $clauses[] = ('group_name = "' . CRM_Core_DAO
::escapeString($group) . '"');
456 $clauses[] = ('path = "' . CRM_Core_DAO
::escapeString($path) . '"');
458 if ($componentID && is_numeric($componentID)) {
459 $clauses[] = ('component_id = ' . (int) $componentID);
461 return $clauses ?
implode(' AND ', $clauses) : '(1)';
465 * Normalize a cache key.
467 * This bridges an impedance mismatch between our traditional caching
468 * and PSR-16 -- PSR-16 accepts a narrower range of cache keys.
473 * Ex: '_abcd1234abcd1234' or 'ab_xx/cd_xxef'.
474 * A similar key, but suitable for use with PSR-16-compliant cache providers.
476 * @see CRM_Utils_Cache::cleanKey()
478 public static function cleanKey($key) {
479 return CRM_Utils_Cache
::cleanKey($key);