sophie/copper
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

lets just keep trying to get ai to fix this command

Browse source
This commit is contained in:
Soph :3 2025-09-09 12:05:49 +03:00
parent 44d0fd22e1
commit b64b0c1cf0
1 changed files with 67 additions and 46 deletions
Download patch file Download diff file Expand all files Collapse all files

111
src/commands/system/deploy.rs
View file

@ -96,61 +96,81 @@ impl Command for DeployCommand {
} }
client.message("Running `cargo run --release`...").await; client.message("Running `cargo run --release`...").await;
let mut cargo_child = match SysCommand::new("cargo")
.arg("run")
.arg("--release")
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
{
Ok(child) => child,
Err(e) => {
client
.message(format!("Failed to start cargo run: {}", e))
.await;
return;
}
};
let cargo_stdout = cargo_child.stdout.take().unwrap();
let cargo_stderr = cargo_child.stderr.take().unwrap();
let client_clone = client.clone(); let client_clone = client.clone();
let client_clone2 = client.clone();
let found_connected = Arc::new(Mutex::new(false)); let found_connected = Arc::new(Mutex::new(false));
let found_connected_cargo = found_connected.clone(); let found_connected_cargo = found_connected.clone();
task::spawn_blocking(async move || { // Spawn cargo run --release in a separate blocking task
let reader = BufReader::new(cargo_stdout); let running_arc = self.running.clone();
for line in reader.lines() { let cargo_task = task::spawn_blocking(move || {
match line { let mut cargo_child = match SysCommand::new("cargo")
Ok(l) => { .arg("run")
let msg = format!("cargo: {}", l); .arg("--release")
let _ = client_clone.message(msg.clone()).await; .stdout(Stdio::piped())
if l.contains("[CONNECTED]") { .stderr(Stdio::piped())
let mut found = found_connected_cargo.blocking_lock(); .spawn()
*found = true; {
break; Ok(child) => child,
Err(e) => {
let _ = client_clone.message(format!("Failed to start cargo run: {}", e));
return;
}
};
// Save the child handle for later killing
{
let mut running = running_arc.blocking_lock();
*running = Some(cargo_child.try_clone().unwrap());
}
let cargo_stdout = cargo_child.stdout.take().unwrap();
let cargo_stderr = cargo_child.stderr.take().unwrap();
// stdout handler
let client_clone_stdout = client_clone.clone();
let found_connected_cargo_stdout = found_connected_cargo.clone();
let stdout_handle = std::thread::spawn(move || {
let reader = BufReader::new(cargo_stdout);
for line in reader.lines() {
match line {
Ok(l) => {
let msg = format!("cargo: {}", l);
let _ = client_clone_stdout.message(msg);
if l.contains("[CONNECTED]") {
let mut found = found_connected_cargo_stdout.blocking_lock();
*found = true;
break;
}
} }
Err(_) => break,
} }
Err(_) => break,
} }
} });
});
// stderr handler
let client_clone2 = client.clone(); let client_clone_stderr = client_clone2.clone();
task::spawn_blocking(async move || { let stderr_handle = std::thread::spawn(move || {
let reader = BufReader::new(cargo_stderr); let reader = BufReader::new(cargo_stderr);
for line in reader.lines() { for line in reader.lines() {
match line { match line {
Ok(l) => { Ok(l) => {
let msg = format!("cargo stderr: {}", l); let msg = format!("cargo stderr: {}", l);
let _ = client_clone2.message(msg.clone()).await; let _ = client_clone_stderr.message(msg);
} }
Err(_) => break, Err(_) => break,
} }
} }
});
let _ = stdout_handle.join();
let _ = stderr_handle.join();
let _ = cargo_child.wait();
}); });
// Wait for [CONNECTED] from cargo run --release
loop { loop {
{ {
let found = found_connected.lock().await; let found = found_connected.lock().await;
@ -260,6 +280,7 @@ impl Command for DeployCommand {
} }
} }
// Step 5: Wait for [CONNECTED] from systemctl copper
client client
.message("Waiting for [CONNECTED] from systemctl copper...") .message("Waiting for [CONNECTED] from systemctl copper...")
.await; .await;