PatchApplier.php

Go to the documentation of this file.

<?php
namespace Magento\Framework\Setup\Patch;

use Magento\Framework\App\ResourceConnection;
use Magento\Framework\Module\ModuleList;
use Magento\Framework\ObjectManagerInterface;
use Magento\Framework\Phrase;
use Magento\Framework\Setup\Exception;
use Magento\Framework\Setup\ModuleDataSetupInterface;

class PatchApplier
{
    const SCHEMA_PATCH = 'schema';

    const DATA_PATCH = 'data';

    private $patchRegistryFactory;

    private $dataPatchReader;

    private $schemaPatchReader;

    private $resourceConnection;

    private $patchHistory;

    private $patchFactory;

    private $schemaSetup;

    private $moduleDataSetup;

    private $objectManager;

    private $patchBackwardCompatability;

    private $moduleList;

    public function __construct(
        PatchReader $dataPatchReader,
        PatchReader $schemaPatchReader,
        PatchRegistryFactory $patchRegistryFactory,
        ResourceConnection $resourceConnection,
        PatchBackwardCompatability $patchBackwardCompatability,
        PatchHistory $patchHistory,
        PatchFactory $patchFactory,
        ObjectManagerInterface $objectManager,
        \Magento\Framework\Setup\SchemaSetupInterface $schemaSetup,
        \Magento\Framework\Setup\ModuleDataSetupInterface $moduleDataSetup,
        ModuleList $moduleList
    ) {
        $this->patchRegistryFactory = $patchRegistryFactory;
        $this->dataPatchReader = $dataPatchReader;
        $this->schemaPatchReader = $schemaPatchReader;
        $this->resourceConnection = $resourceConnection;
        $this->patchHistory = $patchHistory;
        $this->patchFactory = $patchFactory;
        $this->schemaSetup = $schemaSetup;
        $this->moduleDataSetup = $moduleDataSetup;
        $this->objectManager = $objectManager;
        $this->patchBackwardCompatability = $patchBackwardCompatability;
        $this->moduleList = $moduleList;
    }

    public function applyDataPatch($moduleName = null)
    {
        $registry = $this->prepareRegistry($moduleName, self::DATA_PATCH);
        foreach ($registry as $dataPatch) {
            if ($this->patchBackwardCompatability->isSkipableByDataSetupVersion($dataPatch, $moduleName)) {
                $this->patchHistory->fixPatch($dataPatch);
                continue;
            }

            $dataPatch = $this->objectManager->create(
                '\\' . $dataPatch,
                ['moduleDataSetup' => $this->moduleDataSetup]
            );
            if (!$dataPatch instanceof DataPatchInterface) {
                throw new Exception(
                    new Phrase("Patch %1 should implement DataPatchInterface", [get_class($dataPatch)])
                );
            }
            if ($dataPatch instanceof NonTransactionableInterface) {
                $dataPatch->apply();
                $this->patchHistory->fixPatch(get_class($dataPatch));
            } else {
                try {
                    $this->moduleDataSetup->getConnection()->beginTransaction();
                    $dataPatch->apply();
                    $this->patchHistory->fixPatch(get_class($dataPatch));
                    $this->moduleDataSetup->getConnection()->commit();
                } catch (\Exception $e) {
                    $this->moduleDataSetup->getConnection()->rollBack();
                    throw new Exception(new Phrase($e->getMessage()));
                } finally {
                    unset($dataPatch);
                }
            }
        }
    }

    private function prepareRegistry($moduleName, $patchType)
    {
        $reader = $patchType === self::DATA_PATCH ? $this->dataPatchReader : $this->schemaPatchReader;
        $registry = $this->patchRegistryFactory->create();

        //Prepare modules to read
        if ($moduleName === null) {
            $patchNames = [];
            foreach ($this->moduleList->getNames() as $moduleName) {
                $patchNames += $reader->read($moduleName);
            }
        } else {
            $patchNames = $reader->read($moduleName);
        }

        foreach ($patchNames as $patchName) {
            $registry->registerPatch($patchName);
        }

        return $registry;
    }

    public function applySchemaPatch($moduleName = null)
    {
        $registry = $this->prepareRegistry($moduleName, self::SCHEMA_PATCH);
        foreach ($registry as $schemaPatch) {
            try {
                if ($this->patchBackwardCompatability->isSkipableBySchemaSetupVersion($schemaPatch, $moduleName)) {
                    $this->patchHistory->fixPatch($schemaPatch);
                    continue;
                }
                $schemaPatch = $this->patchFactory->create($schemaPatch, ['schemaSetup' => $this->schemaSetup]);
                $schemaPatch->apply();
                $this->patchHistory->fixPatch(get_class($schemaPatch));
            } catch (\Exception $e) {
                throw new Exception(
                    new Phrase(
                        'Unable to apply patch %1 for module %2. Original exception message: %3',
                        [
                            get_class($schemaPatch),
                            $moduleName,
                            $e->getMessage()
                        ]
                    )
                );
            } finally {
                unset($schemaPatch);
            }
        }
    }

    public function revertDataPatches($moduleName = null)
    {
        $registry = $this->prepareRegistry($moduleName, self::DATA_PATCH);
        $adapter = $this->moduleDataSetup->getConnection();

        foreach ($registry->getReverseIterator() as $dataPatch) {
            $dataPatch = $this->objectManager->create(
                '\\' . $dataPatch,
                ['moduleDataSetup' => $this->moduleDataSetup]
            );
            if ($dataPatch instanceof PatchRevertableInterface) {
                try {
                    $adapter->beginTransaction();
                    $dataPatch->revert();
                    $this->patchHistory->revertPatchFromHistory(get_class($dataPatch));
                    $adapter->commit();
                } catch (\Exception $e) {
                    $adapter->rollBack();
                    throw new Exception(new Phrase($e->getMessage()));
                } finally {
                    unset($dataPatch);
                }
            }
        }
    }
}