vBulletin 5.6.5 API

vB_Cache
in package
Uses vB_Trait_NoSerialize

Cache Handler that caches and retrieves data.

Tags
tutorial

// Application init $cache = vB_Cache::create('vB', 'Memcache');

// Read existing cache entry and lock for rebuild if it's expired $write_lock = true; if(!($data = $cache::read('hello_world', $write_lock))) { // rebuild the cache entry $data = 'Bonjour Tout Le Monde!';

if ($write_lock)
{
	// write cache, last for 50 minutes and purge on event 'widget55.update'
	$cache->write('hello_world', $data, 50, "widget{$widgetid}.update");
}

}

// Use data echo($data);

// Meanwhile... when widget 55 is updated, expire stale cache objects $cache->event("widget{$widgetid}.update");

The cache handler also provides slam prevention. Cache slams occur when a cache entry expires and multiple connections attempt to rebuild it.

see
vB_Cache::lock()

The code received a fairly significant rewrite in early 2013. Previously the cache information was stored in an object, and there was a separate observer object which tracked events and cleared cache. The cache object is now an array, and the observer methods have all been collapsed into the cache object. This got rid of a lot of code and unnecessary processing.

Table of Contents

CACHE_FAST  = 1
CACHE_LARGE  = 2
CACHE_LOG_CLEAR  = 6
CACHE_LOG_HASVALUE  = 4
CACHE_LOG_NOVALUE  = 5
CACHE_LOG_READFAIL  = 3
CACHE_LOG_READSUCCESS  = 2
CACHE_LOG_WRITE  = 1
CACHE_STD  = 0
$actions  : mixed
$cacheLogging  : mixed
$cachetype  : string
Cache type of current object.
$disableCache  : mixed
$instance  : vB_Cache
A reference to the singleton instance
$keys_used  : mixed
$meta_info  : mixed
$meta_loaded  : mixed
$metadata_life  : mixed
$metadata_update_min  : mixed
$no_values  : mixed
$noCache  : mixed
$prefix  : string
Unique prefix for item's title, required for multiple forums on the same server using the same classes that read/write to memory
$timeNow  : mixed
The current time - this is used a lot so let's make it a member variable.
$values_read  : mixed
__serialize()  : mixed
__sleep()  : mixed
__unserialize()  : mixed
__wakeup()  : mixed
allCacheEvent()  : mixed
clean()  : mixed
Cleans cache.
cleanNow()  : mixed
Tells the cache to trigger all events.
event()  : mixed
Expires cache objects based on a triggered event.
expire()  : mixed
Expires a cache object.
getContextKey()  : vB_Context
Get a context key
getDefaults()  : mixed
Get the cache defaults.
instance()  : vB_Cache
Returns an instance of the global cache.
isLoaded()  : bool
has a value been loaded for this key?
lock()  : bool
Locks a cache entry.
purge()  : mixed
Purges a cache object.
read()  : array<string|int, mixed>
Reads an array of cache objects from storage.
readSingle()  : mixed
Reads a cache object and returns the data.
resetAllCache()  : mixed
resetCache()  : mixed
restoreCacheInfo()  : mixed
If we used saveCacheInfo to save data, this will get it back.
saveCacheInfo()  : mixed
Based on the assumption that if we go back to a page we're likely to request a lot of the information we requested last time we were on that page, let's store the cached information.
shutdown()  : mixed
unlock()  : mixed
Unlocks a cache entry.
updateTime()  : mixed
This updates the time. It is useful only for testing. Otherwise it does nothing
write()  : string
Writes data as a cache object.
__construct()  : mixed
Constructor protected to enforce singleton use.
expireCache()  : bool
Sets a cache entry as expired in storage.
getSize()  : mixed
logCacheAction()  : mixed
If cache logging is enabled this stores the page cache activity to be loggged.
logCacheActivity()  : mixed
If cache logging is enabled this function writes the activity for this page to the database.
purgeCache()  : mixed
Removes a cache object from storage.
readCache()  : array<string|int, mixed>
Reads the cache object from storage.
writeCache()  : mixed
Writes the cache data to storage.

Constants

CACHE_FAST

public mixed CACHE_FAST = 1

CACHE_LARGE

public mixed CACHE_LARGE = 2

CACHE_LOG_CLEAR

public mixed CACHE_LOG_CLEAR = 6

CACHE_LOG_HASVALUE

public mixed CACHE_LOG_HASVALUE = 4

CACHE_LOG_NOVALUE

public mixed CACHE_LOG_NOVALUE = 5

CACHE_LOG_READFAIL

