diff --git a/core/lib/Drupal/Core/Cache/ChainedFastBackend.php b/core/lib/Drupal/Core/Cache/ChainedFastBackend.php index 051f38d..fd05fef 100644 --- a/core/lib/Drupal/Core/Cache/ChainedFastBackend.php +++ b/core/lib/Drupal/Core/Cache/ChainedFastBackend.php @@ -58,6 +58,13 @@ class ChainedFastBackend implements CacheBackendInterface, CacheTagsInvalidatorI const LAST_WRITE_TIMESTAMP_PREFIX = 'last_write_timestamp_'; /** + * Identifier for the current webhead/process + * + * @var string + */ + protected $headId; + + /** * @var string */ protected $bin; @@ -77,6 +84,13 @@ class ChainedFastBackend implements CacheBackendInterface, CacheTagsInvalidatorI protected $fastBackend; /** + * Last time this binary has been marked as outdated. + * + * @var int + */ + protected $last_invalidation = NULL; + + /** * The time at which the last write to this cache bin happened. * * @var float @@ -84,6 +98,23 @@ class ChainedFastBackend implements CacheBackendInterface, CacheTagsInvalidatorI protected $lastWriteTimestamp; /** + * Generate or retrieve a key that identifies + * the instance of the fastBackend. + * + * @return string + */ + protected function GetHeadId() { + if ($cache = $this->fastBackend->get('headid')) { + return $cache->data; + } + + // Generate a unique ID for this fast backend. + $id = uniqid(microtime(TRUE), TRUE); + $this->fastBackend->set('headid', $id); + return $id; + } + + /** * Constructs a ChainedFastBackend object. * * @param \Drupal\Core\Cache\CacheBackendInterface $consistent_backend @@ -96,6 +127,7 @@ class ChainedFastBackend implements CacheBackendInterface, CacheTagsInvalidatorI public function __construct(CacheBackendInterface $consistent_backend, CacheBackendInterface $fast_backend, $bin) { $this->consistentBackend = $consistent_backend; $this->fastBackend = $fast_backend; + $this->headId = $this->GetHeadId(); $this->bin = 'cache_' . $bin; $this->lastWriteTimestamp = NULL; } @@ -167,12 +199,12 @@ public function getMultiple(&$cids, $allow_invalid = FALSE) { // backend, retrieve them from the consistent backend and store them in the // fast one. if ($cids) { + $missing = array(); foreach ($this->consistentBackend->getMultiple($cids, $allow_invalid) as $item) { $cache[$item->cid] = $item; - // Don't write the cache tags to the fast backend as any cache tag - // invalidation results in an invalidation of the whole fast backend. - $this->fastBackend->set($item->cid, $item->data, $item->expire); + $missing[$item->cid] = (array) $item; } + $this->fastBackend->setMultiple($missing); } return $cache; @@ -183,10 +215,8 @@ public function getMultiple(&$cids, $allow_invalid = FALSE) { */ public function set($cid, $data, $expire = Cache::PERMANENT, array $tags = array()) { $this->consistentBackend->set($cid, $data, $expire, $tags); + $this->fastBackend->set($cid, $data, $expire, $tags); $this->markAsOutdated(); - // Don't write the cache tags to the fast backend as any cache tag - // invalidation results in an invalidation of the whole fast backend. - $this->fastBackend->set($cid, $data, $expire); } /** @@ -194,13 +224,8 @@ public function set($cid, $data, $expire = Cache::PERMANENT, array $tags = array */ public function setMultiple(array $items) { $this->consistentBackend->setMultiple($items); - $this->markAsOutdated(); - // Don't write the cache tags to the fast backend as any cache tag - // invalidation results in an invalidation of the whole fast backend. - foreach ($items as &$item) { - unset($item['tags']); - } $this->fastBackend->setMultiple($items); + $this->markAsOutdated(); } /** @@ -208,6 +233,7 @@ public function setMultiple(array $items) { */ public function delete($cid) { $this->consistentBackend->deleteMultiple(array($cid)); + $this->fastBackend->deleteMultiple(array($cid)); $this->markAsOutdated(); } @@ -216,6 +242,7 @@ public function delete($cid) { */ public function deleteMultiple(array $cids) { $this->consistentBackend->deleteMultiple($cids); + $this->fastBackend->deleteMultiple($cids); $this->markAsOutdated(); } @@ -224,6 +251,7 @@ public function deleteMultiple(array $cids) { */ public function deleteAll() { $this->consistentBackend->deleteAll(); + $this->fastBackend->deleteAll(); $this->markAsOutdated(); } @@ -239,6 +267,7 @@ public function invalidate($cid) { */ public function invalidateMultiple(array $cids) { $this->consistentBackend->invalidateMultiple($cids); + $this->fastBackend->invalidateMultiple($cids); $this->markAsOutdated(); } @@ -249,6 +278,9 @@ public function invalidateTags(array $tags) { if ($this->consistentBackend instanceof CacheTagsInvalidatorInterface) { $this->consistentBackend->invalidateTags($tags); } + if ($this->fastBackend instanceof CacheTagsInvalidatorInterface) { + $this->fastBackend->invalidateTags($tags); + } $this->markAsOutdated(); } @@ -257,6 +289,7 @@ public function invalidateTags(array $tags) { */ public function invalidateAll() { $this->consistentBackend->invalidateAll(); + $this->fastBackend->invalidateAll(); $this->markAsOutdated(); } @@ -289,7 +322,16 @@ public function reset() { protected function getLastWriteTimestamp() { if ($this->lastWriteTimestamp === NULL) { $cache = $this->consistentBackend->get(self::LAST_WRITE_TIMESTAMP_PREFIX . $this->bin); - $this->lastWriteTimestamp = $cache ? $cache->data : 0; + if ($cache && is_array($cache->data) && $cache->data['head'] != $this->headId) { + $this->lastWriteTimestamp = $cache->data['timestamp']; + } + else { + // If we are here this means that either the binary has never been invalidated, + // or that the last invalidation was actually made by ourselves so we retain + // the previous invalidation timestamp that we had. + $cache = $this->fastBackend->get(self::LAST_WRITE_TIMESTAMP_PREFIX . $this->bin); + $this->lastWriteTimestamp = $cache ? $cache->data : 0; + } } return $this->lastWriteTimestamp; } @@ -307,9 +349,21 @@ protected function markAsOutdated() { // costs one additional roundtrip to the persistent cache. $now = round(microtime(TRUE) + .001, 3); if ($now > $this->getLastWriteTimestamp()) { - $this->lastWriteTimestamp = $now; - $this->consistentBackend->set(self::LAST_WRITE_TIMESTAMP_PREFIX . $this->bin, $this->lastWriteTimestamp); + // Invalidate when the object is destroyed. + // $this->last_invalidation = $now; + $this->fastBackend->set(self::LAST_WRITE_TIMESTAMP_PREFIX . $this->bin, $this->lastWriteTimestamp); + $this->consistentBackend->set(self::LAST_WRITE_TIMESTAMP_PREFIX . $this->bin, array('head' => $this->headId, 'timestamp' => $now)); } } + /** + * Shutdown functions. + */ + //function __destruct() { + // if (!empty($this->last_invalidation)) { + // $this->fastBackend->set(self::LAST_WRITE_TIMESTAMP_PREFIX . $this->bin, $this->lastWriteTimestamp); + // $this->consistentBackend->set(self::LAST_WRITE_TIMESTAMP_PREFIX . $this->bin, array('head' => $this->headId, 'timestamp' => $this->last_invalidation)); + // } + //} + } diff --git a/core/tests/Drupal/Tests/Core/Cache/ChainedFastBackendTest.php b/core/tests/Drupal/Tests/Core/Cache/ChainedFastBackendTest.php index 11e1600..26dd2b3 100644 --- a/core/tests/Drupal/Tests/Core/Cache/ChainedFastBackendTest.php +++ b/core/tests/Drupal/Tests/Core/Cache/ChainedFastBackendTest.php @@ -44,8 +44,10 @@ class ChainedFastBackendTest extends UnitTestCase { public function testGetDoesntHitConsistentBackend() { $consistent_cache = $this->getMock('Drupal\Core\Cache\CacheBackendInterface'); $timestamp_cid = ChainedFastBackend::LAST_WRITE_TIMESTAMP_PREFIX . 'cache_foo'; - // Use the request time because that is what we will be comparing against. - $timestamp_item = (object) array('cid' => $timestamp_cid, 'data' => (int) $_SERVER['REQUEST_TIME'] - 60); + $headid = uniqid(microtime(TRUE), TRUE); + // Using a future time to make sure that proper head detection is being enforced. If it is this head + // invalidating the binary, the value from the fastCache should be considered instead. + $timestamp_item = (object) array('cid' => $timestamp_cid, 'data' => array('timestamp' => (int) $_SERVER['REQUEST_TIME'] + 60, 'head' => $headid)); $consistent_cache->expects($this->once()) ->method('get')->with($timestamp_cid) ->will($this->returnValue($timestamp_item)); @@ -54,6 +56,8 @@ public function testGetDoesntHitConsistentBackend() { $fast_cache = new MemoryBackend('foo'); $fast_cache->set('foo', 'baz'); + $fast_cache->set($timestamp_cid, (int) $_SERVER['REQUEST_TIME'] - 60); + $fast_cache->set('headid', $headid); $chained_fast_backend = new ChainedFastBackend( $consistent_cache, @@ -67,10 +71,19 @@ public function testGetDoesntHitConsistentBackend() { * Tests a fast cache miss gets data from the consistent cache backend. */ public function testFallThroughToConsistentCache() { + $headid = uniqid(microtime(TRUE), TRUE); $timestamp_item = (object) array( 'cid' => ChainedFastBackend::LAST_WRITE_TIMESTAMP_PREFIX . 'cache_foo', - 'data' => time() + 60, // Time travel is easy. + 'data' => array('timestamp' => time() + 60, 'head' => $headid) ); + $timestamp_item_fast = (object) array( + 'cid' => ChainedFastBackend::LAST_WRITE_TIMESTAMP_PREFIX . 'cache_foo', + 'data' => time() + 60, + ); + $head_item = (object) array( + 'cid' => 'headid', + 'data' => $headid + ); $cache_item = (object) array( 'cid' => 'foo', 'data' => 'baz', @@ -94,16 +107,24 @@ public function testFallThroughToConsistentCache() { ->with(array($cache_item->cid)) ->will($this->returnValue(array($cache_item->cid => $cache_item))); + // Cache miss for headid + $fast_cache->expects($this->at(0)) + ->method('get') + ->with('headid') + ->will($this->returnValue($head_item)); + + // Retrieve the timestamp. + $fast_cache->expects($this->at(1)) + ->method('get') + ->with($timestamp_item_fast->cid) + ->will($this->returnValue($timestamp_item_fast)); + // We should get a call for the cache item on the fast backend. $fast_cache->expects($this->once()) ->method('getMultiple') ->with(array($cache_item->cid)) ->will($this->returnValue(array($cache_item->cid => $cache_item))); - // We should get a call to set the cache item on the fast backend. - $fast_cache->expects($this->once()) - ->method('set') - ->with($cache_item->cid, $cache_item->data, $cache_item->expire); $chained_fast_backend = new ChainedFastBackend( $consistent_cache, @@ -112,5 +133,4 @@ public function testFallThroughToConsistentCache() { ); $this->assertEquals('baz', $chained_fast_backend->get('foo')->data); } - }