Helper.php

Go to the documentation of this file.

<?php
 
/*
 * 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!
 */
 
namespace ‪TYPO3\CMS\Extensionmanager\Utility\Repository;
 
use ‪TYPO3\CMS\Core\Configuration\ExtensionConfiguration;
use ‪TYPO3\CMS\Core\Core\Environment;
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\SingletonInterface;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Extbase\Object\ObjectManager;
use ‪TYPO3\CMS\Extensionmanager\Domain\Model\Mirrors;
use ‪TYPO3\CMS\Extensionmanager\Domain\Model\Repository;
use ‪TYPO3\CMS\Extensionmanager\Domain\Repository\ExtensionRepository;
use ‪TYPO3\CMS\Extensionmanager\Domain\Repository\RepositoryRepository;
use ‪TYPO3\CMS\Extensionmanager\Exception\ExtensionManagerException;
use ‪TYPO3\CMS\Extensionmanager\Utility\Importer\ExtensionListUtility;
use ‪TYPO3\CMS\Extensionmanager\Utility\Importer\MirrorListUtility;
 
class ‪Helper implements ‪SingletonInterface
{
    const ‪PROBLEM_EXTENSION_FILE_NOT_EXISTING = 1;
    const ‪PROBLEM_EXTENSION_HASH_CHANGED = 2;
 
    const ‪PROBLEM_NO_VERSIONS_IN_DATABASE = 4;
 
    protected ‪$repository;
 
    protected ‪$extensionRepository;
 
    protected ‪$objectManager;
 
    public function ‪__construct()
    {
        $this->objectManager = GeneralUtility::makeInstance(ObjectManager::class);
        $repositoryRepository = $this->objectManager->get(RepositoryRepository::class);
        $this->extensionRepository = $this->objectManager->get(ExtensionRepository::class);
        ‪$repository = $repositoryRepository->findOneTypo3OrgRepository();
        if (is_object(‪$repository)) {
            $this->‪setRepository(‪$repository);
        }
    }
 
    public function ‪setRepository(‪Repository ‪$repository)
    {
        $this->repository = ‪$repository;
    }
 
    public function ‪fetchExtListFile()
    {
        $this->‪fetchFile($this->‪getRemoteExtListFile(), $this->‪getLocalExtListFile());
    }
 
    public function ‪fetchMirrorListFile()
    {
        $this->‪fetchFile($this->‪getRemoteMirrorListFile(), $this->‪getLocalMirrorListFile());
    }
 
    protected function ‪fetchFile($remoteResource, $localResource)
    {
        $isOffline = (bool)GeneralUtility::makeInstance(ExtensionConfiguration::class)->get('extensionmanager', 'offlineMode');
        if ($isOffline) {
            throw new ExtensionManagerException('Extension Manager is in offline mode. No TER connection available.', 1437078780);
        }
        if (is_string($remoteResource) && is_string($localResource) && !empty($remoteResource) && !empty($localResource)) {
            $fileContent = ‪GeneralUtility::getUrl($remoteResource);
            if ($fileContent !== false) {
                if (‪GeneralUtility::writeFileToTypo3tempDir($localResource, $fileContent) !== null) {
                    throw new ExtensionManagerException(sprintf('Could not write to file %s.', $localResource), 1342635378);
                }
            } else {
                throw new ExtensionManagerException(sprintf('Could not access remote resource %s.', $remoteResource), 1342635425);
            }
        }
    }
 
    public function ‪getLocalExtListFile()
    {
        return ‪Environment::getVarPath() . '/extensionmanager/' . (int)$this->repository->getUid() . '.extensions.xml.gz';
    }
 
    public function ‪getRemoteExtListFile()
    {
        $mirror = $this->‪getMirrors(true)->‪getMirror();
        $filePath = 'https://' . $mirror['host'] . $mirror['path'] . 'extensions.xml.gz';
        return $filePath;
    }
 