public mixed CACHE_LOG_READFAIL = 3

CACHE_LOG_READSUCCESS

public mixed CACHE_LOG_READSUCCESS = 2

CACHE_LOG_WRITE

public mixed CACHE_LOG_WRITE = 1

CACHE_STD

public mixed CACHE_STD = ""

Properties

$actions

protected static mixed $actions = array(self::CACHE_STD => array(), self::CACHE_FAST => array(), self::CACHE_LARGE => array(), 4 => array())

$cacheLogging

protected static mixed $cacheLogging = alse

$cachetype

Cache type of current object.

protected string $cachetype

$disableCache

protected static mixed $disableCache = alse

$instance

A reference to the singleton instance

protected static vB_Cache $instance = array()

$keys_used

protected mixed $keys_used

$meta_info

protected mixed $meta_info = alse

$meta_loaded

protected mixed $meta_loaded = alse

$metadata_life

protected mixed $metadata_life = 1440

$metadata_update_min

protected mixed $metadata_update_min = 5

$no_values

protected mixed $no_values = array()

$noCache

protected mixed $noCache = alse

$prefix

Unique prefix for item's title, required for multiple forums on the same server using the same classes that read/write to memory

protected string $prefix = ''

$timeNow

The current time - this is used a lot so let's make it a member variable.

protected mixed $timeNow

$values_read

protected mixed $values_read = array()

Methods

__serialize()

public __serialize() : mixed
Return values
mixed

__sleep()

public __sleep() : mixed
Return values
mixed

__unserialize()

public __unserialize(mixed $serialized) : mixed
Parameters
$serialized : mixed
Return values
mixed

__wakeup()

public __wakeup() : mixed
Return values
mixed

allCacheEvent()

public static allCacheEvent(mixed $events) : mixed
Parameters
$events : mixed
Return values
mixed

clean()

Cleans cache.

public abstract clean([bool $only_expired = true ]) : mixed

$created_before should be a unix timestamp.

Parameters
$only_expired : bool = true
  • Only clean expired entries
Tags
todo

Provide more options

Return values
mixed

cleanNow()

Tells the cache to trigger all events.

public cleanNow() : mixed
Return values
mixed

event()

Expires cache objects based on a triggered event.

public abstract event(mixed $events) : mixed
Parameters
$events : mixed
Return values
mixed

expire()

Expires a cache object.

public expire(mixed $cache_ids) : mixed

This is preferred to purging a cache entry as it ensures that that the cache data can still be served while new cache data is being rebuilt.

Parameters
$cache_ids : mixed
Return values
mixed

getContextKey()

Get a context key

public getContextKey(string $prefix, array<string|int, mixed> $values) : vB_Context

