[6.x] Hybrid Glide image caching

config/assets.php

@@ -46,9 +46,16 @@
         | Save Cached Images
         |--------------------------------------------------------------------------
         |
-        | Enabling this will make Glide save publicly accessible images. It will
-        | increase performance at the cost of the dynamic nature of HTTP based
-        | image manipulation. You will need to invalidate images manually.
+        | This controls how manipulated images are cached and served.
+        |
+        | false  - Images are generated on each HTTP request via Glide routes.
+        | true   - Images are eagerly generated during template rendering and
+        |          saved to a publicly accessible location.
+        | 'hybrid' - Images are generated on-demand on the first HTTP request,
+        |          then saved to a publicly accessible location so the web
+        |          server can serve them directly on subsequent requests.
+        |
+        | When using true or 'hybrid', you should configure the cache_path below.
         |
         */
 

routes/glide.php

@@ -6,6 +6,14 @@
 use Statamic\Facades\URL;
 use Statamic\Http\Controllers\GlideController;
 
+if (Glide::isUsingHybridCaching()) {
+    Route::group(['prefix' => Glide::route()], function () {
+        Route::get('{path}', [GlideController::class, 'generateByPath'])->where('path', '.*');
+    });
+
+    return;
+}
+
 Site::all()->map(function ($site) {
     return trim(URL::makeRelative($site->url()), '/');
 })->unique()->each(function ($sitePrefix) {

routes/routes.php

@@ -29,7 +29,7 @@
     });
 }
 
