Skip to content

Open-source AI coworkers that each get a computer of their own: a browser, files and tools, with every action decided before it happens and recorded after. Bring any AG-UI agent.

fix(desktop): a download fails only when it stalls, not when it takes longer than 30 seconds (#830)

Dustybb2fb434c547
diff --git a/desktop/src-tauri/src/deployment.rs b/desktop/src-tauri/src/deployment.rs
index 563d8474..f4c80148 100644
--- a/desktop/src-tauri/src/deployment.rs
+++ b/desktop/src-tauri/src/deployment.rs
@@ -332,8 +332,25 @@ fn fetch_images(root: &Path, version: &str) -> Result<(), String> {
/// Shared with `install.rs`, which fetches the engine's installers through it and then checks their
/// digests. One client, one user agent, one set of TLS defaults.
pub fn get(url: &str) -> Result<Vec<u8>, String> {
- let response = reqwest::blocking::Client::builder()
+ get_waiting(url, IDLE_TIMEOUT)
+}
+
+/// How long a download may go without receiving anything before it is given up.
+const IDLE_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(30);
+
+/**
+`get`, giving up only when nothing arrives for `idle`.
+
+READ AS A STREAM, NOT WITH `bytes()`. The blocking client's timeout (30 s by default) bounds each
+read on a stream, but `bytes()` waits for the whole body within it, and reports running out of time
+as "error decoding response body". So any download that took longer than 30 seconds failed, however
+steadily it was arriving: Bun's 30 MB on a connection under about 1 MB/s, every time.
+*/
+fn get_waiting(url: &str, idle: std::time::Duration) -> Result<Vec<u8>, String> {
+ use std::io::Read;
+ let mut response = reqwest::blocking::Client::builder()
.user_agent("openbot-desktop")
+ .timeout(idle)
.build()
.map_err(|error| format!("could not prepare the download: {error}"))?
.get(url)
@@ -342,16 +359,64 @@ pub fn get(url: &str) -> Result<Vec<u8>, String> {
if !response.status().is_success() {
return Err(format!("{url} answered {}", response.status()));
}
+ let mut body = Vec::new();
response
- .bytes()
- .map(|body| body.to_vec())
- .map_err(|error| format!("the download did not finish: {error}"))
+ .read_to_end(&mut body)
+ .map_err(|error| format!("the download did not finish: {error}"))?;
+ Ok(body)
}
#[cfg(test)]
mod tests {
use super::*;
+ /// A server that sends `chunks` pieces of `body`, `gap` apart, then closes.
+ fn dripping(chunks: usize, gap: std::time::Duration) -> (String, std::thread::JoinHandle<()>) {
+ use std::io::{Read, Write};
+ let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
+ let url = format!("http://{}/file", listener.local_addr().unwrap());
+ let served = std::thread::spawn(move || {
+ let (mut stream, _) = listener.accept().unwrap();
+ let mut request = [0u8; 1024];
+ let _ = stream.read(&mut request);
+ let length = chunks * 4;
+ stream
+ .write_all(
+ format!(
+ "HTTP/1.1 200 OK\r\ncontent-length: {length}\r\nconnection: close\r\n\r\n"
+ )
+ .as_bytes(),
+ )
+ .unwrap();
+ for _ in 0..chunks {
+ std::thread::sleep(gap);
+ if stream.write_all(b"data").is_err() {
+ return;
+ }
+ let _ = stream.flush();
+ }
+ });
+ (url, served)
+ }
+
+ #[test]
+ fn a_download_that_keeps_arriving_finishes_however_long_it_takes() {
+ // Six pieces 300 ms apart take 1.8 s in all, longer than the 1 s allowed between pieces.
+ // `bytes()` gave up here with "error decoding response body"; a stream does not.
+ let (url, served) = dripping(6, std::time::Duration::from_millis(300));
+ let body = get_waiting(&url, std::time::Duration::from_secs(1)).unwrap();
+ assert_eq!(body, b"data".repeat(6));
+ served.join().unwrap();
+ }
+
+ #[test]
+ fn a_download_that_stalls_is_given_up() {
+ let (url, served) = dripping(2, std::time::Duration::from_millis(1500));
+ let error = get_waiting(&url, std::time::Duration::from_millis(500)).unwrap_err();
+ assert!(error.starts_with("the download did not finish"), "{error}");
+ served.join().unwrap();
+ }
+
fn manifest(names: &[&str]) -> Images {
Images {
version: "v0.0.7".into(),