ExtensionManagementService.php

Go to the documentation of this file.

<?php
namespace ‪TYPO3\CMS\Extensionmanager\Service;
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Extbase\Object\ObjectManager;
use ‪TYPO3\CMS\Extbase\SignalSlot\Dispatcher;
use ‪TYPO3\CMS\Extensionmanager\Domain\Model\Extension;
 
class ‪ExtensionManagementService implements ‪\TYPO3\CMS\Core\SingletonInterface
{
    protected ‪$downloadQueue;
 
    protected ‪$dependencyUtility;
 
    protected ‪$installUtility;
 
    protected ‪$extensionModelUtility;
 
    protected ‪$downloadUtility;
 
    protected ‪$automaticInstallationEnabled = true;
 
    protected ‪$skipDependencyCheck = false;
 
    public function ‪injectDownloadQueue(\‪TYPO3\CMS\Extensionmanager\Domain\Model\DownloadQueue ‪$downloadQueue)
    {
        $this->downloadQueue = ‪$downloadQueue;
    }
 
    public function ‪injectDependencyUtility(\‪TYPO3\CMS\Extensionmanager\Utility\DependencyUtility ‪$dependencyUtility)
    {
        $this->dependencyUtility = ‪$dependencyUtility;
    }
 
    public function ‪injectInstallUtility(\‪TYPO3\CMS\Extensionmanager\Utility\InstallUtility ‪$installUtility)
    {
        $this->installUtility = ‪$installUtility;
    }
 
    public function ‪injectExtensionModelUtility(\‪TYPO3\CMS\Extensionmanager\Utility\ExtensionModelUtility ‪$extensionModelUtility)
    {
        $this->extensionModelUtility = ‪$extensionModelUtility;
    }
 
    public function ‪injectDownloadUtility(\‪TYPO3\CMS\Extensionmanager\Utility\DownloadUtility ‪$downloadUtility)
    {
        $this->downloadUtility = ‪$downloadUtility;
    }
 
    public function ‪markExtensionForInstallation($extensionKey)
    {
        // We have to check for dependencies of the extension first, before marking it for installation
        // because this extension might have dependencies, which need to be installed first
        $this->installUtility->reloadAvailableExtensions();
        $extension = $this->‪getExtension($extensionKey);
        $this->dependencyUtility->checkDependencies($extension);
        $this->downloadQueue->addExtensionToInstallQueue($extension);
    }
 
    public function ‪markExtensionForCopy($extensionKey, $sourceFolder)
    {
        $this->downloadQueue->addExtensionToCopyQueue($extensionKey, $sourceFolder);
    }
 
    public function ‪markExtensionForDownload(‪Extension $extension)
    {
        // We have to check for dependencies of the extension first, before marking it for download
        // because this extension might have dependencies, which need to be downloaded and installed first
        $this->dependencyUtility->checkDependencies($extension);
        if (!$this->dependencyUtility->hasDependencyErrors()) {
            $this->downloadQueue->addExtensionToQueue($extension);
        }
    }
 
    public function ‪markExtensionForUpdate(Extension $extension)
    {
        // We have to check for dependencies of the extension first, before marking it for download
        // because this extension might have dependencies, which need to be downloaded and installed first
        $this->dependencyUtility->checkDependencies($extension);
        $this->downloadQueue->addExtensionToQueue($extension, 'update');
    }
 
    public function ‪setSkipDependencyCheck(‪$skipDependencyCheck)
    {
        $this->skipDependencyCheck = ‪$skipDependencyCheck;
    }
 
    public function ‪setAutomaticInstallationEnabled(‪$automaticInstallationEnabled)
    {
        $this->automaticInstallationEnabled = (bool)‪$automaticInstallationEnabled;
    }
 
    public function ‪installExtension(‪Extension $extension)
    {
        $this->‪downloadExtension($extension);
        if (!$this->‪checkDependencies($extension)) {
            return false;
        }
 
        $downloadedDependencies = [];
        $updatedDependencies = [];
        $installQueue = [];
 
        // First resolve all dependencies and the sub-dependencies until all queues are empty as new extensions might be
        // added each time
        // Extensions have to be installed in reverse order. Extensions which were added at last are dependencies of
        // earlier ones and need to be available before
        while (!$this->downloadQueue->isCopyQueueEmpty()
            || !$this->downloadQueue->isQueueEmpty('download')
            || !$this->downloadQueue->isQueueEmpty('update')
        ) {
            // First copy all available extension
            // This might change other queues again
            $copyQueue = $this->downloadQueue->resetExtensionCopyStorage();
            if (!empty($copyQueue)) {
                $this->‪copyDependencies($copyQueue);
            }
            $installQueue = array_merge($this->downloadQueue->resetExtensionInstallStorage(), $installQueue);
            // Get download and update information
            $queue = $this->downloadQueue->resetExtensionQueue();
            if (!empty($queue['download'])) {
                $downloadedDependencies = array_merge($downloadedDependencies, $this->‪downloadDependencies($queue['download']));
            }
            $installQueue = array_merge($this->downloadQueue->resetExtensionInstallStorage(), $installQueue);
            if ($this->automaticInstallationEnabled) {
                if (!empty($queue['update'])) {
                    $this->‪downloadDependencies($queue['update']);
                    $updatedDependencies = array_merge($updatedDependencies, $this->‪uninstallDependenciesToBeUpdated($queue['update']));
                }
                $installQueue = array_merge($this->downloadQueue->resetExtensionInstallStorage(), $installQueue);
            }
        }
 
        // If there were any dependency errors we have to abort here
        if ($this->dependencyUtility->hasDependencyErrors()) {
            return false;
        }
 
        // Attach extension to install queue
        $this->downloadQueue->addExtensionToInstallQueue($extension);
        $installQueue += $this->downloadQueue->resetExtensionInstallStorage();
        $installedDependencies = [];
        if ($this->automaticInstallationEnabled) {
            $installedDependencies = $this->‪installDependencies($installQueue);
        }
 
        return array_merge($downloadedDependencies, $updatedDependencies, $installedDependencies);
    }
 
