| use super::BashJob; |
| use std::fs::File; |
| use std::io::Read; |
|
|
| const HEAD_BYTES: usize = 8 * 1024; |
| const HEAD_LINES: i32 = 100; |
| const TAIL_BYTES: usize = 32 * 1024; |
| const PROGRESS_TAIL_LINES: i32 = 4; |
| const FINAL_TAIL_LINES: i32 = 20; |
|
|
| pub(super) fn observation(job: &mut BashJob) -> Vec<u8> { |
| job.poll(); |
| let first = !job.observed_once; |
| let (bytes, display_lines, last_nl) = file_stats(&job.path); |
| let elapsed = job.start.elapsed().as_secs_f64(); |
| let mut out = if job.running { |
| format!( |
| "bash job={} pid={} status=running elapsed_sec={elapsed:.1} timeout_sec={:.0}\n", |
| job.id, job.pid, job.timeout_sec |
| ) |
| } else { |
| format!( |
| "bash job={} pid={} status=done elapsed_sec={elapsed:.1} timed_out={}\nexit_status={}\n", |
| job.id, |
| job.pid, |
| i32::from(job.timed_out), |
| job.exit_status |
| ) |
| } |
| .into_bytes(); |
|
|
| if bytes == 0 { |
| out.extend_from_slice(b"<output>\n</output>\n"); |
| } else if first { |
| let (head, shown, byte_limited) = read_head(&job.path); |
| let truncated = byte_limited || display_lines > shown; |
| if !job.running && !truncated { |
| out.extend_from_slice(b"<output>\n"); |
| out.extend_from_slice(&head); |
| if !head.is_empty() && !head.ends_with(b"\n") { |
| out.push(b'\n'); |
| } |
| out.extend_from_slice(b"</output>\n"); |
| } else { |
| append_path_head(&mut out, &job.path, bytes, display_lines, &head); |
| } |
| } else { |
| let tail_lines = if job.running { |
| PROGRESS_TAIL_LINES |
| } else { |
| FINAL_TAIL_LINES |
| }; |
| let tail = read_tail(&job.path, tail_lines); |
| let path = job.path.display(); |
| out.extend_from_slice( |
| format!("output_path={path} ({bytes} bytes, {display_lines} lines)\n").as_bytes(), |
| ); |
| out.extend_from_slice(format!("<tail -{tail_lines} {path}>\n").as_bytes()); |
| out.extend_from_slice(&tail); |
| if !tail.is_empty() && !tail.ends_with(b"\n") { |
| out.push(b'\n'); |
| } |
| out.extend_from_slice(b"</tail>\n"); |
| } |
| if job.running { |
| out.extend_from_slice( |
| format!( |
| "\nUse bash_status job={} to get info before refresh time; use bash_stop job={} to stop execution\n", |
| job.id, job.id |
| ) |
| .as_bytes(), |
| ); |
| } |
| job.observed_once = true; |
| let _ = (last_nl,); |
| out |
| } |
|
|
| fn file_stats(path: &std::path::Path) -> (usize, i32, bool) { |
| let Ok(data) = std::fs::read(path) else { |
| return (0, 0, true); |
| }; |
| if data.is_empty() { |
| return (0, 0, true); |
| } |
| let newlines = data.iter().filter(|byte| **byte == b'\n').count() as i32; |
| let last_nl = data.last() == Some(&b'\n'); |
| (data.len(), newlines + i32::from(!last_nl), last_nl) |
| } |
|
|
| fn read_head(path: &std::path::Path) -> (Vec<u8>, i32, bool) { |
| let Ok(mut file) = File::open(path) else { |
| return (b"<failed to reopen output file>\n".to_vec(), 0, false); |
| }; |
| let mut out = Vec::new(); |
| let mut buf = [0u8; 1]; |
| let mut lines = 0i32; |
| while lines < HEAD_LINES && out.len() < HEAD_BYTES { |
| match file.read(&mut buf) { |
| Ok(0) => break, |
| Ok(_) => { |
| out.push(buf[0]); |
| if buf[0] == b'\n' { |
| lines += 1; |
| } |
| } |
| Err(_) => break, |
| } |
| } |
| let byte_limited = out.len() >= HEAD_BYTES; |
| let shown = lines + i32::from(!out.is_empty() && !out.ends_with(b"\n")); |
| (out, shown, byte_limited) |
| } |
|
|
| fn read_tail(path: &std::path::Path, max_lines: i32) -> Vec<u8> { |
| let Ok(data) = std::fs::read(path) else { |
| return b"<failed to reopen output file>\n".to_vec(); |
| }; |
| if data.is_empty() { |
| return Vec::new(); |
| } |
| let start = data.len().saturating_sub(TAIL_BYTES); |
| let window = &data[start..]; |
| let mut newlines = 0; |
| let mut cut = 0; |
| for (index, byte) in window.iter().enumerate().rev() { |
| if *byte == b'\n' { |
| newlines += 1; |
| if newlines > max_lines { |
| cut = index + 1; |
| break; |
| } |
| } |
| } |
| window[cut..].to_vec() |
| } |
|
|
| fn append_path_head( |
| out: &mut Vec<u8>, |
| path: &std::path::Path, |
| bytes: usize, |
| lines: i32, |
| head: &[u8], |
| ) { |
| let shown = path.display(); |
| out.extend_from_slice( |
| format!("output_path={shown} ({bytes} bytes, {lines} lines)\n").as_bytes(), |
| ); |
| out.extend_from_slice(format!("<head -{HEAD_LINES} {shown}>\n").as_bytes()); |
| out.extend_from_slice(head); |
| if !head.is_empty() && !head.ends_with(b"\n") { |
| out.push(b'\n'); |
| } |
| out.extend_from_slice(b"</head>\n"); |
| } |
|
|
