Merge remote-tracking branch 'origin/2.3-develop' into MC-15406

Author: zakdma

app/code/Magento/Config/App/Config/Type/System.php

@@ -3,6 +3,7 @@
  * Copyright © Magento, Inc. All rights reserved.
  * See COPYING.txt for license details.
  */
+
 namespace Magento\Config\App\Config\Type;
 
 use Magento\Framework\App\Config\ConfigSourceInterface;
@@ -13,18 +14,20 @@
 use Magento\Config\App\Config\Type\System\Reader;
 use Magento\Framework\App\ScopeInterface;
 use Magento\Framework\Cache\FrontendInterface;
+use Magento\Framework\Cache\LockGuardedCacheLoader;
 use Magento\Framework\Lock\LockManagerInterface;
 use Magento\Framework\Serialize\SerializerInterface;
 use Magento\Store\Model\Config\Processor\Fallback;
-use Magento\Store\Model\ScopeInterface as StoreScope;
 use Magento\Framework\Encryption\Encryptor;
+use Magento\Store\Model\ScopeInterface as StoreScope;
 
 /**
  * System configuration type
  *
  * @api
  * @since 100.1.2
  * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
+ * @SuppressWarnings(PHPMD.UnusedPrivateMethod)
  */
 class System implements ConfigTypeInterface
 {
@@ -42,22 +45,6 @@ class System implements ConfigTypeInterface
      * @var string
      */
     private static $lockName = 'SYSTEM_CONFIG';
-    /**
-     * Timeout between retrieves to load the configuration from the cache.
-     *
-     * Value of the variable in microseconds.
-     *
-     * @var int
-     */
-    private static $delayTimeout = 100000;
-    /**
-     * Lifetime of the lock for write in cache.
-     *
-     * Value of the variable in seconds.
-     *
-     * @var int
-     */
-    private static $lockTimeout = 42;
 
     /**
      * @var array
@@ -106,9 +93,9 @@ class System implements ConfigTypeInterface
     private $encryptor;
 
     /**
-     * @var LockManagerInterface
+     * @var LockGuardedCacheLoader
      */
-    private $locker;
+    private $lockQuery;
 
     /**
      * @param ConfigSourceInterface $source
@@ -122,6 +109,7 @@ class System implements ConfigTypeInterface
      * @param Reader|null $reader
      * @param Encryptor|null $encryptor
      * @param LockManagerInterface|null $locker
+     * @param LockGuardedCacheLoader|null $lockQuery
      * @SuppressWarnings(PHPMD.UnusedFormalParameter)
      * @SuppressWarnings(PHPMD.ExcessiveParameterList)
      */
@@ -136,7 +124,8 @@ public function __construct(
         $configType = self::CONFIG_TYPE,
         Reader $reader = null,
         Encryptor $encryptor = null,
-        LockManagerInterface $locker = null
+        LockManagerInterface $locker = null,
+        LockGuardedCacheLoader $lockQuery = null
     ) {
         $this->postProcessor = $postProcessor;
         $this->cache = $cache;
@@ -145,8 +134,8 @@ public function __construct(
         $this->reader = $reader ?: ObjectManager::getInstance()->get(Reader::class);
         $this->encryptor = $encryptor
             ?: ObjectManager::getInstance()->get(Encryptor::class);
-        $this->locker = $locker
-            ?: ObjectManager::getInstance()->get(LockManagerInterface::class);
+        $this->lockQuery = $lockQuery
+            ?: ObjectManager::getInstance()->get(LockGuardedCacheLoader::class);
     }
 
     /**
@@ -225,91 +214,64 @@ private function getWithParts($path)
     }
 
     /**
-     * Make lock on data load.
-     *
-     * @param callable $dataLoader
-     * @param bool $flush
-     * @return array
-     */
-    private function lockedLoadData(callable $dataLoader, bool $flush = false): array
-    {
-        $cachedData = $dataLoader(); //optimistic read
-
-        while ($cachedData === false && $this->locker->isLocked(self::$lockName)) {
-            usleep(self::$delayTimeout);
-            $cachedData = $dataLoader();
-        }
-
-        while ($cachedData === false) {
-            try {
-                if ($this->locker->lock(self::$lockName, self::$lockTimeout)) {
-                    if (!$flush) {
-                        $data = $this->readData();
-                        $this->cacheData($data);
-                        $cachedData = $data;
-                    } else {
-                        $this->cache->clean(\Zend_Cache::CLEANING_MODE_MATCHING_TAG, [self::CACHE_TAG]);
-                        $cachedData = [];
-                    }
-                }
-            } finally {
-                $this->locker->unlock(self::$lockName);
-            }
-
-            if ($cachedData === false) {
-                usleep(self::$delayTimeout);
-                $cachedData = $dataLoader();
-            }
-        }
-
-        return $cachedData;
-    }
-
-    /**
-     * Load configuration data for all scopes
+     * Load configuration data for all scopes.
      *
      * @return array
      */
     private function loadAllData()
     {
-        return $this->lockedLoadData(function () {
+        $loadAction = function () {
             $cachedData = $this->cache->load($this->configType);
             $data = false;
             if ($cachedData !== false) {
                 $data = $this->serializer->unserialize($this->encryptor->decrypt($cachedData));
             }
             return $data;
-        });
+        };
+
+        return $this->lockQuery->lockedLoadData(
+            self::$lockName,
+            $loadAction,
+            \Closure::fromCallable([$this, 'readData']),
+            \Closure::fromCallable([$this, 'cacheData'])
+        );
     }
 
     /**
-     * Load configuration data for default scope
+     * Load configuration data for default scope.
      *
      * @param string $scopeType
      * @return array
      */
     private function loadDefaultScopeData($scopeType)
     {
-        return $this->lockedLoadData(function () use ($scopeType) {
+        $loadAction = function () use ($scopeType) {
             $cachedData = $this->cache->load($this->configType . '_' . $scopeType);
             $scopeData = false;
             if ($cachedData !== false) {
                 $scopeData = [$scopeType => $this->serializer->unserialize($this->encryptor->decrypt($cachedData))];
             }
             return $scopeData;
-        });
+        };
+
+        return $this->lockQuery->lockedLoadData(
+            self::$lockName,
+            $loadAction,
+            \Closure::fromCallable([$this, 'readData']),
+            \Closure::fromCallable([$this, 'cacheData'])
+        );
     }
 
     /**
-     * Load configuration data for a specified scope
+     * Load configuration data for a specified scope.
      *
      * @param string $scopeType
      * @param string $scopeId
      * @return array
      */
     private function loadScopeData($scopeType, $scopeId)
     {
-        return $this->lockedLoadData(function () use ($scopeType, $scopeId) {
+        $loadAction = function () use ($scopeType, $scopeId) {
             $cachedData = $this->cache->load($this->configType . '_' . $scopeType . '_' . $scopeId);
             $scopeData = false;
             if ($cachedData === false) {
@@ -329,7 +291,14 @@ private function loadScopeData($scopeType, $scopeId)
             }
 
             return $scopeData;
-        });
+        };
+
+        return $this->lockQuery->lockedLoadData(
+            self::$lockName,
+            $loadAction,
+            \Closure::fromCallable([$this, 'readData']),
+            \Closure::fromCallable([$this, 'cacheData'])
+        );
     }
 
     /**
@@ -371,7 +340,7 @@ private function cacheData(array $data)
     }
 
     /**
-     * Walk nested hash map by keys from $pathParts
+     * Walk nested hash map by keys from $pathParts.
      *
      * @param array $data to walk in
      * @param array $pathParts keys path
@@ -408,7 +377,7 @@ private function readData(): array
     }
 
     /**
-     * Clean cache and global variables cache
+     * Clean cache and global variables cache.
      *
      * Next items cleared:
      * - Internal property intended to store already loaded configuration data
@@ -420,11 +389,13 @@ private function readData(): array
     public function clean()
     {
         $this->data = [];
-        $this->lockedLoadData(
-            function () {
-                return false;
-            },
-            true
+        $cleanAction = function () {
+            $this->cache->clean(\Zend_Cache::CLEANING_MODE_MATCHING_TAG, [self::CACHE_TAG]);
+        };
+
+        $this->lockQuery->lockedCleanData(
+            self::$lockName,
+            $cleanAction
         );
     }
 }

app/code/Magento/Config/etc/di.xml

@@ -90,9 +90,18 @@
             <argument name="preProcessor" xsi:type="object">Magento\Framework\App\Config\PreProcessorComposite</argument>
             <argument name="serializer" xsi:type="object">Magento\Framework\Serialize\Serializer\Serialize</argument>
             <argument name="reader" xsi:type="object">Magento\Config\App\Config\Type\System\Reader\Proxy</argument>
-            <argument name="locker" xsi:type="object">Magento\Framework\Lock\Backend\Cache</argument>
+            <argument name="lockQuery" xsi:type="object">systemConfigQueryLocker</argument>
         </arguments>
     </type>
+
+    <virtualType name="systemConfigQueryLocker" type="Magento\Framework\Cache\LockGuardedCacheLoader">
+        <arguments>
+            <argument name="locker" xsi:type="object">Magento\Framework\Lock\Backend\Cache</argument>
+            <argument name="lockTimeout" xsi:type="number">42000</argument>
+            <argument name="delayTimeout" xsi:type="number">100</argument>
+        </arguments>
+    </virtualType>
+
     <type name="Magento\Config\App\Config\Type\System\Reader">
         <arguments>
             <argument name="source" xsi:type="object">systemConfigSourceAggregated</argument>

app/code/Magento/Deploy/Console/DeployStaticOptions.php

@@ -6,6 +6,7 @@
 
 namespace Magento\Deploy\Console;
 
+use Magento\Deploy\Process\Queue;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Input\InputArgument;
 
@@ -57,6 +58,11 @@ class DeployStaticOptions
      */
     const JOBS_AMOUNT = 'jobs';
 
+    /**
+     * Key for max execution time option
+     */
+    const MAX_EXECUTION_TIME = 'max-execution-time';
+
     /**
      * Force run of static deploy
      */
@@ -150,6 +156,7 @@ public function getOptionsList()
      * Basic options
      *
      * @return array
+     * @SuppressWarnings(PHPMD.ExcessiveMethodLength)
      */
     private function getBasicOptions()
     {
@@ -216,6 +223,13 @@ private function getBasicOptions()
                 'Enable parallel processing using the specified number of jobs.',
                 self::DEFAULT_JOBS_AMOUNT
             ),
+            new InputOption(
+                self::MAX_EXECUTION_TIME,
+                null,
+                InputOption::VALUE_OPTIONAL,
+                'The maximum expected execution time of deployment static process (in seconds).',
+                Queue::DEFAULT_MAX_EXEC_TIME
+            ),
             new InputOption(
                 self::SYMLINK_LOCALE,
                 null,

app/code/Magento/Deploy/Service/DeployStaticContent.php

@@ -85,24 +85,26 @@ public function deploy(array $options)
             return;
         }
 
-        $queue = $this->queueFactory->create(
-            [
-                'logger' => $this->logger,
-                'options' => $options,
-                'maxProcesses' => $this->getProcessesAmount($options),
-                'deployPackageService' => $this->objectManager->create(
-                    \Magento\Deploy\Service\DeployPackage::class,
-                    [
-                        'logger' => $this->logger
-                    ]
-                )
-            ]
-        );
+        $queueOptions = [
+            'logger' => $this->logger,
+            'options' => $options,
+            'maxProcesses' => $this->getProcessesAmount($options),
+            'deployPackageService' => $this->objectManager->create(
+                \Magento\Deploy\Service\DeployPackage::class,
+                [
+                    'logger' => $this->logger
+                ]
+            )
+        ];
+
+        if (isset($options[Options::MAX_EXECUTION_TIME])) {
+            $queueOptions['maxExecTime'] = (int)$options[Options::MAX_EXECUTION_TIME];
+        }
 
         $deployStrategy = $this->deployStrategyFactory->create(
             $options[Options::STRATEGY],
             [
-                'queue' => $queue
+                'queue' => $this->queueFactory->create($queueOptions)
             ]
         );
 
@@ -133,6 +135,8 @@ public function deploy(array $options)
     }
 
     /**
+     * Returns amount of parallel processes, returns zero if option wasn't set.
+     *
      * @param array $options
      * @return int
      */
@@ -142,6 +146,8 @@ private function getProcessesAmount(array $options)
     }
 
     /**
+     * Checks if need to refresh only version.
+     *
      * @param array $options
      * @return bool
      */