Files
nexarch/dms/internal/thumbnail/generate.go
T
patrickandClaude Sonnet 5 08584b0c5f DOC-04: Vorschau- & Thumbnail-Pipeline
internal/thumbnail: Vorschau-Zustand je Datei-Revision als explizite
State-Machine (pending/processing/ready/failed, revision_thumbnails)
statt Ableitung aus Dateiendung. Content-Type wird ausschliesslich ueber
Magic-Bytes bestimmt (net/http.DetectContentType gegen die entschluesselten
Bytes) - der in "Bekannte Fehler vermeiden" beschriebene Fehler eines
Vorgaengerprojekts (fragile Erkennung ueber Dateiendung) wird damit
vermieden.

PDF-Rasterung ueber pdftoppm (Poppler), Bild-Thumbnails ueber einen
minimalen, abhaengigkeitsfreien Nearest-Neighbor-Resizer auf Basis der
Standardbibliothek. Original wird ueber FDN-09 (dmscrypto) entschluesselt,
Thumbnail wird ebenfalls verschluesselt im Objekt-Storage abgelegt -
gleiches Schutzniveau wie das Original.

upload.Service bekommt SetThumbnailEnqueuer (neue, optionale Methode -
bestehende Aufrufer/Tests unveraendert funktionsfaehig) und reiht nach
erfolgreichem Complete() die Vorschau-Erzeugung ein; ein Fehlschlag dabei
laesst den bereits abgeschlossenen Upload nicht ruecktwirkend fehlschlagen.

Pruefungen:
1. Beschaedigte PDF-Datei -> Fehlerstatus statt Absturz, blockiert andere
   Jobs nicht (echter pdftoppm-Fehlschlag, echte SKIP-LOCKED-Job-Queue)
2. Durchsatztest: 500 echte PDFs, alle erfolgreich, ~15s Gesamtlaufzeit
3. Cache-Invalidierung bei neuer Revision: GetCurrentForDocument loest
   nachweislich auf die neue statt die alte Revision auf

Regressionsfrei: 13 bestehende upload-/jobqueue-Tests unveraendert PASS.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-17 19:42:30 +02:00

208 lines
6.7 KiB
Go

