use maud::{Markup, html};
use runnerd_core::api::{
BarEnd, Bucket, Column, Feature, GapKind, JOBS_HEADING, JobList, JobOrder, JobQuery, JobRange,
JobSort, JobState, JobSummary, Lane, RecordFilter, Section, SlotTimeline, SortOrder, Stats,
StatsQuery, StatsSummary, Status, TimelineBar,
};
use runnerd_core::client::{Client, ClientError};
use serde::de::{DeserializeOwned, IntoDeserializer};
use serde::{Deserialize, Serialize};
use super::{
Page, Parts, badge, heading, js, outcome_kind_class, page, profile_class, time_ago, tone_class,
};
use crate::chart::{Band, Bar, Base, Series, TimeChart, nice_top, stacked_bars};
use crate::format;
const TREND_DAYS: u64 = 30;
const PAGE: u32 = 50;
const CHOICES_READ: u32 = 500;
const OUTCOMES: [(&str, &str); 8] = [
("success", "Succeeded"),
("failure", "Failed"),
("cancelled", "Cancelled"),
("timed_out", "Timed out"),
("running", "Running"),
("queued", "Queued"),
("lost", "Lost"),
("elsewhere", "Not run here"),
];
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub(crate) enum Lens {
#[default]
List,
Timeline,
Trends,
}
impl Lens {
const ALL: [Lens; 3] = [Lens::List, Lens::Timeline, Lens::Trends];
fn label(self) -> &'static str {
match self {
Lens::List => "List",
Lens::Timeline => "Timeline",
Lens::Trends => "Trends",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct Range(JobRange);
impl Range {
fn slug(range: JobRange) -> Option<&'static str> {
match range {
JobRange::Day => Some("24h"),
JobRange::Week => Some("7d"),
JobRange::Month => Some("30d"),
JobRange::All => None,
}
}
}
impl Serialize for Range {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(Range::slug(self.0).unwrap_or_default())
}
}
impl<'de> Deserialize<'de> for Range {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Range, D::Error> {
let slug = String::deserialize(deserializer)?;
JobRange::ALL
.into_iter()
.find(|range| Range::slug(*range) == Some(slug.as_str()))
.map(Range)
.ok_or_else(|| serde::de::Error::custom("no such range"))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct Order(JobOrder);
impl Order {
fn slug(order: JobOrder) -> String {
format!(
"{}-{}",
value_of(&order.sort).unwrap_or_default(),
value_of(&order.order).unwrap_or_default()
)
}
}
impl Serialize for Order {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(&Order::slug(self.0))
}
}
impl<'de> Deserialize<'de> for Order {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Order, D::Error> {
let slug = String::deserialize(deserializer)?;
JobOrder::ALL
.into_iter()
.find(|order| Order::slug(*order) == slug)
.map(Order)
.ok_or_else(|| serde::de::Error::custom("no such order"))
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub(crate) struct Filter {
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "empty_none"
)]
pub(crate) q: Option<String>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "empty_none"
)]
pub(crate) repository: Option<String>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "empty_none"
)]
pub(crate) workflow: Option<String>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "empty_none"
)]
pub(crate) branch: Option<String>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "empty_none"
)]
pub(crate) outcome: Option<String>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "empty_none_of"
)]
pub(crate) range: Option<Range>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "empty_none_of"
)]
pub(crate) record: Option<RecordFilter>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "empty_none_of"
)]
pub(crate) order: Option<Order>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "empty_none_of"
)]
pub(crate) lens: Option<Lens>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "empty_none_of"
)]
pub(crate) before: Option<u64>,
}
fn empty_none<'de, D: serde::Deserializer<'de>>(
deserializer: D,
) -> Result<Option<String>, D::Error> {
Ok(Option::<String>::deserialize(deserializer)?.filter(|value| !value.is_empty()))
}
fn empty_none_of<'de, D: serde::Deserializer<'de>, T: DeserializeOwned>(
deserializer: D,
) -> Result<Option<T>, D::Error> {
Ok(empty_none(deserializer)?.and_then(|value| {
T::deserialize(
IntoDeserializer::<serde::de::value::Error>::into_deserializer(value.as_str()),
)
.ok()
.or_else(|| serde_json::from_str(&value).ok())
}))
}
impl Filter {
fn lens(&self) -> Lens {
self.lens.unwrap_or_default()
}
fn job_order(&self) -> JobOrder {
self.order.map_or(JobOrder::NEWEST, |order| order.0)
}
fn pages(&self) -> bool {
self.job_order().pages()
}
fn query(&self, now: u64) -> JobQuery {
let mut query = JobQuery {
repository: self.repository.clone(),
workflow: self.workflow.clone(),
branch: self.branch.clone(),
q: self.q.clone(),
record: self.record,
since: self.range.and_then(|range| range.0.since(now)),
before: self.before,
limit: Some(PAGE),
..JobQuery::default()
};
self.job_order().apply(&mut query);
match self.outcome.as_deref() {
Some("running") => query.state = Some(JobState::Running),
Some("queued") => query.state = Some(JobState::Queued),
Some("lost") => query.state = Some(JobState::Lost),
Some("elsewhere") => query.state = Some(JobState::Elsewhere),
Some(conclusion) => query.conclusion = Some(conclusion.to_owned()),
None => {}
}
query
}
fn searches(&self) -> bool {
self.q.is_some() || self.branch.is_some() || self.record.is_some() || !self.pages()
}
fn link(&self, change: impl FnOnce(&mut Filter)) -> String {
let mut next = Filter {
before: None,
..self.clone()
};
change(&mut next);
let query = serde_urlencoded::to_string(&next).unwrap_or_default();
if query.is_empty() {
"/history".to_owned()
} else {
format!("/history?{query}")
}
}
}
#[derive(Debug, Clone)]
pub(crate) enum Listing {
Jobs(Box<JobList>),
Refused(String),
}
#[derive(Debug, Clone)]
pub(crate) enum Timeline {
Drawn(SlotTimeline),
Unsupported,
Refused(String),
}
#[derive(Debug, Clone)]
pub(crate) struct History {
pub(crate) now: u64,
pub(crate) filter: Filter,
pub(crate) status: Status,
pub(crate) listing: Option<Listing>,
pub(crate) timeline: Option<Timeline>,
pub(crate) stats: Option<Stats>,
pub(crate) workflows: Vec<String>,
pub(crate) branches: Vec<String>,
}
impl History {
pub(crate) async fn load(
daemon: &Client,
filter: Filter,
now: u64,
) -> Result<History, ClientError> {
let status = daemon.get("/v1/status").await?;
let lens = filter.lens();
let listing = match lens {
Lens::List => {
let query = filter.query(now);
Some(match query.check() {
Ok(()) => Listing::Jobs(Box::new(daemon.jobs(&query).await?)),
Err(reason) => Listing::Refused(reason),
})
}
Lens::Timeline | Lens::Trends => None,
};
let timeline = match lens {
Lens::Timeline => {
let query = timeline_range(&filter).timeline(now);
Some(match daemon.timeline(&query).await {
Ok(timeline) => Timeline::Drawn(timeline),
Err(error) if error.is_unsupported() => Timeline::Unsupported,
Err(ClientError::Api {
status, message, ..
}) if status == axum::http::StatusCode::BAD_REQUEST => {
Timeline::Refused(message)
}
Err(error) => return Err(error),
})
}
Lens::List | Lens::Trends => None,
};
let trends = match lens {
Lens::List | Lens::Trends => Some(
daemon
.get_query(
"/v1/stats",
&StatsQuery {
repository: filter.repository.clone(),
since: Some(day_start(now).saturating_sub((TREND_DAYS - 1) * 86_400)),
until: None,
bucket: Bucket::Day,
},
)
.await?,
),
Lens::Timeline => None,
};
let (workflows, branches) = match lens {
Lens::List => {
let latest = daemon
.jobs(&JobQuery {
repository: filter.repository.clone(),
limit: Some(CHOICES_READ),
..JobQuery::default()
})
.await?;
choices(&latest.page.jobs, &filter)
}
Lens::Timeline | Lens::Trends => (vec![], vec![]),
};
Ok(History {
now,
filter,
status,
listing,
timeline,
stats: trends,
workflows,
branches,
})
}
}
fn choices(jobs: &[JobSummary], filter: &Filter) -> (Vec<String>, Vec<String>) {
let sorted = |mut names: Vec<String>, current: &Option<String>| {
names.extend(current.clone());
names.sort();
names.dedup();
names
};
let workflows = jobs.iter().filter_map(|job| job.workflow.clone()).collect();
let branches = jobs.iter().filter_map(|job| job.branch.clone()).collect();
(
sorted(workflows, &filter.workflow),
sorted(branches, &filter.branch),
)
}
fn day_start(at: u64) -> u64 {
at - at % 86_400
}
fn days(stats: &Stats, now: u64) -> Vec<StatsSummary> {
stats.daily(
day_start(now).saturating_sub((TREND_DAYS - 1) * 86_400),
TREND_DAYS,
)
}
pub(crate) fn render(history: &History) -> Markup {
let main = html! {
(heading(runnerd_core::api::View::Jobs.title(), Some(Page::History), Some(lenses(history))))
@match history.filter.lens() {
Lens::List => {
(summary(history))
(filters(history))
(jobs(history))
}
Lens::Timeline => { (timeline(history)) }
Lens::Trends => { (trends(history)) }
}
};
page(Section::History.title(), Some(Page::History), None, &main)
}
fn lens_link(filter: &Filter, lens: Lens) -> String {
match lens {
Lens::List => filter.link(|next| next.lens = None),
Lens::Timeline => Filter {
lens: Some(Lens::Timeline),
range: filter.range,
..Filter::default()
}
.link(|_| {}),
Lens::Trends => Filter {
lens: Some(Lens::Trends),
repository: filter.repository.clone(),
..Filter::default()
}
.link(|_| {}),
}
}
fn lenses(history: &History) -> Markup {
let current = history.filter.lens();
html! {
nav.lenses aria-label="Lens" {
@for lens in Lens::ALL {
a href=(lens_link(&history.filter, lens))
aria-current=[(lens == current).then_some("page")] { (lens.label()) }
}
}
}
}
fn select(
name: &str,
label: &str,
all: &str,
current: Option<&str>,
options: &[(String, String)],
) -> Markup {
html! {
label.field {
span.field-name { (label) }
select name=(name) data-on:change="el.form.requestSubmit()" {
option value="" selected[current.is_none()] { (all) }
@for (value, text) in options {
option value=(value) selected[current == Some(value.as_str())] { (text) }
}
}
}
}
}
const REPOSITORY_CHIPS: usize = 6;
struct Chips {
outcomes: Vec<(String, String)>,
repositories: Vec<(String, String)>,
}
fn chip_row(
filter: &Filter,
label: &str,
all: &str,
current: Option<&str>,
options: &[(String, String)],
set: fn(&mut Filter, Option<String>),
) -> Markup {
html! {
nav.lenses.chips aria-label=(label) {
a href=(filter.link(|next| set(next, None))) aria-current=[current.is_none().then_some("page")] { (all) }
@for (value, text) in options {
a href=(filter.link(|next| set(next, Some(value.clone()))))
aria-current=[(current == Some(value.as_str())).then_some("page")] { (text) }
}
}
}
}
fn chip_rows(filter: &Filter, chips: &Chips) -> Markup {
html! {
(chip_row(filter, "Outcome", "Any", filter.outcome.as_deref(), &chips.outcomes, |next, outcome| next.outcome = outcome))
@if !chips.repositories.is_empty() {
(chip_row(filter, "Repository", "All repositories", filter.repository.as_deref(), &chips.repositories, |next, repository| next.repository = repository))
}
}
}
fn filters(history: &History) -> Markup {
let filter = &history.filter;
let named = |names: &[String]| -> Vec<(String, String)> {
names
.iter()
.map(|name| (name.clone(), name.clone()))
.collect()
};
let repositories: Vec<String> = history
.status
.repositories
.iter()
.map(|repository| repository.name.clone())
.chain(filter.repository.clone())
.collect::<std::collections::BTreeSet<_>>()
.into_iter()
.collect();
let repository_chips = (2..=REPOSITORY_CHIPS).contains(&repositories.len());
let chips = Chips {
outcomes: OUTCOMES
.iter()
.map(|(value, label)| ((*value).to_owned(), (*label).to_owned()))
.collect(),
repositories: if repository_chips {
named(&repositories)
} else {
vec![]
},
};
let repository_select = !repository_chips && repositories.len() > 1;
let order = filter.order.filter(|order| !order.0.pages());
let folded = [
filter.workflow.is_some(),
filter.branch.is_some(),
filter.range.is_some(),
filter.record.is_some(),
order.is_some(),
repository_select && filter.repository.is_some(),
]
.into_iter()
.filter(|set| *set)
.count();
let chipped = [
filter.outcome.is_some(),
repository_chips && filter.repository.is_some(),
]
.into_iter()
.filter(|set| *set)
.count();
html! {
form.filters method="get" action="/history" role="search" {
div.filter-bar {
label.field.search {
span.visually-hidden { "Search job name, workflow, branch" }
input type="search" name="q" value=[filter.q.as_deref()] data-search
placeholder="Search job name, workflow, branch"
autocomplete="off" spellcheck="false" maxlength="200";
}
div.wide-chips { (chip_rows(filter, &chips)) }
details.more-filters {
summary {
"Filters"
@if folded > 0 { span.filter-count.wide { (folded) } }
@if folded + chipped > 0 { span.filter-count.narrow { (folded + chipped) } }
}
div.filter-fields {
div.narrow-chips { (chip_rows(filter, &chips)) }
(folded_fields(history, repository_select.then_some(repositories.as_slice())))
button.button-quiet type="submit" { "Apply" }
}
}
@if *filter != Filter::default() {
a.clear href="/history" { "Clear" }
}
}
@if let Some(outcome) = &filter.outcome { input type="hidden" name="outcome" value=(outcome); }
@if !repository_select {
@if let Some(repository) = &filter.repository { input type="hidden" name="repository" value=(repository); }
}
}
}
}
fn folded_fields(history: &History, repositories: Option<&[String]>) -> Markup {
let filter = &history.filter;
let named = |names: &[String]| -> Vec<(String, String)> {
names
.iter()
.map(|name| (name.clone(), name.clone()))
.collect()
};
let ranges: Vec<(String, String)> = JobRange::ALL
.iter()
.filter_map(|range| {
Some((
Range::slug(*range)?.to_owned(),
format::sentence(range.words()),
))
})
.collect();
let records: Vec<(String, String)> = RecordFilter::ALL
.iter()
.filter(|record| **record != RecordFilter::Any || filter.record == Some(RecordFilter::Any))
.filter_map(|record| Some((value_of(record)?, format::sentence(record.words()))))
.collect();
let record = filter.record.as_ref().and_then(value_of);
let orders: Vec<(String, String)> = JobOrder::ALL
.iter()
.filter(|order| !order.pages())
.map(|order| (Order::slug(*order), format::sentence(order.words())))
.collect();
let order = filter
.order
.filter(|order| !order.0.pages())
.map(|order| Order::slug(order.0));
html! {
@if let Some(repositories) = repositories {
(select("repository", "Repository", "All", filter.repository.as_deref(), &named(repositories)))
}
@if history.workflows.len() > 1 || filter.workflow.is_some() {
(select("workflow", "Workflow", "All", filter.workflow.as_deref(), &named(&history.workflows)))
}
@if history.branches.len() > 1 || filter.branch.is_some() {
(select("branch", "Branch", "All", filter.branch.as_deref(), &named(&history.branches)))
}
(select("range", "Queued", &format::sentence(JobRange::All.words()), filter.range.and_then(|range| Range::slug(range.0)), &ranges))
(select("record", "Record", "Any job", record.as_deref(), &records))
(select("order", "Sort", &format::sentence(JobOrder::NEWEST.words()), order.as_deref(), &orders))
}
}
fn value_of<T: Serialize>(value: &T) -> Option<String> {
serde_urlencoded::to_string([("v", value)])
.ok()
.and_then(|pair| pair.strip_prefix("v=").map(str::to_owned))
}
const DAY_UNDER_POINTER: &str = "const area = evt.target.closest('.chart-card')?.querySelector('.chart-area'); \
if (area) { const box = area.getBoundingClientRect(); \
$_day = Math.min(29, Math.max(0, Math.floor((evt.clientX - box.left) / box.width * 30))) }";
const DAY_KEYS: &str = "if (evt.key == 'ArrowLeft') { $_day = Math.max(0, ($_day < 0 ? 30 : $_day) - 1); evt.preventDefault() } \
else if (evt.key == 'ArrowRight') { $_day = Math.min(29, $_day + 1); evt.preventDefault() } \
else if (evt.key == 'Escape') { $_day = -1 }";
struct DayCharts {
bars: Vec<Bar>,
times: TimeChart,
time_top: u64,
memory: TimeChart,
memory_top: u64,
}
impl DayCharts {
fn of(days: &[StatsSummary]) -> DayCharts {
let peak = StatsSummary::of(days).memory_peak.unwrap_or(0);
let bars = days
.iter()
.map(|day| Bar {
label: format::short_date(day.start),
parts: vec![day.succeeded, day.failed, day.cancelled, day.other()],
})
.collect();
let durations = daily(days, StatsSummary::average_run);
let waits = daily(days, StatsSummary::average_wait);
let peaks = daily(days, |day| day.memory_peak);
let time_top = nice_top(
durations
.iter()
.chain(&waits)
.map(|point| point.1)
.max()
.unwrap_or(0),
Base::Decimal,
);
DayCharts {
bars,
times: per_day(
"Average run time and wait per day",
vec![
Series::line("run time", "run", durations),
Series::line("wait", "wait", waits),
],
format::duration,
days,
),
time_top,
memory: per_day(
"Highest sampled memory peak per day",
vec![Series::line("memory peak", "memory", peaks)],
format::bytes,
days,
),
memory_top: nice_top(peak, Base::Binary),
}
}
fn jobs(&self, bands: &[Band]) -> Markup {
stacked_bars(
"Jobs per day by conclusion",
&["success", "failure", "neutral", "other"],
&self.bars,
|n| n.to_string(),
bands,
)
}
}
fn summary(history: &History) -> Markup {
let Some(stats) = &history.stats else {
return html! {};
};
let days = days(stats, history.now);
if StatsSummary::of(&days).jobs == 0 {
return html! {};
}
let charts = DayCharts::of(&days);
html! {
section.summary aria-labelledby="summary-title" {
div.summary-head {
h2 #summary-title {
"Last 30 days"
@if let Some(repository) = &history.filter.repository { " " span.muted { (repository) } }
}
a.summary-more href=(lens_link(&history.filter, Lens::Trends)) { "Trends" }
}
(headline(&days, Picking::Whole))
div.mini-charts {
div.mini { h3 { "Jobs per day" } (charts.jobs(&[])) }
div.mini { h3 { "Run and wait" } (charts.times.render(charts.time_top, &Parts::default())) }
div.mini { h3 { "Memory peak" } (charts.memory.render(charts.memory_top, &Parts::default())) }
}
}
}
}
fn trends(history: &History) -> Markup {
let Some(stats) = &history.stats else {
return html! {};
};
let days = days(stats, history.now);
let charts = DayCharts::of(&days);
let mark = |from, to| {
[Band {
from,
to: Some(to),
shown: "$_day >= 0".to_owned(),
label: String::new(),
}]
};
let bar_marks = mark(0, 1);
let day_marks = days
.first()
.map_or(mark(0, 0), |day| mark(day.start, day.start + 86_399));
let dates: Vec<String> = days
.iter()
.map(|day| format::short_date(day.start))
.collect();
html! {
section.trends aria-labelledby="trends-title" "data-signals:_day__ifmissing"="-1" "data-style:--day"="$_day" {
h2 #trends-title data-text=(day_lens("Last 30 days", &dates)) { "Last 30 days" }
p.visually-hidden { "Jobs that finished, by the day they were queued (UTC). Arrow keys step through the days." }
@if let Some(repository) = &history.filter.repository { p.muted { "Jobs of " (repository) "." } }
(headline(&days, Picking::Days))
div.charts.three tabindex="0" role="group" aria-label="Charts per day"
data-on:pointermove=(DAY_UNDER_POINTER) data-on:pointerdown=(DAY_UNDER_POINTER)
data-on:pointerleave="evt.pointerType == 'mouse' && ($_day = -1)" data-on:keydown=(DAY_KEYS) data-on:blur="$_day = -1" {
div.chart-card {
h3 { "Jobs per day" }
(charts.jobs(&bar_marks))
ul.legend {
li.success { span.swatch {} "succeeded" }
li.failure { span.swatch {} "failed or lost" }
li.neutral { span.swatch {} "cancelled" }
}
}
div.chart-card {
h3 { "Run time and wait" }
(charts.times.render_with(charts.time_top, &day_marks, &Parts::default()))
ul.legend {
li.run { span.swatch {} "average run" }
li.wait { span.swatch {} "average wait for a runner" }
}
}
div.chart-card {
h3 { "Memory peak" }
(charts.memory.render_with(charts.memory_top, &day_marks, &Parts::default()))
}
}
}
}
}
fn day_lens(whole: &str, per_day: &[String]) -> String {
let entries: Vec<String> = per_day.iter().map(|entry| js(entry)).collect();
format!(
"$_day < 0 ? {} : [{}][$_day]",
js(whole),
entries.join(", ")
)
}
fn daily(days: &[StatsSummary], value: fn(&StatsSummary) -> Option<u64>) -> Vec<(u64, u64)> {
days.iter()
.filter_map(|day| value(day).map(|value| (day.start + 43_200, value)))
.collect()
}
fn per_day(
title: &str,
series: Vec<Series>,
value: fn(u64) -> String,
days: &[StatsSummary],
) -> TimeChart {
TimeChart {
title: title.to_owned(),
start: days.first().map_or(0, |day| day.start),
end: days.last().map_or(0, |day| day.start + 86_399),
window: None,
live: None,
series,
limits: vec![],
value,
time: format::short_date,
gap: 86_400,
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Picking {
Whole,
Days,
}
fn headline(days: &[StatsSummary], picking: Picking) -> Markup {
let total = StatsSummary::of(days);
let peak = |peak: Option<u64>| peak.map_or("–".to_owned(), format::bytes);
let share = |summary: &StatsSummary| {
summary
.success_percent()
.map_or("–".to_owned(), |percent| format!("{percent}%"))
};
let average = |seconds: Option<u64>| seconds.map_or("–".to_owned(), format::duration);
let each = |value: &dyn Fn(&StatsSummary) -> String| days.iter().map(value).collect::<Vec<_>>();
let figures = [
(
JOBS_HEADING,
total.jobs.to_string(),
each(&|day| day.jobs.to_string()),
),
("Succeeded", share(&total), each(&|day| share(day))),
(
"Average run",
average(total.average_run()),
each(&|day| average(day.average_run())),
),
(
"Average wait",
average(total.average_wait()),
each(&|day| average(day.average_wait())),
),
(
"Sampled memory peak",
peak(total.memory_peak),
each(&|day| peak(day.memory_peak)),
),
];
html! {
dl.headline aria-live="polite" {
@for (label, whole, per_day) in &figures {
div {
dt { (label) }
@match picking {
Picking::Days => dd data-text=(day_lens(whole, per_day)) { (whole) },
Picking::Whole => dd { (whole) },
}
}
}
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Align {
Start,
Number,
}
fn sort_header(filter: &Filter, column: Column, sort: JobSort, align: Align) -> Markup {
let current = filter.job_order();
let order = current.order;
let sorted = current.sort == sort;
let next = if sorted && order == SortOrder::Desc {
SortOrder::Asc
} else {
SortOrder::Desc
};
let href = filter.link(|next_filter| {
let chosen = JobOrder { sort, order: next };
next_filter.order = (!chosen.pages()).then_some(Order(chosen));
});
let aria = sorted.then_some(if order == SortOrder::Asc {
"ascending"
} else {
"descending"
});
html! {
th scope="col" class=[(align == Align::Number).then_some("number")] aria-sort=[aria] {
a.sort.hit href=(href) {
(column.title())
span.sort-mark aria-hidden="true" {
@if sorted { @if order == SortOrder::Asc { "↑" } @else { "↓" } }
}
}
}
}
}
fn jobs(history: &History) -> Markup {
let now = history.now;
let filter = &history.filter;
let list = match &history.listing {
Some(Listing::Jobs(list)) => list,
Some(Listing::Refused(reason)) => {
return html! { p.notice.tone-warn role="alert" { (format::sentence(reason)) "." } };
}
None => return html! {},
};
let next = list.page.next.filter(|_| filter.pages()).map(|before| {
let next = Filter {
before: Some(before),
..filter.clone()
};
format!(
"/history?{}",
serde_urlencoded::to_string(&next).unwrap_or_default()
)
});
html! {
section.jobs aria-labelledby="jobs-title" {
h2 #jobs-title .visually-hidden { (JOBS_HEADING) }
@if let Some(unread) = list.unread_words().filter(|_| filter.searches()) {
p.notice.tone-warn role="status" { (format::sentence(&unread)) "." }
}
@if let Some(shown) = list.shown_line() {
p.list-count.muted { (format::sentence(&shown)) "." }
}
@if list.page.jobs.is_empty() {
p.muted { (format::sentence(JobList::none_words())) "." }
} @else {
div.table-wrap {
table.job-table.history-table {
thead {
tr {
th scope="col" { (Column::Job.title()) }
th scope="col" { (Column::Outcome.title()) }
(sort_header(filter, Column::Queued, JobSort::Queued, Align::Start))
(sort_header(filter, Column::Waited, JobSort::Wait, Align::Number))
(sort_header(filter, Column::Ran, JobSort::Run, Align::Number))
(sort_header(filter, Column::MemoryPeak, JobSort::Memory, Align::Number))
th scope="col" .number { (Column::Cpu.title()) }
th scope="col" .number { (Column::Written.title()) }
}
}
tbody {
@for job in &list.page.jobs {
@let class = job.runner.as_ref().map_or("p-none".to_owned(), |runner| profile_class(&history.status, &runner.profile));
tr class=(class) data-row {
th scope="row" {
a href=(format!("/jobs/{}", job.id)) {
span.swatch aria-hidden="true" {}
span.job-name { (job.title().name) }
span.repo { (job.repository) @if let Some(branch) = &job.branch { " · " (branch) } }
}
}
td {
(badge(job))
@if let Some(mark) = job.record_mark {
@if let Some(words) = mark.words() {
" " span class=(format!("record-mark {}", tone_class(mark.tone()))) { (words) }
}
}
}
td { (time_ago(job.timeline.queued_at, now)) }
td.number data-label="waited" { (job.waited(now).map_or("–".to_owned(), format::duration)) }
td.number data-label="ran" { (job.ran(now).map_or("–".to_owned(), format::duration)) }
td.number data-label="peak" { (job.metrics.memory_peak.map_or("–".to_owned(), format::bytes)) }
td.number data-label="CPU" { (job.metrics.cpu_average.map_or("–".to_owned(), format::cores_used)) }
@match job.metrics.disk {
Some(disk) => td.number class=(tone_class(disk.tone())) data-label="written" { (disk.short()) },
None => td.number data-label="written" { "–" },
}
}
}
}
}
}
}
@if let Some(next) = next {
p.pager { a.button-quiet href=(next) { "Older jobs" } }
}
}
}
}
fn place(timeline: &SlotTimeline, at: u64) -> f64 {
crate::chart::ratio(
at.clamp(timeline.since, timeline.until) - timeline.since,
timeline.until - timeline.since,
)
}
fn bar_label(bar: &TimelineBar) -> String {
let outcome = bar.outcome();
format!(
"{}, {}: {}{}",
bar.title(),
bar.repository,
outcome.label,
bar.end_words()
.map(|words| format!(", {words}"))
.unwrap_or_default()
)
}
fn bar_key(index: usize) -> String {
format!("b{index}")
}
fn timeline_bar(timeline: &SlotTimeline, bar: &TimelineBar, index: usize, left: &str) -> Markup {
let outcome = bar.outcome();
let begins = begins(bar);
let ends = match bar.end {
BarEnd::At { at } => at,
BarEnd::Open => timeline.until,
BarEnd::Unknown | BarEnd::Other => begins,
};
let from = place(timeline, begins);
let to = place(timeline, ends.max(begins));
let waits = bar
.started_at
.map(|started| place(timeline, bar.queued_at.min(started)));
let label = bar_label(bar);
let key = bar_key(index);
html! {
@if let Some(waits) = waits.filter(|waits| *waits < from) {
span.tl-wait aria-hidden="true" style=(format!("--from: {waits:.4}; --to: {from:.4}")) {}
}
a class=(format!("tl-bar {}", outcome_kind_class(outcome.kind))) href=(format!("/jobs/{}", bar.job))
style=(format!("--from: {from:.4}; --to: {to:.4}; --left: {left}")) title=(label) aria-label=(label) data-row
data-class:on=(format!("$_bar == '{key}'"))
data-on:pointerenter=(format!("evt.pointerType == 'mouse' && ($_bar = '{key}')"))
data-on:focus=(format!("el.matches(':focus-visible') && ($_bar = '{key}')"))
data-on:click=(format!("$_bar != '{key}' && (evt.preventDefault(), $_bar = '{key}')")) {}
}
}
fn begins(bar: &TimelineBar) -> u64 {
bar.started_at.unwrap_or(bar.queued_at)
}
const BAR_MIN_SHARE: f64 = 0.012;
const BAR_PUSHED_BY: usize = 12;
fn laid_out(timeline: &SlotTimeline, bars: &[TimelineBar]) -> Vec<(usize, String)> {
let mut order: Vec<usize> = (0..bars.len()).collect();
order.sort_by_key(|index| bars.get(*index).map(begins));
let starts: Vec<f64> = order
.iter()
.filter_map(|index| bars.get(*index))
.map(|bar| place(timeline, begins(bar)))
.collect();
let count = starts.len();
order
.iter()
.zip(&starts)
.enumerate()
.map(|(rank, (index, from))| {
let mut terms = vec![format!("{:.3}%", from * 100.0)];
for back in 1..=rank.min(BAR_PUSHED_BY) {
let earlier = starts[rank - back];
#[allow(clippy::cast_precision_loss, reason = "a count of a dozen bars")]
let reach = earlier + back as f64 * BAR_MIN_SHARE;
if reach > *from {
terms.push(format!("calc({:.3}% + {}px)", earlier * 100.0, back * 3));
}
}
let left = if terms.len() > 1 {
format!("max({})", terms.join(", "))
} else {
terms.swap_remove(0)
};
let room = count - rank;
#[allow(clippy::cast_precision_loss, reason = "a count of bars in one lane")]
let crowded = from + room as f64 * BAR_MIN_SHARE > 1.0;
let left = if crowded {
format!("min({left}, calc(100% - {}px))", room * 3)
} else {
left
};
(*index, left)
})
.collect()
}
fn timeline_range(filter: &Filter) -> JobRange {
match filter.range.map(|range| range.0) {
None | Some(JobRange::Day) => JobRange::Day,
Some(JobRange::Week | JobRange::Month | JobRange::All) => JobRange::Week,
}
}
fn timeline(history: &History) -> Markup {
let range = timeline_range(&history.filter);
let picker = html! {
nav.lenses.ranges aria-label="Time range" {
@for each in [JobRange::Day, JobRange::Week] {
a href=(history.filter.link(|next| next.range = (each != JobRange::Day).then_some(Range(each))))
aria-current=[(each == range).then_some("page")] { (format::sentence(each.words())) }
}
}
};
let timeline = match &history.timeline {
Some(Timeline::Drawn(timeline)) => timeline,
Some(Timeline::Unsupported) => {
return html! { (picker) p.notice.tone-warn role="status" { (format::sentence(&Feature::Timeline.unsupported())) "." } };
}
Some(Timeline::Refused(why)) => {
return html! { (picker) p.notice.tone-warn role="status" { (format::sentence(why)) "." } };
}
None => return picker,
};
let lane_name = |lane: &Lane| format!("{} {}", lane.profile, lane.slot);
let starts: Vec<usize> = timeline
.lanes
.iter()
.scan(0, |next, lane| {
let start = *next;
*next += lane.bars.len();
Some(start)
})
.collect();
let assigned: usize = timeline.lanes.iter().map(|lane| lane.bars.len()).sum();
let ticks = [0u64, 1, 2, 3, 4]
.map(|quarter| timeline.since + (timeline.until - timeline.since) * quarter / 4);
let tick = |at: u64| {
if range == JobRange::Day {
format::clock(at)
} else {
format::short_date(at)
}
};
html! {
(picker)
section.timeline aria-label="Timeline" "data-signals:_bar__ifmissing"="''" {
@if let Some(cut) = timeline.cut_line(history.now) {
p.notice.tone-warn role="status" { (format::sentence(&cut)) "." }
}
ul.tl-key aria-label="Key" {
li { span.tl-swatch.no-job {} (GapKind::NoJob.words()) }
li { span.tl-swatch.unknown {} (GapKind::Unknown.words()) }
li { span.tl-swatch.wait {} "waiting for a runner" }
}
@if timeline.lanes.is_empty() && timeline.unassigned.is_empty() {
p.muted { (format::sentence(SlotTimeline::NONE)) "." }
}
ol.tl-lanes {
@for (lane, start) in timeline.lanes.iter().zip(&starts) {
li class=(format!("tl-lane {}", profile_class(&history.status, &lane.profile))) {
span.tl-name { (lane_name(lane)) }
div.tl-track {
@for gap in lane.gaps(timeline).iter().filter(|gap| gap.kind == GapKind::Unknown) {
span.tl-gap aria-hidden="true" title=(gap.kind.words()) style=(format!("--from: {:.4}; --to: {:.4}", place(timeline, gap.span.from), place(timeline, gap.span.to))) {}
}
@for (index, left) in laid_out(timeline, &lane.bars) { (timeline_bar(timeline, &lane.bars[index], start + index, &left)) }
}
}
}
@if !timeline.unassigned.is_empty() {
li.tl-lane.p-none {
span.tl-name { (format::sentence(SlotTimeline::UNASSIGNED)) }
div.tl-track {
@for (index, left) in laid_out(timeline, &timeline.unassigned) { (timeline_bar(timeline, &timeline.unassigned[index], assigned + index, &left)) }
}
}
}
}
div.tl-axis aria-hidden="true" {
@for at in ticks { span { (tick(at)) } }
}
div.tl-readout aria-hidden="true" {
@for (index, bar) in timeline.lanes.iter().flat_map(|lane| &lane.bars).chain(&timeline.unassigned).enumerate() {
p data-show=(format!("$_bar == '{}'", bar_key(index))) style="display: none" {
a href=(format!("/jobs/{}", bar.job)) tabindex="-1" { (bar_label(bar)) }
" " span.muted { (format::clock(bar.started_at.unwrap_or(bar.queued_at))) }
}
}
}
}
}
}