AlkantarClanX12
Your IP : 18.227.190.231
<?php
namespace W3TC;
/**
* PECL Memcache class
* Older than Memcached
*/
class Cache_Memcache extends Cache_Base {
/**
* Memcache object
*
* @var Memcache
*/
private $_memcache = null;
/*
* Used for faster flushing
*
* @var integer $_key_version
*/
private $_key_version = array();
/**
* constructor
*
* @param array $config
*/
function __construct( $config ) {
parent::__construct( $config );
$this->_memcache = new \Memcache();
if ( !empty( $config['servers'] ) ) {
$persistent = isset( $config['persistent'] ) ? (boolean) $config['persistent'] : false;
foreach ( (array) $config['servers'] as $server ) {
list( $ip, $port ) = Util_Content::endpoint_to_host_port( $server );
$this->_memcache->addServer( $ip, $port, $persistent );
}
} else {
return false;
}
// when disabled - no extra requests are made to obtain key version,
// but flush operations not supported as a result
// group should be always empty
if ( isset( $config['key_version_mode'] ) &&
$config['key_version_mode'] == 'disabled' ) {
$this->_key_version[''] = 1;
}
return true;
}
/**
* Adds data
*
* @param string $key
* @param mixed $var
* @param integer $expire
* @param string $group Used to differentiate between groups of cache values
* @return boolean
*/
function add( $key, &$var, $expire = 0, $group = '' ) {
return $this->set( $key, $var, $expire, $group );
}
/**
* Sets data
*
* @param string $key
* @param mixed $var
* @param integer $expire
* @param string $group Used to differentiate between groups of cache values
* @return boolean
*/
function set( $key, $var, $expire = 0, $group = '' ) {
if ( ! isset( $var['key_version'] ) ) {
$var['key_version'] = $this->_get_key_version( $group );
}
$storage_key = $this->get_item_key( $key );
return @$this->_memcache->set( $storage_key, $var, false, $expire );
}
/**
* Returns data
*
* @param string $key
* @param string $group Used to differentiate between groups of cache values
* @return mixed
*/
function get_with_old( $key, $group = '' ) {
$has_old_data = false;
$storage_key = $this->get_item_key( $key );
$v = @$this->_memcache->get( $storage_key );
if ( !is_array( $v ) || !isset( $v['key_version'] ) )
return array( null, $has_old_data );
$key_version = $this->_get_key_version( $group );
if ( $v['key_version'] == $key_version )
return array( $v, $has_old_data );
if ( $v['key_version'] > $key_version ) {
if ( ! empty( $v['key_version_at_creation'] ) && $v['key_version_at_creation'] !== $key_version ) {
$this->_set_key_version( $v['key_version'], $group );
}
return array( $v, $has_old_data );
}
// key version is old
if ( !$this->_use_expired_data )
return array( null, $has_old_data );
// if we have expired data - update it for future use and let
// current process recalculate it
$expires_at = isset( $v['expires_at'] ) ? $v['expires_at'] : null;
if ( $expires_at == null || time() > $expires_at ) {
$v['expires_at'] = time() + 30;
@$this->_memcache->set( $storage_key, $v, false, 0 );
$has_old_data = true;
return array( null, $has_old_data );
}
// return old version
return array( $v, $has_old_data );
}
/**
* Replaces data
*
* @param string $key
* @param mixed $var
* @param integer $expire
* @param string $group Used to differentiate between groups of cache values
* @return boolean
*/
function replace( $key, &$var, $expire = 0, $group = '' ) {
return $this->set( $key, $var, $expire, $group );
}
/**
* Deletes data
*
* @param string $key
* @param string $group
* @return boolean
*/
function delete( $key, $group = '' ) {
$storage_key = $this->get_item_key( $key );
if ( $this->_use_expired_data ) {
$v = @$this->_memcache->get( $storage_key );
if ( is_array( $v ) ) {
$v['key_version'] = 0;
@$this->_memcache->set( $storage_key, $v, false, 0 );
return true;
}
}
return @$this->_memcache->delete( $storage_key, 0 );
}
/**
* Key to delete, deletes _old and primary if exists.
*
* @param unknown $key
* @return bool
*/
function hard_delete( $key, $group = '' ) {
$storage_key = $this->get_item_key( $key );
return @$this->_memcache->delete( $storage_key, 0 );
}
/**
* Flushes all data
*
* @param string $group Used to differentiate between groups of cache values
* @return boolean
*/
function flush( $group = '' ) {
$this->_increment_key_version( $group );
return true;
}
/**
* Gets a key extension for "ahead generation" mode.
* Used by AlwaysCached functionality to regenerate content
*
* @param string $group Used to differentiate between groups of cache values.
*
* @return array
*/
public function get_ahead_generation_extension( $group ) {
$v = $this->_get_key_version( $group );
return array(
'key_version' => $v + 1,
'key_version_at_creation' => $v,
);
}
/**
* Flushes group with before condition
*
* @param string $group Used to differentiate between groups of cache values.
* @param array $extension Used to set a condition what version to flush.
*
* @return void
*/
public function flush_group_after_ahead_generation( $group, $extension ) {
$v = $this->_get_key_version( $group );
if ( $extension['key_version'] > $v ) {
$this->_set_key_version( $extension['key_version'], $group );
}
}
/**
* Checks if engine can function properly in this environment
*
* @return bool
*/
public function available() {
return class_exists( 'Memcache' );
}
public function get_statistics() {
return $this->_memcache->getStats();
}
/**
* Returns key version
*
* @param string $group Used to differentiate between groups of cache values
* @return integer
*/
private function _get_key_version( $group = '' ) {
if ( !isset( $this->_key_version[$group] ) || $this->_key_version[$group] <= 0 ) {
$v = @$this->_memcache->get( $this->_get_key_version_key( $group ) );
$v = intval( $v );
$this->_key_version[$group] = ( $v > 0 ? $v : 1 );
}
return $this->_key_version[$group];
}
/**
* Sets new key version
*
* @param unknown $v
* @param string $group Used to differentiate between groups of cache values
* @return boolean
*/
private function _set_key_version( $v, $group = '' ) {
// expiration has to be as long as possible since
// all cache data expires when key version expires
@$this->_memcache->set( $this->_get_key_version_key( $group ), $v, false, 0 );
$this->_key_version[$group] = $v;
}
/**
* Increments key version.
*
* @since 0.14.5
*
* @param string $group Used to differentiate between groups of cache values.
*/
private function _increment_key_version( $group = '' ) {
$r = @$this->_memcache->increment( $this->_get_key_version_key( $group ), 1 );
if ( $r ) {
$this->_key_version[$group] = $r;
} else {
// it doesn't initialize the key if it doesn't exist.
$this->_set_key_version( 2, $group );
}
}
/**
* Returns size used by cache
*/
public function get_stats_size( $timeout_time ) {
$size = array(
'bytes' => 0,
'items' => 0,
'timeout_occurred' => false
);
$key_prefix = $this->get_item_key( '' );
$slabs = @$this->_memcache->getExtendedStats( 'slabs' );
$slabs_plain = array();
if ( is_array( $slabs ) ) {
foreach ( $slabs as $server => $server_slabs ) {
foreach ( $server_slabs as $slab_id => $slab_meta ) {
if ( (int)$slab_id > 0 )
$slabs_plain[(int)$slab_id] = '*';
}
}
}
foreach ( $slabs_plain as $slab_id => $nothing ) {
$cdump = @$this->_memcache->getExtendedStats( 'cachedump',
(int)$slab_id );
if ( !is_array( $cdump ) )
continue;
foreach ( $cdump as $server => $keys_data ) {
if ( !is_array( $keys_data ) )
continue;
foreach ( $keys_data as $key => $size_expiration ) {
if ( substr( $key, 0, strlen( $key_prefix ) ) == $key_prefix ) {
if ( count( $size_expiration ) > 0 ) {
$size['bytes'] += $size_expiration[0];
$size['items']++;
}
}
}
}
}
return $size;
}
/**
* Used to replace as atomically as possible known value to new one
*/
public function set_if_maybe_equals( $key, $old_value, $new_value ) {
// cant guarantee atomic action here, memcache doesnt support CAS
$value = $this->get( $key );
if ( isset( $old_value['content'] ) &&
$value['content'] != $old_value['content'] )
return false;
return $this->set( $key, $new_value );
}
/**
* Use key as a counter and add integet value to it
*/
public function counter_add( $key, $value ) {
if ( $value == 0 )
return true;
$storage_key = $this->get_item_key( $key );
$r = @$this->_memcache->increment( $storage_key, $value );
if ( !$r ) // it doesnt initialize counter by itself
$this->counter_set( $key, 0 );
return $r;
}
/**
* Use key as a counter and add integet value to it
*/
public function counter_set( $key, $value ) {
$storage_key = $this->get_item_key( $key );
return @$this->_memcache->set( $storage_key, $value );
}
/**
* Get counter's value
*/
public function counter_get( $key ) {
$storage_key = $this->get_item_key( $key );
$v = (int)@$this->_memcache->get( $storage_key );
return $v;
}
public function get_item_key( $name ) {
// memcached doesn't survive spaces in a key
$key = sprintf( 'w3tc_%d_%s_%d_%s_%s',
$this->_instance_id, $this->_host, $this->_blog_id,
$this->_module, md5( $name ) );
return $key;
}
}