-if (Glide::shouldServeByHttp()) {
+if (Glide::shouldServeByHttp() || Glide::isUsingHybridCaching()) {
     require __DIR__.'/glide.php';
 }
 

src/Facades/Glide.php

@@ -10,6 +10,8 @@
  * @method static \Illuminate\Contracts\Filesystem\Filesystem cacheDisk()
  * @method static bool shouldServeDirectly()
  * @method static bool shouldServeByHttp()
+ * @method static bool isUsingHybridCaching()
+ * @method static bool cachePathIsServedByRoute()
  * @method static string route()
  * @method static string url()
  * @method static \Illuminate\Contracts\Cache\Repository cacheStore()

src/Http/Controllers/GlideController.php

@@ -3,6 +3,8 @@
 namespace Statamic\Http\Controllers;
 
 use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Log;
+use League\Flysystem\PathTraversalDetected;
 use League\Flysystem\UnableToReadFile;
 use League\Glide\Server;
 use League\Glide\Signatures\SignatureException;
@@ -12,6 +14,7 @@
 use Statamic\Facades\Asset;
 use Statamic\Facades\AssetContainer;
 use Statamic\Facades\Config;
+use Statamic\Facades\Glide;
 use Statamic\Facades\Site;
 use Statamic\Imaging\ImageGenerator;
 use Statamic\Support\Str;
@@ -51,6 +54,10 @@ public function __construct(Server $server, Request $request, ImageGenerator $ge
      */
     public function generateByPath($path)
     {
+        if (Glide::isUsingHybridCaching()) {
+            return $this->generateOnDemand($path);
+        }
+
         $this->validateSignature();
 
         // If the auto crop setting is enabled, we will attempt to resolve an asset from the
@@ -79,6 +86,73 @@ public function generateByUrl($url)
         return $this->createResponse($this->generateBy('url', $url));
     }
 
+    /**
+     * Generate an on-demand image for the hybrid caching strategy.
+     *
+     * The URL path is the predicted cache path. A mapping stored in the
+     * Glide cache store links it back to the source and manipulation params.
+     */
+    private function generateOnDemand(string $path)
+    {
+        if ($this->existsInCache($path)) {
+            $this->warnAboutServingThroughPhp($path);
+
+            return $this->createResponse($path);
+        }
+
+        $mapping = Glide::cacheStore()->get('hybrid::'.$path);
+
+        throw_unless($mapping, new NotFoundHttpException);
+
+        $type = $mapping['type'];
+        $params = $mapping['params'];
+
+        $item = match ($type) {
+            'asset' => Asset::find($mapping['id']) ?? throw new NotFoundHttpException,
+            'url' => $mapping['url'],
+            'path' => $mapping['path'],
+        };
+
+        return $this->createResponse($this->ensureGenerated($type, $item, $params));
+    }
+
+    private function existsInCache(string $path): bool
+    {
+        try {
+            return Glide::cacheDisk()->exists($path);
+        } catch (PathTraversalDetected $e) {
+            throw new NotFoundHttpException;
+        }
+    }
+
+    /**
+     * The image already exists, so the web server should have served it without
+     * involving PHP. Warn once, since otherwise this fires on every request
+     * for every image, which is the situation we're complaining about.
+     */
+    private function warnAboutServingThroughPhp(string $path): void
+    {
+        if (! Glide::cacheStore()->add('hybrid-served-through-php-warning', true)) {
+            return;
+        }
+
+        Log::warning('Glide hybrid caching: ['.$path.'] already exists but was still served by PHP. Check that the image_manipulation.cache_path is inside your public directory and reachable at the image_manipulation.route.');
+    }
+
+    /**
+     * Forget any stale cache store entry, then generate the image.
+     *
+     * In hybrid mode, the file on disk is the source of truth.
+     * If we're here, the file doesn't exist, so the cache store
+     * entry (if any) is stale and should be cleared first.
+     */
+    private function ensureGenerated(string $type, $item, array $params)
+    {
+        Glide::cacheStore()->forget(ImageGenerator::manipulationCacheKey($type, $item, $params));
+
+        return $this->generateBy($type, $item, $params);
+    }
+
     /**
      * Generate a manipulated image by an asset reference.
      *
@@ -108,12 +182,12 @@ public function generateByAsset($encoded)
      *
      * @return mixed
      */
-    private function generateBy($type, $item)
+    private function generateBy($type, $item, ?array $params = null)
     {
         $method = 'generateBy'.ucfirst($type);
 
         try {
-            return $this->generator->$method($item, $this->request->all());
+            return $this->generator->$method($item, $params ?? $this->request->all());
         } catch (InvalidRemoteUrlException $e) {
             abort(400, $e->getMessage());
         } catch (UnableToReadFile $e) {

src/Imaging/GlideCachePathResolver.php

@@ -0,0 +1,89 @@
+<?php
+
+namespace Statamic\Imaging;
+
+use League\Glide\Server;
+use Statamic\Contracts\Assets\Asset;
+use Statamic\Facades\URL;
+
+class GlideCachePathResolver
+{
+    public function __construct(private Server $server)
+    {
+    }
+
+    public function resolveForAsset(Asset $asset, array $params): string
+    {
+        if ($asset->isVideo()) {
+            return $this->resolveForPath(ThumbnailExtractor::getFileName($asset), $params);
+        }
+
+        return $this->resolve(
+            $asset->basename(),
+            $params,
+            sourcePathPrefix: $asset->folder(),
+            cachePathPrefix: ImageGenerator::assetCachePathPrefix($asset).'/'.$asset->folder(),
+            asset: $asset,
+        );
+    }
+
+    public function resolveForPath(string $path, array $params): string
+    {
+        return $this->resolve(
+            $path,
+            $params,
+            sourcePathPrefix: '/',
+            cachePathPrefix: 'paths',
+        );
+    }
+
+    public function resolveForUrl(string $url, array $params): string
+    {
+        $parsed = app(RemoteUrlValidator::class)->parse($url);
+        $qs = $parsed['query'];
+        $path = $parsed['path'].($qs ? '?'.$qs : '');
+
+        return $this->resolve(
+            $path,
+            $params,
+            sourcePathPrefix: '/',
+            cachePathPrefix: 'http',
+        );
+    }
+
+    public function resolveForItem($item, array $params): string
+    {
+        if ($item instanceof Asset) {
+            return $this->resolveForAsset($item, $params);
+        }
+
+        if (is_string($item) && URL::isAbsolute($item)) {
+            return $this->resolveForUrl($item, $params);
+        }
+
+        return $this->resolveForPath($item, $params);
+    }
+
+    private function resolve(string $image, array $params, string $sourcePathPrefix, string $cachePathPrefix, ?Asset $asset = null): string
+    {
+        if (isset($params['mark'])) {
+            $params['mark'] = ImageGenerator::watermarkParam($params['mark']);
+        }
+
+        $origSourcePrefix = $this->server->getSourcePathPrefix();
+        $origCachePrefix = $this->server->getCachePathPrefix();
+        $origDefaults = $this->server->getDefaults();
+
+        $this->server->setSourcePathPrefix($sourcePathPrefix);
+        $this->server->setCachePathPrefix($cachePathPrefix);
+        $this->server->setDefaults(ImageGenerator::getDefaultManipulations($asset));
+
+        try {
+            return $this->server->getCachePath($image, $params);
+        } finally {
+            $this->server->setSourcePathPrefix($origSourcePrefix);
+            $this->server->setCachePathPrefix($origCachePrefix);
+            $this->server->setDefaults($origDefaults);
+        }
+    }
+}

src/Imaging/GlideManager.php

@@ -9,6 +9,7 @@
 use Statamic\Events\GlideAssetCacheCleared;
 use Statamic\Facades\Config;
 use Statamic\Facades\Image;
+use Statamic\Facades\Path;
 use Statamic\Facades\URL;
 use Statamic\Imaging\ResponseFactory as LaravelResponseFactory;
 use Statamic\Support\Str;
@@ -49,7 +50,9 @@ public function cacheDisk()
 
     private function wantsCustomFilesystem()
     {
-        return is_string(Config::get('statamic.assets.image_manipulation.cache'));
+        $cache = Config::get('statamic.assets.image_manipulation.cache');
+
+        return is_string($cache) && $cache !== 'hybrid';
     }
 
     private function localCacheFilesystem()
@@ -77,26 +80,47 @@ private function customCacheFilesystem()
      */
     private function cachePath()
     {
-        return $this->shouldServeDirectly()
+        return ($this->shouldServeDirectly() || $this->isUsingHybridCaching())
             ? Config::get('statamic.assets.image_manipulation.cache_path')
             : storage_path('statamic/glide');
     }
 
     public function shouldServeDirectly()
     {
-        return (bool) Config::get('statamic.assets.image_manipulation.cache');
+        $cache = Config::get('statamic.assets.image_manipulation.cache');
+
+        return $cache === true || $this->wantsCustomFilesystem();
     }
 
     public function shouldServeByHttp()
     {
-        return ! $this->shouldServeDirectly();
+        return ! $this->shouldServeDirectly() && ! $this->isUsingHybridCaching();
+    }
+
+    public function isUsingHybridCaching()
+    {
+        return Config::get('statamic.assets.image_manipulation.cache') === 'hybrid';
     }
 
     public function route()
     {
         return Config::get('statamic.assets.image_manipulation.route');
     }
 
+    public function cachePathIsServedByRoute()
+    {
+        $publicPath = Path::tidy(public_path());
+        $cachePath = Path::tidy(Config::get('statamic.assets.image_manipulation.cache_path'));
+
+        if (! Str::startsWith($cachePath, $publicPath)) {
+            return false;
+        }
+
+        $servedPath = trim(Str::after($cachePath, $publicPath), '/');
+
+        return $servedPath === trim(URL::makeRelative($this->route()), '/');
+    }
+
     public function url()
     {
         $url = $this->wantsCustomFilesystem()

src/Imaging/GlideUrlBuilder.php

@@ -4,7 +4,6 @@
 
 use Exception;
 use League\Glide\Urls\UrlBuilderFactory;
-use Statamic\Contracts\Assets\Asset;
 use Statamic\Facades\URL;
 use Statamic\Support\Str;
 
@@ -58,10 +57,7 @@ public function build($item, $params)
             $path .= Str::ensureLeft(URL::encode($filename), '/');
         }
 
-        if (isset($params['mark']) && $params['mark'] instanceof Asset) {
-            $asset = $params['mark'];
-            $params['mark'] = 'asset::'.Str::toBase64Url($asset->containerId().'/'.$asset->path());
-        }
+        $params = $this->withEncodedWatermark($params);
 
         return URL::makeRelative(
             URL::prependSiteUrl($builder->getUrl($path, $params))