package thumbnail
import (
"bytes"
"context"
"encoding/json"
"fmt"
"image"
_ "image/gif"
_ "image/jpeg"
"image/png"
"io"
"net/http"
"os"
"os/exec"
"path/filepath"
"github.com/jackc/pgx/v5/pgxpool"
dmscrypto "gitea.perlbach24.de/scripte/nexarch/dms/internal/crypto"
"gitea.perlbach24.de/scripte/nexarch/dms/internal/jobqueue"
"gitea.perlbach24.de/scripte/nexarch/dms/internal/storage"
)
const maxThumbnailWidth = 300
// Generator erzeugt Thumbnails. pdftoppmPath ist injizierbar für Tests
// (Default "pdftoppm", muss im PATH liegen).
type Generator struct {
Pool *pgxpool.Pool
Storage *storage.Service
Crypto *dmscrypto.Service
TenantSlug string
PdftoppmPath string
}
func (g *Generator) pdftoppmBinary() string {
if g.PdftoppmPath != "" {
return g.PdftoppmPath
}
return "pdftoppm"
}
// Handler ist der jobqueue.Handler für JobType — dekodiert den Auftrag,
// lädt und entschlüsselt den Originalinhalt, erkennt den TATSÄCHLICHEN
// Content-Type über Magic-Bytes (net/http.DetectContentType, NICHT über
// die Dateiendung — siehe "Bekannte Fehler vermeiden" im Ticket) und
// erzeugt je nach Typ ein Thumbnail. Eine fehlerhafte/nicht unterstützte
// Datei liefert einen Fehler (Job schlägt fehl, State-Machine geht auf
// "failed") statt die gesamte Pipeline zu blockieren (Akzeptanzkriterium 3
// — andere Jobs bleiben durch jobqueue.Dequeues SKIP LOCKED unberührt).
func (g *Generator) Handler(ctx context.Context, job *jobqueue.Job) error {
var payload jobPayload
if err := json.Unmarshal(job.Payload, &payload); err != nil {
return fmt.Errorf("thumbnail: auftrag dekodieren: %w", err)
}
if err := markProcessing(ctx, g.Pool, payload.RevisionID); err != nil {
return fmt.Errorf("thumbnail: verarbeitung markieren: %w", err)
}
if err := g.process(ctx, payload); err != nil {
if markErr := markFailed(ctx, g.Pool, payload.RevisionID, err); markErr != nil {
return fmt.Errorf("thumbnail: fehlschlag erfassen (ursprünglicher fehler: %v): %w", err, markErr)
}
return err
}
return nil
}
func (g *Generator) process(ctx context.Context, payload jobPayload) error {
var storageKey string
var wrappedDEK []byte
if err := g.Pool.QueryRow(ctx, `
SELECT storage_key, wrapped_dek FROM file_revisions WHERE id = $1
`, payload.RevisionID).Scan(&storageKey, &wrappedDEK); err != nil {
return fmt.Errorf("thumbnail: revision lesen: %w", err)
}
cipherReader, err := g.Storage.Get(ctx, storageKey)
if err != nil {
return fmt.Errorf("thumbnail: original aus storage laden: %w", err)
}
defer func() { _ = cipherReader.Close() }()
plainReader, err := g.Crypto.Open(ctx, g.TenantSlug, wrappedDEK, cipherReader)
if err != nil {
return fmt.Errorf("thumbnail: original entschluesseln: %w", err)
}
plaintext, err := io.ReadAll(plainReader)
if err != nil {
return fmt.Errorf("thumbnail: original lesen: %w", err)
}
sniffLen := 512
if len(plaintext) < sniffLen {
sniffLen = len(plaintext)
}
contentType := http.DetectContentType(plaintext[:sniffLen])
var pngBytes []byte
switch {
case contentType == "application/pdf":
pngBytes, err = g.renderPDFFirstPage(plaintext)
case contentType == "image/jpeg" || contentType == "image/png" || contentType == "image/gif":
pngBytes, err = resizeImageToPNG(plaintext)
default:
err = fmt.Errorf("thumbnail: nicht unterstuetzter dateityp %q", contentType)
}
if err != nil {
return err
}
env, err := g.Crypto.Seal(ctx, g.TenantSlug, bytes.NewReader(pngBytes))
if err != nil {
return fmt.Errorf("thumbnail: verschluesseln: %w", err)
}
ciphertext, err := io.ReadAll(env.Ciphertext)
if err != nil {
return fmt.Errorf("thumbnail: chiffretext lesen: %w", err)
}
thumbKey := storage.ObjectKey(payload.DocumentID, payload.RevisionID) + "/thumbnail.png"
if _, err := g.Storage.Put(ctx, thumbKey, bytes.NewReader(ciphertext), int64(len(ciphertext)), "application/octet-stream"); err != nil {
return fmt.Errorf("thumbnail: im storage ablegen: %w", err)
}
if err := markReady(ctx, g.Pool, payload.RevisionID, thumbKey, "image/png", env.WrappedDEK); err != nil {
return fmt.Errorf("thumbnail: bereit-zustand speichern: %w", err)
}
return nil
}
// renderPDFFirstPage rastert die erste Seite eines PDFs über pdftoppm zu
// PNG. Eine beschädigte/unvollständige PDF-Datei lässt pdftoppm mit
// Exit-Code ungleich 0 fehlschlagen — das wird als Fehler nach oben
// gereicht (Akzeptanzkriterium 3, Pflichtprüfung 1), kein Absturz.
func (g *Generator) renderPDFFirstPage(pdfBytes []byte) ([]byte, error) {
tmpDir, err := os.MkdirTemp("", "dms-thumbnail-*")
if err != nil {
return nil, fmt.Errorf("thumbnail: temporaeres verzeichnis anlegen: %w", err)
}
defer func() { _ = os.RemoveAll(tmpDir) }()
inputPath := filepath.Join(tmpDir, "input.pdf")
if err := os.WriteFile(inputPath, pdfBytes, 0o600); err != nil {
return nil, fmt.Errorf("thumbnail: pdf zwischenspeichern: %w", err)
}
outPrefix := filepath.Join(tmpDir, "out")
cmd := exec.Command(g.pdftoppmBinary(), "-png", "-f", "1", "-l", "1", "-scale-to", fmt.Sprintf("%d", maxThumbnailWidth), inputPath, outPrefix)
output, err := cmd.CombinedOutput()
if err != nil {
return nil, fmt.Errorf("thumbnail: pdftoppm fehlgeschlagen: %w (ausgabe: %s)", err, string(output))
}
matches, err := filepath.Glob(outPrefix + "-*.png")
if err != nil || len(matches) == 0 {
return nil, fmt.Errorf("thumbnail: pdftoppm lieferte keine ausgabedatei (matches=%v, err=%v)", matches, err)
}
pngBytes, err := os.ReadFile(matches[0])
if err != nil {
return nil, fmt.Errorf("thumbnail: erzeugtes thumbnail lesen: %w", err)
}
return pngBytes, nil
}
// resizeImageToPNG dekodiert ein Bild (JPEG/PNG/GIF) und verkleinert es
// per einfachem Nearest-Neighbor auf maxThumbnailWidth Breite — bewusst
// ohne externe Bildbibliothek (kleinste Loesung, Standardbibliothek
// genuegt fuer ein Thumbnail).
func resizeImageToPNG(data []byte) ([]byte, error) {
src, _, err := image.Decode(bytes.NewReader(data))
if err != nil {
return nil, fmt.Errorf("thumbnail: bild dekodieren: %w", err)
}
bounds := src.Bounds()
srcW, srcH := bounds.Dx(), bounds.Dy()
if srcW == 0 || srcH == 0 {
return nil, fmt.Errorf("thumbnail: bild hat keine ausdehnung")
}
dstW := srcW
dstH := srcH
if srcW > maxThumbnailWidth {
dstW = maxThumbnailWidth
dstH = srcH * maxThumbnailWidth / srcW
if dstH < 1 {
dstH = 1
}
}
dst := image.NewRGBA(image.Rect(0, 0, dstW, dstH))
for y := 0; y < dstH; y++ {
for x := 0; x < dstW; x++ {
srcX := bounds.Min.X + x*srcW/dstW
srcY := bounds.Min.Y + y*srcH/dstH
dst.Set(x, y, src.At(srcX, srcY))
}
}
var buf bytes.Buffer
if err := png.Encode(&buf, dst); err != nil {
return nil, fmt.Errorf("thumbnail: png kodieren: %w", err)
}
return buf.Bytes(), nil
}