d8d22cd52a
* claim: #8139 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_019FAWPuFoh9qxn2uS2j53QZ * 3MF export: a component's bodies as one object with parts (#8139) file.export and file.save_mesh wrote every body as its own 3MF object and build item, so a slicer loaded a multi-body part as separate objects and could arrange them apart on the bed. With objects: "component", each placed component that holds two or more bodies is written as one object whose <components> are its bodies' meshes, built once, so PrusaSlicer, OrcaSlicer, Bambu Studio and Cura load it as one object with a part per body, each of which can take its own filament. The design's own bodies, and a component with a single body, stay objects of their own. The default (objects: "body") writes the same file as before. - io: model_xml_parts and write_3mf_parts write the parts; export_with_parts maps body names to them. model_xml_with and export_with_quality give the same output as before. - engine: mesh_parts reads `objects` (component is refused for formats other than 3MF); component_parts groups the placed bodies by placement, each part named after its occurrence (Bracket:1, Bracket:2). - file.save_mesh passes the parts on when it also sends the file to a slicer; file.send_to_slicer's own folder export is unchanged. Fixes #8139. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_019FAWPuFoh9qxn2uS2j53QZ --------- Co-authored-by: Claude <noreply@anthropic.com>
228 lines
10 KiB
Rust
228 lines
10 KiB
Rust
//! Sending a mesh to a program: the one pipeline behind `file.send_to_slicer` and the `slicer`
|
|
//! parameter of `file.save_mesh`. Write the file, find the target, start it and wait for it if its
|
|
//! rule says so, hand the file over, report. The two commands differ only in where the file goes:
|
|
//! `file.send_to_slicer` writes it into this user's slicer folder under a stable name, so sending
|
|
//! again replaces it; `file.save_mesh` writes it where the caller said.
|
|
//!
|
|
//! It takes a [`TargetKind`], and slicers are the only kind there is; a later Send to App would add
|
|
//! one (see `slicers::TargetKind`) and send through this same function.
|
|
|
|
use serde_json::{Value, json};
|
|
use solidcraft_io::Format;
|
|
|
|
use super::easyprint::{Exported, export_bodies};
|
|
use super::export_to;
|
|
use crate::params::bad;
|
|
use crate::slicers::{self, Slicer, TargetKind};
|
|
use crate::{EngineError, Result, Session};
|
|
|
|
/// What to do when the target has to be started first.
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
|
pub(super) enum Wait {
|
|
/// Start it, wait up to ten seconds for it to be ready, then send.
|
|
Block,
|
|
/// Start it and answer `starting`; the caller waits and sends.
|
|
Return,
|
|
/// Send now, started or not.
|
|
No,
|
|
}
|
|
|
|
impl Wait {
|
|
pub(super) fn parse(s: Option<&str>) -> Option<Wait> {
|
|
match s {
|
|
None | Some("block") => Some(Wait::Block),
|
|
Some("return") => Some(Wait::Return),
|
|
Some("no") => Some(Wait::No),
|
|
Some(_) => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Where the file is written.
|
|
pub(super) enum Dest<'a> {
|
|
/// This user's slicer folder, under a name that stays the same for the same design and bodies.
|
|
Folder,
|
|
/// The path the caller gave.
|
|
Path(&'a str),
|
|
}
|
|
|
|
pub(super) struct Send<'a> {
|
|
/// The command, for its error messages.
|
|
pub cmd: &'static str,
|
|
pub kind: TargetKind,
|
|
/// The target as the caller named it: an id, a name, or a program path.
|
|
pub spec: &'a str,
|
|
pub bodies: Vec<String>,
|
|
/// 3MF objects with parts (`objects: "component"`, #8139). Only for [`Dest::Path`].
|
|
pub parts: Vec<(String, Vec<String>)>,
|
|
pub format: Format,
|
|
/// Only for [`Dest::Path`]; the slicer folder's file is always standard.
|
|
pub quality: solidcraft_io::MeshQuality,
|
|
pub dest: Dest<'a>,
|
|
pub single_instance: bool,
|
|
pub wait: Wait,
|
|
}
|
|
|
|
fn format_name(f: Format) -> &'static str {
|
|
match f {
|
|
Format::StlBinary | Format::StlAscii => "stl",
|
|
Format::ThreeMfTagged => "3mf-tagged",
|
|
_ => "3mf",
|
|
}
|
|
}
|
|
|
|
/// Send the bodies to the target named by `r.spec`.
|
|
pub(super) fn send(s: &mut Session, r: Send<'_>) -> Result<Value> {
|
|
// The target is found before anything is written, so a name that matches nothing writes nothing.
|
|
let target = slicers::resolve_for(r.kind, r.spec).ok_or_else(|| {
|
|
bad(r.cmd, format!("no slicer `{}` (see file.slicers; a program works only once the user has added it under Custom…)", r.spec))
|
|
})?;
|
|
if !target.target().accepts(format_name(r.format)) {
|
|
return Err(bad(r.cmd, format!("{} does not take {}", target.name, format_name(r.format))));
|
|
}
|
|
let mut out = match r.dest {
|
|
Dest::Path(path) => export_to(s, path, r.format, &r.bodies, &r.parts, r.quality)?,
|
|
Dest::Folder => write_in_folder(s, &r)?,
|
|
};
|
|
let path = out.get("path").and_then(Value::as_str).unwrap_or_default().to_string();
|
|
deliver(&target, &path, r.single_instance, r.wait, &mut out);
|
|
Ok(out)
|
|
}
|
|
|
|
/// Write the bodies into the slicer folder.
|
|
fn write_in_folder(s: &mut Session, r: &Send<'_>) -> Result<Value> {
|
|
use crate::slicer_files;
|
|
let Exported { bytes, ext, fell_back, bodies } = export_bodies(s, r.cmd, &r.bodies, r.format)?;
|
|
let dir = slicer_files::dir().ok_or_else(|| bad(r.cmd, "no per-user folder on this system"))?;
|
|
let stem = slicer_files::stem(&s.doc.name, s.path.as_deref(), s.uid, &bodies);
|
|
let (file, numbered) = slicer_files::write(&dir, &stem, ext, &bytes).map_err(|e| EngineError::Other(format!("{}: {e}", dir.display())))?;
|
|
Ok(json!({"path": file.to_string_lossy(), "bytes": bytes.len(), "format": ext, "numbered": numbered, "stl_fallback": fell_back}))
|
|
}
|
|
|
|
/// Hand the file at `path` to `target`, starting it first if it has to be, and say what happened in
|
|
/// `out`: `slicer` when it went, `slicer_error` when the program would not start, `starting` (with
|
|
/// [`Wait::Return`]) or `slicer_timeout` when the target had to be started.
|
|
pub(super) fn deliver(target: &Slicer, path: &str, single_instance: bool, wait: Wait, out: &mut Value) {
|
|
deliver_via(target, path, single_instance, wait, &slicers::busctl_program(), slicers::READY_LIMIT, slicers::READY_POLL, out);
|
|
}
|
|
|
|
#[allow(clippy::too_many_arguments)]
|
|
fn deliver_via(
|
|
target: &Slicer,
|
|
path: &str,
|
|
mut single_instance: bool,
|
|
wait: Wait,
|
|
busctl: &str,
|
|
limit: std::time::Duration,
|
|
poll: std::time::Duration,
|
|
out: &mut Value,
|
|
) {
|
|
let Some(obj) = out.as_object_mut() else { return };
|
|
// A target that drops a file given at a cold start is started alone, and sent the file once it is ready.
|
|
if wait != Wait::No && target.waits_for_ready().is_some() && target.ready_via(busctl, slicers::PROBE_LIMIT) == Some(false) {
|
|
if let Err(e) = target.start(single_instance) {
|
|
obj.insert("slicer_error".into(), json!(e));
|
|
return;
|
|
}
|
|
if wait == Wait::Return {
|
|
obj.insert("starting".into(), json!(target.name));
|
|
return;
|
|
}
|
|
if !slicers::wait_for_ready_via(target, busctl, limit, poll) {
|
|
obj.insert("slicer_timeout".into(), json!(target.name));
|
|
return;
|
|
}
|
|
// After a start the file has to reach the instance that is now running, so the flag goes
|
|
// on whatever `single_instance` says.
|
|
single_instance = true;
|
|
}
|
|
// The file is saved either way; a program that won't start is reported, not fatal.
|
|
match target.open(path, single_instance) {
|
|
Ok(()) => obj.insert("slicer".into(), json!(target.name)),
|
|
Err(e) => obj.insert("slicer_error".into(), json!(e)),
|
|
};
|
|
}
|
|
|
|
#[cfg(test)]
|
|
#[cfg(unix)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::slicers::test_support::fake_program;
|
|
use std::time::Duration;
|
|
|
|
/// A "PrusaSlicer 3" whose launcher logs what it is started with, and a `busctl` that says the
|
|
/// slicer is not up for the first `cold` looks and is up after that.
|
|
fn setup(tag: &str, cold: u32) -> (std::path::PathBuf, Slicer, String) {
|
|
let root = std::env::temp_dir().join(format!("solidcraft-send-{tag}-{}", std::process::id()));
|
|
let _ = std::fs::remove_dir_all(&root);
|
|
let launcher_dir = root.join("slic3r-app-launcher");
|
|
std::fs::create_dir_all(&launcher_dir).unwrap();
|
|
let log = root.join("log");
|
|
let launcher = fake_program(&launcher_dir, "PrusaSlicer", &format!("echo \"$@\" >> {}", log.display()));
|
|
let count = root.join("count");
|
|
let busctl = fake_program(
|
|
&root,
|
|
"busctl",
|
|
&format!(
|
|
"n=$(cat {c} 2>/dev/null || echo 0); echo $((n+1)) > {c}; echo ':1.5 1 x'; [ $n -ge {cold} ] && echo 'com.prusa3d.prusaslicer.BroadcastListener.ab 2 y'; exit 0",
|
|
c = count.display()
|
|
),
|
|
);
|
|
let slicer = Slicer { id: "custom".into(), name: "PrusaSlicer".into(), command: vec![launcher], icon: None, prusa_major: None };
|
|
(root, slicer, busctl)
|
|
}
|
|
|
|
fn lines(root: &std::path::Path) -> Vec<String> {
|
|
for _ in 0..100 {
|
|
if root.join("log").exists() {
|
|
break;
|
|
}
|
|
std::thread::sleep(Duration::from_millis(20));
|
|
}
|
|
std::thread::sleep(Duration::from_millis(100));
|
|
std::fs::read_to_string(root.join("log")).map(|t| t.lines().map(String::from).collect()).unwrap_or_default()
|
|
}
|
|
|
|
#[test]
|
|
fn a_cold_launcher_is_started_alone_waited_for_and_then_sent_the_file() {
|
|
let (root, slicer, busctl) = setup("cold", 2);
|
|
let mut out = json!({"path": "/t/part.3mf"});
|
|
deliver_via(&slicer, "/t/part.3mf", false, Wait::Block, &busctl, Duration::from_secs(10), Duration::from_millis(20), &mut out);
|
|
assert_eq!(out["slicer"], "PrusaSlicer", "{out}");
|
|
let log = lines(&root);
|
|
// Started with no file, then sent the file, both with the single-instance flag the preference could not take away.
|
|
assert_eq!(log, ["--single-instance", "--single-instance /t/part.3mf"]);
|
|
std::fs::remove_dir_all(root).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn a_launcher_that_is_up_is_sent_the_file_at_once_and_wait_no_does_not_look() {
|
|
let (root, slicer, busctl) = setup("warm", 0);
|
|
let mut out = json!({"path": "/t/part.3mf"});
|
|
deliver_via(&slicer, "/t/part.3mf", true, Wait::Block, &busctl, Duration::from_secs(10), Duration::from_millis(20), &mut out);
|
|
assert_eq!(lines(&root), ["--single-instance /t/part.3mf"]);
|
|
let (root2, slicer2, busctl2) = setup("no", 99);
|
|
let mut out = json!({"path": "/t/part.3mf"});
|
|
deliver_via(&slicer2, "/t/part.3mf", true, Wait::No, &busctl2, Duration::from_secs(10), Duration::from_millis(20), &mut out);
|
|
assert_eq!(lines(&root2), ["--single-instance /t/part.3mf"], "sent without a start");
|
|
std::fs::remove_dir_all(root).unwrap();
|
|
std::fs::remove_dir_all(root2).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn return_starts_it_and_answers_and_a_launcher_that_never_comes_up_times_out_unsent() {
|
|
let (root, slicer, busctl) = setup("return", 99);
|
|
let mut out = json!({"path": "/t/part.3mf"});
|
|
deliver_via(&slicer, "/t/part.3mf", true, Wait::Return, &busctl, Duration::from_secs(10), Duration::from_millis(20), &mut out);
|
|
assert_eq!(out["starting"], "PrusaSlicer");
|
|
assert_eq!(lines(&root), ["--single-instance"], "started, no file");
|
|
let mut out = json!({"path": "/t/part.3mf"});
|
|
deliver_via(&slicer, "/t/part.3mf", true, Wait::Block, &busctl, Duration::from_millis(200), Duration::from_millis(20), &mut out);
|
|
assert_eq!(out["slicer_timeout"], "PrusaSlicer");
|
|
assert!(out.get("slicer").is_none());
|
|
let log = lines(&root);
|
|
assert!(log.iter().all(|l| !l.contains("part.3mf")), "{log:?}: the file was not sent");
|
|
std::fs::remove_dir_all(root).unwrap();
|
|
}
|
|
}
|