    public function ‪getDependencyErrors()
    {
        return $this->dependencyUtility->getDependencyErrors();
    }
 
    public function ‪getExtension($extensionKey)
    {
        return $this->extensionModelUtility->mapExtensionArrayToModel(
            $this->installUtility->enrichExtensionWithDetails($extensionKey)
        );
    }
 
    public function ‪isAvailable($extensionKey)
    {
        return $this->installUtility->isAvailable($extensionKey);
    }
 
    public function ‪reloadPackageInformation($extensionKey)
    {
        $this->installUtility->reloadPackageInformation($extensionKey);
    }
 
    protected function ‪downloadExtension(‪Extension $extension)
    {
        $this->‪downloadMainExtension($extension);
        $this->‪setInExtensionRepository($extension->‪getExtensionKey());
    }
 
    protected function ‪checkDependencies(‪Extension $extension)
    {
        $this->dependencyUtility->setSkipDependencyCheck($this->skipDependencyCheck);
        $this->dependencyUtility->checkDependencies($extension);
 
        return !$this->dependencyUtility->hasDependencyErrors();
    }
 
    protected function ‪setInExtensionRepository($extensionKey)
    {
        $paths = ‪Extension::returnInstallPaths();
        $path = $paths[$this->downloadUtility->getDownloadPath()];
        $localExtensionStorage = $path . $extensionKey . '/Initialisation/Extensions/';
        $this->dependencyUtility->setLocalExtensionStorage($localExtensionStorage);
    }
 
    protected function ‪copyDependencies(array $copyQueue)
    {
        $installPaths = ‪Extension::returnAllowedInstallPaths();
        foreach ($copyQueue as $extensionKey => $sourceFolder) {
            $destination = $installPaths['Local'] . $extensionKey;
            GeneralUtility::mkdir($destination);
            GeneralUtility::copyDirectory($sourceFolder . $extensionKey, $destination);
            $this->‪markExtensionForInstallation($extensionKey);
            $this->downloadQueue->removeExtensionFromCopyQueue($extensionKey);
        }
    }
 
    protected function ‪uninstallDependenciesToBeUpdated(array $updateQueue)
    {
        $resolvedDependencies = [];
        foreach ($updateQueue as $extensionToUpdate) {
            $this->installUtility->uninstall($extensionToUpdate->getExtensionKey());
            $resolvedDependencies['updated'][$extensionToUpdate->getExtensionKey()] = $extensionToUpdate;
        }
        return $resolvedDependencies;
    }
 
    protected function ‪installDependencies(array $installQueue)
    {
        if (empty($installQueue)) {
            return [];
        }
        $this->‪emitWillInstallExtensionsSignal($installQueue);
        $resolvedDependencies = [];
        $this->installUtility->install(...array_keys($installQueue));
        foreach ($installQueue as $extensionKey => $_) {
            $this->‪emitHasInstalledExtensionSignal($extensionKey);
            if (!isset($resolvedDependencies['installed']) || !is_array($resolvedDependencies['installed'])) {
                $resolvedDependencies['installed'] = [];
            }
            $resolvedDependencies['installed'][$extensionKey] = $extensionKey;
        }
        return $resolvedDependencies;
    }
 
    protected function ‪downloadDependencies(array ‪$downloadQueue)
    {
        $resolvedDependencies = [];
        foreach (‪$downloadQueue as $extensionToDownload) {
            $this->downloadUtility->download($extensionToDownload);
            $this->downloadQueue->removeExtensionFromQueue($extensionToDownload);
            $resolvedDependencies['downloaded'][$extensionToDownload->getExtensionKey()] = $extensionToDownload;
            $this->‪markExtensionForInstallation($extensionToDownload->getExtensionKey());
        }
        return $resolvedDependencies;
    }
 
    public function ‪getAndResolveDependencies(‪Extension $extension)
    {
        $this->dependencyUtility->setSkipDependencyCheck($this->skipDependencyCheck);
        $this->dependencyUtility->checkDependencies($extension);
        $installQueue = $this->downloadQueue->getExtensionInstallStorage();
        if (is_array($installQueue) && !empty($installQueue)) {
            $installQueue = ['install' => $installQueue];
        }
        return array_merge($this->downloadQueue->getExtensionQueue(), $installQueue);
    }
 
    public function ‪downloadMainExtension(‪Extension $extension)
    {
        // The extension object has a uid if the extension is not present in the system
        // or an update of a present extension is triggered.
        if ($extension->‪getUid()) {
            $this->downloadUtility->download($extension);
        }
    }
 
    protected function ‪emitWillInstallExtensionsSignal(array $installQueue)
    {
        $this->‪getSignalSlotDispatcher()->‪dispatch(__CLASS__, 'willInstallExtensions', [$installQueue]);
    }
 
    protected function ‪emitHasInstalledExtensionSignal($extensionKey)
    {
        $this->‪getSignalSlotDispatcher()->‪dispatch(__CLASS__, 'hasInstalledExtensions', [$extensionKey]);
    }
 
    protected function ‪getSignalSlotDispatcher()
    {
        if (!isset($this->signalSlotDispatcher)) {
            $this->signalSlotDispatcher = GeneralUtility::makeInstance(ObjectManager::class)
                ->get(Dispatcher::class);
        }
        return ‪$this->signalSlotDispatcher;
    }
}