375 lines
15 KiB
Python
375 lines
15 KiB
Python
"""Render dispatcher — routes render jobs to Celery or Flamenco.
|
|
|
|
Backend selection priority:
|
|
1. OutputType.render_backend per-type override ("celery" / "flamenco")
|
|
2. OutputType.is_animation — animations default to Flamenco
|
|
3. System setting render_backend — global default ("celery" / "flamenco" / "auto")
|
|
4. "auto" mode: stills → Celery, animations → Flamenco
|
|
"""
|
|
import json
|
|
import logging
|
|
from datetime import datetime
|
|
|
|
from sqlalchemy import select, update as sql_update
|
|
from sqlalchemy.orm import Session, joinedload
|
|
|
|
from app.models.order_line import OrderLine
|
|
from app.models.output_type import OutputType
|
|
from app.models.product import Product
|
|
from app.models.system_setting import SystemSetting
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def _load_setting(session: Session, key: str, default: str = "") -> str:
|
|
"""Load a single system setting (sync)."""
|
|
row = session.execute(
|
|
select(SystemSetting).where(SystemSetting.key == key)
|
|
).scalar_one_or_none()
|
|
return row.value if row else default
|
|
|
|
|
|
def resolve_backend(output_type: OutputType | None, system_backend: str) -> str:
|
|
"""Determine which backend to use for a given output type.
|
|
|
|
Returns "celery" or "flamenco".
|
|
"""
|
|
if output_type is None:
|
|
return "celery"
|
|
|
|
# Priority 1: explicit per-type override
|
|
ot_backend = output_type.render_backend
|
|
if ot_backend in ("celery", "flamenco"):
|
|
return ot_backend
|
|
|
|
# Priority 2+3: is_animation + system setting
|
|
if system_backend in ("celery", "flamenco"):
|
|
return system_backend
|
|
|
|
# Priority 4: auto mode — animations → Flamenco, stills → Celery
|
|
if output_type.is_animation:
|
|
return "flamenco"
|
|
return "celery"
|
|
|
|
|
|
def build_flamenco_job_settings(
|
|
output_type: OutputType,
|
|
product: Product,
|
|
step_path: str,
|
|
output_dir: str,
|
|
system_settings: dict[str, str],
|
|
lighting_only: bool = False,
|
|
shadow_catcher: bool = False,
|
|
camera_orbit: bool = True,
|
|
cycles_device: str = "auto",
|
|
rotation_x: float = 0.0,
|
|
rotation_y: float = 0.0,
|
|
rotation_z: float = 0.0,
|
|
) -> dict:
|
|
"""Build Flamenco job settings from output type and product metadata."""
|
|
render_settings = output_type.render_settings or {}
|
|
engine = render_settings.get("engine", system_settings.get("blender_engine", "cycles"))
|
|
samples_key = f"blender_{engine}_samples"
|
|
samples = render_settings.get("samples", int(system_settings.get(samples_key, "256")))
|
|
stl_quality = render_settings.get("stl_quality", system_settings.get("stl_quality", "low"))
|
|
width = render_settings.get("width", 1920 if output_type.is_animation else 1024)
|
|
height = render_settings.get("height", 1080 if output_type.is_animation else 1024)
|
|
|
|
part_colors = {}
|
|
part_names_ordered = []
|
|
if product.cad_file and product.cad_file.parsed_objects:
|
|
part_names_ordered = product.cad_file.parsed_objects.get("objects", [])
|
|
materials_source = product.cad_part_materials
|
|
if materials_source:
|
|
from app.services.step_processor import build_part_colors
|
|
part_colors = build_part_colors(part_names_ordered, materials_source)
|
|
|
|
transparent_bg = bool(output_type.transparent_bg) if hasattr(output_type, 'transparent_bg') else False
|
|
|
|
settings = {
|
|
"step_path": step_path,
|
|
"engine": engine,
|
|
"samples": samples,
|
|
"stl_quality": stl_quality,
|
|
"width": width,
|
|
"height": height,
|
|
"part_colors_json": json.dumps(part_colors),
|
|
"transparent_bg": transparent_bg,
|
|
"template_path": "",
|
|
"target_collection": "Product",
|
|
"material_library_path": "",
|
|
"material_map_json": "{}",
|
|
"part_names_ordered_json": json.dumps(part_names_ordered),
|
|
"lighting_only": lighting_only,
|
|
"shadow_catcher": shadow_catcher,
|
|
"cycles_device": cycles_device,
|
|
"rotation_x": rotation_x,
|
|
"rotation_y": rotation_y,
|
|
"rotation_z": rotation_z,
|
|
}
|
|
|
|
for dk in ('noise_threshold', 'denoiser', 'denoising_input_passes',
|
|
'denoising_prefilter', 'denoising_quality', 'denoising_use_gpu'):
|
|
settings[dk] = str(render_settings.get(dk, ""))
|
|
|
|
if output_type.is_animation:
|
|
# Turntable-specific settings
|
|
output_name = render_settings.get("output_name", "turntable")
|
|
settings["output_dir"] = output_dir
|
|
settings["output_name"] = output_name
|
|
settings["frame_count"] = render_settings.get("frame_count", 120)
|
|
settings["fps"] = render_settings.get("fps", 30)
|
|
settings["turntable_degrees"] = render_settings.get("turntable_degrees", 360)
|
|
settings["turntable_axis"] = render_settings.get("turntable_axis", "world_z")
|
|
settings["bg_color"] = render_settings.get("bg_color", "")
|
|
settings["camera_orbit"] = camera_orbit
|
|
else:
|
|
# Still-specific settings
|
|
ext = output_type.output_format or "png"
|
|
settings["output_path"] = f"{output_dir}/render.{ext}"
|
|
|
|
return settings
|
|
|
|
|
|
def dispatch_render(order_line_id: str) -> dict:
|
|
"""Route a render job to Celery or Flamenco based on configuration.
|
|
|
|
Must be called from a sync context (Celery task or sync wrapper).
|
|
Returns {"backend": "celery"|"flamenco", "job_ref": str}.
|
|
"""
|
|
from app.config import settings as app_settings
|
|
from app.services.render_log import emit, clear
|
|
|
|
clear(order_line_id)
|
|
emit(order_line_id, "Dispatch started — loading order line data")
|
|
|
|
sync_url = app_settings.database_url.replace("+asyncpg", "")
|
|
from sqlalchemy import create_engine
|
|
engine_db = create_engine(sync_url)
|
|
|
|
with Session(engine_db) as session:
|
|
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", "error")
|
|
logger.error(f"OrderLine {order_line_id} not found")
|
|
return {"backend": "none", "job_ref": "", "error": "not_found"}
|
|
|
|
product_name = line.product.name or line.product.pim_id or "unknown"
|
|
output_name = line.output_type.name if line.output_type else "default"
|
|
emit(order_line_id, f"Product: {product_name} | Output: {output_name}")
|
|
|
|
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 {"backend": "none", "job_ref": "", "error": "no_cad_file"}
|
|
|
|
cad_name = line.product.cad_file.original_name if line.product.cad_file else "?"
|
|
emit(order_line_id, f"CAD file: {cad_name}")
|
|
|
|
# Load system settings
|
|
system_backend = _load_setting(session, "render_backend", "celery")
|
|
flamenco_url = _load_setting(session, "flamenco_manager_url", "http://flamenco-manager:8080")
|
|
|
|
backend = resolve_backend(line.output_type, system_backend)
|
|
emit(order_line_id, f"Resolved backend: {backend}")
|
|
|
|
# Mark as processing
|
|
now = datetime.utcnow()
|
|
session.execute(
|
|
sql_update(OrderLine)
|
|
.where(OrderLine.id == line.id)
|
|
.values(
|
|
render_status="processing",
|
|
render_backend_used=backend,
|
|
render_started_at=now,
|
|
)
|
|
)
|
|
session.commit()
|
|
|
|
if backend == "flamenco":
|
|
emit(order_line_id, f"Submitting job to Flamenco Manager ({flamenco_url})")
|
|
result = _dispatch_flamenco(session, line, flamenco_url)
|
|
if result.get("error"):
|
|
emit(order_line_id, f"Flamenco submit failed: {result['error']}", "error")
|
|
else:
|
|
emit(order_line_id, f"Flamenco job submitted: {result.get('job_ref', '?')}")
|
|
return result
|
|
else:
|
|
emit(order_line_id, "Dispatching to Celery render worker")
|
|
return _dispatch_celery(order_line_id)
|
|
|
|
engine_db.dispose()
|
|
|
|
|
|
def _dispatch_celery(order_line_id: str) -> dict:
|
|
"""Dispatch to the existing Celery render task."""
|
|
from app.tasks.step_tasks import render_order_line_task
|
|
result = render_order_line_task.delay(order_line_id)
|
|
return {"backend": "celery", "job_ref": result.id}
|
|
|
|
|
|
def _dispatch_flamenco(session: Session, line: OrderLine, flamenco_url: str) -> dict:
|
|
"""Submit a job to Flamenco Manager."""
|
|
import re
|
|
from app.services.flamenco_client import get_flamenco_client
|
|
|
|
# Load all needed system settings
|
|
all_keys = ["blender_engine", "blender_cycles_samples", "blender_eevee_samples", "stl_quality", "cycles_device"]
|
|
sys_settings = {}
|
|
for key in all_keys:
|
|
sys_settings[key] = _load_setting(session, key, "")
|
|
|
|
output_type = line.output_type
|
|
product = line.product
|
|
cad_file = product.cad_file
|
|
|
|
# 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
|
|
|
|
# Flamenco mounts the uploads volume at /shared, backend uses /app/uploads
|
|
raw_path = cad_file.stored_path if cad_file else ""
|
|
step_path = raw_path.replace("/app/uploads/", "/shared/") if raw_path else ""
|
|
output_dir = f"/shared/renders/{line.id}"
|
|
|
|
job_type = "schaeffler-turntable" if (output_type and output_type.is_animation) else "schaeffler-still"
|
|
|
|
# Resolve render template + material library BEFORE building job settings
|
|
# (template.lighting_only is needed by build_flamenco_job_settings)
|
|
from app.services.template_service import resolve_template, get_material_library_path
|
|
|
|
category_key = product.category_key if 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()
|
|
|
|
# Resolve cycles_device: per-output-type override wins, fall back to system setting
|
|
ot_cycles_device = output_type.cycles_device if output_type else None
|
|
effective_cycles_device = ot_cycles_device or sys_settings.get("cycles_device", "gpu") or "gpu"
|
|
|
|
settings = build_flamenco_job_settings(
|
|
output_type=output_type,
|
|
product=product,
|
|
step_path=step_path,
|
|
output_dir=output_dir,
|
|
system_settings=sys_settings,
|
|
lighting_only=bool(template.lighting_only) if template else False,
|
|
shadow_catcher=bool(template.shadow_catcher_enabled) if template else False,
|
|
camera_orbit=bool(template.camera_orbit) if template else True,
|
|
cycles_device=effective_cycles_device,
|
|
rotation_x=rotation_x,
|
|
rotation_y=rotation_y,
|
|
rotation_z=rotation_z,
|
|
)
|
|
|
|
if template:
|
|
# Remap path for Flamenco shared volume
|
|
tmpl_path = template.blend_file_path.replace("/app/uploads/", "/shared/")
|
|
settings["template_path"] = tmpl_path
|
|
settings["target_collection"] = template.target_collection
|
|
logger.info(
|
|
f"Flamenco job: using render template '{template.name}' "
|
|
f"(id={template.id}, path={tmpl_path}, collection={template.target_collection})"
|
|
)
|
|
else:
|
|
logger.info(
|
|
f"Flamenco job: no render template found for "
|
|
f"category_key={category_key!r}, output_type_id={ot_id!r} — using factory settings"
|
|
)
|
|
|
|
# Material library + material map: send whenever library exists and product
|
|
# has material assignments — works with or without a render template.
|
|
# When a template is present, only apply if material_replace_enabled is set.
|
|
materials_source = product.cad_part_materials
|
|
use_materials = bool(material_library and materials_source)
|
|
if template and not template.material_replace_enabled:
|
|
use_materials = False
|
|
|
|
if use_materials:
|
|
mat_lib_path = material_library.replace("/app/uploads/", "/shared/")
|
|
settings["material_library_path"] = mat_lib_path
|
|
mat_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
|
|
mat_map = resolve_material_map(mat_map)
|
|
settings["material_map_json"] = json.dumps(mat_map)
|
|
|
|
# Output naming: meaningful filename instead of generic render.ext
|
|
def _sanitize(s: str) -> str:
|
|
return re.sub(r'[^\w\-.]', '_', s.strip())[:100]
|
|
|
|
product_name = product.name or product.pim_id or "product"
|
|
ot_name = output_type.name if output_type else "render"
|
|
|
|
if not (output_type and output_type.is_animation):
|
|
ext = output_type.output_format or "png" if output_type else "png"
|
|
filename = f"{_sanitize(product_name)}_{_sanitize(ot_name)}.{ext}"
|
|
settings["output_path"] = f"{output_dir}/{filename}"
|
|
|
|
metadata = {
|
|
"order_line_id": str(line.id),
|
|
"order_id": str(line.order_id),
|
|
"product_name": product.name or "",
|
|
"output_type": output_type.name if output_type else "",
|
|
"category": product.category_key or "",
|
|
}
|
|
|
|
job_name = f"{product.name or product.pim_id} - {output_type.name if output_type else 'render'}"
|
|
|
|
try:
|
|
client = get_flamenco_client(flamenco_url)
|
|
job = client.submit_job(
|
|
name=job_name[:200],
|
|
job_type=job_type,
|
|
settings=settings,
|
|
metadata=metadata,
|
|
)
|
|
job_id = job.get("id", "")
|
|
|
|
# Save flamenco_job_id
|
|
session.execute(
|
|
sql_update(OrderLine)
|
|
.where(OrderLine.id == line.id)
|
|
.values(flamenco_job_id=job_id)
|
|
)
|
|
session.commit()
|
|
|
|
logger.info(f"Flamenco job submitted: {job_id} for OrderLine {line.id}")
|
|
return {"backend": "flamenco", "job_ref": job_id}
|
|
|
|
except Exception as exc:
|
|
logger.error(f"Flamenco submit failed for OrderLine {line.id}: {exc}")
|
|
session.execute(
|
|
sql_update(OrderLine)
|
|
.where(OrderLine.id == line.id)
|
|
.values(
|
|
render_status="failed",
|
|
render_completed_at=datetime.utcnow(),
|
|
render_log={"error": f"Flamenco submit failed: {str(exc)[:500]}"},
|
|
)
|
|
)
|
|
session.commit()
|
|
return {"backend": "flamenco", "job_ref": "", "error": str(exc)}
|