Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

Desktop: overlap owner liveness probes and skip redundant preflight HTTP

Daniel Han027efa386ee4
diff --git a/studio/src-tauri/src/desktop_backend_owner.rs b/studio/src-tauri/src/desktop_backend_owner.rs
index e8c98ee1dac..e0727e6219f 100644
--- a/studio/src-tauri/src/desktop_backend_owner.rs
+++ b/studio/src-tauri/src/desktop_backend_owner.rs
@@ -1029,11 +1029,30 @@ pub(crate) async fn probe_owned_backend_state_with_timeout(
Some(port) => vec![port],
None => desktop_candidate_ports().collect(),
};
+ probe_owned_backend_state_on_ports(owner, ports, require_desktop_secret, timeout).await
+}
+
+async fn probe_owned_backend_state_on_ports(
+ owner: BackendOwnerState,
+ ports: Vec<u16>,
+ require_desktop_secret: bool,
+ timeout: Duration,
+) -> OwnedBackendProbe {
let mut verified = Vec::new();
// Set only by a complete parsed answer naming someone else, so silence never reads as a takeover.
let mut answered_with_a_different_owner = false;
+ // Preserve port order and sequential auth; abort unread liveness tasks when the scan ends.
+ let mut pending = Vec::with_capacity(ports.len());
for port in ports {
- let liveness = match fetch_liveness(port, timeout).await {
+ let task = tokio::spawn(fetch_liveness(port, timeout));
+ pending.push((port, AbortOnDrop(task)));
+ }
+ for (port, mut answer) in pending {
+ let answer = match (&mut answer.0).await {
+ Ok(answer) => answer,
+ Err(error) => std::panic::resume_unwind(error.into_panic()),
+ };
+ let liveness = match answer {
Ok(Some(liveness)) => liveness,
Ok(None) => continue,
Err(error) => {
@@ -1102,6 +1121,14 @@ pub(crate) async fn probe_owned_backend_state_with_timeout(
})
}
+struct AbortOnDrop<T>(tokio::task::JoinHandle<T>);
+
+impl<T> Drop for AbortOnDrop<T> {
+ fn drop(&mut self) {
+ self.0.abort();
+ }
+}
+
#[allow(dead_code)]
pub(crate) async fn probe_verified_owned_backend() -> Result<OwnedBackendProbe, String> {
let Some(path) = metadata_path() else {
@@ -1119,24 +1146,63 @@ async fn probe_verified_owned_backend_at_path_with_expected(
path: &Path,
expected_studio_root_id: Option<&str>,
) -> Result<OwnedBackendProbe, String> {
+ verified_owned_backend_metadata_at_path_with_expected(path, expected_studio_root_id)?
+ .finish()
+ .await
+}
+
+pub(crate) enum VerifiedOwnedBackendMetadata {
+ Decided(OwnedBackendProbe),
+ NeedsProbe {
+ owner: BackendOwnerState,
+ port: Option<u16>,
+ },
+}
+
+impl VerifiedOwnedBackendMetadata {
+ pub(crate) async fn finish(self) -> Result<OwnedBackendProbe, String> {
+ match self {
+ Self::Decided(probe) => Ok(probe),
+ Self::NeedsProbe { owner, port } => {
+ Ok(probe_owned_backend_state(owner, port, true).await)
+ }
+ }
+ }
+}
+
+pub(crate) fn verified_owned_backend_metadata() -> Result<VerifiedOwnedBackendMetadata, String> {
+ let Some(path) = metadata_path() else {
+ return Ok(VerifiedOwnedBackendMetadata::Decided(
+ OwnedBackendProbe::NoMetadata,
+ ));
+ };
+ let expected = read_expected_studio_root_id();
+ verified_owned_backend_metadata_at_path_with_expected(&path, expected.as_deref())
+}
+
+fn verified_owned_backend_metadata_at_path_with_expected(
+ path: &Path,
+ expected_studio_root_id: Option<&str>,
+) -> Result<VerifiedOwnedBackendMetadata, String> {
+ let decided = |probe| Ok(VerifiedOwnedBackendMetadata::Decided(probe));
let Some(metadata) = read_metadata(path).map_err(|e| format!("read owner metadata: {e}"))?
else {
- return Ok(OwnedBackendProbe::NoMetadata);
+ return decided(OwnedBackendProbe::NoMetadata);
};
if !metadata_is_well_formed(&metadata) {
remove_metadata_file(path);
- return Ok(OwnedBackendProbe::RemovedMalformed);
+ return decided(OwnedBackendProbe::RemovedMalformed);
}
match previous_app_pid_status(metadata.app_pid) {
PreviousAppPidStatus::AliveOrCurrent => {
- return Ok(OwnedBackendProbe::NotVerified {
+ return decided(OwnedBackendProbe::NotVerified {
reason: "previous_desktop_app_still_running".to_string(),
});
}
PreviousAppPidStatus::Uncertain => {
- return Ok(OwnedBackendProbe::NotVerified {
+ return decided(OwnedBackendProbe::NotVerified {
reason: "previous_desktop_app_liveness_uncertain".to_string(),
});
}
@@ -1144,14 +1210,14 @@ async fn probe_verified_owned_backend_at_path_with_expected(
}
if expected_studio_root_id != Some(metadata.studio_root_id.as_str()) {
- return Ok(OwnedBackendProbe::NotVerified {
+ return decided(OwnedBackendProbe::NotVerified {
reason: "studio_root_id_mismatch".to_string(),
});
}
let owner = BackendOwnerState::from_metadata(path.to_path_buf(), metadata);
let port = owner.port();
- Ok(probe_owned_backend_state(owner, port, true).await)
+ Ok(VerifiedOwnedBackendMetadata::NeedsProbe { owner, port })
}
/// False only when the pid is provably gone. An unresolvable pid counts as running (on Windows
@@ -1820,6 +1886,196 @@ mod tests {
}
}
+ async fn silent_port() -> (u16, tokio::task::JoinHandle<()>) {
+ let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0))
+ .await
+ .unwrap();
+ let port = listener.local_addr().unwrap().port();
+ let task = tokio::spawn(async move {
+ let mut held = Vec::new();
+ while let Ok((socket, _)) = listener.accept().await {
+ held.push(socket);
+ }
+ });
+ (port, task)
+ }
+
+ async fn delayed_json_port(
+ delay: Duration,
+ body: &'static str,
+ ) -> (u16, tokio::task::JoinHandle<()>) {
+ use tokio::io::{AsyncReadExt, AsyncWriteExt};
+ let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0))
+ .await
+ .unwrap();
+ let port = listener.local_addr().unwrap().port();
+ let task = tokio::spawn(async move {
+ while let Ok((mut socket, _)) = listener.accept().await {
+ tokio::spawn(async move {
+ let mut raw = Vec::new();
+ let mut chunk = [0u8; 2048];
+ while !raw.windows(4).any(|w| w == b"\r\n\r\n") {
+ match socket.read(&mut chunk).await {
+ Ok(0) | Err(_) => return,
+ Ok(count) => raw.extend_from_slice(&chunk[..count]),
+ }
+ }
+ tokio::time::sleep(delay).await;
+ let response = format!(
+ "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
+ body.len(),
+ body
+ );
+ let _ = socket.write_all(response.as_bytes()).await;
+ });
+ }
+ });
+ (port, task)
+ }
+
+ const OWNED_BUT_INCOMPATIBLE: &str = r#"{"status":"alive","service":"Unsloth UI Backend","studio_root_id":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","desktop_owner":{"kind":"tauri","token_sha256":"943501cb7d1feb2aa8cde1bf09b80092c25b95dbafaca9ccc12d6785b229a6fd"}}"#;
+
+ #[tokio::test]
+ async fn the_portless_scan_waits_for_one_timeout_not_one_per_silent_port() {
+ let timeout = Duration::from_millis(600);
+ let mut ports = Vec::new();
+ let mut servers = Vec::new();
+ for _ in 0..5 {
+ let (port, server) = silent_port().await;
+ ports.push(port);
+ servers.push(server);
+ }
+ let owner = BackendOwnerState::from_metadata(
+ std::env::temp_dir().join("unsloth-silent-scan.json"),
+ metadata(std::process::id(), None),
+ );
+
+ let started = std::time::Instant::now();
+ let probe = probe_owned_backend_state_on_ports(owner, ports, false, timeout).await;
+ let elapsed = started.elapsed();
+ for server in servers {
+ server.abort();
+ }
+
+ assert!(matches!(
+ probe,
+ OwnedBackendProbe::NotVerified { ref reason } if reason == "owned_backend_not_found"
+ ));
+ assert!(
+ elapsed < timeout * 3,
+ "silent ports were probed one after another: {elapsed:?}"
+ );
+ }
+
+ #[tokio::test]
+ async fn the_portless_scan_keeps_port_order_when_a_later_port_answers_first() {
+ let (slow, slow_server) =
+ delayed_json_port(Duration::from_millis(300), OWNED_BUT_INCOMPATIBLE).await;
+ let (fast, fast_server) = delayed_json_port(Duration::ZERO, OWNED_BUT_INCOMPATIBLE).await;
+ let closed = closed_port();
+ for ports in [vec![slow, fast], vec![closed, slow, fast], vec![fast, slow]] {
+ let first = *ports.iter().find(|port| **port != closed).unwrap();
+ let owner = BackendOwnerState::from_metadata(
+ std::env::temp_dir().join("unsloth-ordered-scan.json"),
+ metadata(std::process::id(), None),
+ );
+ let probe =
+ probe_owned_backend_state_on_ports(owner, ports, false, Duration::from_secs(5))
+ .await;
+ match probe {
+ OwnedBackendProbe::Unmanageable { port, reason } => {
+ assert_eq!(port, first);
+ assert_eq!(reason, "desktop_protocol_incompatible");
+ }
+ other => panic!("expected the first answering port to decide: {other:?}"),
+ }
+ }
+ slow_server.abort();
+ fast_server.abort();
+ }
+
+ #[tokio::test]
+ async fn an_early_answer_aborts_the_liveness_probes_still_in_flight() {
+ use tokio::io::AsyncReadExt;
+ let (first, first_server) =
+ delayed_json_port(Duration::from_millis(300), OWNED_BUT_INCOMPATIBLE).await;
+ let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0))
+ .await
+ .unwrap();
+ let silent = listener.local_addr().unwrap().port();
+ let (closed_tx, closed_rx) = tokio::sync::oneshot::channel();
+ let silent_server = tokio::spawn(async move {
+ let (mut socket, _) = listener.accept().await.unwrap();
+ let mut chunk = [0u8; 2048];
+ while !matches!(socket.read(&mut chunk).await, Ok(0) | Err(_)) {}
+ let _ = closed_tx.send(());
+ });
+ let owner = BackendOwnerState::from_metadata(
+ std::env::temp_dir().join("unsloth-abort-scan.json"),
+ metadata(std::process::id(), None),
+ );
+ let probe = probe_owned_backend_state_on_ports(
+ owner,
+ vec![first, silent],
+ false,
+ Duration::from_secs(30),
+ )
+ .await;
+ assert!(matches!(probe, OwnedBackendProbe::Unmanageable { port, .. } if port == first));
+ tokio::time::timeout(Duration::from_secs(5), closed_rx)
+ .await
+ .expect("a liveness probe outlived the scan that no longer reads it")
+ .unwrap();
+ first_server.abort();
+ silent_server.abort();
+ }
+
+ #[tokio::test]
+ async fn owner_metadata_then_probe_matches_the_one_shot_probe() {
+ let path = temp_metadata_path("split");
+ let (live, live_server) = delayed_json_port(Duration::ZERO, OWNED_BUT_INCOMPATIBLE).await;
+ let dead = dead_child_pid();
+ let mut malformed = metadata(dead, Some(live));
+ malformed.token_sha256 = "0".repeat(64);
+ let cases: Vec<(Option<DesktopBackendMetadata>, Option<&str>)> = vec![
+ (None, Some(ROOT_ID)),
+ (Some(malformed), Some(ROOT_ID)),
+ (
+ Some(metadata(std::process::id(), Some(live))),
+ Some(ROOT_ID),
+ ),
+ (Some(metadata(u32::MAX - 1, Some(live))), Some(ROOT_ID)),
+ (Some(metadata(dead, Some(live))), Some(ROOT_ID)),
+ (Some(metadata(dead, Some(live))), None),
+ (Some(metadata(dead, Some(closed_port()))), Some(ROOT_ID)),
+ ];
+ for (case, expected) in cases {
+ let write = || match &case {
+ Some(metadata) => write_metadata(&path, metadata).unwrap(),
+ None => {
+ let _ = std::fs::remove_file(&path);
+ }
+ };
+ write();
+ let one_shot = probe_verified_owned_backend_at_path_with_expected(&path, expected)
+ .await
+ .map(|probe| format!("{probe:?}"));
+ let one_shot_file = path.exists();
+ write();
+ let split = verified_owned_backend_metadata_at_path_with_expected(&path, expected);
+ let split_file = path.exists();
+ let split = match split {
+ Ok(half) => half.finish().await.map(|probe| format!("{probe:?}")),
+ Err(error) => Err(error),
+ };
+ assert_eq!(split, one_shot);
+ assert_eq!(split_file, one_shot_file);
+ }
+ live_server.abort();
+ let _ = std::fs::remove_file(&path);
+ let _ = std::fs::remove_dir(path.parent().unwrap());
+ }
+
#[tokio::test]
async fn a_port_that_says_nothing_is_not_reported_as_an_owner_mismatch() {
// A closed or stalled port is not evidence of a takeover; only a parsed answer is.
diff --git a/studio/src-tauri/src/preflight.rs b/studio/src-tauri/src/preflight.rs
index 7887997dba4..3ce0822ea8a 100644
--- a/studio/src-tauri/src/preflight.rs
+++ b/studio/src-tauri/src/preflight.rs
@@ -274,10 +274,19 @@ pub async fn desktop_preflight_result() -> DesktopPreflightResult {
pub async fn desktop_preflight_result_with_state(
state: &crate::process::BackendState,
) -> Result<(DesktopPreflightResult, Option<(u64, bool)>), String> {
+ let state_owns_backend = matches!(crate::process::owned_backend_snapshot(state), Ok(Some(_)));
let (managed, backend, owned) = tokio::join!(
probe_managed_install(),
probe_existing_backends(&[]),
- crate::desktop_backend_owner::probe_verified_owned_backend()
+ async {
+ if state_owns_backend {
+ crate::desktop_backend_owner::verified_owned_backend_metadata()
+ } else {
+ crate::desktop_backend_owner::probe_verified_owned_backend()
+ .await
+ .map(crate::desktop_backend_owner::VerifiedOwnedBackendMetadata::Decided)
+ }
+ }
);
if let Some(snapshot) = crate::process::owned_backend_snapshot(state)? {
@@ -353,6 +362,10 @@ pub async fn desktop_preflight_result_with_state(
}
}
+ let owned = match owned {
+ Ok(metadata) => metadata.finish().await,
+ Err(error) => Err(error),
+ };
let owned = match owned {
Ok(owned) => owned,
Err(error) => {