This is intended to generate a cache key from complex information, particularly arrays which affect the generation of the cached data. The end result will is not guarenteed to be particular readable (and most likely isn't) but it should be unique to that combination of params.

Parameters
$prefix : string

-- Human readable string to prefix the cachekey. intended to help debugging by allowing inspection to understand where that key came from.

$values : array<string|int, mixed>

-- array/value pairs to encode into the key. Order doesn't matter since they will be sorted on key generation.

Return values
vB_Context

getDefaults()

Get the cache defaults.

public static getDefaults() : mixed
Return values
mixed

instance()

Returns an instance of the global cache.

public static instance([mixed $type = self::CACHE_STD ]) : vB_Cache

The cache type used is defined in options.

Parameters
$type : mixed = self::CACHE_STD
Return values
vB_Cache
  • Reference to instance of the cache handler

isLoaded()

has a value been loaded for this key?

public isLoaded(mixed $key) : bool
Parameters
$key : mixed
Return values
bool

lock()

Locks a cache entry.

public lock(mixed $keys) : bool

This is done to prevent a cache slam where concurrent connections attempt to rebuild an expired cache entry. While a cache entry is locked, it should be considered valid and served to all connections except the one that has the lock. After the cache entry has been rebuilt it will be unlocked, allowing all new connections to consume the fresh entry.

Parameters
$keys : mixed
Return values
bool
  • TRUE iff the lock was obtained

purge()

Purges a cache object.

public purge(mixed $cacheid) : mixed
Parameters
$cacheid : mixed
Return values
mixed

read()

Reads an array of cache objects from storage.

public read(string $keys[, mixed $writeLock = false ][, mixed $save_meta = false ]) : array<string|int, mixed>
Parameters
$keys : string
  • Ids of the cache entry to read
$writeLock : mixed = false
$save_meta : mixed = false
Return values
array<string|int, mixed>

of array includes key, data, expires

readSingle()

Reads a cache object and returns the data.

public readSingle(mixed $key[, bool &$write_lock = false ][, mixed $save_meta = false ]) : mixed

Integrity checking should be performed by the client code, ensuring that the returned data is in the expected form.

$key should be a string key with all of the identifying information for the required cache objects. This must match the $key used to write the cache object.

The implicit lock can be set to true to indicate that the client code will rebuild the cache on an expired read. This allows cache handlers to lock the cache for the current connection. Normally, if a cache entry is locked then subsequent reads should return the expired cache data until it is unlocked. This cannot be done for cache entries that don't yet exist, but can be used on existing entries to prevent cache slams - where multiple connections decide to rebuild the cache under a race condition.

Cache handlers should ensure to implement an expiration on cache locks.

Parameters
$key : mixed
  • Identifying key. String or array of strings
$write_lock : bool = false
  • Whether a failed read implies a lock for writing
$save_meta : mixed = false
Tags
see
cache::Write()
Return values
mixed
  • The cached data (string or array of strings) or boolean false

resetAllCache()

public static resetAllCache([mixed $expiredOnly = false ]) : mixed
Parameters
$expiredOnly : mixed = false
Return values
mixed

resetCache()

public static resetCache([mixed $expiredOnly = false ]) : mixed
Parameters
$expiredOnly : mixed = false
Return values
mixed

restoreCacheInfo()

If we used saveCacheInfo to save data, this will get it back.

public restoreCacheInfo(mixed $cacheid) : mixed
Parameters
$cacheid : mixed
Return values
mixed

saveCacheInfo()

Based on the assumption that if we go back to a page we're likely to request a lot of the information we requested last time we were on that page, let's store the cached information.

public saveCacheInfo(mixed $cacheid) : mixed
Parameters
$cacheid : mixed
Return values
mixed

shutdown()

public shutdown() : mixed
Return values
mixed

unlock()

Unlocks a cache entry.

public unlock(mixed $keys) : mixed

Most implementations may unlock the cache during write, making this redundant.

Parameters
$keys : mixed
Return values
mixed

updateTime()

This updates the time. It is useful only for testing. Otherwise it does nothing

public updateTime([mixed $time = false ]) : mixed
@param	integer		timestamp- optional
Parameters
$time : mixed = false
Return values
mixed

write()

Writes data as a cache object.

public write(string $key, mixed $data[, mixed $lifetime_mins = false ][, mixed $events = false ]) : string

A string key is required to uniquely identify a cache object. Client code should add all information that would affect the individualisation of the cache object to the key.

If lifetime_mins is supplied the cache object will be purged the next time it is read after the TTL has passed.

If a cache object should be purged on triggered events then events should be supplied as an array of string id's of the form 'scope.event', for example 'widget55.updated' may be used to purge a cache of a defined widget with the id 55 when it is reconfigured.

Parameters
$key : string
  • Identifying key
$data : mixed
  • Data to cache
$lifetime_mins : mixed = false
$events : mixed = false
Return values
string

| bool - Cache id or false

__construct()

Constructor protected to enforce singleton use.

protected __construct(mixed $cachetype) : mixed
Parameters
$cachetype : mixed
Tags
see
instance()
Return values
mixed

expireCache()

Sets a cache entry as expired in storage.

protected abstract expireCache(int $cache_id) : bool
Parameters
$cache_id : int
  • Id of the cache entry to expire
Return values
bool

getSize()

protected getSize(mixed $data) : mixed
Parameters
$data : mixed
Return values
mixed

logCacheAction()

If cache logging is enabled this stores the page cache activity to be loggged.

protected static logCacheAction(mixed $cacheid, mixed $action[, mixed $type = 4 ], mixed $size) : mixed
Parameters
$cacheid : mixed
$action : mixed
$type : mixed = 4
$size : mixed
Return values
mixed

logCacheActivity()

If cache logging is enabled this function writes the activity for this page to the database.

protected logCacheActivity() : mixed
Return values
mixed

purgeCache()

Removes a cache object from storage.

protected abstract purgeCache(int $cache_id) : mixed
Parameters
$cache_id : int
  • Id of the cache entry to purge
Return values
mixed

readCache()

Reads the cache object from storage.

protected abstract readCache(string $key) : array<string|int, mixed>
Parameters
$key : string
  • Identifying key
Return values
array<string|int, mixed>

includes key, data, expires

writeCache()

Writes the cache data to storage.

protected abstract writeCache(mixed $cache) : mixed
Parameters
$cache : mixed
Return values
mixed

Search results