PackageManager.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Core\Package;

/*                                                                        *
 * This script belongs to the TYPO3 Flow framework.                       *
 *                                                                        *
 * It is free software; you can redistribute it and/or modify it under    *
 * the terms of the GNU Lesser General Public License, either version 3   *
 * of the License, or (at your option) any later version.                 *
 *                                                                        *
 * The TYPO3 project - inspiring people to share!                         *
 *                                                                        */

use TYPO3\Flow\Annotations as Flow;

class PackageManager extends \TYPO3\Flow\Package\PackageManager implements \TYPO3\CMS\Core\SingletonInterface {

    protected $classLoader;

    protected $dependencyResolver;

    protected $bootstrap;

    protected $coreCache;

    protected $cacheIdentifier;

    protected $extAutoloadClassFiles;

    protected $packagesBasePaths = array();

    protected $packageAliasMap = array();

    protected $requiredPackageKeys = array();

    protected $runtimeActivatedPackages = array();

    protected $packagesBasePath = PATH_site;

    public function __construct() {
        // The order of paths is crucial for allowing overriding of system extension by local extensions.
        // Pay attention if you change order of the paths here.
        $this->packagesBasePaths = array(
            'local'     => PATH_typo3conf . 'ext',
            'global'    => PATH_typo3 . 'ext',
            'sysext'    => PATH_typo3 . 'sysext',
            'composer'  => PATH_site . 'Packages',
        );
        $this->packageStatesPathAndFilename = PATH_typo3conf . 'PackageStates.php';
        $this->packageFactory = new PackageFactory($this);
    }

    public function injectClassLoader(\TYPO3\CMS\Core\Core\ClassLoader $classLoader) {
        $this->classLoader = $classLoader;
    }

    public function injectCoreCache(\TYPO3\CMS\Core\Cache\Frontend\PhpFrontend $coreCache) {
        $this->coreCache = $coreCache;
    }

    public function injectDependencyResolver(DependencyResolver $dependencyResolver) {
        $this->dependencyResolver = $dependencyResolver;
    }

    public function initialize(\TYPO3\Flow\Core\Bootstrap $bootstrap) {
        $this->bootstrap = $bootstrap;

        $loadedFromCache = FALSE;
        try {
            $this->loadPackageManagerStatesFromCache();
            $loadedFromCache = TRUE;
        } catch (Exception\PackageManagerCacheUnavailableException $exception) {
            $this->loadPackageStates();
            $this->initializePackageObjects();
            $this->initializeCompatibilityLoadedExtArray();
        }

        //@deprecated since 6.2, don't use
        if (!defined('REQUIRED_EXTENSIONS')) {
            // List of extensions required to run the core
            define('REQUIRED_EXTENSIONS', implode(',', $this->requiredPackageKeys));
        }

        $cacheIdentifier = $this->getCacheIdentifier();
        if ($cacheIdentifier === NULL) {
            // Create an artificial cache identifier if the package states file is not available yet
            // in order that the class loader and class alias map can cache anyways.
            $cacheIdentifier = md5(implode('###', array_keys($this->activePackages)));
        }
        $this->classLoader->setCacheIdentifier($cacheIdentifier)->setPackages($this->activePackages);

        foreach ($this->activePackages as $package) {
            $package->boot($bootstrap);
        }

        if (!$loadedFromCache) {
            $this->saveToPackageCache();
        }
    }

    protected function getPackageFactory() {
        if (!isset($this->packageFactory)) {
            $this->packageFactory = new PackageFactory($this);
        }
        return $this->packageFactory;
    }

    protected function getCacheIdentifier() {
        if ($this->cacheIdentifier === NULL) {
            $mTime = @filemtime($this->packageStatesPathAndFilename);
            if ($mTime !== FALSE) {
                $this->cacheIdentifier = md5($this->packageStatesPathAndFilename . $mTime);
            } else {
                $this->cacheIdentifier = NULL;
            }
        }
        return $this->cacheIdentifier;
    }

