MC-33275: Stale cache implementation

Author: vzabaznov

lib/internal/Magento/Framework/Cache/Backend/RemoteSynchronizedCache.php

@@ -6,6 +6,9 @@
 
 namespace Magento\Framework\Cache\Backend;
 
+use Magento\Framework\App\ObjectManager;
+use Magento\Framework\Lock\LockManagerInterface;
+
 /**
  * Remote synchronized cache
  *
@@ -42,6 +45,11 @@ class RemoteSynchronizedCache extends \Zend_Cache_Backend implements \Zend_Cache
      */
     private const HASH_SUFFIX = ':hash';
 
+    /**
+     * @var LockManagerInterface
+     */
+    private $lockManager;
+
     /**
      * @inheritdoc
      */
@@ -101,6 +109,8 @@ public function __construct(array $options = [])
                 );
             }
         }
+
+        $this->lockManager = ObjectManager::getInstance()->get(LockManagerInterface::class);
     }
 
     /**

lib/internal/Magento/Framework/Cache/Frontend/Adapter/InMemoryCache.php

@@ -6,7 +6,9 @@
 
 namespace Magento\Framework\Cache;
 
+use Magento\Framework\App\ObjectManager;
 use Magento\Framework\Lock\LockManagerInterface;
+use Magento\Framework\App\DeploymentConfig;
 
 /**
  * Default mutex that provide concurrent access to cache storage.
@@ -55,24 +57,47 @@ class LockGuardedCacheLoader
     private $minimalDelayTimeout;
 
     /**
+     * @var DeploymentConfig
+     */
+    private $deploymentConfig;
+
+    /**
+     * Option that allows to switch off blocking for parallel generation.
+     *
+     * @var string
+     */
+    private const CONFIG_PATH_ALLOW_BLOCKING_GENERATION = 'cache/allow_parallel_generation';
+
+    /**
+     * Config value of parallel generation.
+     *
+     * @var bool
+     */
+    private $allowParallelGenerationConfigValue;
+
+    /**
+     * LockGuardedCacheLoader constructor.
      * @param LockManagerInterface $locker
      * @param int $lockTimeout
      * @param int $delayTimeout
      * @param int $loadTimeout
      * @param int $minimalDelayTimeout
+     * @param DeploymentConfig|null $deploymentConfig
      */
     public function __construct(
         LockManagerInterface $locker,
         int $lockTimeout = 10000,
         int $delayTimeout = 20,
         int $loadTimeout = 10000,
-        int $minimalDelayTimeout = 5
+        int $minimalDelayTimeout = 5,
+        DeploymentConfig $deploymentConfig = null
     ) {
         $this->locker = $locker;
         $this->lockTimeout = $lockTimeout;
         $this->delayTimeout = $delayTimeout;
         $this->loadTimeout = $loadTimeout;
         $this->minimalDelayTimeout = $minimalDelayTimeout;
+        $this->deploymentConfig = $deploymentConfig ?? ObjectManager::getInstance()->get(DeploymentConfig::class);
     }
 
     /**
@@ -93,6 +118,12 @@ public function lockedLoadData(
         $cachedData = $dataLoader(); //optimistic read
         $deadline = microtime(true) + $this->loadTimeout / 100;
 
+        if (empty($this->allowParallelGenerationConfigValue)) {
+            $this->allowParallelGenerationConfigValue = $this
+                ->deploymentConfig
+                ->getConfigData([self::CONFIG_PATH_ALLOW_BLOCKING_GENERATION]);
+        }
+
         while ($cachedData === false) {
             if ($deadline <= microtime(true)) {
                 return $dataCollector();
@@ -106,6 +137,8 @@ public function lockedLoadData(
                 } finally {
                     $this->locker->unlock($lockName);
                 }
+            } elseif ($this->allowParallelGenerationConfigValue === true) {
+                return $dataCollector();
             }
 
             if ($cachedData === false) {

lib/internal/Magento/Framework/Cache/LockGuardedCacheLoader.php

@@ -1107,51 +1107,35 @@ protected function _loadCache()
             }
 
             $this->_beforeToHtml();
-            $data = $this->_toHtml();
+            return $this->_toHtml();
+        };
 
+        if ($this->getCacheLifetime() === null || !$this->_cacheState->isEnabled(self::CACHE_GROUP)) {
+            $html = $collectAction();
             if ($this->hasData('translate_inline')) {
                 $this->inlineTranslation->resume();
             }
-
-            return $data;
-        };
-
-        if ($this->getCacheLifetime() === null || !$this->_cacheState->isEnabled(self::CACHE_GROUP)) {
-            return $collectAction();
+            return $html;
         }
-
         $loadAction = function () {
             return $this->_cache->load($this->getCacheKey());
         };
 
         $saveAction = function ($data) {
             $this->_saveCache($data);
-            return $data;
+            if ($this->hasData('translate_inline')) {
+                $this->inlineTranslation->resume();
+            }
         };
 
-        return (string)$this->lockQuery->nonBlockingLockedLoadData(
-            $this->shortenLockName($this->getCacheKey()),
+        return (string)$this->lockQuery->lockedLoadData(
+            $this->getCacheKey(),
             $loadAction,
             $collectAction,
             $saveAction
         );
     }
 
-    /**
-     * Shortens lock name in case plugin increased cache key size out of sha1 length
-     *
-     * @param string $cacheKey
-     * @return string
-     */
-    private function shortenLockName(string $cacheKey)
-    {
-        if (strlen(self::CACHE_KEY_PREFIX) + 40 < strlen($cacheKey)) {
-            return self::CACHE_KEY_PREFIX . sha1($cacheKey);
-        }
-
-        return $cacheKey;
-    }
-
     /**
      * Save block content to cache storage
      *

lib/internal/Magento/Framework/View/Element/AbstractBlock.php

@@ -39,6 +39,8 @@ class Cache implements ConfigOptionsListInterface
     const CONFIG_PATH_CACHE_BACKEND_COMPRESS_DATA = 'cache/frontend/default/backend_options/compress_data';
     const CONFIG_PATH_CACHE_BACKEND_COMPRESSION_LIB = 'cache/frontend/default/backend_options/compression_lib';
     const CONFIG_PATH_CACHE_ID_PREFIX = 'cache/frontend/default/id_prefix';
+    const CONFIG_PATH_ALLOW_BLOCKING_GENERATION = 'cache/allow_parallel_generation';
+
 
     /**
      * @var array
@@ -165,6 +167,8 @@ public function createConfig(array $options, DeploymentConfig $deploymentConfig)
             }
         }
 
+        $configData->set(self::CONFIG_PATH_ALLOW_BLOCKING_GENERATION, false);
+
         foreach ($this->inputKeyToConfigPathMap as $inputKey => $configPath) {
             if (isset($options[$inputKey])) {
                 $configData->set($configPath, $options[$inputKey]);