PageContentErrorHandler.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
/*
 * 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\Core\Error\PageErrorHandler;
 
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use ‪TYPO3\CMS\Core\Cache\CacheManager;
use ‪TYPO3\CMS\Core\Cache\Exception\NoSuchCacheException;
use ‪TYPO3\CMS\Core\Controller\ErrorPageController;
use ‪TYPO3\CMS\Core\Exception\SiteNotFoundException;
use ‪TYPO3\CMS\Core\Http\HtmlResponse;
use ‪TYPO3\CMS\Core\Http\RequestFactory;
use ‪TYPO3\CMS\Core\LinkHandling\LinkService;
use ‪TYPO3\CMS\Core\Locking\Exception\LockAcquireWouldBlockException;
use ‪TYPO3\CMS\Core\Locking\LockFactory;
use ‪TYPO3\CMS\Core\Locking\LockingStrategyInterface;
use ‪TYPO3\CMS\Core\Routing\InvalidRouteArgumentsException;
use ‪TYPO3\CMS\Core\Site\Entity\Site;
use ‪TYPO3\CMS\Core\Site\Entity\SiteLanguage;
use ‪TYPO3\CMS\Core\Site\SiteFinder;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
 
class ‪PageContentErrorHandler implements ‪PageErrorHandlerInterface
{
 
    protected ‪$statusCode;
 
    protected ‪$errorHandlerConfiguration;
 
    protected ‪$pageUid = 0;
 
    public function ‪__construct(int ‪$statusCode, array $configuration)
    {
        $this->statusCode = ‪$statusCode;
        if (empty($configuration['errorContentSource'])) {
            throw new \InvalidArgumentException('PageContentErrorHandler needs to have a proper link set.', 1522826413);
        }
        $this->errorHandlerConfiguration = $configuration;
    }
 
    public function ‪handlePageError(ServerRequestInterface $request, string $message, array $reasons = []): ResponseInterface
    {
        try {
            $resolvedUrl = $this->‪resolveUrl($request, $this->errorHandlerConfiguration['errorContentSource']);
 
            $cache = GeneralUtility::makeInstance(CacheManager::class)->getCache('pages');
            $cacheIdentifier = 'errorPage_' . md5($resolvedUrl);
            $cacheContent = $cache->get($cacheIdentifier);
 
            if (!$cacheContent && $resolvedUrl !== (string)$request->getUri()) {
                $lockFactory = GeneralUtility::makeInstance(LockFactory::class);
                $lock = $lockFactory->createLocker(
                    $cacheIdentifier,
                    ‪LockingStrategyInterface::LOCK_CAPABILITY_EXCLUSIVE | ‪LockingStrategyInterface::LOCK_CAPABILITY_NOBLOCK
                );
                try {
                    $locked = $lock->acquire(
                        ‪LockingStrategyInterface::LOCK_CAPABILITY_EXCLUSIVE | ‪LockingStrategyInterface::LOCK_CAPABILITY_NOBLOCK
                    );
                    if (!$locked) {
                        return $this->‪createGenericErrorResponse();
                    }
 
                    $subResponse = GeneralUtility::makeInstance(RequestFactory::class)
                        ->request($resolvedUrl, 'GET', $this->‪getSubRequestOptions());
                    $lock->release();
                } catch (‪LockAcquireWouldBlockException $_) {
                    $lock->release();
                    return $this->‪createGenericErrorResponse();
                } catch (\‪Exception $e) {
                    throw new \RuntimeException('Error handler could not fetch error page "' . $resolvedUrl . '", reason: ' . $e->getMessage(), 1544172838);
                }
                if ($subResponse->getStatusCode() >= 300) {
                    throw new \RuntimeException('Error handler could not fetch error page "' . $resolvedUrl . '", status code: ' . $subResponse->getStatusCode(), 1544172839);
                }
 
                $body = $subResponse->getBody()->getContents();
                $contentType = $subResponse->getHeader('Content-Type');
 
                // Cache body and content-type if sub-response returned a HTTP status 200
                if ($subResponse->getStatusCode() === 200) {
                    $cacheTags = ['errorPage'];
                    if ($this->pageUid > 0) {
                        // Cache Tag "pageId_" ensures, cache is purged when content of 404 page changes
                        $cacheTags[] = 'pageId_' . ‪$this->pageUid;
                    }
                    $cacheContent = [
                        'body' => $body,
                        'headers' => ['Content-Type' => $contentType],
                    ];
                    $cache->set($cacheIdentifier, $cacheContent, $cacheTags);
                }
            }
            if ($cacheContent && $cacheContent['body'] && $cacheContent['headers']) {
                // We use a HtmlResponse here, since no Stream is available for cached response content
                return new ‪HtmlResponse($cacheContent['body'], $this->statusCode, $cacheContent['headers']);
            }
            $content = 'The error page could not be resolved, as the error page itself is not accessible';
        } catch (‪InvalidRouteArgumentsException | ‪SiteNotFoundException $e) {
            $content = 'Invalid error handler configuration: ' . $this->errorHandlerConfiguration['errorContentSource'];
        }
        return new ‪HtmlResponse($content, $this->statusCode);
    }
 
    protected function ‪createGenericErrorResponse(string $message = ''): ResponseInterface
    {
        $content = GeneralUtility::makeInstance(ErrorPageController::class)->errorAction(
            'Page Not Found',
            $message ?: 'The page did not exist or was inaccessible. Error page is being generated'
        );
        return new ‪HtmlResponse($content, 503);
    }
 
    protected function ‪getSubRequestOptions(): array
    {
        $options = [];
        if ((int)‪$GLOBALS['TYPO3_CONF_VARS']['HTTP']['timeout'] === 0) {
            $options = [
                'timeout' => 10
            ];
        }
        return $options;
    }
 
    protected function ‪resolveUrl(ServerRequestInterface $request, string $typoLinkUrl): string
    {
        $linkService = GeneralUtility::makeInstance(LinkService::class);
        $urlParams = $linkService->resolve($typoLinkUrl);
        if ($urlParams['type'] !== 'page' && $urlParams['type'] !== 'url') {
            throw new \InvalidArgumentException('PageContentErrorHandler can only handle TYPO3 urls of types "page" or "url"', 1522826609);
        }
        if ($urlParams['type'] === 'url') {
            return $urlParams['url'];
        }
 
        $this->pageUid = (int)$urlParams['pageuid'];
 
        // Get the site related to the configured error page
        $site = GeneralUtility::makeInstance(SiteFinder::class)->getSiteByPageId($this->pageUid);
        // Fall back to current request for the site
        if (!$site instanceof Site) {
            $site = $request->getAttribute('site', null);
        }
        $requestLanguage = $request->getAttribute('language', null);
        // Try to get the current request language from the site that was found above
        if ($requestLanguage instanceof SiteLanguage && $requestLanguage->isEnabled()) {
            try {
                $language = $site->getLanguageById($requestLanguage->getLanguageId());
            } catch (\InvalidArgumentException $e) {
                $language = $site->getDefaultLanguage();
            }
        } else {
            $language = $site->getDefaultLanguage();
        }
 
        // Build Url
        $uri = $site->getRouter()->generateUri(
            (int)$urlParams['pageuid'],
            ['_language' => $language]
        );
 
        // Fallback to the current URL if the site is not having a proper scheme and host
        $currentUri = $request->getUri();
        if (empty($uri->getScheme())) {
            $uri = $uri->withScheme($currentUri->getScheme());
        }
        if (empty($uri->getUserInfo())) {
            $uri = $uri->withUserInfo($currentUri->getUserInfo());
        }
        if (empty($uri->getHost())) {
            $uri = $uri->withHost($currentUri->getHost());
        }
        if ($uri->getPort() === null) {
            $uri = $uri->withPort($currentUri->getPort());
        }
 
        return (string)$uri;
    }
}