use super::super::Capture;
use super::super::stream::{Offsets, Piece, Post, Standing};
pub(super) const LISTEN_SECONDS: i64 = 30;
pub(super) const UNREAD_LIMIT: usize = crate::wire::frame::MAX_FRAME / 16;
#[derive(Debug, Clone, PartialEq, Default)]
struct Held {
base: u64,
text: String,
dropped: usize,
}
impl Held {
fn push(&mut self, piece: &str) {
let mut keep = piece
.len()
.min(UNREAD_LIMIT.saturating_sub(self.text.len()));
while !piece.is_char_boundary(keep) {
keep -= 1;
}
self.text.push_str(piece.get(..keep).unwrap_or_default());
self.dropped += piece.len() - keep;
}
fn from(&mut self, at: u64) -> Option<String> {
let skip = usize::try_from(at.checked_sub(self.base)?).ok()?;
self.text = self.text.get(skip..)?.to_owned();
self.base = at;
Some(self.text.clone())
}
fn arrived(&self) -> u64 {
self.base + self.text.len() as u64
}
fn elided(&self, name: &str) -> String {
if self.dropped == 0 {
return String::new();
}
format!(
"\nyog: {name} exceeded this server's {UNREAD_LIMIT}-byte capture limit; \
{} further bytes were dropped\n",
self.dropped
)
}
}
#[derive(Debug, Clone, PartialEq, Default)]
pub(super) struct Run {
out: Held,
err: Held,
posted: Option<i64>,
exit: Option<i32>,
}
impl Run {
pub(super) fn over(&self) -> bool {
self.exit.is_some()
}
pub(super) fn acknowledged(&self) -> bool {
self.posted.is_some()
}
pub(super) fn silent(&self, now: i64) -> bool {
!self.over() && self.posted.is_some_and(|last| now - last > LISTEN_SECONDS)
}
pub(super) fn arrived(&self) -> Offsets {
Offsets {
stdout: self.out.arrived(),
stderr: self.err.arrived(),
}
}
pub(super) fn absorb(&mut self, now: i64, mark: Option<String>, post: &Post) {
let (stdout, stderr, exit) = match post {
Post::Partial(piece) => (&piece.stdout, &piece.stderr, None),
Post::Capture(capture) => (&capture.stdout, &capture.stderr, Some(capture.exit_code)),
};
if let Some(mark) = mark.filter(|_| self.posted.is_none()) {
self.err.push(&mark);
if exit.is_none() || !stderr.is_empty() {
self.err.push("\n");
}
}
self.out.push(stdout);
self.err.push(stderr);
self.posted = Some(now);
if let Some(code) = exit {
self.end(code);
}
}
pub(super) fn doubt(&mut self, sentence: &str) {
if !self.err.text.is_empty() {
self.err.text.push('\n');
}
self.err.text.push_str(sentence);
self.end(1);
}
fn end(&mut self, code: i32) {
let notes = format!("{}{}", self.out.elided("stdout"), self.err.elided("stderr"));
self.err.text.push_str(¬es);
self.exit = Some(code);
}
pub(super) fn receipt(&self) -> Standing {
match self.exit {
Some(_) => self.whole(),
None => Standing {
partial: Some(Piece::default()),
capture: None,
},
}
}
pub(super) fn answer(&mut self, since: Option<Offsets>) -> Option<Standing> {
let Some(at) = since else {
return Some(self.whole());
};
let piece = Piece {
stdout: self.out.from(at.stdout)?,
stderr: self.err.from(at.stderr)?,
};
Some(match self.exit {
Some(exit_code) => Standing {
partial: None,
capture: Some(Capture {
stdout: piece.stdout,
stderr: piece.stderr,
exit_code,
}),
},
None => Standing {
partial: self.posted.map(|_| piece),
capture: None,
},
})
}
fn whole(&self) -> Standing {
Standing {
partial: None,
capture: self.exit.map(|exit_code| Capture {
stdout: self.out.text.clone(),
stderr: self.err.text.clone(),
exit_code,
}),
}
}
}