aft/bash_background/
buffer.rs

1use std::fs::{self, File};
2use std::io::{self, Read, Seek, SeekFrom};
3use std::path::{Path, PathBuf};
4
5pub const DISK_LIMIT_BYTES: u64 = 100 * 1024 * 1024;
6
7#[derive(Debug, Clone, Copy)]
8pub enum StreamKind {
9    Stdout,
10    Stderr,
11}
12
13#[derive(Debug, Clone)]
14pub struct BgBuffer {
15    stdout_path: PathBuf,
16    stderr_path: PathBuf,
17    rotated: bool,
18}
19
20impl BgBuffer {
21    pub fn new(stdout_path: PathBuf, stderr_path: PathBuf) -> Self {
22        Self {
23            stdout_path,
24            stderr_path,
25            rotated: false,
26        }
27    }
28
29    pub fn stdout_path(&self) -> &Path {
30        &self.stdout_path
31    }
32
33    pub fn stderr_path(&self) -> &Path {
34        &self.stderr_path
35    }
36
37    pub fn read_tail(&self, max_bytes: usize) -> (String, bool) {
38        let stdout = read_file_tail(&self.stdout_path, max_bytes);
39        let stderr = read_file_tail(&self.stderr_path, max_bytes);
40        match (stdout, stderr) {
41            (Ok((stdout, stdout_truncated)), Ok((stderr, stderr_truncated))) => {
42                let mut output = Vec::with_capacity(stdout.len().saturating_add(stderr.len()));
43                output.extend_from_slice(&stdout);
44                output.extend_from_slice(&stderr);
45                if output.len() > max_bytes {
46                    let keep_from = output.len().saturating_sub(max_bytes);
47                    output.drain(..keep_from);
48                }
49                (
50                    String::from_utf8_lossy(&output).into_owned(),
51                    self.rotated
52                        || stdout_truncated
53                        || stderr_truncated
54                        || output.len() >= max_bytes && (stdout.len() + stderr.len()) > max_bytes,
55                )
56            }
57            (Ok((stdout, stdout_truncated)), Err(_)) => (
58                String::from_utf8_lossy(&stdout).into_owned(),
59                self.rotated || stdout_truncated,
60            ),
61            (Err(_), Ok((stderr, stderr_truncated))) => (
62                String::from_utf8_lossy(&stderr).into_owned(),
63                self.rotated || stderr_truncated,
64            ),
65            (Err(_), Err(_)) => (String::new(), self.rotated),
66        }
67    }
68
69    pub fn read_stream_tail(&self, stream: StreamKind, max_bytes: usize) -> (String, bool) {
70        let path = match stream {
71            StreamKind::Stdout => &self.stdout_path,
72            StreamKind::Stderr => &self.stderr_path,
73        };
74        match read_file_tail(path, max_bytes) {
75            Ok((bytes, truncated)) => (
76                String::from_utf8_lossy(&bytes).into_owned(),
77                self.rotated || truncated,
78            ),
79            Err(_) => (String::new(), self.rotated),
80        }
81    }
82
83    /// Path to the stdout spill file (alias of `stdout_path` for backward compat).
84    pub fn output_path(&self) -> Option<PathBuf> {
85        Some(self.stdout_path.clone())
86    }
87
88    // stderr_path() already exists above returning &Path — no duplicate needed.
89
90    pub fn enforce_terminal_cap(&mut self) {
91        if truncate_front(&self.stdout_path, DISK_LIMIT_BYTES).unwrap_or(false) {
92            self.rotated = true;
93        }
94        if truncate_front(&self.stderr_path, DISK_LIMIT_BYTES).unwrap_or(false) {
95            self.rotated = true;
96        }
97    }
98
99    pub fn cleanup(&self) {
100        let _ = fs::remove_file(&self.stdout_path);
101        let _ = fs::remove_file(&self.stderr_path);
102    }
103}
104
105fn read_file_tail(path: &Path, max_bytes: usize) -> io::Result<(Vec<u8>, bool)> {
106    if max_bytes == 0 {
107        return Ok((
108            Vec::new(),
109            path.metadata()
110                .map(|metadata| metadata.len() > 0)
111                .unwrap_or(false),
112        ));
113    }
114
115    let mut file = File::open(path)?;
116    let len = file.metadata()?.len();
117    let read_len = len.min(max_bytes as u64);
118    if read_len > 0 {
119        file.seek(SeekFrom::End(-(read_len as i64)))?;
120    }
121    let mut bytes = Vec::with_capacity(read_len as usize);
122    file.read_to_end(&mut bytes)?;
123    Ok((bytes, len > max_bytes as u64))
124}
125
126fn truncate_front(path: &Path, retain_bytes: u64) -> io::Result<bool> {
127    let len = match path.metadata() {
128        Ok(metadata) => metadata.len(),
129        Err(error) if error.kind() == io::ErrorKind::NotFound => return Ok(false),
130        Err(error) => return Err(error),
131    };
132    if len <= retain_bytes {
133        return Ok(false);
134    }
135
136    let mut file = File::open(path)?;
137    file.seek(SeekFrom::End(-(retain_bytes as i64)))?;
138    let mut tail = Vec::with_capacity(retain_bytes as usize);
139    file.read_to_end(&mut tail)?;
140    let tmp = path.with_extension(format!(
141        "{}.tmp",
142        path.extension()
143            .and_then(|extension| extension.to_str())
144            .unwrap_or("out")
145    ));
146    fs::write(&tmp, tail)?;
147    fs::rename(&tmp, path)?;
148    Ok(true)
149}
aft/bash_background/buffer.rs

aft/bash_background/
buffer.rs
