TASK: Extract the generation of public CacheControl Headers into separate middleware

This allows the FullPageCache Package to be used in cases where cacheability and lifetime cannot be
extracted from the fusionCache. A possible useCase for that are custom controllers may or may not use
fusion for rendering.

The public lifetime is now calculated from the  header `X-FullPageCache-Lifetime` limited by the Setting `maxPublicCacheTime`.
If the response already contains a `CacheControl` header this is skipped.

Author: mficzel

Classes/Middleware/CacheHeaderMiddleware.php

@@ -32,12 +32,6 @@ class CacheHeaderMiddleware implements MiddlewareInterface
      */
     protected $enabled;
 
-    /**
-     * @var boolean
-     * @Flow\InjectConfiguration(path="maxPublicCacheTime")
-     */
-    protected $maxPublicCacheTime;
-
     public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
     {
         if (!$this->enabled || !$request->hasHeader(RequestCacheMiddleware::HEADER_ENABLED)) {
@@ -52,23 +46,6 @@ public function process(ServerRequestInterface $request, RequestHandlerInterface
             return $response;
         }
 
-        $publicLifetime = 0;
-        if ($this->maxPublicCacheTime > 0) {
-            if ($lifetime > 0 && $lifetime < $this->maxPublicCacheTime) {
-                $publicLifetime = $lifetime;
-            } else {
-                $publicLifetime = $this->maxPublicCacheTime;
-            }
-        }
-
-        if ($publicLifetime > 0) {
-            $entryContentHash = md5($response->getBody()->getContents());
-            $response->getBody()->rewind();
-            $response = $response
-                ->withHeader('ETag', '"' . $entryContentHash . '"')
-                ->withHeader('CacheControl', 'public, max-age=' . $publicLifetime);
-        }
-
         $response = $response
             ->withHeader(RequestCacheMiddleware::HEADER_ENABLED, "");
 

Classes/Middleware/PublicCacheHeaderMiddleware.php

@@ -0,0 +1,60 @@
+<?php
+declare(strict_types=1);
+
+namespace Flowpack\FullPageCache\Middleware;
+
+use Neos\Flow\Annotations as Flow;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\MiddlewareInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+
+class PublicCacheHeaderMiddleware implements MiddlewareInterface
+{
+
+    /**
+     * @var boolean
+     * @Flow\InjectConfiguration(path="enabled")
+     */
+    protected $enabled;
+
+    /**
+     * @var boolean
+     * @Flow\InjectConfiguration(path="maxPublicCacheTime")
+     */
+    protected $maxPublicCacheTime;
+
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
+    {
+        if (!$this->enabled || !$request->hasHeader(RequestCacheMiddleware::HEADER_ENABLED) || $this->maxPublicCacheTime == 0) {
+            return $next->handle($request);
+        }
+
+        $response = $next->handle($request);
+
+        if ($response->hasHeader("CacheControl")) {
+            return $response;
+        }
+
+        $lifetime = (int)$response->getHeaderLine(RequestCacheMiddleware::HEADER_LIFTIME);
+
+        $publicLifetime = 0;
+        if ($this->maxPublicCacheTime > 0) {
+            if ($lifetime > 0 && $lifetime < $this->maxPublicCacheTime) {
+                $publicLifetime = $lifetime;
+            } else {
+                $publicLifetime = $this->maxPublicCacheTime;
+            }
+        }
+
+        if ($publicLifetime > 0) {
+            $entryContentHash = md5($response->getBody()->getContents());
+            $response->getBody()->rewind();
+            $response = $response
+                ->withHeader('ETag', '"' . $entryContentHash . '"')
+                ->withHeader('CacheControl', 'public, max-age=' . $publicLifetime);
+        }
+
+        return $response;
+    }
+}

Configuration/Settings.yaml

@@ -38,6 +38,9 @@ Neos:
         'fullPageRequestCache':
           middleware: 'Flowpack\FullPageCache\Middleware\RequestCacheMiddleware'
           position: 'after trustedProxies'
+        'fullPagePublicCacheHeader':
+          middleware: 'Flowpack\FullPageCache\Middleware\PublicCacheHeaderMiddleware'
+          position: 'before fullPageCacheHeader'
         'fullPageCacheHeader':
           middleware: 'Flowpack\FullPageCache\Middleware\CacheHeaderMiddleware'
           position: 'after fullPageRequestCache'

README.md

@@ -51,6 +51,25 @@ Flowpack:
 
 You can also move the cache backend to something faster if available, to improve performance even more.
 
+How it works
+------------
+
+The package defines three http middlewares:
+  
+- RequestCacheMiddleware: If a request is cacheble the cache is asked first and only if no response is found the 
+  reqeust is passed down the middleware chain. The cache lifetime and tags are determined from the 
+  `X-FullPageCache-Enabled`, `X-FullPageCache-Lifetime` and `X-FullPageCache-Tags` that are set by upstream middlewares 
+  or controllers. 
+
+- PublicCacheHeaderMiddleware: Set `ETag` and `CacheControl` Headers based on the `X-FullPageCache-Enabled` and the 
+  `X-FullPageCache-Lifetime` headers taking the `maxPublicCacheTime` into account.
+  
+- CacheHeaderMiddleware: Connects to the fusion cache and extracts tags plus the allowed lifetime which is then 
+  stored in the response headers `X-FullPageCache-Enabled`, `X-FullPageCache-Lifetime` and `X-FullPageCache-Tags`
+
+Controllers that want to control the caching behavior directly can set the headers `X-FullPageCache-Enabled`, 
+`X-FullPageCache-Lifetime` and `X-FullPageCache-Tags` directly.
+
 Warning
 -------