use std::collections::BTreeMap;
use serde::{Deserialize, Serialize};
use super::facts::outcome_of;
use super::log::title;
use super::{JobState, JobSummary, JobTitle, Outcome, job_title};
pub const TIMELINE_DEFAULT: u64 = 24 * 3600;
pub const TIMELINE_WINDOW_MAX: u64 = 7 * 24 * 3600;
pub const TIMELINE_BARS_MAX: usize = 2000;
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct TimelineQuery {
pub since: Option<u64>,
pub until: Option<u64>,
}
impl TimelineQuery {
pub fn window(&self, now: u64) -> Result<Span, String> {
let to = self.until.unwrap_or(now).min(now);
let from = self
.since
.unwrap_or_else(|| to.saturating_sub(TIMELINE_DEFAULT));
if from >= to {
return Err("a timeline's since is before its until".to_owned());
}
if to - from > TIMELINE_WINDOW_MAX {
return Err(format!(
"a timeline shows {} at most",
crate::api::duration(TIMELINE_WINDOW_MAX)
));
}
Ok(Span { from, to })
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub struct Span {
pub from: u64,
pub to: u64,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case", tag = "kind")]
pub enum BarEnd {
At {
at: u64,
},
Open,
Unknown,
#[serde(other)]
Other,
}
impl BarEnd {
pub fn of_job(finished_at: Option<u64>, cleaned_at: Option<u64>, open: bool) -> BarEnd {
match (finished_at, open) {
(Some(at), _) => BarEnd::At {
at: cleaned_at.map_or(at, |cleaned| cleaned.min(at)),
},
(None, true) => BarEnd::Open,
(None, false) => BarEnd::Unknown,
}
}
pub fn at(self) -> Option<u64> {
match self {
BarEnd::At { at } => Some(at),
BarEnd::Open | BarEnd::Unknown | BarEnd::Other => None,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct TimelineBar {
pub job: u64,
pub repository: String,
pub workflow: Option<String>,
pub name: String,
pub state: JobState,
pub conclusion: Option<String>,
pub runner_fault: bool,
pub queued_at: u64,
pub started_at: Option<u64>,
pub end: BarEnd,
pub runner: Option<String>,
}
impl TimelineBar {
pub fn of(job: &JobSummary) -> TimelineBar {
let end = BarEnd::of_job(
job.timeline.finished_at,
job.timeline.cleaned_at,
!job.state.is_final(),
);
TimelineBar {
job: job.id,
repository: job.repository.clone(),
workflow: job.workflow.clone(),
name: job.name.clone(),
state: job.state,
conclusion: job.conclusion.clone(),
runner_fault: job.runner_fault,
queued_at: job.timeline.queued_at,
started_at: job.timeline.started_at,
end,
runner: job.runner.as_ref().map(|runner| runner.name.clone()),
}
}
pub fn outcome(&self) -> Outcome {
outcome_of(
self.state,
self.conclusion.as_deref(),
self.started_at.is_some(),
self.runner_fault,
)
}
pub fn title(&self) -> JobTitle<'_> {
job_title(self.workflow.as_deref(), &self.name, Some(self.job))
}
pub fn end_words(&self) -> Option<&'static str> {
match (self.end, self.started_at) {
(BarEnd::At { .. }, _) => None,
(BarEnd::Open, Some(_)) => Some("running"),
(BarEnd::Open, None) => Some("waiting"),
(BarEnd::Unknown | BarEnd::Other, _) => Some("end unknown"),
}
}
fn begins(&self) -> u64 {
self.started_at.unwrap_or(self.queued_at)
}
pub fn overlaps(&self, window: Span, runner: Option<BarEnd>) -> bool {
self.queued_at < window.to
&& match (self.end, runner) {
(BarEnd::At { at }, _) => at > window.from,
(BarEnd::Open, _) => true,
(BarEnd::Unknown | BarEnd::Other, Some(runner)) => {
runner.at().is_none_or(|at| at > window.from)
}
(BarEnd::Unknown | BarEnd::Other, None) => self.begins() >= window.from,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct RunnerSpan {
pub name: String,
pub started_at: u64,
pub end: BarEnd,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Lane {
pub profile: String,
pub slot: usize,
pub bars: Vec<TimelineBar>,
pub runners: Vec<RunnerSpan>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum GapKind {
NoJob,
Unknown,
}
impl GapKind {
pub fn words(self) -> &'static str {
match self {
GapKind::NoJob => "no job",
GapKind::Unknown => "unknown",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Gap {
pub span: Span,
pub kind: GapKind,
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct SlotTimeline {
pub since: u64,
pub until: u64,
pub lanes: Vec<Lane>,
pub unassigned: Vec<TimelineBar>,
pub observed: Vec<Span>,
pub history_from: u64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub cut_before: Option<u64>,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct TimelineRows {
pub window: Option<Span>,
pub jobs: Vec<SlottedBar>,
pub runners: Vec<SlottedRunner>,
pub observed: Vec<Span>,
pub history_from: u64,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SlottedBar {
pub bar: TimelineBar,
pub slot: Option<SlotKey>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SlottedRunner {
pub span: RunnerSpan,
pub slot: SlotKey,
}
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub struct SlotKey {
pub profile: String,
pub slot: usize,
}
impl SlotTimeline {
pub const UNASSIGNED: &'static str = "no runner here";
pub const NONE: &'static str = "no job ran or waited in this window";
pub fn cut_line(&self, now: u64) -> Option<String> {
let cut = self.cut_before?;
Some(format!(
"more than {TIMELINE_BARS_MAX} jobs and runners in this window: jobs that began before {} are left out",
crate::api::ago(cut, now)
))
}
pub fn assemble(rows: TimelineRows) -> SlotTimeline {
let window = rows.window.unwrap_or(Span { from: 0, to: 0 });
let mut jobs = rows.jobs;
jobs.sort_by_key(|job| std::cmp::Reverse((job.bar.queued_at, job.bar.job)));
let mut runners = rows.runners;
runners.sort_by(|a, b| {
(b.span.started_at, &b.span.name).cmp(&(a.span.started_at, &a.span.name))
});
let mut cut_before = None;
if jobs.len() > TIMELINE_BARS_MAX {
jobs.truncate(TIMELINE_BARS_MAX);
cut_before = jobs.last().map(|job| job.bar.queued_at);
}
if runners.len() > TIMELINE_BARS_MAX {
runners.truncate(TIMELINE_BARS_MAX);
let cut = runners.last().map(|runner| runner.span.started_at);
cut_before = cut_before.max(cut);
}
let mut lanes: BTreeMap<SlotKey, Lane> = BTreeMap::new();
let mut unassigned = Vec::new();
for job in jobs.into_iter().rev() {
let mut bar = job.bar;
bar.name = title(&bar.name);
bar.workflow = bar.workflow.as_deref().map(title);
match job.slot {
Some(key) => lane(&mut lanes, key).bars.push(bar),
None => unassigned.push(bar),
}
}
for runner in runners.into_iter().rev() {
lane(&mut lanes, runner.slot).runners.push(runner.span);
}
for lane in lanes.values_mut() {
lane.bars
.sort_by_key(|bar| (bar.begins(), bar.queued_at, bar.job));
}
SlotTimeline {
since: window.from,
until: window.to,
lanes: lanes.into_values().collect(),
unassigned,
observed: rows.observed,
history_from: rows.history_from,
cut_before,
}
}
pub fn of(
jobs: &[JobSummary],
window: Span,
observed: Vec<Span>,
history_from: u64,
) -> SlotTimeline {
let mut rows = TimelineRows {
window: Some(window),
observed,
history_from,
..TimelineRows::default()
};
for job in jobs {
let bar = TimelineBar::of(job);
let runner_end = job.runner.as_ref().map(|_| {
match (job.timeline.cleaned_at, job.state.is_final()) {
(Some(at), _) => BarEnd::At { at },
(None, false) => BarEnd::Open,
(None, true) => BarEnd::Unknown,
}
});
if !bar.overlaps(window, runner_end) {
continue;
}
let slot = job.runner.as_ref().map(|runner| SlotKey {
profile: runner.profile.clone(),
slot: runner.slot,
});
if let (Some(runner), Some(slot), Some(end)) = (&job.runner, &slot, runner_end) {
let started_at = job.timeline.container_started_at.unwrap_or(bar.queued_at);
let up = started_at < window.to && end.at().is_none_or(|at| at > window.from);
if up {
rows.runners.push(SlottedRunner {
span: RunnerSpan {
name: runner.name.clone(),
started_at,
end,
},
slot: slot.clone(),
});
}
}
rows.jobs.push(SlottedBar { bar, slot });
}
SlotTimeline::assemble(rows)
}
}
impl Lane {
pub fn gaps(&self, timeline: &SlotTimeline) -> Vec<Gap> {
let window = Span {
from: timeline.since,
to: timeline.until,
};
if timeline.cut_before.is_some() {
return subtract(window, &self.busy(window))
.into_iter()
.map(|span| Gap {
span,
kind: GapKind::Unknown,
})
.collect();
}
let removed = |bar: &TimelineBar| {
self.runners
.iter()
.find(|runner| Some(&runner.name) == bar.runner.as_ref())
.and_then(|runner| runner.end.at())
};
let mut unsure = Vec::new();
for bar in &self.bars {
match (bar.started_at, bar.end) {
(Some(_), BarEnd::At { .. } | BarEnd::Open) => {}
(Some(from), BarEnd::Unknown | BarEnd::Other) => unsure.push(Span {
from,
to: removed(bar).unwrap_or(window.to),
}),
(None, end) => unsure.push(Span {
from: bar.queued_at,
to: end.at().unwrap_or(window.to),
}),
}
}
let mut gaps = Vec::new();
for free in subtract(window, &self.busy(window)) {
let mut known = Vec::new();
let watched = timeline
.observed
.iter()
.filter_map(|seen| clip(*seen, free));
for seen in watched {
known.extend(subtract(seen, &unsure));
}
for span in subtract(free, &known) {
gaps.push(Gap {
span,
kind: GapKind::Unknown,
});
}
gaps.extend(known.into_iter().map(|span| Gap {
span,
kind: GapKind::NoJob,
}));
}
gaps.sort_by_key(|gap| gap.span.from);
gaps
}
fn busy(&self, window: Span) -> Vec<Span> {
self.bars
.iter()
.filter_map(|bar| match (bar.started_at, bar.end) {
(Some(from), BarEnd::At { at }) => Some(Span { from, to: at }),
(Some(from), BarEnd::Open) => Some(Span {
from,
to: window.to,
}),
_ => None,
})
.collect()
}
}
fn clip(span: Span, within: Span) -> Option<Span> {
let from = span.from.max(within.from);
let to = span.to.min(within.to);
(from < to).then_some(Span { from, to })
}
fn subtract(span: Span, taken: &[Span]) -> Vec<Span> {
let mut taken: Vec<Span> = taken.iter().filter_map(|part| clip(*part, span)).collect();
taken.sort_by_key(|part| part.from);
let mut left = Vec::new();
let mut from = span.from;
for part in taken {
if part.from > from {
left.push(Span {
from,
to: part.from,
});
}
from = from.max(part.to);
}
if from < span.to {
left.push(Span { from, to: span.to });
}
left
}
fn lane(lanes: &mut BTreeMap<SlotKey, Lane>, key: SlotKey) -> &mut Lane {
lanes.entry(key).or_insert_with_key(|key| Lane {
profile: key.profile.clone(),
slot: key.slot,
bars: Vec::new(),
runners: Vec::new(),
})
}
#[cfg(test)]
#[cfg(any(feature = "host", feature = "client"))]
mod tests;