Bugfix/13.1.1 hashed identifiers php 8.3

Classes/Cache/IdentifierBuilder.php

@@ -22,7 +22,7 @@ class IdentifierBuilder extends StaticFileCacheObject
      */
     public function getFilepath(string $requestUri): string
     {
-        if (!$this->isValidEntryIdentifier($requestUri)) {
+        if (!$this->isValidEntryUri($requestUri)) {
             throw new \Exception('Invalid RequestUri as cache identifier: '.$requestUri, 2346782);
         }
         $urlParts = parse_url($requestUri);
@@ -51,16 +51,33 @@ public function getFilepath(string $requestUri): string
         return $resultPath;
     }
 
+    public function getUrl(string $filePath, int $stripPort): string
+    {
+        $p = strpos($filePath, '_');
+        $p2 = strpos($filePath, '_', $p + 1);
+        $first = substr($filePath, 0, $p) . '://' . substr($filePath, $p + 1, $p2 - $p - 1);
+        if ($stripPort && strpos($filePath, '_' . $stripPort)) {
+            return $first . substr($filePath, $p2 + 1 + strlen((string)$stripPort));
+        }
+
+        return  $first . ':' . substr($filePath, $p2 + 1);
+    }
+
     /**
      * Check if the $requestUri is a valid base for cache identifier.
      */
-    public function isValidEntryIdentifier(string $requestUri): bool
+    public function isValidEntryIdentifier(string $identifier): bool
+    {
+        return preg_replace('/[a-z0-9]{64}/', '', $identifier) === '';
+    }
+
+    public function isValidEntryUri(string $requestUri): bool
     {
         if (false === GeneralUtility::isValidUrl($requestUri)) {
             return false;
         }
         $urlParts = parse_url($requestUri);
-        $required = ['host', 'path', 'scheme'];
+        $required = ['host', 'scheme'];
         foreach ($required as $item) {
             if (!isset($urlParts[$item]) || mb_strlen($urlParts[$item]) <= 0) {
                 return false;
@@ -69,4 +86,9 @@ public function isValidEntryIdentifier(string $requestUri): bool
 
         return true;
     }
+
+    public function hash(string $requestUri): string
+    {
+        return hash('sha256', $requestUri);
+    }
 }

Classes/Cache/StaticFileBackend.php

@@ -7,6 +7,7 @@
 use TYPO3\CMS\Core\Cache\Exception\InvalidDataException;
 use TYPO3\CMS\Core\Context\Context;
 use Psr\EventDispatcher\EventDispatcherInterface;
+use Exception;
 use Psr\Http\Message\ResponseInterface;
 use SFC\Staticfilecache\Domain\Repository\CacheRepository;
 use SFC\Staticfilecache\Domain\Repository\QueueRepository;
@@ -17,7 +18,11 @@
 use SFC\Staticfilecache\Service\GeneratorService;
 use SFC\Staticfilecache\Service\QueueService;
 use SFC\Staticfilecache\Service\RemoveService;
+use SFC\Staticfilecache\Utility\UriUtility;
+use Symfony\Component\Console\Output\NullOutput;
 use TYPO3\CMS\Core\Cache\Backend\TransientBackendInterface;
+use TYPO3\CMS\Core\Database\Connection;
+use TYPO3\CMS\Core\Database\ConnectionPool;
 use TYPO3\CMS\Core\Utility\GeneralUtility;
 use TYPO3\CMS\Core\Utility\PathUtility;
 use TYPO3\CMS\Frontend\Controller\TypoScriptFrontendController;
@@ -31,6 +36,14 @@
  */
 class StaticFileBackend extends StaticDatabaseBackend implements TransientBackendInterface
 {
+    protected IdentifierBuilder $identifierBuilder;
+
+    public function __construct($context, array $options = [])
+    {
+        parent::__construct($context, $options);
+        $this->identifierBuilder = GeneralUtility::makeInstance(IdentifierBuilder::class);
+    }
+
     /**
      * Saves data in the cache.
      *
@@ -62,9 +75,7 @@ public function set($entryIdentifier, $data, array $tags = [], $lifetime = null)
         }
 
         $this->logger->debug('SFC Set', [$entryIdentifier, $tags, $lifetime]);
-
-        $identifierBuilder = GeneralUtility::makeInstance(IdentifierBuilder::class);
-        $fileName = $identifierBuilder->getFilepath($entryIdentifier);
+        $fileName = $this->identifierBuilder->getFilepath($entryIdentifier);
 
         try {
             // Create dir
@@ -73,21 +84,18 @@ public function set($entryIdentifier, $data, array $tags = [], $lifetime = null)
                 GeneralUtility::mkdir_deep($cacheDir);
             }
 
-            if ($this->isHashedIdentifier()) {
-                $databaseData['url'] = $entryIdentifier;
-                $entryIdentifierForDatabase = $this->hash($entryIdentifier);
-            } else {
-                $entryIdentifierForDatabase = $entryIdentifier;
-            }
+            $databaseData['url'] = $entryIdentifier;
+            $entryIdentifierForDatabase = $this->identifierBuilder->hash($entryIdentifier);
 
             // call set in front of the generation, because the set method
             // of the DB backend also call remove (this remove do not remove the folder already created above)
+            $this->removeFromDatabase($entryIdentifierForDatabase);
             parent::set($entryIdentifierForDatabase, serialize($databaseData), $tags, $realLifetime);
 
             $this->removeStaticFiles($entryIdentifier);
 
             GeneralUtility::makeInstance(GeneratorService::class)->generate($entryIdentifier, $fileName, $data, $realLifetime);
-        } catch (\Exception $exception) {
+        } catch (Exception $exception) {
             $this->logger->error('Error in cache create process', ['exception' => $exception]);
         }
     }
@@ -104,12 +112,12 @@ public function get($entryIdentifier)
         if (!$this->has($entryIdentifier)) {
             return false;
         }
-        $result = parent::get($entryIdentifier);
+        $result = parent::get($this->identifierBuilder->hash($entryIdentifier));
         if (!\is_string($result)) {
             return false;
         }
 
-        return unserialize($result);
+        return unserialize($result, ['allowed_classes' => false]);
     }
 
     /**
@@ -121,7 +129,16 @@ public function get($entryIdentifier)
      */
     public function has($entryIdentifier)
     {
-        return is_file($this->getFilepath($entryIdentifier)) || parent::has($entryIdentifier);
+        if (!$entryIdentifier) {
+            return false;
+        }
+
+        if (GeneralUtility::isValidUrl($entryIdentifier)) {
+            $entryIdentifierForDatabase = $this->identifierBuilder->hash($entryIdentifier);
+        } else {
+            $entryIdentifierForDatabase = $entryIdentifier;
+        }
+        return is_file($this->getFilepath($entryIdentifier)) && parent::has($entryIdentifierForDatabase);
     }
 
     /**
@@ -143,7 +160,7 @@ public function remove($entryIdentifier)
 
         if ($this->isBoostMode()) {
             $this->getQueue()
-                ->addIdentifier($entryIdentifier)
+                ->addIdentifiers([$entryIdentifier])
             ;
 
             return true;
@@ -242,6 +259,7 @@ public function flushByTag($tag): void
         if ($this->isBoostMode()) {
             $this->getQueue()->addIdentifiers($identifiers);
 
+
             return;
         }
 
@@ -253,27 +271,21 @@ public function flushByTag($tag): void
 
     /**
      * Does garbage collection.
-     *
-     * Note: Do not check boostmode. If we check boost mode, we get the problem, that the core garbage collection drop
-     * the DB related part of StaticFileCache but not the files, because the "garbage collection" works directly on
-     * the caching backends and not on the caches itself. By ignoring the boost mode in this function we take care,
-     * that the StaticFileCache drop the file AND the db representation. Please take care, that you select both backends
-     * in the garbage collection task in the Scheduler.
      */
     public function collectGarbage(): void
     {
         $expiredIdentifiers = GeneralUtility::makeInstance(CacheRepository::class)->findExpiredIdentifiers();
+        if ($this->isBoostMode()) {
+            $this->getQueue()->addIdentifiers($expiredIdentifiers);
+            parent::collectGarbage();
+            return;
+        }
         parent::collectGarbage();
         foreach ($expiredIdentifiers as $identifier) {
             $this->removeStaticFiles($identifier);
         }
     }
 
-    protected function hash(string $entryIdentifier): string
-    {
-        return hash('sha256', $entryIdentifier);
-    }
-
     /**
      * Get prority.
      *
@@ -300,16 +312,20 @@ protected function getPriority(string $uri)
      */
     protected function getFilepath(string $entryIdentifier): string
     {
-        $url = $entryIdentifier;
-        if ($this->isHashedIdentifier()) {
+        if (GeneralUtility::isValidUrl($entryIdentifier)) {
+            $url = $entryIdentifier;
+        } else {
             $data = parent::get($entryIdentifier);
             if (!$data) {
                 return '';
             }
-            $entry = unserialize($data);
-            if (!empty($entry['url'])) {
-                $url = $entry['url'];
+
+            $entry = unserialize($data, ['allowed_classes' => false]);
+            if (empty($entry['url'])) {
+                return '';
             }
+
+            $url = $entry['url'];
         }
         $identifierBuilder = GeneralUtility::makeInstance(IdentifierBuilder::class);
 
@@ -357,7 +373,7 @@ protected function getQueue(): QueueService
             // Build Queue Service manually, because here is no DI
             $queueService = GeneralUtility::makeInstance(
                 QueueService::class,
-                GeneralUtility::makeInstance(QueueRepository::class),
+                GeneralUtility::makeInstance(QueueRepository::class, GeneralUtility::makeInstance(ConfigurationService::class)),
                 GeneralUtility::makeInstance(ConfigurationService::class),
                 GeneralUtility::makeInstance(ClientService::class, GeneralUtility::makeInstance(EventDispatcherInterface::class)),
                 GeneralUtility::makeInstance(CacheService::class)
@@ -380,11 +396,21 @@ protected function isBoostMode(): bool
         return (bool) $this->configuration->get('boostMode');
     }
 
-    /**
-     * Check if the "hashUriInCache" feature is enabled.
-     */
-    protected function isHashedIdentifier(): bool
+    protected function removeFromDatabase(string $entryIdentifierForDatabase)
     {
-        return (bool) $this->configuration->isBool('hashUriInCache');
+        GeneralUtility::makeInstance(ConnectionPool::class)
+            ->getConnectionForTable($this->cacheTable)
+            ->delete(
+                $this->cacheTable,
+                [
+                    'identifier' => $entryIdentifierForDatabase,
+                ]
+            );
+
+        GeneralUtility::makeInstance(ConnectionPool::class)
+            ->getConnectionForTable($this->tagsTable)
+            ->delete($this->tagsTable, [
+                'identifier' => $entryIdentifierForDatabase,
+            ]);
     }
 }

Classes/Cache/UriFrontend.php

@@ -17,21 +17,44 @@ class UriFrontend extends VariableFrontend
     /**
      * Check if the identifier is a valid URI incl. host and path.
      *
-     * @param string $identifier
+     * @param string $requestUri
      *
      * @return bool
      */
-    public function isValidEntryIdentifier($identifier)
+    public function isValidEntryIdentifier($requestUri)
     {
         try {
             $identifierBuilder = GeneralUtility::makeInstance(IdentifierBuilder::class);
-
-            return $identifierBuilder->isValidEntryIdentifier($identifier);
+            return $identifierBuilder->isValidEntryUri($requestUri);
         } catch (\Exception $exception) {
             return false;
         }
     }
 
+    /**
+     * Finds and returns a variable value from the cache.
+     *
+     * @param string $entryIdentifier Identifier of the cache entry to fetch
+     *
+     * @return mixed The value
+     * @throws \InvalidArgumentException if the identifier is not valid
+     */
+    public function get($entryIdentifier)
+    {
+        $identifierBuilder = GeneralUtility::makeInstance(IdentifierBuilder::class);
+        if (!$identifierBuilder->isValidEntryUri($entryIdentifier)) {
+            throw new \InvalidArgumentException(
+                $entryIdentifier . '" is not a valid cache entry identifier.',
+                1233058294
+            );
+        }
+        $rawResult = $this->backend->get($entryIdentifier);
+        if ($rawResult === false) {
+            return false;
+        }
+        return $this->backend instanceof TransientBackendInterface ? $rawResult : unserialize($rawResult, ['allowed_classes' => false]);
+    }
+
     /**
      * Finds and returns all cache entries which are tagged by the specified tag.
      *