    protected function getCacheEntryIdentifier() {
        $cacheIdentifier = $this->getCacheIdentifier();
        return $cacheIdentifier !== NULL ? 'PackageManager_' . $cacheIdentifier : NULL;
    }

    protected function saveToPackageCache() {
        $cacheEntryIdentifier = $this->getCacheEntryIdentifier();
        if ($cacheEntryIdentifier !== NULL && !$this->coreCache->has($cacheEntryIdentifier)) {
            // Package objects get their own cache entry, so PHP does not have to parse the serialized string
            $packageObjectsCacheEntryIdentifier = str_replace('.', '', uniqid('PackageObjects_', TRUE));
            // Build cache file
            $packageCache = array(
                'packageStatesConfiguration'  => $this->packageStatesConfiguration,
                'packageAliasMap' => $this->packageAliasMap,
                'packageKeys' => $this->packageKeys,
                'activePackageKeys' => array_keys($this->activePackages),
                'requiredPackageKeys' => $this->requiredPackageKeys,
                'loadedExtArray' => $GLOBALS['TYPO3_LOADED_EXT'],
                'packageObjectsCacheEntryIdentifier' => $packageObjectsCacheEntryIdentifier
            );
            $packageClassSources = array(
                'typo3\\flow\\package\\package' => NULL,
                'typo3\\cms\\core\\package\\package' => NULL,
            );
            foreach ($this->packages as $package) {
                $packageClassName = strtolower(get_class($package));
                if (!isset($packageClassSources[$packageClassName]) || $packageClassSources[$packageClassName] === NULL) {
                    $reflectionPackageClass = new \ReflectionClass($packageClassName);
                    $packageClassSource = file_get_contents($reflectionPackageClass->getFileName());
                    $packageClassSources[$packageClassName] = preg_replace('/<\?php|\?>/i', '', $packageClassSource);
                }
            }
            $this->coreCache->set($packageObjectsCacheEntryIdentifier, serialize($this->packages));
            $this->coreCache->set(
                $cacheEntryIdentifier,
                implode(PHP_EOL, $packageClassSources) . PHP_EOL .
                    'return ' . PHP_EOL . var_export($packageCache, TRUE) . ';'
            );
        }
    }

    protected function loadPackageManagerStatesFromCache() {
        $cacheEntryIdentifier = $this->getCacheEntryIdentifier();
        if ($cacheEntryIdentifier === NULL || !$this->coreCache->has($cacheEntryIdentifier) || !($packageCache = $this->coreCache->requireOnce($cacheEntryIdentifier))) {
            throw new Exception\PackageManagerCacheUnavailableException('The package state cache could not be loaded.', 1393883342);
        }
        $this->packageStatesConfiguration = $packageCache['packageStatesConfiguration'];
        $this->packageAliasMap = $packageCache['packageAliasMap'];
        $this->packageKeys = $packageCache['packageKeys'];
        $this->requiredPackageKeys = $packageCache['requiredPackageKeys'];
        $GLOBALS['TYPO3_LOADED_EXT'] = $packageCache['loadedExtArray'];
        $GLOBALS['TYPO3_currentPackageManager'] = $this;
        // Strip off PHP Tags from Php Cache Frontend
        $packageObjects = substr(substr($this->coreCache->get($packageCache['packageObjectsCacheEntryIdentifier']), 6), 0, -2);
        $this->packages = unserialize($packageObjects);
        foreach ($packageCache['activePackageKeys'] as $activePackageKey) {
            $this->activePackages[$activePackageKey] = $this->packages[$activePackageKey];
        }
        unset($GLOBALS['TYPO3_currentPackageManager']);
    }

