IndexerService.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Core\Resource\Service;

use TYPO3\CMS\Core\Resource\File;
use TYPO3\CMS\Core\Resource\Index\FileIndexRepository;
use TYPO3\CMS\Core\Utility\GeneralUtility;

class IndexerService implements \TYPO3\CMS\Core\SingletonInterface {

    protected $repository;

    public function __construct() {

    }

    protected function getRepository() {
        if ($this->repository === NULL) {
            $this->repository = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Resource\\FileRepository');
        }
        return $this->repository;
    }

    protected function getFileIndexRepository() {
        return GeneralUtility::makeInstance('TYPO3\CMS\Core\Resource\Index\FileIndexRepository');
    }


    public function getFactory() {
        return GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Resource\\ResourceFactory');
    }

    public function indexFile(File $fileObject, $updateObject = TRUE) {
        $fileObject->setIndexingInProgess(TRUE);
        // Get the file information of this object
        $fileInfo = $this->gatherFileInformation($fileObject);
        // Signal slot BEFORE the file was indexed
        $this->emitPreFileIndexSignal($fileObject, $fileInfo);

        // If the file is already indexed, then the file information will
        // be updated on the existing record
        if ($fileObject->isIndexed()) {
            $fileInfo['missing'] = 0;
            $fileObject->updateProperties($fileInfo);
            $this->getFileIndexRepository()->update($fileObject);
        } else {
            // Check if a file has been moved outside of FAL -- we have some
            // orphaned index record in this case we could update
            $resultRows = $this->getFileIndexRepository()->findByContentHash($fileInfo['sha1']);
            $otherFiles = array();
            foreach ($resultRows as $row) {
                $otherFiles[] = $this->getFactory()->getFileObject($row['uid'], $row);
            }

            $movedFile = FALSE;
            foreach ($otherFiles as $otherFile) {
                if (!$otherFile->exists()) {
                    // @todo: create a log entry
                    $movedFile = TRUE;
                    $fileInfo['missing'] = 0;
                    $otherFile->updateProperties($fileInfo);
                    $this->getFileIndexRepository()->update($otherFile);
                    $fileInfo['uid'] = $otherFile->getUid();
                    $fileObject = $otherFile;
                    // Skip the rest of the files here as we might have more files that are missing, but we can only
                    // have one entry. The optimal solution would be to merge these records then, but this requires
                    // some more advanced logic that we currently have not implemented.
                    break;
                }
            }
            // File was not moved, so it is a new index record
            if ($movedFile === FALSE) {
                // Crdate and tstamp should not be present when updating
                // the file object, as they only relate to the index record
                $additionalInfo = array(
                    'crdate' => $GLOBALS['EXEC_TIME'],
                    'tstamp' => $GLOBALS['EXEC_TIME']
                );
                if (isset($GLOBALS['BE_USER']->user['uid'])) {
                    $additionalInfo['cruser_id'] = (int)$GLOBALS['BE_USER']->user['uid'];
                }
                $indexRecord = array_merge($fileInfo, $additionalInfo);

                $fileObject->updateProperties($indexRecord);
                $this->getFileIndexRepository()->add($fileObject);
            }
        }
        // Check for an error during the execution and throw an exception
        $error = $GLOBALS['TYPO3_DB']->sql_error();
        if ($error) {
            throw new \RuntimeException('Error during file indexing: "' . $error . '"', 1314455642);
        }
        if ($fileInfo['type'] == $fileObject::FILETYPE_IMAGE) {
            $rawFileLocation = $fileObject->getForLocalProcessing(FALSE);
            $metaData = array();
            $imageSize = getimagesize($rawFileLocation);
            if ($imageSize === FALSE) {
                $metaData['width'] = 0;
                $metaData['height'] = 0;
            } else {
                list($metaData['width'], $metaData['height']) = $imageSize;
            }
            $this->getMetaDataRepository()->update($fileObject->getUid(), $metaData);
        }
        // Signal slot AFTER the file was indexed
        $this->emitPostFileIndexSignal($fileObject, $fileInfo);
        $fileObject->setIndexingInProgess(FALSE);
        if ($updateObject) {
            return $fileObject;
        } else {
            return $fileInfo;
        }
    }

    public function indexFiles(array $fileObjects) {
        // emit signal
        $this->emitPreMultipleFilesIndexSignal($fileObjects);
        foreach ($fileObjects as $fileObject) {
            $this->indexFile($fileObject);
        }
        // emit signal
        $this->emitPostMultipleFilesIndexSignal($fileObjects);
    }

