Hartmut
ee6eb34b4c
- GPU: fix Cycles device activation order — set compute_device_type BEFORE engine init, re-set AFTER open_mainfile wipes preferences - GPU: remove _mark_sharp_and_seams edit-mode loop (redundant with Blender 5.0 shade_smooth_by_angle), saves ~200s/render on 175 parts - Material: fix _AFN suffix mismatch — build AF-stripped mat_map keys and add prefix fallback in _apply_material_library (blender_render.py) - Material: production GLB now uses get_material_library_path() which checks active AssetLibrary instead of empty legacy system setting - Admin: RenderTemplateTable multi-select output types (M2M frontend) - Admin: MaterialLibraryPanel replaced with link to Asset Libraries - UX: move Toaster to top-left to avoid dispatch button overlap - SQLAlchemy: add .unique() to all RenderTemplate M2M collection queries - Logging: flush=True on all Blender progress prints, stdout reconfigure Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
1171 lines
53 KiB
Python
1171 lines
53 KiB
Python
"""Celery tasks for STEP file processing and thumbnail generation."""
|
||
import logging
|
||
from pathlib import Path
|
||
from app.tasks.celery_app import celery_app
|
||
from app.core.task_logs import log_task_event
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
|
||
def _bbox_from_glb(glb_path: str) -> dict | None:
|
||
"""Extract bounding box from a GLB file (meters → converted to mm).
|
||
|
||
Returns {"dimensions_mm": {x,y,z}, "bbox_center_mm": {x,y,z}} or None on failure.
|
||
OCC GLB output is in meters; multiply by 1000 to get mm.
|
||
"""
|
||
try:
|
||
import trimesh
|
||
p = Path(glb_path)
|
||
if not p.exists():
|
||
return None
|
||
scene = trimesh.load(str(p), force="scene")
|
||
bounds = getattr(scene, "bounds", None)
|
||
if bounds is None:
|
||
return None
|
||
mins, maxs = bounds
|
||
dims = maxs - mins
|
||
return {
|
||
"dimensions_mm": {
|
||
"x": round(float(dims[0]) * 1000, 2),
|
||
"y": round(float(dims[1]) * 1000, 2),
|
||
"z": round(float(dims[2]) * 1000, 2),
|
||
},
|
||
"bbox_center_mm": {
|
||
"x": round(float((mins[0] + maxs[0]) / 2) * 1000, 2),
|
||
"y": round(float((mins[1] + maxs[1]) / 2) * 1000, 2),
|
||
"z": round(float((mins[2] + maxs[2]) / 2) * 1000, 2),
|
||
},
|
||
}
|
||
except Exception as exc:
|
||
logger.debug(f"_bbox_from_glb failed for {glb_path}: {exc}")
|
||
return None
|
||
|
||
|
||
def _bbox_from_step_cadquery(step_path: str) -> dict | None:
|
||
"""Fallback: extract bounding box by re-parsing STEP via cadquery."""
|
||
try:
|
||
import cadquery as cq
|
||
bb = cq.importers.importStep(step_path).val().BoundingBox()
|
||
return {
|
||
"dimensions_mm": {
|
||
"x": round(bb.xlen, 2),
|
||
"y": round(bb.ylen, 2),
|
||
"z": round(bb.zlen, 2),
|
||
},
|
||
"bbox_center_mm": {
|
||
"x": round((bb.xmin + bb.xmax) / 2, 2),
|
||
"y": round((bb.ymin + bb.ymax) / 2, 2),
|
||
"z": round((bb.zmin + bb.zmax) / 2, 2),
|
||
},
|
||
}
|
||
except Exception as exc:
|
||
logger.debug(f"_bbox_from_step_cadquery failed for {step_path}: {exc}")
|
||
return None
|
||
|
||
|
||
@celery_app.task(bind=True, name="app.tasks.step_tasks.process_step_file", queue="step_processing")
|
||
def process_step_file(self, cad_file_id: str):
|
||
"""Process a STEP file: extract objects, generate thumbnail, convert to glTF.
|
||
|
||
After processing completes, auto-populate cad_part_materials from Excel
|
||
component data for any linked products that don't yet have materials assigned.
|
||
|
||
A per-file Redis lock (TTL = 10 min) prevents duplicate tasks from processing
|
||
the same file concurrently — e.g. when 'Process Unprocessed' is clicked while
|
||
a file is already being processed.
|
||
"""
|
||
import redis as redis_lib
|
||
from app.config import settings as app_settings
|
||
|
||
lock_key = f"step_processing_lock:{cad_file_id}"
|
||
r = redis_lib.from_url(app_settings.redis_url)
|
||
acquired = r.set(lock_key, "1", nx=True, ex=600) # 10-minute TTL
|
||
if not acquired:
|
||
logger.warning(f"STEP file {cad_file_id} is already being processed — skipping duplicate task")
|
||
return
|
||
|
||
try:
|
||
logger.info(f"Processing STEP file (metadata only): {cad_file_id}")
|
||
try:
|
||
from app.services.step_processor import extract_cad_metadata
|
||
extract_cad_metadata(cad_file_id)
|
||
except Exception as exc:
|
||
logger.error(f"STEP metadata extraction failed for {cad_file_id}: {exc}")
|
||
r.delete(lock_key) # release lock so a retry can proceed
|
||
raise self.retry(exc=exc, countdown=60, max_retries=3)
|
||
finally:
|
||
r.delete(lock_key) # always release on completion or unhandled error
|
||
|
||
# Queue thumbnail rendering on the dedicated single-concurrency worker
|
||
render_step_thumbnail.delay(cad_file_id)
|
||
|
||
|
||
def _auto_populate_materials_for_cad(cad_file_id: str) -> None:
|
||
"""Sync helper: auto-populate cad_part_materials from Excel for newly-processed CAD files.
|
||
|
||
Only fills products where cad_part_materials is empty or all-blank,
|
||
preventing overwrites of manually assigned materials.
|
||
"""
|
||
from sqlalchemy import create_engine, select as sql_select, update as sql_update
|
||
from sqlalchemy.orm import Session
|
||
from app.config import settings as app_settings
|
||
from app.models.cad_file import CadFile
|
||
from app.models.product import Product
|
||
from app.api.routers.products import build_materials_from_excel
|
||
from app.services.step_processor import build_part_colors
|
||
|
||
sync_url = app_settings.database_url.replace("+asyncpg", "")
|
||
eng = create_engine(sync_url)
|
||
with Session(eng) as session:
|
||
# Load the CAD file to get parsed objects
|
||
cad_file = session.execute(
|
||
sql_select(CadFile).where(CadFile.id == cad_file_id)
|
||
).scalar_one_or_none()
|
||
if cad_file is None:
|
||
return
|
||
|
||
parsed_objects = cad_file.parsed_objects or {}
|
||
cad_parts: list[str] = parsed_objects.get("objects", [])
|
||
if not cad_parts:
|
||
return
|
||
|
||
# Find products linked to this CAD file that have Excel components
|
||
products = session.execute(
|
||
sql_select(Product).where(
|
||
Product.cad_file_id == cad_file.id,
|
||
Product.is_active.is_(True),
|
||
)
|
||
).scalars().all()
|
||
|
||
final_part_colors = None
|
||
for product in products:
|
||
excel_components: list[dict] = product.components or []
|
||
if not excel_components:
|
||
continue
|
||
|
||
# Only auto-fill when cad_part_materials is empty or all-blank
|
||
existing = product.cad_part_materials or []
|
||
if existing and any(m.get("material", "").strip() for m in existing):
|
||
continue # has at least one real material — don't overwrite
|
||
|
||
new_materials = build_materials_from_excel(cad_parts, excel_components)
|
||
session.execute(
|
||
sql_update(Product)
|
||
.where(Product.id == product.id)
|
||
.values(cad_part_materials=new_materials)
|
||
)
|
||
session.flush()
|
||
|
||
# Compute part colors; thumbnail queued once after the loop
|
||
try:
|
||
final_part_colors = build_part_colors(cad_parts, new_materials)
|
||
except Exception:
|
||
logger.exception(f"Part colors build failed for product {product.id}")
|
||
|
||
logger.info(
|
||
f"Auto-populated {len(new_materials)} materials for product {product.id} "
|
||
f"from {len(excel_components)} Excel components"
|
||
)
|
||
|
||
session.commit()
|
||
|
||
# Queue exactly ONE thumbnail regeneration per CAD file regardless of how many
|
||
# products were auto-populated. Queuing once-per-product multiplies the task
|
||
# count needlessly and causes the Redis queue depth to grow instead of shrink.
|
||
if final_part_colors is not None:
|
||
try:
|
||
regenerate_thumbnail.delay(str(cad_file_id), final_part_colors)
|
||
except Exception:
|
||
logger.exception(f"Thumbnail regen queue failed for cad_file {cad_file_id}")
|
||
|
||
eng.dispose()
|
||
|
||
|
||
@celery_app.task(bind=True, name="app.tasks.step_tasks.render_step_thumbnail", queue="thumbnail_rendering")
|
||
def render_step_thumbnail(self, cad_file_id: str):
|
||
"""Render the thumbnail for a freshly-processed STEP file.
|
||
|
||
Runs on the dedicated thumbnail_rendering queue (concurrency=1) so the
|
||
blender-renderer service is never overwhelmed by concurrent requests.
|
||
On success, also auto-populates materials and marks the CadFile as completed.
|
||
"""
|
||
logger.info(f"Rendering thumbnail for CAD file: {cad_file_id}")
|
||
|
||
# Compute and persist STEP file hash for STL cache lookups
|
||
try:
|
||
from sqlalchemy import create_engine
|
||
from sqlalchemy.orm import Session
|
||
from app.config import settings as app_settings
|
||
from app.models.cad_file import CadFile
|
||
from app.domains.products.cache_service import compute_step_hash
|
||
|
||
sync_url = app_settings.database_url.replace("+asyncpg", "")
|
||
_eng = create_engine(sync_url)
|
||
with Session(_eng) as _sess:
|
||
_cad = _sess.get(CadFile, cad_file_id)
|
||
if _cad and _cad.stored_path and not _cad.step_file_hash:
|
||
_hash = compute_step_hash(_cad.stored_path)
|
||
_cad.step_file_hash = _hash
|
||
_sess.commit()
|
||
logger.info(f"Saved step_file_hash for {cad_file_id}: {_hash[:12]}…")
|
||
_eng.dispose()
|
||
except Exception:
|
||
logger.warning(f"step_file_hash computation failed for {cad_file_id} (non-fatal)")
|
||
|
||
try:
|
||
from app.services.step_processor import regenerate_cad_thumbnail
|
||
success = regenerate_cad_thumbnail(cad_file_id, part_colors={})
|
||
if not success:
|
||
raise RuntimeError("regenerate_cad_thumbnail returned False")
|
||
except Exception as exc:
|
||
logger.error(f"Thumbnail render failed for {cad_file_id}: {exc}")
|
||
raise self.retry(exc=exc, countdown=30, max_retries=2)
|
||
|
||
# Extract bounding box from the thumbnail GLB generated by the renderer.
|
||
# GLB bbox via trimesh is fast and avoids re-parsing the STEP file.
|
||
# Falls back to cadquery STEP re-parse if GLB is not found.
|
||
try:
|
||
from sqlalchemy import create_engine
|
||
from sqlalchemy.orm import Session
|
||
from app.config import settings as _cfg2
|
||
from app.models.cad_file import CadFile as _CadFile2
|
||
|
||
_sync_url2 = _cfg2.database_url.replace("+asyncpg", "")
|
||
_eng2 = create_engine(_sync_url2)
|
||
with Session(_eng2) as _sess2:
|
||
_cad2 = _sess2.get(_CadFile2, cad_file_id)
|
||
_step_path = _cad2.stored_path if _cad2 else None
|
||
_eng2.dispose()
|
||
|
||
if _step_path and not (_cad2.mesh_attributes or {}).get("dimensions_mm"):
|
||
_step = Path(_step_path)
|
||
_glb = _step.parent / f"{_step.stem}_thumbnail.glb"
|
||
bbox_data = _bbox_from_glb(str(_glb)) or _bbox_from_step_cadquery(_step_path)
|
||
if bbox_data:
|
||
_eng2 = create_engine(_sync_url2)
|
||
with Session(_eng2) as _sess2:
|
||
_cad2 = _sess2.get(_CadFile2, cad_file_id)
|
||
if _cad2:
|
||
_cad2.mesh_attributes = {**( _cad2.mesh_attributes or {}), **bbox_data}
|
||
_sess2.commit()
|
||
dims = bbox_data["dimensions_mm"]
|
||
logger.info(
|
||
f"bbox for {cad_file_id}: "
|
||
f"{dims['x']}×{dims['y']}×{dims['z']} mm"
|
||
)
|
||
_eng2.dispose()
|
||
except Exception:
|
||
logger.exception(f"bbox extraction failed for {cad_file_id} (non-fatal)")
|
||
|
||
# Auto-populate materials now that parsed_objects are available
|
||
try:
|
||
_auto_populate_materials_for_cad(cad_file_id)
|
||
except Exception:
|
||
logger.exception(
|
||
f"Auto material population failed for cad_file {cad_file_id} (non-fatal)"
|
||
)
|
||
|
||
# Broadcast WebSocket event for live UI updates
|
||
try:
|
||
from sqlalchemy import create_engine, select as sql_select2
|
||
from sqlalchemy.orm import Session as _Session
|
||
from app.config import settings as _cfg
|
||
from app.models.cad_file import CadFile as _CadFile
|
||
_sync_url = _cfg.database_url.replace("+asyncpg", "")
|
||
_eng = create_engine(_sync_url)
|
||
with _Session(_eng) as _s:
|
||
_cad = _s.get(_CadFile, cad_file_id)
|
||
_tid = str(_cad.tenant_id) if _cad and _cad.tenant_id else None
|
||
_eng.dispose()
|
||
if _tid:
|
||
from app.core.websocket import publish_event_sync
|
||
publish_event_sync(_tid, {
|
||
"type": "cad_processing_complete",
|
||
"cad_file_id": cad_file_id,
|
||
"status": "completed",
|
||
})
|
||
except Exception:
|
||
logger.debug("WebSocket publish for CAD complete skipped (non-fatal)")
|
||
|
||
# Auto-generate geometry GLB so the 3D viewer is ready without manual trigger
|
||
try:
|
||
generate_gltf_geometry_task.delay(cad_file_id)
|
||
logger.info("render_step_thumbnail: queued generate_gltf_geometry_task for %s", cad_file_id)
|
||
except Exception:
|
||
logger.debug("Could not queue generate_gltf_geometry_task (non-fatal)")
|
||
|
||
|
||
@celery_app.task(name="app.tasks.step_tasks.reextract_cad_metadata", queue="thumbnail_rendering")
|
||
def reextract_cad_metadata(cad_file_id: str):
|
||
"""Re-extract bounding-box dimensions for an already-completed CAD file.
|
||
|
||
Uses cadquery (available in render-worker) to compute dimensions_mm.
|
||
Updates mesh_attributes without changing processing_status or re-rendering.
|
||
Safe to run on completed files.
|
||
"""
|
||
from sqlalchemy import create_engine
|
||
from sqlalchemy.orm import Session
|
||
from app.config import settings as app_settings
|
||
from app.models.cad_file import CadFile
|
||
|
||
sync_url = app_settings.database_url.replace("+asyncpg", "")
|
||
eng = create_engine(sync_url)
|
||
with Session(eng) as session:
|
||
cad_file = session.get(CadFile, cad_file_id)
|
||
if not cad_file or not cad_file.stored_path:
|
||
logger.warning(f"reextract_cad_metadata: file not found {cad_file_id}")
|
||
eng.dispose()
|
||
return
|
||
step_path = cad_file.stored_path
|
||
|
||
try:
|
||
p = Path(step_path)
|
||
glb_path = p.parent / f"{p.stem}_thumbnail.glb"
|
||
patch = _bbox_from_glb(str(glb_path)) or _bbox_from_step_cadquery(step_path)
|
||
if patch:
|
||
with Session(eng) as session:
|
||
cad_file = session.get(CadFile, cad_file_id)
|
||
if cad_file:
|
||
cad_file.mesh_attributes = {**(cad_file.mesh_attributes or {}), **patch}
|
||
session.commit()
|
||
dims = patch["dimensions_mm"]
|
||
logger.info(
|
||
f"reextract_cad_metadata: {cad_file_id} → "
|
||
f"{dims['x']}×{dims['y']}×{dims['z']} mm"
|
||
)
|
||
else:
|
||
logger.warning(f"reextract_cad_metadata: no bbox data for {cad_file_id}")
|
||
except Exception as exc:
|
||
logger.error(f"reextract_cad_metadata failed for {cad_file_id}: {exc}")
|
||
finally:
|
||
eng.dispose()
|
||
|
||
|
||
@celery_app.task(bind=True, name="app.tasks.step_tasks.generate_gltf_geometry_task", queue="thumbnail_rendering", max_retries=1)
|
||
def generate_gltf_geometry_task(self, cad_file_id: str):
|
||
"""Export a geometry GLB directly from STEP via OCC (no STL intermediary).
|
||
|
||
Pipeline:
|
||
1. Reads STEP file directly (no STL needed)
|
||
2. Builds color_map from product.cad_part_materials (hex colors)
|
||
3. Runs export_step_to_gltf.py (Python/OCP): STEP → GLB with per-part colors
|
||
4. Stores result as gltf_geometry MediaAsset (replaces any existing one)
|
||
|
||
Output is in meters, Y-up (glTF convention).
|
||
"""
|
||
import json as _json
|
||
import os as _os
|
||
import subprocess as _subprocess
|
||
import sys as _sys
|
||
from pathlib import Path as _Path
|
||
from sqlalchemy import create_engine, select as _select
|
||
from sqlalchemy.orm import Session
|
||
from app.config import settings as app_settings
|
||
from app.models.cad_file import CadFile
|
||
|
||
from app.models.system_setting import SystemSetting as _SysSetting
|
||
|
||
sync_url = app_settings.database_url.replace("+asyncpg", "")
|
||
eng = create_engine(sync_url)
|
||
with Session(eng) as session:
|
||
cad_file = session.get(CadFile, cad_file_id)
|
||
if not cad_file or not cad_file.stored_path:
|
||
logger.error("generate_gltf_geometry_task: no stored_path for %s", cad_file_id)
|
||
return
|
||
step_path_str = cad_file.stored_path
|
||
|
||
# Build hex color_map from product.cad_part_materials
|
||
from app.domains.products.models import Product
|
||
product = session.execute(
|
||
_select(Product).where(Product.cad_file_id == cad_file.id)
|
||
).scalar_one_or_none()
|
||
|
||
color_map: dict[str, str] = {}
|
||
product_id = str(product.id) if product else None
|
||
if product and product.cad_part_materials:
|
||
for entry in product.cad_part_materials:
|
||
part_name = entry.get("part_name") or entry.get("name", "")
|
||
hex_color = entry.get("hex_color") or entry.get("color", "")
|
||
if part_name and hex_color:
|
||
color_map[part_name] = hex_color
|
||
|
||
settings_rows = session.execute(_select(_SysSetting)).scalars().all()
|
||
sys_settings = {s.key: s.value for s in settings_rows}
|
||
eng.dispose()
|
||
|
||
linear_deflection = float(sys_settings.get("gltf_preview_linear_deflection", "0.1"))
|
||
angular_deflection = float(sys_settings.get("gltf_preview_angular_deflection", "0.5"))
|
||
|
||
step = _Path(step_path_str)
|
||
if not step.exists():
|
||
log_task_event(self.request.id, f"Failed: STEP file not found: {step}", "error")
|
||
raise RuntimeError(f"STEP file not found: {step}")
|
||
|
||
output_path = step.parent / f"{step.stem}_geometry.glb"
|
||
|
||
log_task_event(
|
||
self.request.id,
|
||
f"Starting OCC GLB export: {len(color_map)} part colors",
|
||
"info",
|
||
)
|
||
|
||
# Run export_step_to_gltf.py as a subprocess so OCP imports don't pollute worker state
|
||
scripts_dir = _Path(_os.environ.get("RENDER_SCRIPTS_DIR", "/render-scripts"))
|
||
script_path = scripts_dir / "export_step_to_gltf.py"
|
||
|
||
python_bin = _sys.executable
|
||
cmd = [
|
||
python_bin, str(script_path),
|
||
"--step_path", str(step),
|
||
"--output_path", str(output_path),
|
||
"--color_map", _json.dumps(color_map),
|
||
"--linear_deflection", str(linear_deflection),
|
||
"--angular_deflection", str(angular_deflection),
|
||
]
|
||
log_task_event(
|
||
self.request.id,
|
||
f"OCC tessellation: linear={linear_deflection}mm, angular={angular_deflection}rad",
|
||
"info",
|
||
)
|
||
|
||
try:
|
||
result = _subprocess.run(cmd, capture_output=True, text=True, timeout=120)
|
||
for line in result.stdout.splitlines():
|
||
logger.info("[occ-gltf] %s", line)
|
||
for line in result.stderr.splitlines():
|
||
logger.warning("[occ-gltf stderr] %s", line)
|
||
|
||
if result.returncode != 0 or not output_path.exists() or output_path.stat().st_size == 0:
|
||
raise RuntimeError(
|
||
f"export_step_to_gltf.py failed (exit {result.returncode}).\n"
|
||
f"STDERR: {result.stderr[-1000:]}"
|
||
)
|
||
except Exception as exc:
|
||
log_task_event(self.request.id, f"Failed: {exc}", "error")
|
||
logger.error("generate_gltf_geometry_task OCC export failed: %s", exc)
|
||
raise self.retry(exc=exc, countdown=15)
|
||
|
||
log_task_event(self.request.id, f"OCC GLB export completed: {output_path.name}", "done")
|
||
|
||
# --- Store MediaAsset (replace existing gltf_geometry for this cad_file) ---
|
||
import uuid as _uuid
|
||
from sqlalchemy import create_engine as _ce, delete as _del
|
||
from sqlalchemy.orm import Session as _Session
|
||
from app.domains.media.models import MediaAsset, MediaAssetType
|
||
|
||
_sync_url = app_settings.database_url.replace("+asyncpg", "")
|
||
_eng2 = _ce(_sync_url)
|
||
with _Session(_eng2) as _sess:
|
||
_sess.execute(
|
||
_del(MediaAsset).where(
|
||
MediaAsset.cad_file_id == _uuid.UUID(cad_file_id),
|
||
MediaAsset.asset_type == MediaAssetType.gltf_geometry,
|
||
)
|
||
)
|
||
_key = str(output_path)
|
||
_prefix = str(app_settings.upload_dir).rstrip("/") + "/"
|
||
if _key.startswith(_prefix):
|
||
_key = _key[len(_prefix):]
|
||
asset = MediaAsset(
|
||
cad_file_id=_uuid.UUID(cad_file_id),
|
||
product_id=_uuid.UUID(product_id) if product_id else None,
|
||
asset_type=MediaAssetType.gltf_geometry,
|
||
storage_key=_key,
|
||
mime_type="model/gltf-binary",
|
||
file_size_bytes=output_path.stat().st_size if output_path.exists() else None,
|
||
)
|
||
_sess.add(asset)
|
||
_sess.commit()
|
||
asset_id = str(asset.id)
|
||
_eng2.dispose()
|
||
|
||
logger.info("generate_gltf_geometry_task: MediaAsset %s created for cad %s", asset_id, cad_file_id)
|
||
return {"glb_path": str(output_path), "asset_id": asset_id}
|
||
|
||
|
||
@celery_app.task(
|
||
bind=True,
|
||
name="app.tasks.step_tasks.generate_gltf_production_task",
|
||
queue="thumbnail_rendering",
|
||
max_retries=2,
|
||
)
|
||
def generate_gltf_production_task(self, cad_file_id: str, product_id: str | None = None) -> dict:
|
||
"""Generate a production GLB (Blender + PBR materials) from a geometry GLB via export_gltf.py.
|
||
|
||
1. Ensures a gltf_geometry MediaAsset exists (runs OCC export inline if not).
|
||
2. Resolves SCHAEFFLER material map for the CadFile's product.
|
||
3. Runs Blender headless with export_gltf.py → production GLB.
|
||
4. Stores result as gltf_production MediaAsset.
|
||
"""
|
||
import json as _json
|
||
import os as _os
|
||
import subprocess as _subprocess
|
||
import sys as _sys
|
||
import uuid as _uuid
|
||
from pathlib import Path as _Path
|
||
|
||
from sqlalchemy import create_engine as _ce, delete as _del, select as _sel
|
||
from sqlalchemy.orm import Session as _Session
|
||
|
||
from app.config import settings as app_settings
|
||
from app.domains.media.models import MediaAsset, MediaAssetType
|
||
from app.services.render_blender import find_blender, is_blender_available
|
||
|
||
log_task_event(self.request.id, f"generate_gltf_production_task started for cad {cad_file_id}", "info")
|
||
|
||
_sync_url = app_settings.database_url.replace("+asyncpg", "")
|
||
_eng = _ce(_sync_url)
|
||
|
||
# --- 1. Resolve STEP file path and system settings ---
|
||
from app.models.cad_file import CadFile as _CF
|
||
from app.models.system_setting import SystemSetting
|
||
|
||
with _Session(_eng) as _sess:
|
||
_cad = _sess.execute(
|
||
_sel(_CF).where(_CF.id == _uuid.UUID(cad_file_id))
|
||
).scalar_one_or_none()
|
||
step_path_str = _cad.stored_path if _cad else None
|
||
|
||
settings_rows = _sess.execute(_sel(SystemSetting)).scalars().all()
|
||
sys_settings = {s.key: s.value for s in settings_rows}
|
||
|
||
if not step_path_str:
|
||
raise RuntimeError(f"CadFile {cad_file_id} not found in DB")
|
||
step_path = _Path(step_path_str)
|
||
if not step_path.exists():
|
||
raise RuntimeError(f"STEP file not found: {step_path}")
|
||
|
||
smooth_angle = float(sys_settings.get("blender_smooth_angle", "30"))
|
||
prod_linear = float(sys_settings.get("gltf_production_linear_deflection", "0.03"))
|
||
prod_angular = float(sys_settings.get("gltf_production_angular_deflection", "0.2"))
|
||
|
||
scripts_dir = _Path(_os.environ.get("RENDER_SCRIPTS_DIR", "/render-scripts"))
|
||
occ_script = scripts_dir / "export_step_to_gltf.py"
|
||
if not occ_script.exists():
|
||
raise RuntimeError(f"export_step_to_gltf.py not found at {occ_script}")
|
||
|
||
prod_geom_glb = step_path.parent / f"{step_path.stem}_production_geom.glb"
|
||
python_bin = _sys.executable
|
||
occ_cmd = [
|
||
python_bin, str(occ_script),
|
||
"--step_path", str(step_path),
|
||
"--output_path", str(prod_geom_glb),
|
||
"--linear_deflection", str(prod_linear),
|
||
"--angular_deflection", str(prod_angular),
|
||
]
|
||
log_task_event(
|
||
self.request.id,
|
||
f"Re-exporting STEP at production quality (linear={prod_linear}mm, angular={prod_angular}rad)",
|
||
"info",
|
||
)
|
||
try:
|
||
occ_result = _subprocess.run(occ_cmd, capture_output=True, text=True, timeout=180)
|
||
for line in occ_result.stdout.splitlines():
|
||
logger.info("[occ-prod] %s", line)
|
||
if occ_result.returncode != 0 or not prod_geom_glb.exists() or prod_geom_glb.stat().st_size == 0:
|
||
raise RuntimeError(
|
||
f"OCC export failed (exit {occ_result.returncode}): {occ_result.stderr[-500:]}"
|
||
)
|
||
except Exception as exc:
|
||
log_task_event(self.request.id, f"OCC re-export failed: {exc}", "error")
|
||
raise self.retry(exc=exc, countdown=30)
|
||
|
||
geom_glb_path = prod_geom_glb
|
||
|
||
# --- 2. Resolve material map from Product.cad_part_materials (SCHAEFFLER library names) ---
|
||
# cad_part_materials lives on Product (list[dict]), NOT on CadFile.
|
||
# We look up the Product that owns this CadFile (prefer product_id arg if given).
|
||
from app.services.material_service import resolve_material_map
|
||
from app.domains.products.models import Product as _Product
|
||
|
||
with _Session(_eng) as _sess:
|
||
_prod_query = _sel(_Product).where(_Product.cad_file_id == _uuid.UUID(cad_file_id))
|
||
if product_id:
|
||
_prod_query = _prod_query.where(_Product.id == _uuid.UUID(product_id))
|
||
_product = _sess.execute(_prod_query).scalars().first()
|
||
raw_materials: list[dict] = _product.cad_part_materials if _product else []
|
||
|
||
# Convert list[{"part_name": X, "material": Y}] → dict[str, str] for resolve_material_map
|
||
raw_mat_map: dict[str, str] = {
|
||
m["part_name"]: m["material"]
|
||
for m in raw_materials
|
||
if m.get("part_name") and m.get("material")
|
||
}
|
||
mat_map = resolve_material_map(raw_mat_map)
|
||
logger.info(
|
||
"generate_gltf_production_task: resolved %d material(s) for cad %s (product: %s)",
|
||
len(mat_map), cad_file_id, _product.id if _product else "none",
|
||
)
|
||
|
||
# --- 3. Run Blender: apply materials + smooth shading + export production GLB ---
|
||
# Use get_material_library_path() which checks active AssetLibrary first,
|
||
# then falls back to the legacy material_library_path system setting.
|
||
from app.services.template_service import get_material_library_path
|
||
asset_library_blend = get_material_library_path() or ""
|
||
_eng.dispose()
|
||
|
||
output_path = step_path.parent / f"{step_path.stem}_production.glb"
|
||
|
||
export_script = scripts_dir / "export_gltf.py"
|
||
if not is_blender_available():
|
||
raise RuntimeError("Blender is not available — cannot generate production GLB")
|
||
if not export_script.exists():
|
||
raise RuntimeError(f"export_gltf.py not found at {export_script}")
|
||
|
||
blender_bin = find_blender()
|
||
cmd = [
|
||
blender_bin, "--background",
|
||
"--python", str(export_script),
|
||
"--",
|
||
"--glb_path", str(geom_glb_path),
|
||
"--output_path", str(output_path),
|
||
"--material_map", _json.dumps(mat_map),
|
||
"--smooth_angle", str(smooth_angle),
|
||
]
|
||
if asset_library_blend:
|
||
cmd += ["--asset_library_blend", asset_library_blend]
|
||
|
||
log_task_event(
|
||
self.request.id,
|
||
f"Running Blender export_gltf.py — {len(mat_map)} material(s), smooth={smooth_angle}°",
|
||
"info",
|
||
)
|
||
try:
|
||
result = _subprocess.run(cmd, capture_output=True, text=True, timeout=300)
|
||
for line in result.stdout.splitlines():
|
||
logger.info("[export-gltf] %s", line)
|
||
if result.returncode != 0:
|
||
raise RuntimeError(
|
||
f"export_gltf.py exited {result.returncode}:\n{result.stderr[-500:]}"
|
||
)
|
||
except Exception as exc:
|
||
log_task_event(self.request.id, f"Blender production GLB failed: {exc}", "error")
|
||
logger.error("generate_gltf_production_task Blender failed for cad %s: %s", cad_file_id, exc)
|
||
raise self.retry(exc=exc, countdown=30)
|
||
finally:
|
||
# Clean up the high-quality temp geometry GLB (not needed after Blender export)
|
||
try:
|
||
prod_geom_glb.unlink(missing_ok=True)
|
||
except Exception:
|
||
pass
|
||
|
||
log_task_event(self.request.id, f"Production GLB exported: {output_path.name}", "done")
|
||
|
||
# --- 4. Store MediaAsset (replace existing gltf_production for this cad_file) ---
|
||
_eng2 = _ce(_sync_url)
|
||
with _Session(_eng2) as _sess:
|
||
_sess.execute(
|
||
_del(MediaAsset).where(
|
||
MediaAsset.cad_file_id == _uuid.UUID(cad_file_id),
|
||
MediaAsset.asset_type == MediaAssetType.gltf_production,
|
||
)
|
||
)
|
||
_key = str(output_path)
|
||
_prefix = str(app_settings.upload_dir).rstrip("/") + "/"
|
||
if _key.startswith(_prefix):
|
||
_key = _key[len(_prefix):]
|
||
asset = MediaAsset(
|
||
cad_file_id=_uuid.UUID(cad_file_id),
|
||
product_id=_uuid.UUID(product_id) if product_id else None,
|
||
asset_type=MediaAssetType.gltf_production,
|
||
storage_key=_key,
|
||
mime_type="model/gltf-binary",
|
||
file_size_bytes=output_path.stat().st_size if output_path.exists() else None,
|
||
)
|
||
_sess.add(asset)
|
||
_sess.commit()
|
||
asset_id = str(asset.id)
|
||
_eng2.dispose()
|
||
|
||
logger.info("generate_gltf_production_task: MediaAsset %s created for cad %s", asset_id, cad_file_id)
|
||
return {"glb_path": str(output_path), "asset_id": asset_id}
|
||
|
||
|
||
@celery_app.task(bind=True, name="app.tasks.step_tasks.regenerate_thumbnail", queue="thumbnail_rendering")
|
||
def regenerate_thumbnail(self, cad_file_id: str, part_colors: dict):
|
||
"""Regenerate thumbnail with per-part colours."""
|
||
logger.info(f"Regenerating thumbnail for CAD file: {cad_file_id}")
|
||
try:
|
||
from app.services.step_processor import regenerate_cad_thumbnail
|
||
success = regenerate_cad_thumbnail(cad_file_id, part_colors)
|
||
if not success:
|
||
raise RuntimeError("regenerate_cad_thumbnail returned False")
|
||
except Exception as exc:
|
||
logger.error(f"Thumbnail regeneration failed for {cad_file_id}: {exc}")
|
||
raise self.retry(exc=exc, countdown=30, max_retries=2)
|
||
|
||
|
||
@celery_app.task(name="app.tasks.step_tasks.dispatch_order_line_render", queue="step_processing")
|
||
def dispatch_order_line_render(order_line_id: str):
|
||
"""Route an order-line render to render_order_line_task."""
|
||
logger.info(f"Dispatching render for order line: {order_line_id}")
|
||
render_order_line_task.delay(order_line_id)
|
||
|
||
|
||
@celery_app.task(bind=True, name="app.tasks.step_tasks.render_order_line_task", queue="thumbnail_rendering", max_retries=3)
|
||
def render_order_line_task(self, order_line_id: str):
|
||
"""Render a specific output type for an order line.
|
||
|
||
Loads OrderLine → Product → CadFile → OutputType.render_settings.
|
||
Merges with system render settings. Stores result at order_line.result_path.
|
||
"""
|
||
logger.info(f"Rendering order line: {order_line_id}")
|
||
from app.services.render_log import emit
|
||
|
||
emit(order_line_id, "Celery render task started")
|
||
try:
|
||
from sqlalchemy import create_engine, select, update as sql_update
|
||
from sqlalchemy.orm import Session, joinedload
|
||
from app.config import settings as app_settings
|
||
|
||
# Use sync session for Celery (no async event loop)
|
||
sync_url = app_settings.database_url.replace("+asyncpg", "")
|
||
engine = create_engine(sync_url)
|
||
|
||
with Session(engine) as session:
|
||
from app.models.order_line import OrderLine
|
||
from app.models.product import Product
|
||
|
||
emit(order_line_id, "Loading order line from database")
|
||
line = session.execute(
|
||
select(OrderLine)
|
||
.where(OrderLine.id == order_line_id)
|
||
.options(
|
||
joinedload(OrderLine.product).joinedload(Product.cad_file),
|
||
joinedload(OrderLine.output_type),
|
||
)
|
||
).scalar_one_or_none()
|
||
|
||
if line is None:
|
||
emit(order_line_id, "Order line not found in database", "error")
|
||
logger.error(f"OrderLine {order_line_id} not found")
|
||
return
|
||
|
||
if line.product.cad_file_id is None:
|
||
emit(order_line_id, "Product has no CAD file — marking as failed", "error")
|
||
logger.warning(f"OrderLine {order_line_id}: product has no CAD file")
|
||
session.execute(
|
||
sql_update(OrderLine)
|
||
.where(OrderLine.id == line.id)
|
||
.values(render_status="failed")
|
||
)
|
||
session.commit()
|
||
return
|
||
|
||
# Mark as processing with timing
|
||
from datetime import datetime
|
||
render_start = datetime.utcnow()
|
||
session.execute(
|
||
sql_update(OrderLine)
|
||
.where(OrderLine.id == line.id)
|
||
.values(
|
||
render_status="processing",
|
||
render_backend_used="celery",
|
||
render_started_at=render_start,
|
||
)
|
||
)
|
||
session.commit()
|
||
|
||
cad_file = line.product.cad_file
|
||
materials_source = line.product.cad_part_materials
|
||
|
||
part_colors = {}
|
||
if cad_file and cad_file.parsed_objects:
|
||
parsed_names = cad_file.parsed_objects.get("objects", [])
|
||
if materials_source:
|
||
from app.services.step_processor import build_part_colors
|
||
part_colors = build_part_colors(parsed_names, materials_source)
|
||
|
||
# Resolve render template + material library
|
||
from app.services.template_service import resolve_template, get_material_library_path
|
||
|
||
category_key = line.product.category_key if line.product else None
|
||
ot_id = str(line.output_type_id) if line.output_type_id else None
|
||
template = resolve_template(category_key=category_key, output_type_id=ot_id)
|
||
material_library = get_material_library_path()
|
||
|
||
# Build material_map (part_name → material_name) for material replacement.
|
||
# Works with or without a render template — only suppressed if a
|
||
# template explicitly has material_replace_enabled=False.
|
||
material_map = None
|
||
use_materials = bool(material_library and materials_source)
|
||
if template and not template.material_replace_enabled:
|
||
use_materials = False
|
||
if use_materials:
|
||
material_map = {
|
||
m["part_name"]: m["material"]
|
||
for m in materials_source
|
||
if m.get("part_name") and m.get("material")
|
||
}
|
||
# Resolve raw material names to SCHAEFFLER library names via aliases
|
||
from app.services.material_service import resolve_material_map
|
||
material_map = resolve_material_map(material_map)
|
||
|
||
if template:
|
||
emit(order_line_id, f"Using render template: {template.name} (collection={template.target_collection}, material_replace={template.material_replace_enabled}, lighting_only={template.lighting_only})")
|
||
logger.info(f"Render template resolved: '{template.name}' path={template.blend_file_path}, lighting_only={template.lighting_only}")
|
||
else:
|
||
emit(order_line_id, "No render template found — using factory settings (Mode A)")
|
||
logger.info(f"No render template for category_key={category_key!r}, output_type_id={ot_id!r}")
|
||
|
||
cad_name = cad_file.original_name if cad_file else "?"
|
||
# Load render_position for rotation values
|
||
rotation_x = rotation_y = rotation_z = 0.0
|
||
if line.render_position_id:
|
||
from app.models.render_position import ProductRenderPosition
|
||
rp = session.get(ProductRenderPosition, line.render_position_id)
|
||
if rp:
|
||
rotation_x, rotation_y, rotation_z = rp.rotation_x, rp.rotation_y, rp.rotation_z
|
||
emit(order_line_id, f"Render position: '{rp.name}' ({rotation_x}°, {rotation_y}°, {rotation_z}°)")
|
||
|
||
emit(order_line_id, f"Starting render for {cad_name} ({len(part_colors)} coloured parts)")
|
||
|
||
# Determine if this is an animation output type
|
||
is_animation = bool(line.output_type and getattr(line.output_type, 'is_animation', False))
|
||
|
||
# Determine output format/extension
|
||
out_ext = "jpg"
|
||
if line.output_type and line.output_type.output_format:
|
||
fmt = line.output_type.output_format.lower()
|
||
if fmt == "mp4":
|
||
out_ext = "mp4"
|
||
elif fmt in ("png", "jpg", "jpeg"):
|
||
out_ext = "png" if fmt == "png" else "jpg"
|
||
|
||
# Build meaningful output filename
|
||
import re
|
||
def _sanitize(s: str) -> str:
|
||
return re.sub(r'[^\w\-.]', '_', s.strip())[:100]
|
||
|
||
product_name = line.product.name or line.product.pim_id or "product"
|
||
ot_name = line.output_type.name if line.output_type else "render"
|
||
filename = f"{_sanitize(product_name)}_{_sanitize(ot_name)}.{out_ext}"
|
||
|
||
# Render to per-line output directory
|
||
from pathlib import Path as _Path
|
||
render_dir = _Path(app_settings.upload_dir) / "renders" / order_line_id
|
||
render_dir.mkdir(parents=True, exist_ok=True)
|
||
output_path = str(render_dir / filename)
|
||
|
||
# Extract per-output-type render settings
|
||
render_width = None
|
||
render_height = None
|
||
render_engine = None
|
||
render_samples = None
|
||
noise_threshold = ""
|
||
denoiser = ""
|
||
denoising_input_passes = ""
|
||
denoising_prefilter = ""
|
||
denoising_quality = ""
|
||
denoising_use_gpu = ""
|
||
frame_count = 24
|
||
fps = 25
|
||
bg_color = ""
|
||
turntable_axis = "world_z"
|
||
if line.output_type and line.output_type.render_settings:
|
||
rs = line.output_type.render_settings
|
||
if rs.get("width"):
|
||
render_width = int(rs["width"])
|
||
if rs.get("height"):
|
||
render_height = int(rs["height"])
|
||
if rs.get("engine"):
|
||
render_engine = rs["engine"]
|
||
if rs.get("samples"):
|
||
render_samples = int(rs["samples"])
|
||
if rs.get("frame_count"):
|
||
frame_count = int(rs["frame_count"])
|
||
if rs.get("fps"):
|
||
fps = int(rs["fps"])
|
||
bg_color = rs.get("bg_color", "")
|
||
turntable_axis = rs.get("turntable_axis", "world_z")
|
||
noise_threshold = str(rs.get("noise_threshold", ""))
|
||
denoiser = str(rs.get("denoiser", ""))
|
||
denoising_input_passes = str(rs.get("denoising_input_passes", ""))
|
||
denoising_prefilter = str(rs.get("denoising_prefilter", ""))
|
||
denoising_quality = str(rs.get("denoising_quality", ""))
|
||
denoising_use_gpu = str(rs.get("denoising_use_gpu", ""))
|
||
|
||
transparent_bg = bool(line.output_type and line.output_type.transparent_bg)
|
||
cycles_device_val = (line.output_type.cycles_device or "auto") if line.output_type else "auto"
|
||
|
||
# Build ordered part names list for index-based Blender matching
|
||
part_names_ordered = None
|
||
if cad_file and cad_file.parsed_objects:
|
||
part_names_ordered = cad_file.parsed_objects.get("objects", []) or None
|
||
|
||
tmpl_info = f" template={template.name}" if template else ""
|
||
|
||
if is_animation:
|
||
# ── Turntable animation path ────────────────────────────────
|
||
emit(order_line_id, f"Starting turntable render: {frame_count} frames @ {fps}fps, {render_width or 1920}x{render_height or 1920}{tmpl_info}")
|
||
from app.services.render_blender import is_blender_available, render_turntable_to_file
|
||
if not is_blender_available():
|
||
raise RuntimeError("Blender not available on this worker")
|
||
|
||
from app.services.step_processor import _get_all_settings
|
||
_sys = _get_all_settings()
|
||
try:
|
||
service_data = render_turntable_to_file(
|
||
step_path=_Path(cad_file.stored_path),
|
||
output_path=_Path(output_path),
|
||
frame_count=frame_count,
|
||
fps=fps,
|
||
width=render_width or 1920,
|
||
height=render_height or 1920,
|
||
engine=render_engine or _sys.get("blender_engine", "cycles"),
|
||
samples=render_samples or int(_sys.get(f"blender_{render_engine or _sys.get('blender_engine','cycles')}_samples", 128)),
|
||
stl_quality=_sys.get("stl_quality", "low"),
|
||
smooth_angle=int(_sys.get("blender_smooth_angle", 30)),
|
||
cycles_device=cycles_device_val,
|
||
transparent_bg=transparent_bg,
|
||
bg_color=bg_color,
|
||
turntable_axis=turntable_axis,
|
||
part_colors=part_colors or None,
|
||
template_path=template.blend_file_path if template else None,
|
||
target_collection=template.target_collection if template else "Product",
|
||
material_library_path=material_library if use_materials else None,
|
||
material_map=material_map,
|
||
part_names_ordered=part_names_ordered,
|
||
lighting_only=bool(template.lighting_only) if template else False,
|
||
shadow_catcher=bool(template.shadow_catcher_enabled) if template else False,
|
||
rotation_x=rotation_x,
|
||
rotation_y=rotation_y,
|
||
rotation_z=rotation_z,
|
||
)
|
||
success = True
|
||
render_log = {
|
||
"renderer": "blender",
|
||
"type": "turntable",
|
||
"format": "mp4",
|
||
"engine": render_engine or _sys.get("blender_engine", "cycles"),
|
||
"engine_used": service_data.get("engine_used", "cycles"),
|
||
"samples": render_samples,
|
||
"cycles_device": cycles_device_val,
|
||
"width": render_width or 1920,
|
||
"height": render_height or 1920,
|
||
"frame_count": service_data.get("frame_count", frame_count),
|
||
"fps": fps,
|
||
"total_duration_s": service_data.get("total_duration_s"),
|
||
"stl_duration_s": service_data.get("stl_duration_s"),
|
||
"render_duration_s": service_data.get("render_duration_s"),
|
||
"ffmpeg_duration_s": service_data.get("ffmpeg_duration_s"),
|
||
"stl_size_bytes": service_data.get("stl_size_bytes"),
|
||
"output_size_bytes": service_data.get("output_size_bytes"),
|
||
"log_lines": service_data.get("log_lines", []),
|
||
}
|
||
if template:
|
||
render_log["template"] = template.blend_file_path
|
||
except Exception as exc:
|
||
success = False
|
||
render_log = {"renderer": "blender", "type": "turntable", "error": str(exc)[:500]}
|
||
logger.error("Turntable render failed for %s: %s", order_line_id, exc)
|
||
else:
|
||
# ── Still image path ────────────────────────────────────────
|
||
emit(order_line_id, f"Calling renderer (STEP → GLB → Blender) {render_width or 'default'}x{render_height or 'default'}{' [transparent]' if transparent_bg else ''}{f' engine={render_engine}' if render_engine else ''}{f' samples={render_samples}' if render_samples else ''}{tmpl_info}")
|
||
from app.services.step_processor import render_to_file
|
||
|
||
success, render_log = render_to_file(
|
||
step_path=cad_file.stored_path,
|
||
output_path=output_path,
|
||
part_colors=part_colors,
|
||
width=render_width,
|
||
height=render_height,
|
||
transparent_bg=transparent_bg,
|
||
engine=render_engine,
|
||
samples=render_samples,
|
||
template_path=template.blend_file_path if template else None,
|
||
target_collection=template.target_collection if template else "Product",
|
||
material_library_path=material_library if use_materials else None,
|
||
material_map=material_map,
|
||
part_names_ordered=part_names_ordered,
|
||
lighting_only=bool(template.lighting_only) if template else False,
|
||
shadow_catcher=bool(template.shadow_catcher_enabled) if template else False,
|
||
cycles_device=line.output_type.cycles_device if line.output_type else None,
|
||
rotation_x=rotation_x,
|
||
rotation_y=rotation_y,
|
||
rotation_z=rotation_z,
|
||
job_id=order_line_id,
|
||
order_line_id=order_line_id,
|
||
noise_threshold=noise_threshold,
|
||
denoiser=denoiser,
|
||
denoising_input_passes=denoising_input_passes,
|
||
denoising_prefilter=denoising_prefilter,
|
||
denoising_quality=denoising_quality,
|
||
denoising_use_gpu=denoising_use_gpu,
|
||
)
|
||
|
||
new_status = "completed" if success else "failed"
|
||
render_end = datetime.utcnow()
|
||
elapsed = (render_end - render_start).total_seconds()
|
||
|
||
update_values = dict(
|
||
render_status=new_status,
|
||
render_completed_at=render_end,
|
||
render_log=render_log,
|
||
)
|
||
if success:
|
||
update_values["result_path"] = output_path
|
||
|
||
session.execute(
|
||
sql_update(OrderLine)
|
||
.where(OrderLine.id == line.id)
|
||
.values(**update_values)
|
||
)
|
||
session.commit()
|
||
|
||
if success:
|
||
# Create MediaAsset so the render appears in the Media Browser
|
||
try:
|
||
from app.domains.media.models import MediaAsset, MediaAssetType as MAT
|
||
from app.config import settings as _cfg2
|
||
_ext = str(output_path).rsplit(".", 1)[-1].lower() if "." in str(output_path) else "bin"
|
||
_mime = "video/mp4" if _ext in ("mp4", "webm") else ("image/jpeg" if _ext in ("jpg", "jpeg") else "image/png")
|
||
# Extension determines type — poster frames (.jpg/.png) from animations are still stills
|
||
_at = MAT.turntable if _ext in ("mp4", "webm") else MAT.still
|
||
_tenant_id = line.product.cad_file.tenant_id if (line.product and line.product.cad_file) else None
|
||
# Normalize storage_key to relative path
|
||
_raw_key = str(output_path)
|
||
_upload_prefix = str(_cfg2.upload_dir).rstrip("/") + "/"
|
||
_norm_key = _raw_key[len(_upload_prefix):] if _raw_key.startswith(_upload_prefix) else _raw_key
|
||
_existing = session.execute(
|
||
select(MediaAsset.id).where(MediaAsset.storage_key == _norm_key).limit(1)
|
||
).scalar_one_or_none()
|
||
if not _existing:
|
||
_asset = MediaAsset(
|
||
tenant_id=_tenant_id,
|
||
order_line_id=line.id,
|
||
product_id=line.product_id,
|
||
asset_type=_at,
|
||
storage_key=_norm_key,
|
||
mime_type=_mime,
|
||
)
|
||
session.add(_asset)
|
||
session.commit()
|
||
except Exception:
|
||
logger.exception("Failed to create MediaAsset for order_line %s", order_line_id)
|
||
|
||
if success:
|
||
emit(order_line_id, f"Render completed in {elapsed:.1f}s", "success")
|
||
else:
|
||
emit(order_line_id, f"Render failed after {elapsed:.1f}s", "error")
|
||
|
||
# Broadcast WebSocket event for live UI updates
|
||
try:
|
||
from app.core.websocket import publish_event_sync
|
||
_tenant_id = str(line.product.cad_file.tenant_id) if (
|
||
line.product and line.product.cad_file and line.product.cad_file.tenant_id
|
||
) else None
|
||
if _tenant_id:
|
||
publish_event_sync(_tenant_id, {
|
||
"type": "render_complete" if success else "render_failed",
|
||
"order_line_id": order_line_id,
|
||
"order_id": str(line.order_id),
|
||
"status": new_status,
|
||
})
|
||
except Exception:
|
||
logger.debug("WebSocket publish skipped (non-fatal)")
|
||
|
||
# Notify order creator about render result
|
||
try:
|
||
from app.models.order import Order as OrderModel
|
||
order_row = session.execute(
|
||
select(OrderModel.created_by, OrderModel.order_number)
|
||
.where(OrderModel.id == line.order_id)
|
||
).one_or_none()
|
||
if order_row:
|
||
from app.services.notification_service import emit_notification_sync
|
||
details: dict = {
|
||
"order_number": order_row[1],
|
||
"product_name": product_name,
|
||
"output_type": ot_name,
|
||
}
|
||
if not success and isinstance(render_log, dict):
|
||
err = render_log.get("error") or render_log.get("stderr", "")
|
||
if err:
|
||
details["error"] = str(err)[:300]
|
||
emit_notification_sync(
|
||
actor_user_id=None,
|
||
target_user_id=str(order_row[0]),
|
||
action="render.completed" if success else "render.failed",
|
||
entity_type="order",
|
||
entity_id=str(line.order_id),
|
||
details=details,
|
||
)
|
||
except Exception:
|
||
logger.exception("Failed to emit render notification")
|
||
|
||
# Check if all lines for this order are done → auto-advance
|
||
order_id_str = str(line.order_id)
|
||
|
||
engine.dispose()
|
||
|
||
from app.services.order_status_service import check_order_completion
|
||
check_order_completion(order_id_str)
|
||
|
||
except Exception as exc:
|
||
logger.error(f"render_order_line_task failed for {order_line_id}: {exc}")
|
||
# If retries exhausted, mark as failed so the line doesn't stay stuck
|
||
if self.request.retries >= self.max_retries:
|
||
logger.error(f"Max retries reached for {order_line_id}, marking as failed")
|
||
try:
|
||
from sqlalchemy import create_engine, update as sql_update2
|
||
from sqlalchemy.orm import Session as SyncSession
|
||
from app.config import settings as app_settings
|
||
from app.models.order_line import OrderLine as OL2
|
||
sync_url2 = app_settings.database_url.replace("+asyncpg", "")
|
||
eng2 = create_engine(sync_url2)
|
||
with SyncSession(eng2) as s2:
|
||
from datetime import datetime as dt2
|
||
s2.execute(
|
||
sql_update2(OL2).where(OL2.id == order_line_id)
|
||
.values(
|
||
render_status="failed",
|
||
render_completed_at=dt2.utcnow(),
|
||
render_log={"error": str(exc)[:500]},
|
||
)
|
||
)
|
||
s2.commit()
|
||
eng2.dispose()
|
||
from app.services.order_status_service import check_order_completion
|
||
# Try to get order_id from DB
|
||
eng3 = create_engine(sync_url2)
|
||
with SyncSession(eng3) as s3:
|
||
from sqlalchemy import select as sel
|
||
row = s3.execute(sel(OL2.order_id).where(OL2.id == order_line_id)).scalar_one_or_none()
|
||
if row:
|
||
check_order_completion(str(row))
|
||
eng3.dispose()
|
||
# Notify the order creator about the failure
|
||
try:
|
||
from sqlalchemy import select as sel2
|
||
from app.models.order import Order as OrderModel2
|
||
eng4 = create_engine(sync_url2)
|
||
with SyncSession(eng4) as s4:
|
||
order_row2 = s4.execute(
|
||
sel2(OrderModel2.created_by, OrderModel2.order_number)
|
||
.join(OL2, OL2.order_id == OrderModel2.id)
|
||
.where(OL2.id == order_line_id)
|
||
).one_or_none()
|
||
eng4.dispose()
|
||
if order_row2:
|
||
from app.services.notification_service import emit_notification_sync
|
||
emit_notification_sync(
|
||
actor_user_id=None,
|
||
target_user_id=str(order_row2[0]),
|
||
action="render.failed",
|
||
entity_type="order",
|
||
entity_id=None,
|
||
details={
|
||
"order_number": order_row2[1],
|
||
"product_name": "unknown",
|
||
"output_type": "unknown",
|
||
"error": str(exc)[:300],
|
||
},
|
||
)
|
||
except Exception:
|
||
logger.exception("Failed to emit render failure notification")
|
||
except Exception:
|
||
logger.exception(f"Failed to mark {order_line_id} as failed in DB")
|
||
raise
|
||
raise self.retry(exc=exc, countdown=60)
|