Performance: FOP Worker Pool für 5-10x schnellere PDF-Generierung
Implementiert persistente JVM-Prozesse für Apache FOP analog zum bestehenden SaxonWorkerPool-System. Eliminiert JVM-Startup-Overhead durch Wiederverwendung von Worker-Prozessen. Änderungen: - Neues Modul fop_pool.py mit FopWorkerPool und Java Worker-Klasse - Integration in transform.py mit automatischem Fallback auf subprocess - GUI-Einstellungen für FOP Worker Pool (aktivieren/deaktivieren) - Automatische Neuinitialisierung bei Einstellungsänderungen - Konfiguration: use_fop_worker_pool in AppSettings (Standard: aktiviert) Performance: 5-10x schnellere PDF-Generierung bei vielen kleinen PDFs durch Wiederverwendung von FopFactory und Font-Caches. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
This commit is contained in:
@@ -144,6 +144,7 @@ class AppSettings(BaseSettings):
|
||||
theme: str | None = None
|
||||
max_workers: int = 8 # Anzahl paralleler Worker für Transformationen (Standard: 8)
|
||||
use_saxon_worker_pool: bool = True # SaxonWorkerPool aktivieren (schneller, benötigt JDK)
|
||||
use_fop_worker_pool: bool = True # FopWorkerPool aktivieren (schneller, benötigt JDK)
|
||||
|
||||
# UI-Zustand
|
||||
window_geometry: tuple[int, int, int, int] | None = None # (x, y, width, height)
|
||||
|
||||
+454
@@ -0,0 +1,454 @@
|
||||
"""
|
||||
FOP Worker Pool - Persistente JVM-Prozesse für schnelle PDF-Generierung.
|
||||
|
||||
Eliminiert JVM-Startup-Overhead durch Vorinitialisierung von N Worker-Prozessen.
|
||||
Jeder Worker läuft als Daemon und verarbeitet mehrere FO→PDF Transformationen nacheinander.
|
||||
"""
|
||||
|
||||
import logging
|
||||
import subprocess
|
||||
import threading
|
||||
from pathlib import Path
|
||||
from queue import Queue
|
||||
from typing import Optional
|
||||
import tempfile
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
# Java-Worker-Code (wird zur Laufzeit kompiliert)
|
||||
FOP_WORKER_JAVA = """
|
||||
import org.apache.fop.apps.*;
|
||||
import org.xml.sax.SAXException;
|
||||
import javax.xml.transform.*;
|
||||
import javax.xml.transform.sax.SAXResult;
|
||||
import javax.xml.transform.stream.StreamSource;
|
||||
import java.io.*;
|
||||
import java.net.URI;
|
||||
|
||||
public class FopWorker {
|
||||
public static void main(String[] args) {
|
||||
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
|
||||
String line;
|
||||
|
||||
System.err.println("FopWorker starting...");
|
||||
System.err.flush();
|
||||
|
||||
// Create FopFactory once and reuse (major performance boost!)
|
||||
FopFactory fopFactory = null;
|
||||
|
||||
try {
|
||||
// Check if config file is provided as first argument
|
||||
if (args.length > 0 && !args[0].isEmpty()) {
|
||||
File configFile = new File(args[0]);
|
||||
if (configFile.exists()) {
|
||||
System.err.println("Loading FOP config: " + configFile.getAbsolutePath());
|
||||
fopFactory = FopFactory.newInstance(configFile);
|
||||
} else {
|
||||
System.err.println("Config file not found, using default configuration");
|
||||
fopFactory = FopFactory.newInstance(new File(".").toURI());
|
||||
}
|
||||
} else {
|
||||
System.err.println("No config file specified, using default FOP configuration");
|
||||
fopFactory = FopFactory.newInstance(new File(".").toURI());
|
||||
}
|
||||
|
||||
System.err.println("FopWorker started and ready");
|
||||
System.err.flush();
|
||||
|
||||
} catch (Exception e) {
|
||||
System.err.println("FATAL: Failed to initialize FopFactory: " + e.getMessage());
|
||||
e.printStackTrace(System.err);
|
||||
System.exit(1);
|
||||
}
|
||||
|
||||
try {
|
||||
while ((line = reader.readLine()) != null) {
|
||||
System.err.println("DEBUG: Received line: " + line.substring(0, Math.min(100, line.length())));
|
||||
System.err.flush();
|
||||
|
||||
if ("EXIT".equals(line.trim())) {
|
||||
System.err.println("FopWorker exiting");
|
||||
break;
|
||||
}
|
||||
|
||||
try {
|
||||
// Parse job
|
||||
System.err.println("DEBUG: Parsing job...");
|
||||
System.err.flush();
|
||||
|
||||
String[] parts = line.split("\\t");
|
||||
System.err.println("DEBUG: Parts count: " + parts.length);
|
||||
System.err.flush();
|
||||
|
||||
if (parts.length < 2) {
|
||||
System.out.println("ERROR: Invalid job format");
|
||||
System.out.flush();
|
||||
continue;
|
||||
}
|
||||
|
||||
String inputFo = parts[0];
|
||||
String outputPdf = parts[1];
|
||||
|
||||
System.err.println("DEBUG: Input FO: " + inputFo);
|
||||
System.err.println("DEBUG: Output PDF: " + outputPdf);
|
||||
System.err.flush();
|
||||
|
||||
// Create FOUserAgent for this transformation
|
||||
FOUserAgent foUserAgent = fopFactory.newFOUserAgent();
|
||||
|
||||
// Note: Event Listener für detailliertes Error-Logging könnte hier hinzugefügt werden,
|
||||
// aber ist nicht kritisch - Fehler werden durch Exceptions gefangen
|
||||
|
||||
// Create output stream
|
||||
File outputFile = new File(outputPdf);
|
||||
outputFile.getParentFile().mkdirs();
|
||||
OutputStream out = new BufferedOutputStream(new FileOutputStream(outputFile));
|
||||
|
||||
try {
|
||||
System.err.println("DEBUG: Creating Fop instance...");
|
||||
System.err.flush();
|
||||
|
||||
// Create Fop instance
|
||||
Fop fop = fopFactory.newFop(MimeConstants.MIME_PDF, foUserAgent, out);
|
||||
|
||||
System.err.println("DEBUG: Setting up transformer...");
|
||||
System.err.flush();
|
||||
|
||||
// Setup Transformer
|
||||
TransformerFactory transformerFactory = TransformerFactory.newInstance();
|
||||
Transformer transformer = transformerFactory.newTransformer();
|
||||
|
||||
// Setup input and output
|
||||
Source src = new StreamSource(new File(inputFo));
|
||||
Result res = new SAXResult(fop.getDefaultHandler());
|
||||
|
||||
System.err.println("DEBUG: Running FOP transformation...");
|
||||
System.err.flush();
|
||||
|
||||
// Run transformation
|
||||
transformer.transform(src, res);
|
||||
|
||||
System.err.println("DEBUG: FOP transformation completed");
|
||||
System.err.flush();
|
||||
|
||||
} finally {
|
||||
out.close();
|
||||
}
|
||||
|
||||
// Transformation erfolgreich
|
||||
System.out.println("OK");
|
||||
System.out.flush();
|
||||
|
||||
} catch (Exception e) {
|
||||
System.err.println("DEBUG: Job processing exception: " + e.getClass().getName());
|
||||
System.err.flush();
|
||||
e.printStackTrace(System.err);
|
||||
|
||||
String errorMsg = e.getMessage();
|
||||
if (errorMsg == null || errorMsg.isEmpty()) {
|
||||
errorMsg = e.getClass().getSimpleName();
|
||||
}
|
||||
System.out.println("ERROR: " + errorMsg);
|
||||
System.out.flush();
|
||||
}
|
||||
}
|
||||
} catch (IOException e) {
|
||||
System.err.println("FopWorker I/O error: " + e.getMessage());
|
||||
e.printStackTrace(System.err);
|
||||
}
|
||||
}
|
||||
}
|
||||
"""
|
||||
|
||||
|
||||
class FopWorkerPool:
|
||||
"""
|
||||
Pool von lang-laufenden JVM-Prozessen für Apache FOP PDF-Generierung.
|
||||
|
||||
Eliminiert JVM-Startup-Overhead durch Wiederverwendung von N Worker-Prozessen.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
num_workers: int,
|
||||
java_vm_path: Path,
|
||||
apache_fop_dir: Path,
|
||||
fop_config_file: Optional[Path] = None,
|
||||
log_dir: Optional[Path] = None,
|
||||
):
|
||||
"""
|
||||
Initialisiert den FOP-Worker-Pool.
|
||||
|
||||
Args:
|
||||
num_workers: Anzahl der Worker-Prozesse
|
||||
java_vm_path: Pfad zur Java VM Binary
|
||||
apache_fop_dir: Pfad zum Apache FOP-Verzeichnis
|
||||
fop_config_file: Optionaler Pfad zur fop.xconf Konfigurationsdatei
|
||||
log_dir: Optionales Verzeichnis für Worker-Logs (Standard: temp_dir/temp)
|
||||
"""
|
||||
self.num_workers = num_workers
|
||||
self.java_vm_path = java_vm_path
|
||||
self.apache_fop_dir = apache_fop_dir
|
||||
self.fop_config_file = fop_config_file
|
||||
self.log_dir = log_dir
|
||||
|
||||
# Worker-Prozesse und Queues
|
||||
self.workers: list[subprocess.Popen] = []
|
||||
self.job_queue: Queue = Queue()
|
||||
self.result_queue: Queue = Queue()
|
||||
self.worker_locks: list[threading.Lock] = []
|
||||
|
||||
# Temporäres Verzeichnis für kompilierte Java-Klasse
|
||||
self.temp_dir: Optional[Path] = None
|
||||
self.worker_class_path: Optional[Path] = None
|
||||
self.worker_log_dir: Optional[Path] = None
|
||||
|
||||
# Classpath für FOP
|
||||
self.fop_classpath: Optional[str] = None
|
||||
|
||||
# Initialisierung
|
||||
self._build_fop_classpath()
|
||||
self._compile_worker_class()
|
||||
self._start_workers()
|
||||
|
||||
logger.info(f"FopWorkerPool initialisiert mit {num_workers} Workern")
|
||||
|
||||
def _build_fop_classpath(self):
|
||||
"""Erstellt den Classpath für Apache FOP."""
|
||||
import glob
|
||||
import sys
|
||||
|
||||
# Sammle alle JAR-Dateien im FOP-Verzeichnis
|
||||
all_jars = glob.glob(str(self.apache_fop_dir / "build" / "*.jar"))
|
||||
|
||||
# FOP lib-Verzeichnis
|
||||
lib_dir = self.apache_fop_dir / "lib"
|
||||
if lib_dir.exists() and lib_dir.is_dir():
|
||||
all_jars.extend(glob.glob(str(lib_dir / "*.jar")))
|
||||
|
||||
if not all_jars:
|
||||
raise RuntimeError(f"Keine FOP JAR-Dateien gefunden in {self.apache_fop_dir}")
|
||||
|
||||
classpath_separator = ";" if sys.platform == "win32" else ":"
|
||||
self.fop_classpath = classpath_separator.join(all_jars)
|
||||
|
||||
logger.debug(f"FOP Classpath: {len(all_jars)} JARs")
|
||||
|
||||
def _compile_worker_class(self):
|
||||
"""Kompiliert die FopWorker-Java-Klasse."""
|
||||
try:
|
||||
# Erstelle temporäres Verzeichnis
|
||||
self.temp_dir = Path(tempfile.mkdtemp(prefix="fop_worker_"))
|
||||
|
||||
# Schreibe Java-Quellcode
|
||||
java_file = self.temp_dir / "FopWorker.java"
|
||||
java_file.write_text(FOP_WORKER_JAVA, encoding="utf-8")
|
||||
|
||||
# Kompiliere Java-Klasse
|
||||
javac_cmd = [
|
||||
str(self.java_vm_path).replace("java", "javac"),
|
||||
"-cp",
|
||||
self.fop_classpath,
|
||||
str(java_file),
|
||||
]
|
||||
|
||||
logger.debug(f"Kompiliere FopWorker: {' '.join(javac_cmd[:3])}...")
|
||||
|
||||
result = subprocess.run(javac_cmd, capture_output=True, text=True, timeout=30)
|
||||
|
||||
if result.returncode != 0:
|
||||
raise RuntimeError(f"Java-Kompilierung fehlgeschlagen: {result.stderr}")
|
||||
|
||||
self.worker_class_path = self.temp_dir
|
||||
|
||||
logger.info(f"FopWorker erfolgreich kompiliert: {self.temp_dir}")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Kompilieren von FopWorker: {e}")
|
||||
raise
|
||||
|
||||
def _start_workers(self):
|
||||
"""Startet N Worker-Prozesse."""
|
||||
import sys
|
||||
|
||||
# Füge Worker-Classpath zum FOP-Classpath hinzu
|
||||
classpath_separator = ";" if sys.platform == "win32" else ":"
|
||||
full_classpath = str(self.worker_class_path) + classpath_separator + self.fop_classpath
|
||||
|
||||
# Bestimme Log-Verzeichnis
|
||||
self.worker_log_dir = self.log_dir if self.log_dir else self.temp_dir
|
||||
if self.log_dir:
|
||||
self.worker_log_dir.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
for i in range(self.num_workers):
|
||||
try:
|
||||
# Starte JVM-Prozess mit FopWorker
|
||||
# Übergebe fop.xconf als Argument falls vorhanden
|
||||
cmd = [str(self.java_vm_path), "-cp", full_classpath, "FopWorker"]
|
||||
|
||||
if self.fop_config_file and self.fop_config_file.exists():
|
||||
cmd.append(str(self.fop_config_file))
|
||||
|
||||
# Öffne stderr-Log-Datei für diesen Worker
|
||||
stderr_log = self.worker_log_dir / f"fop_worker_{i}_stderr.log"
|
||||
stderr_file = open(stderr_log, "w", encoding="utf-8")
|
||||
|
||||
process = subprocess.Popen(
|
||||
cmd,
|
||||
stdin=subprocess.PIPE,
|
||||
stdout=subprocess.PIPE,
|
||||
stderr=stderr_file, # Redirect stderr to file
|
||||
text=True,
|
||||
bufsize=1, # Line buffered
|
||||
)
|
||||
|
||||
self.workers.append(process)
|
||||
self.worker_locks.append(threading.Lock())
|
||||
|
||||
logger.debug(f"FOP Worker {i} gestartet (PID: {process.pid}, stderr: {stderr_log})")
|
||||
|
||||
# Warte kurz damit Worker initialisieren kann
|
||||
import time
|
||||
|
||||
time.sleep(0.2) # FOP braucht etwas länger zum Initialisieren
|
||||
|
||||
# Prüfe ob Worker noch läuft
|
||||
if process.poll() is not None:
|
||||
# Worker ist bereits beendet - Fehler!
|
||||
stderr_file.close()
|
||||
with open(stderr_log, "r") as f:
|
||||
stderr_content = f.read()
|
||||
raise RuntimeError(
|
||||
f"FOP Worker {i} ist sofort beendet (Exit Code: {process.returncode})\nstderr:\n{stderr_content}"
|
||||
)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Starten von FOP Worker {i}: {e}")
|
||||
raise
|
||||
|
||||
logger.info(f"{len(self.workers)} FOP-Worker erfolgreich gestartet")
|
||||
|
||||
def build_pdf(self, input_fo: Path, output_pdf: Path) -> tuple[bool, str]:
|
||||
"""
|
||||
Generiert PDF aus FO-Datei mit einem Worker aus dem Pool.
|
||||
|
||||
Args:
|
||||
input_fo: Pfad zur FO-Eingabedatei
|
||||
output_pdf: Pfad zur PDF-Ausgabedatei
|
||||
|
||||
Returns:
|
||||
tuple[bool, str]: (Erfolg, Fehlermeldung/Info)
|
||||
"""
|
||||
# Finde freien Worker
|
||||
worker_idx = None
|
||||
for i, lock in enumerate(self.worker_locks):
|
||||
if lock.acquire(blocking=False):
|
||||
worker_idx = i
|
||||
break
|
||||
|
||||
if worker_idx is None:
|
||||
# Kein freier Worker, warte auf ersten verfügbaren
|
||||
for i, lock in enumerate(self.worker_locks):
|
||||
lock.acquire()
|
||||
worker_idx = i
|
||||
break
|
||||
|
||||
try:
|
||||
worker = self.workers[worker_idx]
|
||||
|
||||
# Prüfe ob Worker noch läuft
|
||||
if worker.poll() is not None:
|
||||
# Worker ist tot!
|
||||
stderr_log = self.worker_log_dir / f"fop_worker_{worker_idx}_stderr.log"
|
||||
try:
|
||||
with open(stderr_log, "r") as f:
|
||||
stderr_content = f.read()
|
||||
error_msg = (
|
||||
f"FOP Worker {worker_idx} ist beendet (Exit: {worker.returncode})\nstderr:\n{stderr_content}"
|
||||
)
|
||||
except Exception:
|
||||
error_msg = f"FOP Worker {worker_idx} ist beendet (Exit: {worker.returncode})"
|
||||
logger.error(error_msg)
|
||||
return False, error_msg
|
||||
|
||||
# Erstelle Job-String (Tab-separated)
|
||||
job = f"{input_fo}\t{output_pdf}\n"
|
||||
|
||||
logger.debug(f"Sende FOP-Job an Worker {worker_idx}: {input_fo.name} → {output_pdf.name}")
|
||||
|
||||
# Sende Job an Worker
|
||||
worker.stdin.write(job)
|
||||
worker.stdin.flush()
|
||||
|
||||
# Warte auf Antwort
|
||||
response = worker.stdout.readline().strip()
|
||||
|
||||
logger.debug(f"FOP Worker {worker_idx} Antwort: '{response}'")
|
||||
|
||||
if response == "OK":
|
||||
return True, "Erfolgreich"
|
||||
elif response.startswith("ERROR:"):
|
||||
error_msg = response[6:].strip()
|
||||
return False, f"FOP-Fehler: {error_msg}"
|
||||
else:
|
||||
# Leere Antwort bedeutet Worker ist crashed
|
||||
if not response:
|
||||
stderr_log = self.worker_log_dir / f"fop_worker_{worker_idx}_stderr.log"
|
||||
try:
|
||||
with open(stderr_log, "r") as f:
|
||||
stderr_content = f.read()[-500:] # Letzte 500 Zeichen
|
||||
return False, f"FOP Worker {worker_idx} crashed (keine Antwort)\nstderr:\n{stderr_content}"
|
||||
except Exception:
|
||||
return False, f"FOP Worker {worker_idx} crashed (keine Antwort)"
|
||||
return False, f"Unerwartete Antwort: {response}"
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler bei FOP Worker {worker_idx}: {e}")
|
||||
return False, f"Worker-Fehler: {str(e)}"
|
||||
|
||||
finally:
|
||||
# Gebe Worker-Lock frei
|
||||
self.worker_locks[worker_idx].release()
|
||||
|
||||
def shutdown(self):
|
||||
"""Beendet alle Worker-Prozesse sauber."""
|
||||
logger.info("Beende FOP-Worker-Pool...")
|
||||
|
||||
for i, worker in enumerate(self.workers):
|
||||
try:
|
||||
# Sende EXIT-Befehl
|
||||
if worker.stdin and not worker.stdin.closed:
|
||||
worker.stdin.write("EXIT\n")
|
||||
worker.stdin.flush()
|
||||
|
||||
# Warte auf Beendigung (max 2 Sekunden)
|
||||
worker.wait(timeout=2)
|
||||
logger.debug(f"FOP Worker {i} beendet")
|
||||
|
||||
except subprocess.TimeoutExpired:
|
||||
# Force kill falls nötig
|
||||
worker.kill()
|
||||
logger.warning(f"FOP Worker {i} musste gekillt werden")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Beenden von FOP Worker {i}: {e}")
|
||||
|
||||
# Lösche temporäres Verzeichnis
|
||||
if self.temp_dir and self.temp_dir.exists():
|
||||
try:
|
||||
import shutil
|
||||
|
||||
shutil.rmtree(self.temp_dir)
|
||||
logger.debug(f"Temporäres Verzeichnis gelöscht: {self.temp_dir}")
|
||||
except Exception as e:
|
||||
logger.warning(f"Konnte temporäres Verzeichnis nicht löschen: {e}")
|
||||
|
||||
logger.info("FOP-Worker-Pool beendet")
|
||||
|
||||
def __enter__(self):
|
||||
"""Context manager entry."""
|
||||
return self
|
||||
|
||||
def __exit__(self, exc_type, exc_val, exc_tb):
|
||||
"""Context manager exit."""
|
||||
self.shutdown()
|
||||
@@ -15,12 +15,16 @@ from typing import Any, Optional, TYPE_CHECKING
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from saxon_pool import SaxonWorkerPool
|
||||
from fop_pool import FopWorkerPool
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
# Globaler Saxon-Worker-Pool (wird von MainWindow initialisiert)
|
||||
_saxon_worker_pool: Optional["SaxonWorkerPool"] = None
|
||||
|
||||
# Globaler FOP-Worker-Pool (wird von MainWindow initialisiert)
|
||||
_fop_worker_pool: Optional["FopWorkerPool"] = None
|
||||
|
||||
|
||||
def set_saxon_worker_pool(pool: Optional["SaxonWorkerPool"]):
|
||||
"""Setzt den globalen Saxon-Worker-Pool."""
|
||||
@@ -32,6 +36,16 @@ def set_saxon_worker_pool(pool: Optional["SaxonWorkerPool"]):
|
||||
logger.info("Saxon-Worker-Pool deaktiviert (Fallback auf subprocess)")
|
||||
|
||||
|
||||
def set_fop_worker_pool(pool: Optional["FopWorkerPool"]):
|
||||
"""Setzt den globalen FOP-Worker-Pool."""
|
||||
global _fop_worker_pool
|
||||
_fop_worker_pool = pool
|
||||
if pool:
|
||||
logger.info(f"FOP-Worker-Pool aktiviert mit {pool.num_workers} Workern")
|
||||
else:
|
||||
logger.info("FOP-Worker-Pool deaktiviert (Fallback auf subprocess)")
|
||||
|
||||
|
||||
class TransformationJob:
|
||||
"""
|
||||
Repräsentiert einen einzelnen Transformations-Job.
|
||||
@@ -303,6 +317,49 @@ class TransformationJob:
|
||||
logger.error(error_msg)
|
||||
return False, error_msg
|
||||
|
||||
logger.info(f"Starte Apache FOP PDF-Generierung: {self.xml_file.name}")
|
||||
|
||||
# Versuche zuerst den Worker-Pool zu nutzen (schneller!)
|
||||
global _fop_worker_pool
|
||||
if _fop_worker_pool:
|
||||
try:
|
||||
success, message = _fop_worker_pool.build_pdf(
|
||||
input_fo=self.temp_fo,
|
||||
output_pdf=self.new_pdf,
|
||||
)
|
||||
|
||||
if success:
|
||||
logger.info(f"FOP PDF-Generierung erfolgreich (Worker-Pool): {self.xml_file.name}")
|
||||
|
||||
# Temporäre FO-Datei löschen
|
||||
if self.temp_fo.exists():
|
||||
try:
|
||||
self.temp_fo.unlink()
|
||||
logger.debug(f"Temporäre FO-Datei gelöscht: {self.temp_fo}")
|
||||
except Exception as e:
|
||||
logger.warning(f"Konnte FO-Datei nicht löschen: {e}")
|
||||
|
||||
# Wenn kein Ref-PDF existiert, erstelle es
|
||||
if not self.ref_pdf.exists():
|
||||
try:
|
||||
import shutil
|
||||
|
||||
shutil.copy2(self.new_pdf, self.ref_pdf)
|
||||
logger.info(f"Ref-PDF erstellt: {self.ref_pdf}")
|
||||
except Exception as e:
|
||||
logger.warning(f"Konnte Ref-PDF nicht erstellen: {e}")
|
||||
|
||||
return True, "Erfolgreich"
|
||||
else:
|
||||
logger.error(f"FOP PDF-Generierung fehlgeschlagen (Worker-Pool): {message}")
|
||||
return False, message
|
||||
|
||||
except Exception as e:
|
||||
logger.warning(f"FOP Worker-Pool-Fehler, Fallback auf subprocess: {e}")
|
||||
# Fallback auf subprocess unten
|
||||
|
||||
# Fallback: Traditionelle subprocess-Methode (langsamer, aber robuster)
|
||||
|
||||
# Apache FOP Kommandozeile
|
||||
cmd_line = [
|
||||
str(self.fop_cmd),
|
||||
|
||||
+162
-10
@@ -662,9 +662,10 @@ class MainWindow(QMainWindow):
|
||||
|
||||
# Erstelle Aktion für Performance-Einstellungen
|
||||
performance_action = QAction("Performance-Einstellungen...", self)
|
||||
pool_status = "aktiviert" if app_settings.use_saxon_worker_pool else "deaktiviert"
|
||||
saxon_pool_status = "aktiviert" if app_settings.use_saxon_worker_pool else "deaktiviert"
|
||||
fop_pool_status = "aktiviert" if app_settings.use_fop_worker_pool else "deaktiviert"
|
||||
performance_action.setToolTip(
|
||||
f"Worker: {app_settings.max_workers} | SaxonWorkerPool: {pool_status}"
|
||||
f"Worker: {app_settings.max_workers} | SaxonWorkerPool: {saxon_pool_status} | FopWorkerPool: {fop_pool_status}"
|
||||
)
|
||||
performance_action.triggered.connect(self._open_performance_settings)
|
||||
|
||||
@@ -675,7 +676,16 @@ class MainWindow(QMainWindow):
|
||||
|
||||
def _open_performance_settings(self):
|
||||
"""Öffnet einen Dialog für Performance-Einstellungen."""
|
||||
from PySide6.QtWidgets import QDialog, QVBoxLayout, QHBoxLayout, QLabel, QSpinBox, QCheckBox, QPushButton, QGroupBox
|
||||
from PySide6.QtWidgets import (
|
||||
QDialog,
|
||||
QVBoxLayout,
|
||||
QHBoxLayout,
|
||||
QLabel,
|
||||
QSpinBox,
|
||||
QCheckBox,
|
||||
QPushButton,
|
||||
QGroupBox,
|
||||
)
|
||||
|
||||
# Erstelle benutzerdefinierten Dialog
|
||||
dialog = QDialog(self)
|
||||
@@ -727,6 +737,33 @@ class MainWindow(QMainWindow):
|
||||
pool_group.setLayout(pool_layout)
|
||||
layout.addWidget(pool_group)
|
||||
|
||||
# FopWorkerPool Einstellung
|
||||
fop_pool_group = QGroupBox("FopWorkerPool Einstellungen")
|
||||
fop_pool_layout = QVBoxLayout()
|
||||
|
||||
fop_pool_checkbox = QCheckBox("FopWorkerPool verwenden (empfohlen)")
|
||||
fop_pool_checkbox.setChecked(app_settings.use_fop_worker_pool)
|
||||
fop_pool_checkbox.setToolTip(
|
||||
"Aktiviert persistente JVM-Prozesse für Apache FOP PDF-Generierung.\n"
|
||||
"Vorteile: Bis zu 10x schneller durch Eliminierung von JVM-Startup-Overhead\n"
|
||||
"Nachteile: Benötigt JDK (javac) - funktioniert nicht mit JRE allein\n\n"
|
||||
"Deaktivieren Sie diese Option, wenn:\n"
|
||||
"• Sie nur ein JRE (keine JDK) installiert haben\n"
|
||||
"• Sie Probleme mit dem Worker-Pool haben\n"
|
||||
"• Sie die Funktion testen möchten"
|
||||
)
|
||||
|
||||
fop_pool_info = QLabel(
|
||||
"<i>Hinweis: FopWorkerPool benötigt ein JDK (Java Development Kit).<br>"
|
||||
"Mit JRE allein werden PDFs im Fallback-Modus generiert.</i>"
|
||||
)
|
||||
fop_pool_info.setWordWrap(True)
|
||||
|
||||
fop_pool_layout.addWidget(fop_pool_checkbox)
|
||||
fop_pool_layout.addWidget(fop_pool_info)
|
||||
fop_pool_group.setLayout(fop_pool_layout)
|
||||
layout.addWidget(fop_pool_group)
|
||||
|
||||
# OK/Abbrechen Buttons
|
||||
button_layout = QHBoxLayout()
|
||||
ok_button = QPushButton("OK")
|
||||
@@ -747,9 +784,11 @@ class MainWindow(QMainWindow):
|
||||
# Speichere Änderungen
|
||||
current_workers = app_settings.max_workers
|
||||
current_use_pool = app_settings.use_saxon_worker_pool
|
||||
current_use_fop_pool = app_settings.use_fop_worker_pool
|
||||
|
||||
new_workers = worker_spinbox.value()
|
||||
new_use_pool = pool_checkbox.isChecked()
|
||||
new_use_fop_pool = fop_pool_checkbox.isChecked()
|
||||
|
||||
changes = []
|
||||
|
||||
@@ -764,20 +803,51 @@ class MainWindow(QMainWindow):
|
||||
changes.append(f"SaxonWorkerPool: {status}")
|
||||
logger.info(f"use_saxon_worker_pool geändert: {current_use_pool} → {new_use_pool}")
|
||||
|
||||
if new_use_fop_pool != current_use_fop_pool:
|
||||
app_settings.use_fop_worker_pool = new_use_fop_pool
|
||||
status = "aktiviert" if new_use_fop_pool else "deaktiviert"
|
||||
changes.append(f"FopWorkerPool: {status}")
|
||||
logger.info(f"use_fop_worker_pool geändert: {current_use_fop_pool} → {new_use_fop_pool}")
|
||||
|
||||
if changes:
|
||||
# WICHTIG: Speichere Settings BEVOR wir Pools neu initialisieren
|
||||
app_settings.save()
|
||||
logger.info(f"Performance-Einstellungen gespeichert: {changes}")
|
||||
|
||||
# Initialisiere Worker Pools neu falls sich relevante Einstellungen geändert haben
|
||||
pools_reinitialized = False
|
||||
if self.project:
|
||||
# Saxon Worker Pool neu initialisieren?
|
||||
if new_use_pool != current_use_pool or new_workers != current_workers:
|
||||
logger.info(
|
||||
f"Saxon Worker Pool wird neu initialisiert "
|
||||
f"(use_pool: {current_use_pool}→{new_use_pool}, workers: {current_workers}→{new_workers})"
|
||||
)
|
||||
self._initialize_saxon_worker_pool()
|
||||
pools_reinitialized = True
|
||||
|
||||
# FOP Worker Pool neu initialisieren?
|
||||
if new_use_fop_pool != current_use_fop_pool or new_workers != current_workers:
|
||||
logger.info(
|
||||
f"FOP Worker Pool wird neu initialisiert "
|
||||
f"(use_pool: {current_use_fop_pool}→{new_use_fop_pool}, workers: {current_workers}→{new_workers})"
|
||||
)
|
||||
self._initialize_fop_worker_pool()
|
||||
pools_reinitialized = True
|
||||
else:
|
||||
logger.warning("Kein Projekt geladen - Worker Pools werden nicht neu initialisiert")
|
||||
|
||||
# Informiere Benutzer über Änderungen
|
||||
changes_text = "\n".join(f"• {change}" for change in changes)
|
||||
restart_hint = ""
|
||||
status_hint = ""
|
||||
|
||||
if new_use_pool != current_use_pool and self.project:
|
||||
restart_hint = "\n\nHinweis: Bitte öffnen Sie das Projekt neu, damit die Änderung wirksam wird."
|
||||
if pools_reinitialized:
|
||||
status_hint = "\n\nDie Worker Pools wurden automatisch mit den neuen Einstellungen neu gestartet."
|
||||
|
||||
QMessageBox.information(
|
||||
self,
|
||||
"Einstellungen gespeichert",
|
||||
f"Folgende Einstellungen wurden geändert:\n\n{changes_text}{restart_hint}",
|
||||
f"Folgende Einstellungen wurden geändert:\n\n{changes_text}{status_hint}",
|
||||
)
|
||||
|
||||
def open_existing_project(self, project: Project):
|
||||
@@ -818,6 +888,9 @@ class MainWindow(QMainWindow):
|
||||
# Initialisiere Saxon-Worker-Pool für schnellere Transformationen
|
||||
self._initialize_saxon_worker_pool()
|
||||
|
||||
# Initialisiere FOP-Worker-Pool für schnellere PDF-Generierung
|
||||
self._initialize_fop_worker_pool()
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Laden des Projekts '{project.name}': {e}")
|
||||
# Fallback: Erstelle Standard-Einstellungen
|
||||
@@ -891,6 +964,84 @@ class MainWindow(QMainWindow):
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Beenden des Saxon-Worker-Pools: {e}")
|
||||
|
||||
def _initialize_fop_worker_pool(self):
|
||||
"""Initialisiert den FOP-Worker-Pool für schnelle PDF-Generierung."""
|
||||
try:
|
||||
# Shutdown vorherigen Pool falls vorhanden
|
||||
self._shutdown_fop_worker_pool()
|
||||
|
||||
# Prüfe ob FopWorkerPool aktiviert ist
|
||||
if not app_settings.use_fop_worker_pool:
|
||||
logger.info("FopWorkerPool deaktiviert - Verwende Fallback-Modus (subprocess)")
|
||||
return
|
||||
|
||||
if not self.project:
|
||||
logger.warning("Kein Projekt geladen, FOP-Worker-Pool nicht initialisiert")
|
||||
return
|
||||
|
||||
# Hole Tool-Konfigurationen
|
||||
java_vm = next((vm for vm in app_settings.java_vms if vm.id == self.project.java_vm_id), None)
|
||||
apache_fop = next((fop for fop in app_settings.apache_fops if fop.id == self.project.apache_fop_id), None)
|
||||
|
||||
if not java_vm or not apache_fop:
|
||||
logger.warning("Java VM oder Apache FOP nicht gefunden, Pool nicht initialisiert")
|
||||
return
|
||||
|
||||
# FOP-Konfigurationsdatei (falls vorhanden)
|
||||
fop_config_file = None
|
||||
if self.project.fop_config_dir:
|
||||
fop_config_file = self.project.fop_config_dir / "fop.xconf"
|
||||
else:
|
||||
default_config = apache_fop.path_to_dir / "conf" / "fop.xconf"
|
||||
if default_config.exists():
|
||||
fop_config_file = default_config
|
||||
|
||||
# Importiere FopWorkerPool
|
||||
from fop_pool import FopWorkerPool
|
||||
from transform import set_fop_worker_pool
|
||||
|
||||
# Erstelle Worker-Pool
|
||||
num_workers = app_settings.max_workers
|
||||
log_dir = self.project.project_dir / "temp"
|
||||
pool = FopWorkerPool(
|
||||
num_workers=num_workers,
|
||||
java_vm_path=java_vm.path_to_binary_file,
|
||||
apache_fop_dir=apache_fop.path_to_dir,
|
||||
fop_config_file=fop_config_file,
|
||||
log_dir=log_dir,
|
||||
)
|
||||
|
||||
# Setze globalen Pool
|
||||
set_fop_worker_pool(pool)
|
||||
|
||||
logger.info(
|
||||
f"FOP-Worker-Pool initialisiert: {num_workers} Worker "
|
||||
f"(erwartet: {num_workers}x schneller für PDF-Generierung)"
|
||||
)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Initialisieren des FOP-Worker-Pools: {e}")
|
||||
logger.info("Fallback auf subprocess-Modus")
|
||||
# Kein Pool ist OK - Fallback auf subprocess
|
||||
|
||||
def _shutdown_fop_worker_pool(self):
|
||||
"""Beendet den FOP-Worker-Pool sauber."""
|
||||
try:
|
||||
# Importiere transform um Zugriff auf globalen Pool zu haben
|
||||
import transform
|
||||
|
||||
if transform._fop_worker_pool:
|
||||
logger.info("Beende FOP-Worker-Pool...")
|
||||
transform._fop_worker_pool.shutdown()
|
||||
# Importiere set_fop_worker_pool
|
||||
from transform import set_fop_worker_pool
|
||||
|
||||
set_fop_worker_pool(None)
|
||||
logger.info("FOP-Worker-Pool beendet")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Beenden des FOP-Worker-Pools: {e}")
|
||||
|
||||
def change_theme(self, theme_name):
|
||||
"""
|
||||
Wechselt das Theme der Anwendung.
|
||||
@@ -4796,9 +4947,7 @@ class MainWindow(QMainWindow):
|
||||
logger.info(f"Öffne Referenz-PDF im System-Viewer: {self.current_ref_pdf_path}")
|
||||
url = QUrl.fromLocalFile(str(self.current_ref_pdf_path))
|
||||
if not QDesktopServices.openUrl(url):
|
||||
QMessageBox.critical(
|
||||
self, "Fehler", f"Konnte Referenz-PDF nicht öffnen:\n{self.current_ref_pdf_path}"
|
||||
)
|
||||
QMessageBox.critical(self, "Fehler", f"Konnte Referenz-PDF nicht öffnen:\n{self.current_ref_pdf_path}")
|
||||
logger.error(f"Fehler beim Öffnen der Referenz-PDF: {self.current_ref_pdf_path}")
|
||||
|
||||
def _on_view_new_pdf_clicked(self):
|
||||
@@ -4884,6 +5033,9 @@ class MainWindow(QMainWindow):
|
||||
# Beende Saxon-Worker-Pool
|
||||
self._shutdown_saxon_worker_pool()
|
||||
|
||||
# Beende FOP-Worker-Pool
|
||||
self._shutdown_fop_worker_pool()
|
||||
|
||||
# PDF-Dokumente schließen ist bei QtPdf automatisch durch Garbage Collection
|
||||
super().closeEvent(event)
|
||||
|
||||
|
||||
Reference in New Issue
Block a user