    protected function loadPackageStates() {
        $this->packageStatesConfiguration = @include($this->packageStatesPathAndFilename) ?: array();
        if (!isset($this->packageStatesConfiguration['version']) || $this->packageStatesConfiguration['version'] < 4) {
            $this->packageStatesConfiguration = array();
        }
        if ($this->packageStatesConfiguration !== array()) {
            $this->registerPackagesFromConfiguration();
        } else {
            throw new Exception\PackageStatesUnavailableException('The PackageStates.php file is either corrupt or unavailable.', 1381507733);
        }
    }

    protected function initializePackageObjects() {
        $requiredPackages = array();
        foreach ($this->packages as $packageKey => $package) {
            $protected = $package->isProtected();
            if ($protected) {
                $requiredPackages[$packageKey] = $package;
            }
            if (isset($this->packageStatesConfiguration['packages'][$packageKey]['state']) && $this->packageStatesConfiguration['packages'][$packageKey]['state'] === 'active') {
                $this->activePackages[$packageKey] = $package;
            }
        }
        $previousActivePackage = $this->activePackages;
        $this->activePackages = array_merge($requiredPackages, $this->activePackages);
        $this->requiredPackageKeys = array_keys($requiredPackages);

        if ($this->activePackages != $previousActivePackage) {
            foreach ($this->requiredPackageKeys as $requiredPackageKey) {
                $this->packageStatesConfiguration['packages'][$requiredPackageKey]['state'] = 'active';
            }
            $this->sortAndSavePackageStates();
        }
    }

    protected function initializeCompatibilityLoadedExtArray() {
        $loadedExtObj = new \TYPO3\CMS\Core\Compatibility\LoadedExtensionsArray($this);
        $GLOBALS['TYPO3_LOADED_EXT'] = $loadedExtObj->toArray();
    }


    public function scanAvailablePackages() {
        $previousPackageStatesConfiguration = $this->packageStatesConfiguration;

        if (isset($this->packageStatesConfiguration['packages'])) {
            foreach ($this->packageStatesConfiguration['packages'] as $packageKey => $configuration) {
                if (!@file_exists($this->packagesBasePath . $configuration['packagePath'])) {
                    unset($this->packageStatesConfiguration['packages'][$packageKey]);
                }
            }
        } else {
            $this->packageStatesConfiguration['packages'] = array();
        }

        foreach ($this->packagesBasePaths as $key => $packagesBasePath) {
            if (!is_dir($packagesBasePath)) {
                unset($this->packagesBasePaths[$key]);
            }
        }

        $packagePaths = $this->scanLegacyExtensions();
        foreach ($this->packagesBasePaths as $packagesBasePath) {
            $this->scanPackagesInPath($packagesBasePath, $packagePaths);
        }

        foreach ($packagePaths as $composerManifestPath) {
            $packagePath = $composerManifestPath;
            $packagesBasePath = PATH_site;
            foreach ($this->packagesBasePaths as $basePath) {
                if (strpos($packagePath, $basePath) === 0) {
                    $packagesBasePath = $basePath;
                    break;
                }
            }
            try {
                $composerManifest = self::getComposerManifest($composerManifestPath);
                $packageKey = PackageFactory::getPackageKeyFromManifest($composerManifest, $packagePath, $packagesBasePath);
                $this->composerNameToPackageKeyMap[strtolower($composerManifest->name)] = $packageKey;
                $this->packageStatesConfiguration['packages'][$packageKey]['manifestPath'] = substr($composerManifestPath, strlen($packagePath)) ? : '';
                $this->packageStatesConfiguration['packages'][$packageKey]['composerName'] = $composerManifest->name;
            } catch (\TYPO3\Flow\Package\Exception\MissingPackageManifestException $exception) {
                $relativePackagePath = substr($packagePath, strlen($packagesBasePath));
                $packageKey = substr($relativePackagePath, strpos($relativePackagePath, '/') + 1, -1);
                if (!$this->isPackageKeyValid($packageKey)) {
                    continue;
                }
            } catch (\TYPO3\Flow\Package\Exception\InvalidPackageKeyException $exception) {
                continue;
            }
            if (!isset($this->packageStatesConfiguration['packages'][$packageKey]['state'])) {
                $this->packageStatesConfiguration['packages'][$packageKey]['state'] = 'inactive';
            }

            $this->packageStatesConfiguration['packages'][$packageKey]['packagePath'] = str_replace($this->packagesBasePath, '', $packagePath);

            // Change this to read the target from Composer or any other source
            $this->packageStatesConfiguration['packages'][$packageKey]['classesPath'] = Package::DIRECTORY_CLASSES;
        }

        $registerOnlyNewPackages = !empty($this->packages);
        $this->registerPackagesFromConfiguration($registerOnlyNewPackages);
        if ($this->packageStatesConfiguration != $previousPackageStatesConfiguration) {
            $this->sortAndsavePackageStates();
        }
    }

