Skip to content

AI media harness for planning, generating, and editing locally

TypeScript

Route worker cancels and prefer reachable LAN addresses

Bitti7575e0b3ebb2
diff --git a/src-tauri/src/worker/client.rs b/src-tauri/src/worker/client.rs
index d27011c..17968d4 100644
--- a/src-tauri/src/worker/client.rs
+++ b/src-tauri/src/worker/client.rs
@@ -63,7 +63,8 @@ struct Inner {
saved: Mutex<Saved>,
announced: Mutex<Vec<Announced>>,
probes: Mutex<HashMap<String, Probe>>,
- jobs: Mutex<HashMap<String, Arc<AtomicBool>>>,
+ /// Jobs sent from here, with the worker each one went to.
+ jobs: Mutex<HashMap<String, (Arc<AtomicBool>, Connection)>>,
daemon: Mutex<Option<mdns_sd::ServiceDaemon>>,
}
@@ -282,14 +283,16 @@ impl Workers {
/// Every address a worker id might answer on, best first.
fn addresses_for(&self, id: &str, saved: &Saved) -> Vec<String> {
- let mut addresses: Vec<String> = self.0.announced.lock().map(|announced| announced.iter()
+ // The address that last answered first, then what mDNS announces.
+ let mut addresses: Vec<String> = saved.known.get(id).map(|known| known.address.clone()).into_iter().collect();
+ for address in self.0.announced.lock().map(|announced| announced.iter()
.filter(|worker| worker.id == id)
.flat_map(|worker| worker.addresses.iter().map(socket_address))
- .collect()).unwrap_or_default();
- if let Some(known) = saved.known.get(id) {
- addresses.push(known.address.clone());
+ .collect::<Vec<_>>()).unwrap_or_default() {
+ if !addresses.contains(&address) {
+ addresses.push(address);
+ }
}
- addresses.dedup();
addresses
}
@@ -471,13 +474,13 @@ impl Workers {
}
}
- fn register(&self, job_id: &str) -> Result<Arc<AtomicBool>, String> {
+ fn register(&self, job_id: &str, connection: &Connection) -> Result<Arc<AtomicBool>, String> {
let mut jobs = self.0.jobs.lock().map_err(|_| "Worker job lock failed.")?;
if jobs.contains_key(job_id) {
return Err("This generation job is already queued.".into());
}
let cancel = Arc::new(AtomicBool::new(false));
- jobs.insert(job_id.to_string(), cancel.clone());
+ jobs.insert(job_id.to_string(), (cancel.clone(), connection.clone()));
Ok(cancel)
}
@@ -487,17 +490,16 @@ impl Workers {
}
}
- /// Cancels a job this computer sent to a worker. False when it sent none.
+ /// Cancels a job this computer sent to a worker, on the worker it went
+ /// to even if another one is selected now. False when it sent none.
pub(crate) fn cancel(&self, job_id: &str) -> bool {
- let Some(flag) = self.0.jobs.lock().ok().and_then(|jobs| jobs.get(job_id).cloned()) else { return false };
+ let Some((flag, connection)) = self.0.jobs.lock().ok().and_then(|jobs| jobs.get(job_id).cloned()) else { return false };
flag.store(true, Ordering::Release);
- if let Ok(Some(connection)) = self.active() {
- let job_id = job_id.to_string();
- std::thread::spawn(move || {
- let _ = connection.post::<serde_json::Value>(&format!("/v1/jobs/{job_id}/cancel"), &());
- let _ = connection.post::<serde_json::Value>(&format!("/v1/prepare/{job_id}/cancel"), &());
- });
- }
+ let job_id = job_id.to_string();
+ std::thread::spawn(move || {
+ let _ = connection.post::<serde_json::Value>(&format!("/v1/jobs/{job_id}/cancel"), &());
+ let _ = connection.post::<serde_json::Value>(&format!("/v1/prepare/{job_id}/cancel"), &());
+ });
true
}
@@ -562,7 +564,7 @@ impl Workers {
pub(crate) fn plan(&self, connection: &Connection, request: &GenerationRequest, settings: &BTreeMap<String, ProviderSetting>) -> Result<serde_json::Value, String> {
let (job, sources) = build_job(request, settings)?;
- let cancel = self.register(&request.job_id)?;
+ let cancel = self.register(&request.job_id, connection)?;
let result = self.send_files(connection, &job, &sources, &cancel)
.and_then(|_| connection.post::<serde_json::Value>("/v1/plan", &job));
self.unregister(&request.job_id);
@@ -575,7 +577,7 @@ impl Workers {
pub(crate) fn enqueue(&self, connection: Connection, request: GenerationRequest, settings: &BTreeMap<String, ProviderSetting>) -> Result<(), String> {
crate::media::artifacts::generated_file_stem(&request.job_id)?;
let (job, sources) = build_job(&request, settings)?;
- let cancel = self.register(&request.job_id)?;
+ let cancel = self.register(&request.job_id, &connection)?;
let workers = self.clone();
let latents = request.save_latents_path.clone();
diagnostics::info("workers", "job.sending", "Generation is being sent to a worker.", serde_json::json!({
diff --git a/src-tauri/src/worker/discovery.rs b/src-tauri/src/worker/discovery.rs
index cc8fb40..c18ea26 100644
--- a/src-tauri/src/worker/discovery.rs
+++ b/src-tauri/src/worker/discovery.rs
@@ -26,6 +26,19 @@ fn host_label(name: &str) -> String {
if label.is_empty() { "slopus-worker".into() } else { label }
}
+/// Which announced address to try first. Home and office LANs use
+/// 192.168/16 and 10/8; 172.16/12 is often a Hyper-V or WSL adapter other
+/// computers cannot reach, and link-local IPv6 needs a scope URLs drop.
+fn address_rank(address: &SocketAddr) -> (u8, SocketAddr) {
+ let rank = match address.ip() {
+ IpAddr::V4(ip) if ip.octets()[0] == 192 || ip.octets()[0] == 10 => 0,
+ IpAddr::V4(ip) if ip.is_private() => 1,
+ IpAddr::V4(_) => 2,
+ IpAddr::V6(_) => 3,
+ };
+ (rank, *address)
+}
+
/// Keeps announcing this worker for as long as the returned daemon lives.
pub(crate) fn advertise(info: &WorkerInfo, port: u16) -> Result<ServiceDaemon, String> {
let daemon = ServiceDaemon::new().map_err(|error| error.to_string())?;
@@ -65,8 +78,8 @@ pub(crate) fn browse(changed: impl Fn(Vec<Announced>) + Send + 'static) -> Resul
.filter(|ip| !ip.is_loopback() || service.get_addresses().len() == 1)
.map(|ip| SocketAddr::new(ip, service.get_port()))
.collect();
- // IPv4 first: link-local IPv6 needs a scope that URLs drop.
- addresses.sort_by_key(|address| matches!(address.ip(), IpAddr::V6(_)));
+ addresses.sort_by_key(address_rank);
+ addresses.dedup();
seen.insert(service.get_fullname().to_string(), Announced {
name: service.get_property_val_str("name").unwrap_or(&id).to_string(),
id,
@@ -86,3 +99,34 @@ pub(crate) fn browse(changed: impl Fn(Vec<Announced>) + Send + 'static) -> Resul
.map_err(|error| error.to_string())?;
Ok(daemon)
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use std::sync::{Arc, Mutex};
+
+ /// Needs a worker running on this network (`slopus-worker`).
+ #[test]
+ #[ignore]
+ fn finds_a_running_worker() {
+ let found = Arc::new(Mutex::new(Vec::new()));
+ let seen = found.clone();
+ let _daemon = browse(move |workers| *seen.lock().unwrap() = workers).unwrap();
+ let started = std::time::Instant::now();
+ while found.lock().unwrap().is_empty() {
+ assert!(started.elapsed() < std::time::Duration::from_secs(15), "no worker announced itself");
+ std::thread::sleep(std::time::Duration::from_millis(100));
+ }
+ println!("{:?}", found.lock().unwrap());
+ }
+
+ #[test]
+ fn lan_addresses_are_tried_before_virtual_adapters_and_ipv6() {
+ let mut addresses: Vec<SocketAddr> = ["[fe80::1]:1", "172.19.144.1:1", "8.8.8.8:1", "192.168.88.232:1", "172.19.144.1:1"]
+ .iter().map(|text| text.parse().unwrap()).collect();
+ addresses.sort_by_key(address_rank);
+ addresses.dedup();
+ assert_eq!(addresses.iter().map(ToString::to_string).collect::<Vec<_>>(),
+ vec!["192.168.88.232:1", "172.19.144.1:1", "8.8.8.8:1", "[fe80::1]:1"]);
+ }
+}
diff --git a/src-tauri/src/worker/server.rs b/src-tauri/src/worker/server.rs
index 54b0210..abd61c6 100644
--- a/src-tauri/src/worker/server.rs
+++ b/src-tauri/src/worker/server.rs
@@ -73,6 +73,7 @@ impl JobLog {
struct Preparation {
status: Mutex<FilePreparation>,
cancel: Arc<AtomicBool>,
+ created: Instant,
}
struct Worker {
@@ -388,11 +389,16 @@ impl Worker {
let preparation = Arc::new(Preparation {
status: Mutex::new(FilePreparation { state: "running".into(), ..Default::default() }),
cancel: Arc::new(AtomicBool::new(false)),
+ created: Instant::now(),
});
{
let mut preparations = self.preparations.lock().map_err(|_| "Lock failed.")?;
- // Finished entries are only read once; keep the map small.
- preparations.retain(|_, entry| entry.status.lock().is_ok_and(|status| status.state == "running"));
+ // Keep finished results long enough for their client to read them.
+ preparations.retain(|_, entry| entry.created.elapsed() < Duration::from_secs(60 * 60)
+ || entry.status.lock().is_ok_and(|status| status.state == "running"));
+ if preparations.get(id).is_some_and(|entry| entry.status.lock().is_ok_and(|status| status.state != "running")) {
+ preparations.remove(id);
+ }
if preparations.contains_key(id) {
return Err("Files for this job are already being prepared.".into());
}