    public function ‪getRemoteExtHashFile()
    {
        $mirror = $this->‪getMirrors(true)->‪getMirror();
        $filePath = 'https://' . $mirror['host'] . $mirror['path'] . 'extensions.md5';
        return $filePath;
    }
 
    public function ‪getLocalMirrorListFile()
    {
        return ‪Environment::getVarPath() . '/extensionmanager/' . (int)$this->repository->getUid() . '.mirrors.xml.gz';
    }
 
    public function ‪getRemoteMirrorListFile()
    {
        $filePath = $this->repository->getMirrorListUrl();
        return $filePath;
    }
 
    public function ‪getMirrors($forcedUpdateFromRemote = true)
    {
        $assignedMirror = $this->repository->‪getMirrors();
        if ($forcedUpdateFromRemote || $assignedMirror === null || !is_object($assignedMirror)) {
            if ($forcedUpdateFromRemote || !is_file($this->‪getLocalMirrorListFile())) {
                $this->‪fetchMirrorListFile();
            }
            $objMirrorListImporter = GeneralUtility::makeInstance(MirrorListUtility::class);
            $this->repository->addMirrors($objMirrorListImporter->getMirrors($this->getLocalMirrorListFile()));
        }
        return $this->repository->getMirrors();
    }
 
    public function ‪isExtListUpdateNecessary()
    {
        if ($this->repository === null) {
            throw new ExtensionManagerException('No extension repository was found.', 1500060252);
        }
        $updateNecessity = 0;
        if ($this->extensionRepository->countByRepository($this->repository->getUid()) <= 0) {
            $updateNecessity |= ‪self::PROBLEM_NO_VERSIONS_IN_DATABASE;
        }
        if (!is_file($this->‪getLocalExtListFile())) {
            $updateNecessity |= ‪self::PROBLEM_EXTENSION_FILE_NOT_EXISTING;
        } else {
            $remotemd5 = ‪GeneralUtility::getUrl($this->‪getRemoteExtHashFile());
            if ($remotemd5 !== false) {
                $localmd5 = md5_file($this->‪getLocalExtListFile());
                if ($remotemd5 !== $localmd5) {
                    $updateNecessity |= ‪self::PROBLEM_EXTENSION_HASH_CHANGED;
                }
            } else {
                throw new ExtensionManagerException('Could not retrieve extension hash file from remote server.', 1342635016);
            }
        }
        return $updateNecessity;
    }
 
    public function ‪updateExtList()
    {
        $updated = false;
        $updateNecessity = $this->‪isExtListUpdateNecessary();
        if ($updateNecessity !== 0) {
            // retrieval of file necessary
            $tmpBitmask = self::PROBLEM_EXTENSION_FILE_NOT_EXISTING | ‪self::PROBLEM_EXTENSION_HASH_CHANGED;
            if (($tmpBitmask & $updateNecessity) > 0) {
                $this->‪fetchExtListFile();
                $updateNecessity &= ~$tmpBitmask;
            }
            // database table cleanup
            if ($updateNecessity & self::PROBLEM_NO_VERSIONS_IN_DATABASE) {
                $updateNecessity &= ~self‪::PROBLEM_NO_VERSIONS_IN_DATABASE;
            } else {
                // Use straight query as extbase "remove" is too slow here
                // This truncates the whole table. It would be more correct to remove only rows of a specific
                // repository, but multiple repository handling is not implemented, and truncate is quicker.
                GeneralUtility::makeInstance(ConnectionPool::class)
                    ->getConnectionForTable('tx_extensionmanager_domain_model_extension')
                    ->truncate('tx_extensionmanager_domain_model_extension');
            }
            // no further problems - start of import process
            if ($updateNecessity === 0) {
                $uid = $this->repository->getUid();
                $objExtListImporter = $this->objectManager->get(ExtensionListUtility::class);
                $objExtListImporter->import($this->‪getLocalExtListFile(), $uid);
                $updated = true;
            }
        }
        return $updated;
    }
}