    protected function scanLegacyExtensions(&$collectedExtensionPaths = array()) {
        $legacyCmsPackageBasePathTypes = array('sysext', 'global', 'local');
        foreach ($this->packagesBasePaths as $type => $packageBasePath) {
            if (!in_array($type, $legacyCmsPackageBasePathTypes)) {
                continue;
            }
            foreach (new \DirectoryIterator($packageBasePath) as $fileInfo) {
                if (!$fileInfo->isDir()) {
                    continue;
                }
                $filename = $fileInfo->getFilename();
                if ($filename[0] !== '.') {
                    $currentPath = \TYPO3\Flow\Utility\Files::getUnixStylePath($fileInfo->getPathName()) . '/';
                    // Only add the extension if we have an EMCONF and the extension is not yet registered.
                    // This is crucial in order to allow overriding of system extension by local extensions
                    // and strongly depends on the order of paths defined in $this->packagesBasePaths.
                    if (file_exists($currentPath . 'ext_emconf.php') && !isset($collectedExtensionPaths[$filename])) {
                        $collectedExtensionPaths[$filename] = $currentPath;
                    }
                }
            }
        }
        return $collectedExtensionPaths;
    }

    protected function findComposerManifestPaths($packagePath) {
        // If an ext_emconf.php file is found, we don't need to look deeper
        if (file_exists($packagePath . '/ext_emconf.php')) {
            return array();
        }
        return parent::findComposerManifestPaths($packagePath);
    }

    protected function registerPackagesFromConfiguration($registerOnlyNewPackages = FALSE) {
        $packageStatesHasChanged = FALSE;
        foreach ($this->packageStatesConfiguration['packages'] as $packageKey => $stateConfiguration) {

            if ($registerOnlyNewPackages && $this->isPackageAvailable($packageKey)) {
                continue;
            }

            $packagePath = isset($stateConfiguration['packagePath']) ? $stateConfiguration['packagePath'] : NULL;
            $classesPath = isset($stateConfiguration['classesPath']) ? $stateConfiguration['classesPath'] : NULL;
            $manifestPath = isset($stateConfiguration['manifestPath']) ? $stateConfiguration['manifestPath'] : NULL;

            try {
                $package = $this->getPackageFactory()->create($this->packagesBasePath, $packagePath, $packageKey, $classesPath, $manifestPath);
            } catch (\TYPO3\Flow\Package\Exception\InvalidPackagePathException $exception) {
                $this->unregisterPackageByPackageKey($packageKey);
                $packageStatesHasChanged = TRUE;
                continue;
            } catch (\TYPO3\Flow\Package\Exception\InvalidPackageKeyException $exception) {
                $this->unregisterPackageByPackageKey($packageKey);
                $packageStatesHasChanged = TRUE;
                continue;
            }

            $this->registerPackage($package, FALSE);

            if (!$this->packages[$packageKey] instanceof \TYPO3\Flow\Package\PackageInterface) {
                throw new \TYPO3\Flow\Package\Exception\CorruptPackageException(sprintf('The package class in package "%s" does not implement PackageInterface.', $packageKey), 1300782488);
            }

            $this->packageKeys[strtolower($packageKey)] = $packageKey;
            if ($stateConfiguration['state'] === 'active') {
                $this->activePackages[$packageKey] = $this->packages[$packageKey];
            }
        }
        if ($packageStatesHasChanged) {
            $this->sortAndSavePackageStates();
        }
    }

