use std::fmt::Write as _;
use serde::{Deserialize, Serialize};
use super::{LineKind, LineRead, StoredLine, StyledLine, classify, plain, prefix, time_of};
use crate::api::{Job, RecordNote, RecordState, Step, Tone};
pub(crate) const DEPTH_MAX: usize = 8;
pub(crate) const GROUP_MAX: u64 = 1000;
pub(crate) const MARK_MAX: u64 = 1000;
const SECTION_MAX: u64 = 200;
const TITLE_MAX: usize = 200;
pub(crate) const TITLE_SOURCE_MAX: usize = 4 * TITLE_MAX;
const TIME_PREFIX: u64 = 64;
const EXIT_PREFIX: u64 = 256;
const EXCERPT_LINE_BYTES: u64 = 4 << 10;
const EXIT_SCAN: u64 = 200;
const EXCERPT: u64 = 10;
const SECTIONS: [&str; 4] = [
"Post job cleanup.",
"Cleaning up orphan processes",
"A job started hook has been configured by the self-hosted runner administrator",
"A job completed hook has been configured by the self-hosted runner administrator",
];
const HEADER: &str = "Run ";
const HEADERLESS: [&str; 4] = [
"Initialize containers",
"Stop containers",
"Wait for all background steps",
"Create custom image",
];
const HEADERLESS_GROUPS: [&str; 2] = ["Pull down action image", "Build container for action use"];
const EXIT: &str = "Process completed with exit code ";
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct SavedOutline {
pub from: u64,
pub errors: u64,
pub warnings: u64,
pub groups: u64,
pub marks: u64,
pub sections: u64,
pub dropped: u64,
pub hidden: u64,
pub open: Vec<u64>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum OutlineChange {
Opened {
start: u64,
depth: u32,
title: String,
},
Closed {
start: u64,
end: u64,
},
Marked(LogMark),
Section {
line: u64,
},
}
#[derive(Debug)]
pub struct Outliner {
saved: SavedOutline,
}
impl Outliner {
pub fn new(from: u64) -> Outliner {
Outliner {
saved: SavedOutline {
from,
..SavedOutline::default()
},
}
}
pub fn resume(saved: SavedOutline) -> Outliner {
Outliner { saved }
}
pub fn saved(&self) -> &SavedOutline {
&self.saved
}
pub fn line(&mut self, line: u64, text: &str) -> Option<OutlineChange> {
let saved = &mut self.saved;
let (kind, rest) = classify(text);
match kind {
LineKind::Group => {
if saved.hidden > 0 || saved.open.len() >= DEPTH_MAX || saved.groups >= GROUP_MAX {
saved.hidden += 1;
saved.dropped += 1;
return None;
}
let depth = u32::try_from(saved.open.len()).unwrap_or(u32::MAX);
saved.open.push(line);
saved.groups += 1;
Some(OutlineChange::Opened {
start: line,
depth,
title: title(rest),
})
}
LineKind::EndGroup => {
if saved.hidden > 0 {
saved.hidden -= 1;
return None;
}
let start = saved.open.pop()?;
Some(OutlineChange::Closed { start, end: line })
}
LineKind::Error | LineKind::Warning => {
let kind = if kind == LineKind::Error {
saved.errors += 1;
MarkKind::Error
} else {
saved.warnings += 1;
MarkKind::Warning
};
(saved.marks < MARK_MAX).then(|| {
saved.marks += 1;
OutlineChange::Marked(LogMark { line, kind })
})
}
LineKind::Output if SECTIONS.contains(&rest) && saved.sections < SECTION_MAX => {
saved.sections += 1;
Some(OutlineChange::Section { line })
}
_ => None,
}
}
}
pub(crate) fn title(text: &str) -> String {
let title = plain(prefix(text, TITLE_SOURCE_MAX));
prefix(&title, TITLE_MAX).to_owned()
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub struct LineRange {
pub from: u64,
pub to: u64,
}
impl LineRange {
pub fn is_empty(&self) -> bool {
self.to <= self.from
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct LogGroup {
pub start: u64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub end: Option<u64>,
pub depth: u32,
pub title: String,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum MarkKind {
Error,
Warning,
#[serde(other)]
Unknown,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub struct LogMark {
pub line: u64,
pub kind: MarkKind,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "kebab-case")]
pub enum StepLog {
Lines(LineRange),
Empty,
Unattributed,
#[serde(other)]
Unknown,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub struct StepLines {
pub number: u32,
pub lines: StepLog,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum LogEvidence {
Complete,
Running,
Partial,
Truncated,
Expired,
Missing,
NotOutlined,
#[serde(other)]
Unknown,
}
impl LogEvidence {
pub fn words(self) -> Option<&'static str> {
match self {
LogEvidence::Complete => None,
LogEvidence::Running => Some("still running"),
LogEvidence::Partial => Some("outlined from a later line"),
LogEvidence::Truncated => Some("cut at history.log_max"),
LogEvidence::Expired => Some("deleted after history.logs"),
LogEvidence::Missing => Some("no log was captured"),
LogEvidence::NotOutlined => Some("kept without an outline"),
LogEvidence::Unknown => Some("read by a newer runnerd"),
}
}
pub fn tone(self) -> Tone {
match self {
LogEvidence::Truncated => Tone::Warn,
LogEvidence::Complete => Tone::Neutral,
_ => Tone::Quiet,
}
}
pub fn grows(self) -> bool {
self == LogEvidence::Running
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct FailureSummary {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub step: Option<u32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub exit_code: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub excerpt: Option<Vec<StyledLine>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub shell: Option<String>,
}
impl FailureSummary {
pub fn headline(&self, steps: &[Step]) -> String {
let Some(number) = self.step else {
return "No step reports the failure".to_owned();
};
let mut text = match steps.iter().find(|step| step.number == number) {
Some(step) => format!("Step {number}, {}, failed", title(&step.name)),
None => format!("Step {number} failed"),
};
if let Some(code) = self.exit_code {
write!(text, " with exit code {code}").ok();
}
text
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct LogOutline {
pub job: u64,
pub evidence: LogEvidence,
pub lines: u64,
pub from: u64,
pub groups: Vec<LogGroup>,
pub steps: Vec<StepLines>,
pub unattributed: Vec<LineRange>,
pub errors: u64,
pub warnings: u64,
pub marks: Vec<LogMark>,
pub capped: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub failure: Option<FailureSummary>,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct StoredLog {
pub lines: u64,
pub truncated: bool,
pub kept: bool,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct OutlineParts {
pub saved: Option<SavedOutline>,
pub groups: Vec<LogGroup>,
pub marks: Vec<LogMark>,
pub sections: Vec<u64>,
}
#[derive(Debug)]
struct Segment {
range: LineRange,
first: Option<u64>,
last: Option<u64>,
}
impl LogOutline {
pub fn count_words(lines: usize) -> String {
if lines == 1 {
"1 line".to_owned()
} else {
format!("{lines} lines")
}
}
pub fn tail_words(first: u64, shown: usize) -> Option<String> {
(first > 0)
.then(|| format!("the last {shown} lines; the full log has the {first} before them"))
}
pub fn assemble(
job: &Job,
stored: StoredLog,
parts: OutlineParts,
read: &mut dyn FnMut(LineRead) -> Vec<StoredLine>,
) -> LogOutline {
let evidence = evidence(job, stored, parts.saved.as_ref());
let outlined = stored.kept && parts.saved.is_some();
let saved = parts.saved.unwrap_or_default();
let from = if outlined { saved.from } else { stored.lines };
let segments = if outlined {
segments(from, stored.lines, &parts.groups, &parts.sections, read)
} else {
Vec::new()
};
let ends = Ends {
leading: from > 0,
trailing: stored.truncated || !job.summary.state.is_final(),
};
let ranges = block_starts(from, stored.lines, &parts.groups, &parts.sections, &saved)
.and_then(|starts| by_blocks(&job.steps, &segments, &starts, ends))
.unwrap_or_else(|| attribute(&job.steps, &segments));
let steps: Vec<StepLines> = job
.steps
.iter()
.zip(&ranges)
.map(|(step, range)| StepLines {
number: step.number,
lines: match range {
Some(range) => StepLog::Lines(*range),
None if step.started_at.is_none()
|| step.conclusion.as_deref() == Some("skipped") =>
{
StepLog::Empty
}
None => StepLog::Unattributed,
},
})
.collect();
let readable = !matches!(evidence, LogEvidence::Expired | LogEvidence::Missing);
let unattributed = if readable {
gaps(stored.lines, ranges.iter().flatten())
} else {
Vec::new()
};
let failure = job.summary.is_failure().then(|| failure(job, &steps, read));
LogOutline {
job: job.summary.id,
evidence,
lines: stored.lines,
from,
capped: saved.dropped > 0 || saved.marks < saved.errors + saved.warnings,
errors: saved.errors,
warnings: saved.warnings,
groups: parts.groups,
marks: parts.marks,
steps,
unattributed,
failure,
}
}
pub fn of(job: &Job, lines: &[String]) -> LogOutline {
let mut outliner = Outliner::new(0);
let mut parts = OutlineParts::default();
for (number, text) in (0..).zip(lines) {
match outliner.line(number, text) {
Some(OutlineChange::Opened {
start,
depth,
title,
}) => {
parts.groups.push(LogGroup {
start,
end: None,
depth,
title,
});
}
Some(OutlineChange::Closed { start, end }) => {
if let Some(group) = parts.groups.iter_mut().find(|group| group.start == start)
{
group.end = Some(end);
}
}
Some(OutlineChange::Marked(mark)) => parts.marks.push(mark),
Some(OutlineChange::Section { line }) => parts.sections.push(line),
None => {}
}
}
parts.saved = (!lines.is_empty()).then(|| outliner.saved().clone());
let stored = StoredLog {
lines: lines.len() as u64,
truncated: job.summary.log.truncated,
kept: true,
};
LogOutline::assemble(job, stored, parts, &mut |read| read.of(lines))
}
pub fn step_lines(&self, number: u32) -> Option<LineRange> {
self.steps
.iter()
.find(|step| step.number == number)
.and_then(|step| match step.lines {
StepLog::Lines(range) => Some(range),
_ => None,
})
}
}
fn evidence(job: &Job, stored: StoredLog, saved: Option<&SavedOutline>) -> LogEvidence {
let fin = job.summary.state.is_final();
if stored.lines > 0 && !stored.kept {
return LogEvidence::Expired;
}
if stored.truncated {
return LogEvidence::Truncated;
}
if stored.lines == 0 {
return if fin {
LogEvidence::Missing
} else {
LogEvidence::Running
};
}
let Some(saved) = saved else {
return LogEvidence::NotOutlined;
};
if saved.from > 0 {
LogEvidence::Partial
} else if !fin {
LogEvidence::Running
} else {
LogEvidence::Complete
}
}
fn read_range(
read: &mut dyn FnMut(LineRead) -> Vec<StoredLine>,
range: LineRange,
prefix: u64,
) -> Vec<StoredLine> {
let mut lines = read(LineRead {
from: range.from,
limit: range.to.saturating_sub(range.from),
prefix,
bytes: u64::MAX,
});
lines.retain(|line| line.line < range.to);
lines
}
fn segments(
from: u64,
lines: u64,
groups: &[LogGroup],
sections: &[u64],
read: &mut dyn FnMut(LineRead) -> Vec<StoredLine>,
) -> Vec<Segment> {
let mut starts: Vec<u64> = std::iter::once(from)
.chain(groups.iter().map(|group| group.start))
.chain(sections.iter().copied())
.filter(|start| (from..lines).contains(start))
.collect();
starts.sort_unstable();
starts.dedup();
let mut time = |line: u64| {
read_range(
read,
LineRange {
from: line,
to: line + 1,
},
TIME_PREFIX,
)
.first()
.and_then(|line| time_of(&line.text))
};
starts
.iter()
.enumerate()
.map(|(index, &start)| {
let end = starts.get(index + 1).copied().unwrap_or(lines);
Segment {
range: LineRange {
from: start,
to: end,
},
first: time(start),
last: time(end - 1),
}
})
.collect()
}
fn holds(step: &Step, at: u64) -> bool {
step.started_at
.is_some_and(|started| at >= started && step.completed_at.is_none_or(|end| at <= end))
}
fn attribute(steps: &[Step], segments: &[Segment]) -> Vec<Option<LineRange>> {
let mut ranges: Vec<Option<LineRange>> = vec![None; steps.len()];
let mut earliest = 0;
for segment in segments {
let times: Vec<u64> = [segment.first, segment.last]
.into_iter()
.flatten()
.collect();
if times.is_empty() {
continue;
}
let mut candidates = (earliest..steps.len())
.filter(|&index| times.iter().all(|&at| holds(&steps[index], at)));
let chosen = match (candidates.next(), candidates.next()) {
(Some(only), None) => Some(only),
_ => None,
};
if let Some(index) = chosen {
earliest = index;
let range = ranges[index].get_or_insert(segment.range);
range.to = segment.range.to;
}
}
ranges
}
#[derive(Debug, Clone, Copy)]
struct Ends {
leading: bool,
trailing: bool,
}
fn block_starts(
from: u64,
lines: u64,
groups: &[LogGroup],
sections: &[u64],
saved: &SavedOutline,
) -> Option<Vec<u64>> {
let headerless = groups.iter().any(|group| {
group.depth == 0
&& HEADERLESS_GROUPS
.iter()
.any(|title| group.title.starts_with(title))
});
if saved.dropped > 0 || saved.sections >= SECTION_MAX || headerless {
return None;
}
let headers = groups
.iter()
.filter(|group| group.depth == 0 && group.title.starts_with(HEADER))
.map(|group| group.start)
.filter(|&start| start == 0 || !sections.contains(&(start - 1)));
let mut starts: Vec<u64> = std::iter::once(from)
.chain(sections.iter().copied())
.chain(headers)
.filter(|start| (from..lines).contains(start))
.collect();
starts.sort_unstable();
starts.dedup();
Some(starts)
}
#[derive(Debug)]
struct Block {
range: LineRange,
times: Option<(u64, u64)>,
}
fn by_blocks(
steps: &[Step],
segments: &[Segment],
starts: &[u64],
ends: Ends,
) -> Option<Vec<Option<LineRange>>> {
if steps
.iter()
.any(|step| HEADERLESS.contains(&step.name.as_str()))
{
return None;
}
let mut blocks: Vec<Block> = Vec::new();
for segment in segments {
let opens = starts.binary_search(&segment.range.from).is_ok();
if opens || blocks.is_empty() {
blocks.push(Block {
range: LineRange {
from: segment.range.from,
to: segment.range.from,
},
times: None,
});
}
let block = blocks.last_mut()?;
for at in [segment.first, segment.last].into_iter().flatten() {
let (low, high) = block.times.get_or_insert((at, at));
*low = (*low).min(at);
*high = (*high).max(at);
block.range.to = segment.range.to;
}
}
let ran: Vec<usize> = (0..steps.len())
.filter(|&index| {
steps[index].started_at.is_some()
&& steps[index].conclusion.as_deref() != Some("skipped")
})
.collect();
let owners = Orders::new(&blocks, steps, &ran, ends)?.owners();
let mut ranges: Vec<Option<LineRange>> = vec![None; steps.len()];
for (block, owner) in blocks.iter().zip(owners) {
if let (Some(index), Some(_), false) = (owner, block.times, block.range.is_empty()) {
let range = ranges[index].get_or_insert(block.range);
range.to = block.range.to;
}
}
Some(ranges)
}
struct Orders<'log> {
blocks: &'log [Block],
steps: &'log [Step],
ran: &'log [usize],
ends: Ends,
fresh: Vec<bool>,
open: Vec<bool>,
}
impl<'log> Orders<'log> {
fn new(
blocks: &'log [Block],
steps: &'log [Step],
ran: &'log [usize],
ends: Ends,
) -> Option<Orders<'log>> {
let cells = (blocks.len() + 1) * (ran.len() + 1);
let mut orders = Orders {
blocks,
steps,
ran,
ends,
fresh: vec![false; cells],
open: vec![false; cells],
};
orders.fresh[0] = true;
for i in 0..=blocks.len() {
for k in 0..ran.len() {
let at = orders.cell(i, k);
if orders.fresh[at] && orders.may_skip(i, k) {
let next = orders.cell(i, k + 1);
orders.fresh[next] = true;
}
if orders.open[at] {
let next = orders.cell(i, k + 1);
orders.fresh[next] = true;
}
if i < blocks.len() && (orders.fresh[at] || orders.open[at]) && orders.fits(i, k) {
let next = orders.cell(i + 1, k);
orders.open[next] = true;
}
}
}
let done = orders.cell(blocks.len(), ran.len());
orders.fresh[done].then_some(orders)
}
fn cell(&self, i: usize, k: usize) -> usize {
i * (self.ran.len() + 1) + k
}
fn may_skip(&self, i: usize, k: usize) -> bool {
let ended = matches!(
self.steps[self.ran[k]].conclusion.as_deref(),
Some("success" | "failure")
);
!ended || (i == 0 && self.ends.leading) || (i == self.blocks.len() && self.ends.trailing)
}
fn fits(&self, i: usize, k: usize) -> bool {
let step = &self.steps[self.ran[k]];
self.blocks[i]
.times
.is_none_or(|(low, high)| holds(step, low) && holds(step, high))
}
fn owners(&self) -> Vec<Option<usize>> {
let (blocks, ran) = (self.blocks.len(), self.ran.len());
let mut fresh = vec![false; self.fresh.len()];
let mut open = vec![false; self.open.len()];
let done = self.cell(blocks, ran);
fresh[done] = true;
for i in (0..=blocks).rev() {
for k in (0..ran).rev() {
let at = self.cell(i, k);
let next_step = fresh[self.cell(i, k + 1)];
let takes = i < blocks && self.fits(i, k) && open[self.cell(i + 1, k)];
fresh[at] = (self.may_skip(i, k) && next_step) || takes;
open[at] = next_step || takes;
}
}
(0..blocks)
.map(|i| {
let mut owners = (0..ran).filter(|&k| {
let at = self.cell(i, k);
(self.fresh[at] || self.open[at])
&& self.fits(i, k)
&& open[self.cell(i + 1, k)]
});
match (owners.next(), owners.next()) {
(Some(only), None) => Some(self.ran[only]),
_ => None,
}
})
.collect()
}
}
fn gaps<'range>(lines: u64, ranges: impl Iterator<Item = &'range LineRange>) -> Vec<LineRange> {
let mut ranges: Vec<LineRange> = ranges.copied().collect();
ranges.sort_unstable_by_key(|range| range.from);
let mut gaps = Vec::new();
let mut at = 0;
for range in ranges {
if range.from > at {
gaps.push(LineRange {
from: at,
to: range.from,
});
}
at = at.max(range.to);
}
if at < lines {
gaps.push(LineRange {
from: at,
to: lines,
});
}
gaps
}
fn failure(
job: &Job,
steps: &[StepLines],
read: &mut dyn FnMut(LineRead) -> Vec<StoredLine>,
) -> FailureSummary {
let step = job
.steps
.iter()
.find(|step| step.conclusion.as_deref() == Some("failure"))
.map(|step| step.number);
let range = step.and_then(|number| {
steps
.iter()
.find(|step| step.number == number)
.and_then(|step| match step.lines {
StepLog::Lines(range) => Some(range),
_ => None,
})
});
let last = |count: u64, range: LineRange| LineRange {
from: range.to.saturating_sub(count).max(range.from),
to: range.to,
};
let exit_code = range.and_then(|range| {
read_range(read, last(EXIT_SCAN, range), EXIT_PREFIX)
.iter()
.rev()
.map(StoredLine::styled)
.find_map(|line| {
(line.kind == LineKind::Error && line.omitted == 0)
.then(|| line.text())
.and_then(|text| {
text.strip_prefix(EXIT)?
.strip_suffix('.')?
.parse::<i64>()
.ok()
})
})
});
let excerpt = range.map(|range| {
read_range(read, last(EXCERPT, range), EXCERPT_LINE_BYTES)
.iter()
.map(StoredLine::styled)
.collect()
});
let shell = job
.record
.as_ref()
.filter(|record| matches!(record.state(), RecordState::Kept { .. }))
.map(|_| RecordNote::shell_command(job.summary.id));
FailureSummary {
step,
exit_code,
excerpt,
shell,
}
}