    public function indexFilesInFolder(\TYPO3\CMS\Core\Resource\Folder $folder) {
        $numberOfIndexedFiles = 0;
        $fileIdentifiers = array();

        // Index all files in this folder
        $fileObjects = $folder->getFiles();

        // emit signal
        $this->emitPreMultipleFilesIndexSignal($fileObjects);
        foreach ($fileObjects as $fileObject) {
            $this->indexFile($fileObject);
            $fileIdentifiers[] = $fileObject->getIdentifier();
            $numberOfIndexedFiles++;
        }

        // check for deleted files (file not found during indexing are marked as missing)
        $fileIndexRecords = $this->getFileIndexRepository()->findByFolder($folder);
        foreach ($fileIndexRecords as $file) {
            if (!in_array($file['identifier'], $fileIdentifiers)) {
                $fileObject = $this->getRepository()->findByIdentifier($file['uid']);
                $fileObject->setMissing(TRUE);
                $this->getFileIndexRepository()->update($fileObject);
            }
        }

        // emit signal
        $this->emitPostMultipleFilesIndexSignal($fileObjects);

        // cleanup to prevent to much memory use on big folders
        unset($fileObjects);
        unset($fileIdentifiers);

        // Call this function recursively for each subfolder
        $subFolders = $folder->getSubfolders();
        foreach ($subFolders as $subFolder) {
            $numberOfIndexedFiles += $this->indexFilesInFolder($subFolder);
        }
        return $numberOfIndexedFiles;
    }

    protected function gatherFileInformation(File $file) {
        $fileInfo = new \ArrayObject(array());
        $gatherDefaultInformation = new \stdClass();
        $gatherDefaultInformation->getDefaultFileInfo = 1;
        // signal before the files are modified
        $this->emitPreGatherFileInformationSignal($file, $fileInfo, $gatherDefaultInformation);
        // the check helps you to disable the regular file fetching,
        // so a signal could actually remotely access the service
        if ($gatherDefaultInformation->getDefaultFileInfo) {
            $storage = $file->getStorage();
            // TODO: See if we can't just return info, as it contains most of the
            // stuff we put together in array form again later here.
            $info = $storage->getFileInfo($file);
            $defaultFileInfo = array(
                'creation_date' => $info['ctime'],
                'modification_date' => $info['mtime'],
                'size' => $info['size'],
                'identifier' => $file->getIdentifier(),
                'identifier_hash' => $storage->hashFileIdentifier($file->getIdentifier()),
                'folder_hash' => $storage->hashFileIdentifier($storage->getFolderIdentifierFromFileIdentifier($file->getIdentifier())),
                'storage' => $storage->getUid(),
                'name' => $file->getName(),
                'sha1' => $storage->hashFile($file, 'sha1'),
                'type' => $file->getType(),
                'mime_type' => $file->getMimeType(),
                'extension' => $file->getExtension()
            );
            $fileInfo = array_merge($defaultFileInfo, $fileInfo->getArrayCopy());
            $fileInfo = new \ArrayObject($fileInfo);
        }
        // signal after the file information is fetched
        $this->emitPostGatherFileInformationSignal($file, $fileInfo, $gatherDefaultInformation);
        return $fileInfo->getArrayCopy();
    }

    protected function emitPreGatherFileInformationSignal(File $fileObject, $fileInfo, $gatherDefaultInformation) {
        $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\Service\\IndexerService', 'preGatherFileInformation', array($fileObject, $fileInfo, $gatherDefaultInformation));
    }

    protected function emitPostGatherFileInformationSignal(File $fileObject, $fileInfo, $hasGatheredDefaultInformation) {
        $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\Service\\IndexerService', 'postGatherFileInformation', array($fileObject, $fileInfo, $hasGatheredDefaultInformation));
    }

    protected function emitPreMultipleFilesIndexSignal(array $fileObjectsToIndex) {
        $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\Service\\IndexerService', 'preMultipleFileIndex', array($fileObjectsToIndex));
    }

    protected function emitPostMultipleFilesIndexSignal(array $fileObjectsToIndex) {
        $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\Service\\IndexerService', 'postMultipleFileIndex', array($fileObjectsToIndex));
    }

    protected function emitPreFileIndexSignal(File $fileObject, $fileInfo) {
        $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\Service\\IndexerService', 'preFileIndex', array($fileObject, $fileInfo));
    }

    protected function emitPostFileIndexSignal(File $fileObject, $fileInfo) {
        $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\Service\\IndexerService', 'postFileIndex', array($fileObject, $fileInfo));
    }

    protected function getSignalSlotDispatcher() {
        return $this->getObjectManager()->get('TYPO3\\CMS\\Extbase\\SignalSlot\\Dispatcher');
    }

    protected function getObjectManager() {
        return \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance('TYPO3\\CMS\\Extbase\\Object\\ObjectManager');
    }

    protected function getMetaDataRepository() {
        return GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Resource\\Index\\MetaDataRepository');
    }

}