    public function registerPackage(\TYPO3\Flow\Package\PackageInterface $package, $sortAndSave = TRUE) {
        $package = parent::registerPackage($package, $sortAndSave);
        if ($package instanceof PackageInterface) {
            foreach ($package->getPackageReplacementKeys() as $packageToReplace => $versionConstraint) {
                $this->packageAliasMap[strtolower($packageToReplace)] = $package->getPackageKey();
            }
        }
        return $package;
    }

    protected function unregisterPackageByPackageKey($packageKey) {
        try {
            $package = $this->getPackage($packageKey);
            if ($package instanceof PackageInterface) {
                foreach ($package->getPackageReplacementKeys() as $packageToReplace => $versionConstraint) {
                    unset($this->packageAliasMap[strtolower($packageToReplace)]);
                }
                $packageKey = $package->getPackageKey();
            }
        } catch (\TYPO3\Flow\Package\Exception\UnknownPackageException $e) {
        }
        unset($this->packages[$packageKey]);
        unset($this->packageKeys[strtolower($packageKey)]);
        unset($this->packageStatesConfiguration['packages'][$packageKey]);
    }

    public function getPackageKeyFromComposerName($composerName) {
        if (isset($this->packageAliasMap[$composerName])) {
            return $this->packageAliasMap[$composerName];
        }
        try {
            return parent::getPackageKeyFromComposerName($composerName);
        } catch (\TYPO3\Flow\Package\Exception\InvalidPackageStateException $exception) {
            return $composerName;
        }
    }

    public function getExtAutoloadRegistry() {
        if (!isset($this->extAutoloadClassFiles)) {
            $classRegistry = array();
            foreach ($this->activePackages as $packageKey => $packageData) {
                try {
                    $extensionAutoloadFile = \TYPO3\CMS\Core\Utility\ExtensionManagementUtility::extPath($packageKey, 'ext_autoload.php');
                    if (@file_exists($extensionAutoloadFile)) {
                        $classRegistry = array_merge($classRegistry, require $extensionAutoloadFile);
                    }
                } catch (\BadFunctionCallException $e) {
                }
            }
            $this->extAutoloadClassFiles = $classRegistry;
        }
        return $this->extAutoloadClassFiles;
    }

    public function getPackage($packageKey) {
        if (isset($this->packageAliasMap[$lowercasedPackageKey = strtolower($packageKey)])) {
            $packageKey = $this->packageAliasMap[$lowercasedPackageKey];
        }
        return parent::getPackage($packageKey);
    }

    public function isPackageAvailable($packageKey) {
        if (isset($this->packageAliasMap[$lowercasedPackageKey = strtolower($packageKey)])) {
            $packageKey = $this->packageAliasMap[$lowercasedPackageKey];
        }
        return parent::isPackageAvailable($packageKey);
    }

    public function isPackageActive($packageKey) {
        if (isset($this->packageAliasMap[$lowercasedPackageKey = strtolower($packageKey)])) {
            $packageKey = $this->packageAliasMap[$lowercasedPackageKey];
        }
        return isset($this->runtimeActivatedPackages[$packageKey]) || parent::isPackageActive($packageKey);
    }

    public function deactivatePackage($packageKey) {
        $package = $this->getPackage($packageKey);
        parent::deactivatePackage($package->getPackageKey());
    }

    public function activatePackage($packageKey) {
        $package = $this->getPackage($packageKey);
        parent::activatePackage($package->getPackageKey());
        $this->classLoader->addActivePackage($package);
    }

