Hero: grote foto's in de achtergrond robuust en sneller, voortgang en opnieuw proberen; admin zonder inline script

- Een decode voor de hele set, per breedte eenmaal geschaald voor WebP en AVIF (6000x4000: 21,1 s -> 6,4 s per set)
- Eigen limiet per set (Media:RenderSetTimeoutSeconds 600), harde limiet rond een foto, de renderer stopt nooit door een uitzondering, een mislukte foto wacht tot de volgende ronde en houdt de rij niet op
- Logging per foto (start, per variant, einde, fout); voortgang per variant in de admin; nieuwe uitsnede na focuswijziging zichtbaar (oude afbeelding blijft, shimmer); knop Opnieuw proberen
- Thema-script als /theme-init.js (CSP script-src 'self'), test en smoke-controle op inline scripts

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-16 22:23:15 +01:00
co-authored by Claude Sonnet 5.5
parent 9d647bb049
commit 1b542dee98
22 changed files with 567 additions and 54 deletions
@@ -25,7 +25,9 @@ public record HeroImageDto(
string Src,
IReadOnlyList<HeroVariantDto> Variants,
bool Processing = false,
bool Failed = false);
bool Failed = false,
int? RenderDone = null,
int? RenderTotal = null);
public record HeroButtonDto(string Label, string Target);
@@ -40,6 +40,9 @@ public interface IHeroImageService
/// </summary>
void ApplyFocus(HeroImage image, HeroFocusRequest request);
/// <summary>The variant the renderer is busy with: (done, total), or null when the image is not being cut right now.</summary>
(int Done, int Total)? RenderProgress(Guid imageId);
/// <summary>True when the background renderer gave up on the image after a few failed tries (until a retry or a restart).</summary>
bool IsRenderFailed(Guid imageId);
@@ -160,6 +163,8 @@ public class HeroImageService(
public bool IsRenderFailed(Guid imageId) => signal?.IsGivenUp(imageId) ?? false;
public (int Done, int Total)? RenderProgress(Guid imageId) => signal?.GetProgress(imageId);
public async Task RetryRenderAsync(Guid imageId, CancellationToken cancellationToken)
{
_ = await repository.GetImageAsync(imageId, cancellationToken) ?? throw new HeroImageNotFoundException();
@@ -181,8 +186,13 @@ public class HeroImageService(
}
catch (Exception exception) when (exception is not OperationCanceledException)
{
logger.LogError(exception, "Hero image {ImageId}: cutting the variants failed.", image.Id);
throw new HeroImageRenderException(image.Id, exception);
}
finally
{
signal?.ClearProgress(image.Id);
}
}
private async Task<Guid?> RenderAsync(HeroImage image, CancellationToken cancellationToken)
@@ -193,6 +203,7 @@ public class HeroImageService(
Dictionary<string, byte[]> files;
List<HeroVariant> variants;
var watch = System.Diagnostics.Stopwatch.StartNew();
logger.LogInformation("Hero image {ImageId}: cutting the variants starts ({Width}x{Height}, {Bytes} bytes, {Reason}).", image.Id, image.Width, image.Height, image.Bytes, image.Variants.Count == 0 ? "new" : "focus changed");
using (await gate.EnterAsync(cancellationToken))
{
var file = await store.OpenReadAsync(image.OriginalKey, cancellationToken)
@@ -204,7 +215,13 @@ public class HeroImageService(
}
var storedFormat = ImageFormatExtensions.FromExtension(Path.GetExtension(image.OriginalKey).TrimStart('.'));
(files, variants) = await RenderSetAsync(image, memory.ToArray(), storedFormat, cancellationToken);
var lastStep = watch.Elapsed;
(files, variants) = await RenderSetAsync(image, memory.ToArray(), storedFormat, (done, total) =>
{
signal?.SetProgress(image.Id, done, total);
logger.LogInformation("Hero image {ImageId}: variant {Done} of {Total} in {Milliseconds:0} ms.", image.Id, done, total, (watch.Elapsed - lastStep).TotalMilliseconds);
lastStep = watch.Elapsed;
}, cancellationToken);
}
await store.PutSetAsync(HeroMapping.Area, target, files, cancellationToken);
@@ -260,22 +277,25 @@ public class HeroImageService(
assign((f.X, f.Y, f.Zoom));
}
/// <summary>Cuts and encodes every planned variant of the image at its current focus. Returns the files by name and the variant list.</summary>
private async Task<(Dictionary<string, byte[]> Files, List<HeroVariant> Variants)> RenderSetAsync(HeroImage image, byte[] original, ImageFormat storedFormat, CancellationToken cancellationToken)
/// <summary>Cuts and encodes every planned variant of the image at its current focus (one decode for the whole set).</summary>
private async Task<(Dictionary<string, byte[]> Files, List<HeroVariant> Variants)> RenderSetAsync(HeroImage image, byte[] original, ImageFormat storedFormat, Action<int, int>? progress, CancellationToken cancellationToken)
{
var ratios = new[] { Ratio.Wide, Ratio.Tall }
.Select(r => new RatioPlan(r, image.FocusFor(r.Name), VariantPlanner.DefaultWidths(r)))
.ToList();
var specs = VariantPlanner.Plan(image.Width, image.Height, ratios, processor.SupportedOutput);
progress?.Invoke(0, specs.Count);
var rendered = await processor.RenderSetAsync(original, storedFormat, specs, progress, cancellationToken);
var files = new Dictionary<string, byte[]>();
var variants = new List<HeroVariant>();
foreach (var spec in specs)
for (var i = 0; i < specs.Count; i++)
{
var rendered = await processor.RenderAsync(original, storedFormat, spec, cancellationToken);
var spec = specs[i];
var name = MediaPaths.FileName(spec.Ratio.Name, spec.Width, spec.Format);
files[name] = rendered.Bytes;
variants.Add(new HeroVariant(spec.Ratio.Name, rendered.Width, rendered.Height, spec.Format.MimeType(), name, rendered.Bytes.LongLength));
files[name] = rendered[i].Bytes;
variants.Add(new HeroVariant(spec.Ratio.Name, rendered[i].Width, rendered[i].Height, spec.Format.MimeType(), name, rendered[i].Bytes.LongLength));
}
return (files, variants);
@@ -1,6 +1,8 @@
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using SlpModularCms.Core.Media;
namespace SlpModularCms.Modules.Hero.Services;
@@ -32,6 +34,14 @@ public sealed class HeroRenderSignal
public IReadOnlySet<Guid> GivenUp() => _failures.Where(f => f.Value >= MaxAttempts).Select(f => f.Key).ToHashSet();
private readonly System.Collections.Concurrent.ConcurrentDictionary<Guid, (int Done, int Total)> _progress = new();
public void SetProgress(Guid imageId, int done, int total) => _progress[imageId] = (done, total);
public (int Done, int Total)? GetProgress(Guid imageId) => _progress.TryGetValue(imageId, out var p) ? p : null;
public void ClearProgress(Guid imageId) => _progress.TryRemove(imageId, out _);
/// <summary>Forgets the failures of an image (after a success, a retry or a new upload of the same photo).</summary>
public void Reset(Guid imageId) => _failures.TryRemove(imageId, out _);
@@ -45,18 +55,28 @@ public sealed class HeroRenderSignal
/// its new set) the moment its set is complete; until then the old set, or nothing, is published. Looks again when woken
/// and at least every minute, and at start-up, so work interrupted by a restart is picked up.
/// </summary>
public sealed class HeroRenderService(IServiceScopeFactory scopes, HeroRenderSignal signal, ILogger<HeroRenderService> logger) : BackgroundService
public sealed class HeroRenderService(IServiceScopeFactory scopes, HeroRenderSignal signal, IOptions<MediaOptions> media, ILogger<HeroRenderService> logger) : BackgroundService
{
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
try
{
// Let the start-up (migrations, health check) finish first.
// Let the start-up (migrations, health check) finish first; whatever was still pending is picked up then.
await Task.Delay(TimeSpan.FromSeconds(10), stoppingToken);
logger.LogInformation("Hero image renderer started.");
while (!stoppingToken.IsCancellationRequested)
{
await RunPassAsync(stoppingToken);
try
{
await RunPassAsync(stoppingToken);
}
catch (Exception exception) when (exception is not OperationCanceledException)
{
// Whatever happens, the renderer does not stop: it logs and looks again at the next wake-up.
logger.LogError(exception, "A round of the hero image renderer failed; it goes on.");
}
await signal.WaitAsync(TimeSpan.FromMinutes(1), stoppingToken);
}
}
@@ -68,20 +88,32 @@ public sealed class HeroRenderService(IServiceScopeFactory scopes, HeroRenderSig
private async Task RunPassAsync(CancellationToken stoppingToken)
{
// An image that failed in this pass waits for the next pass (a minute later or the next wake-up): one difficult photo
// must not hold up the others, and it is not retried straight away.
var failedInThisPass = new HashSet<Guid>();
while (!stoppingToken.IsCancellationRequested)
{
var skip = signal.GivenUp();
var skip = signal.GivenUp().Concat(failedInThisPass).ToHashSet();
Guid? handled = null;
try
{
using var scope = scopes.CreateScope();
handled = await scope.ServiceProvider.GetRequiredService<IHeroImageService>().RenderNextPendingAsync(skip, stoppingToken);
// A hard limit around one image, a little above the time the image library itself is allowed: nothing can
// keep the renderer waiting for ever.
using var limit = CancellationTokenSource.CreateLinkedTokenSource(stoppingToken);
limit.CancelAfter(TimeSpan.FromSeconds(Math.Max(30, media.Value.RenderSetTimeoutSeconds) + 60));
handled = await scope.ServiceProvider.GetRequiredService<IHeroImageService>().RenderNextPendingAsync(skip, limit.Token);
}
catch (OperationCanceledException) when (!stoppingToken.IsCancellationRequested)
{
logger.LogError("Cutting a hero image took longer than the hard limit; the round is stopped and tried again at the next wake-up.");
return;
}
catch (HeroImageRenderException failure)
{
failedInThisPass.Add(failure.ImageId);
var attempts = signal.RecordFailure(failure.ImageId);
logger.LogError(failure.InnerException, "Cutting the variants of hero image {ImageId} failed (attempt {Attempt} of {Max}).", failure.ImageId, attempts, HeroRenderSignal.MaxAttempts);
await Task.Delay(TimeSpan.FromSeconds(5), stoppingToken);
continue;
}
catch (Exception exception) when (exception is not OperationCanceledException)
@@ -38,13 +38,19 @@ public class HeroService(
public async Task<HeroAdminDto> GetAsync(CancellationToken cancellationToken)
=> WithFailures(HeroMapping.ToAdmin(await repository.GetReadOnlyAsync(HeroLanguages.Default, cancellationToken), _time.GetUtcNow(), options.Value.MaxPublishedSlides));
/// <summary>Marks the images the background renderer gave up on (that state lives in memory, not in the database).</summary>
/// <summary>Adds what only the running renderer knows (gave up on the image, which variant it is cutting); it lives in memory, not in the database.</summary>
private HeroAdminDto WithFailures(HeroAdminDto dto)
=> dto with
{
Slides = dto.Slides
.Select(s => imageService.IsRenderFailed(Guid.Parse(s.ImageId)) ? s with { Image = s.Image with { Failed = true } } : s)
.ToList(),
Slides = dto.Slides.Select(s =>
{
var id = Guid.Parse(s.ImageId);
var progress = imageService.RenderProgress(id);
var failed = imageService.IsRenderFailed(id);
return failed || progress is not null
? s with { Image = s.Image with { Failed = failed, RenderDone = progress?.Done, RenderTotal = progress?.Total } }
: s;
}).ToList(),
};
public async Task<HeroAdminDto> SaveAsync(HeroSaveRequest request, Guid callerId, CancellationToken cancellationToken)