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>
208 lines
6.7 KiB
Go
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
|
|
}
|