    public function activatePackageDuringRuntime($packageKey) {
        $package = $this->getPackage($packageKey);
        $this->runtimeActivatedPackages[$package->getPackageKey()] = $package;
        $this->classLoader->addActivePackage($package);
        if (!isset($GLOBALS['TYPO3_LOADED_EXT'][$package->getPackageKey()])) {
            $loadedExtArrayElement = new \TYPO3\CMS\Core\Compatibility\LoadedExtensionArrayElement($package);
            $GLOBALS['TYPO3_LOADED_EXT'][$package->getPackageKey()] = $loadedExtArrayElement->toArray();
        }
    }


    public function deletePackage($packageKey) {
        $package = $this->getPackage($packageKey);
        parent::deletePackage($package->getPackageKey());
    }


    public function freezePackage($packageKey) {
        $package = $this->getPackage($packageKey);
        parent::freezePackage($package->getPackageKey());
    }

    public function isPackageFrozen($packageKey) {
        $package = $this->getPackage($packageKey);
        return parent::isPackageFrozen($package->getPackageKey());
    }

    public function unfreezePackage($packageKey) {
        $package = $this->getPackage($packageKey);
        parent::unfreezePackage($package->getPackageKey());
    }

    public function refreezePackage($packageKey) {
        $package = $this->getPackage($packageKey);
        parent::refreezePackage($package->getPackageKey());
    }

    public function getActivePackages() {
        return array_merge(parent::getActivePackages(), $this->runtimeActivatedPackages);
    }

    protected function sortAvailablePackagesByDependencies() {
        $this->resolvePackageDependencies();

        // sort the packages by key at first, so we get a stable sorting of "equivalent" packages afterwards
        ksort($this->packageStatesConfiguration['packages']);
        $this->packageStatesConfiguration['packages'] = $this->dependencyResolver->sortPackageStatesConfigurationByDependency($this->packageStatesConfiguration['packages']);

        // Reorder the packages according to the loading order
        $newPackages = array();
        foreach ($this->packageStatesConfiguration['packages'] as $packageKey => $_) {
            $newPackages[$packageKey] = $this->packages[$packageKey];
        }
        $this->packages = $newPackages;
    }

    protected function resolvePackageDependencies() {
        parent::resolvePackageDependencies();
        foreach ($this->packages as $packageKey => $package) {
            $this->packageStatesConfiguration['packages'][$packageKey]['suggestions'] = $this->getSuggestionArrayForPackage($packageKey);
        }
    }

    protected function getSuggestionArrayForPackage($packageKey) {
        if (!isset($this->packages[$packageKey])) {
            return NULL;
        }
        $suggestedPackageKeys = array();
        $suggestedPackageConstraints = $this->packages[$packageKey]->getPackageMetaData()->getConstraintsByType(\TYPO3\Flow\Package\MetaDataInterface::CONSTRAINT_TYPE_SUGGESTS);
        foreach ($suggestedPackageConstraints as $constraint) {
            if ($constraint instanceof \TYPO3\Flow\Package\MetaData\PackageConstraint) {
                $suggestedPackageKey = $constraint->getValue();
                if (isset($this->packages[$suggestedPackageKey])) {
                    $suggestedPackageKeys[] = $suggestedPackageKey;
                }
            }
        }
        return array_reverse($suggestedPackageKeys);
    }

    protected function sortAndSavePackageStates() {
        parent::sortAndSavePackageStates();
        \TYPO3\CMS\Core\Utility\GeneralUtility::fixPermissions($this->packageStatesPathAndFilename);

        $this->initializeCompatibilityLoadedExtArray();
        \TYPO3\CMS\Core\Utility\OpcodeCacheUtility::clearAllActive($this->packageStatesPathAndFilename);
    }

    public function isPackageKeyValid($packageKey) {
        return parent::isPackageKeyValid($packageKey) || preg_match(\TYPO3\CMS\Core\Package\Package::PATTERN_MATCH_EXTENSIONKEY, $packageKey) === 1;
    }
}