use std::collections::BTreeMap;
use maud::{Markup, html};
use runnerd_core::api::{
Activity, ActivityQuery, Attention, AttentionItem, Feature, Fix, HealthKind, HeldKind,
HeldPart, HostSample, HostSamples, Job, JobPage, JobQuery, JobState, JobSummary, JobTitle,
ProfileStatus, QueuedJob, RepositoryStatus, Sample, SampleSeries, Savings, Section, SlotStatus,
Status, Subject, View, WaitKind, cpus, in_cores,
};
use runnerd_core::client::{Client, ClientError};
use super::{
Live, Page, Parts, badge, digest, heading, js, page, profile_class, repository_id, slot_id,
time_ago, tone_class,
};
use crate::chart::{Base, Series, Sparkline, TimeChart, nice_top};
use crate::format;
pub(crate) const HOST_WINDOW: u64 = 30 * 60;
const HOST_MARGIN: u64 = 5 * 60;
const SPARK_WINDOW: u64 = 5 * 60;
const RECENT: u32 = 6;
const MAX_JOBS: u32 = 500;
const QUEUED_SHOWN: usize = 6;
const QUEUED_SHOWN_NARROW: usize = 3;
const DAY: u64 = 24 * 3600;
#[derive(Debug, Clone)]
pub(crate) struct Overview {
pub(crate) now: u64,
pub(crate) status: Status,
pub(crate) running: Vec<Job>,
pub(crate) samples: BTreeMap<u64, Vec<Sample>>,
pub(crate) host: HostSamples,
pub(crate) recent: Vec<JobSummary>,
pub(crate) day: Activity,
pub(crate) savings: Option<Savings>,
pub(crate) attention: Option<Attention>,
}
impl Overview {
pub(crate) async fn load(daemon: &Client, now: u64) -> Result<Overview, ClientError> {
let status: Status = daemon.get("/v1/status").await?;
let host = daemon
.get(&format!(
"/v1/host/samples?since={}",
now.saturating_sub(HOST_WINDOW + HOST_MARGIN)
))
.await?;
let recent = read_recent(daemon, &status).await?;
let mut overview = Overview {
now,
status,
running: Vec::new(),
samples: BTreeMap::new(),
host,
recent,
day: Activity {
since: now.saturating_sub(DAY),
until: now,
started: Vec::new(),
finished: 0,
failed: 0,
runner_failed: 0,
},
savings: None,
attention: daemon.attention().await?,
};
overview.reload_running(daemon).await?;
overview.reload_day(daemon, now).await?;
Ok(overview)
}
pub(crate) async fn reload_day(
&mut self,
daemon: &Client,
now: u64,
) -> Result<(), ClientError> {
self.day = daemon
.get_query(
"/v1/activity",
&ActivityQuery {
since: Some(now.saturating_sub(DAY)),
},
)
.await?;
self.savings = daemon.get("/v1/savings").await.ok();
Ok(())
}
pub(crate) async fn reload_running(&mut self, daemon: &Client) -> Result<(), ClientError> {
let page: JobPage = daemon
.get_query(
"/v1/jobs",
&JobQuery {
state: Some(JobState::Running),
limit: Some(100),
..JobQuery::default()
},
)
.await?;
let mut running = Vec::with_capacity(page.jobs.len());
for summary in page.jobs {
running.push(
daemon
.get::<Job>(&format!("/v1/jobs/{}", summary.id))
.await?,
);
}
self.samples
.retain(|id, _| running.iter().any(|job| job.summary.id == *id));
for job in &running {
if let std::collections::btree_map::Entry::Vacant(entry) =
self.samples.entry(job.summary.id)
{
let series: SampleSeries = daemon
.get(&format!("/v1/jobs/{}/samples", job.summary.id))
.await?;
entry.insert(series.samples);
}
}
self.running = running;
Ok(())
}
pub(crate) fn add_job_sample(&mut self, job: u64, sample: Sample) {
if let Some(samples) = self.samples.get_mut(&job) {
samples.push(sample);
}
}
pub(crate) fn add_host_sample(&mut self, sample: HostSample) {
let since = sample.at.saturating_sub(HOST_WINDOW + HOST_MARGIN);
self.host.samples.push(sample);
self.host.samples.retain(|sample| sample.at >= since);
}
fn job_in(&self, profile: &str, slot: usize) -> Option<&Job> {
self.running.iter().find(|job| {
job.summary
.runner
.as_ref()
.is_some_and(|runner| runner.profile == profile && runner.slot == slot)
})
}
}
pub(crate) fn regions(overview: &Overview) -> [(&'static str, Markup, Parts); 8] {
let region = |id, render: &dyn Fn(&Parts) -> Markup| {
let parts = Parts::default();
let markup = render(&parts);
(id, markup, parts)
};
[
region("health", &|_| health(overview)),
region("attention", &|_| attention(overview)),
region("budget", &|parts| budget(overview, parts)),
region("slots", &|parts| slots(overview, parts)),
region("host", &|parts| host(overview, parts)),
region("queue", &|_| queue(overview)),
region("recent", &|_| recent(overview)),
region("repositories", &|_| {
repositories_noting(&overview.status, overview.attention.as_ref())
}),
]
}
pub(crate) fn render(overview: &Overview) -> Markup {
let regions = regions(overview);
let live = Live {
url: "/live/overview",
at: overview.now,
log: None,
regions: regions
.iter()
.map(|(id, markup, _)| (*id, digest(&markup.0)))
.collect(),
};
let [
health,
attention,
budget,
slots,
host,
queue,
recent,
repositories,
] = regions;
let main = html! {
(heading(View::Overview.title(), Some(Page::Overview), Some(attention.1)))
div.overview "data-signals:_slot__ifmissing"="''" "data-signals:_repo__ifmissing"="''" {
(health.1)
section.machine aria-labelledby="budget-title" {
(budget.1)
(slots.1)
}
div.work {
(queue.1)
(recent.1)
(repositories.1)
(host.1)
}
@if let Some(savings) = &overview.savings {
p.savings { (savings.month.headline()) }
}
}
};
page(
View::Overview.title(),
Some(Page::Overview),
Some(&live),
&main,
)
}
fn subject_href(subject: &Subject) -> Option<String> {
match subject {
Subject::Job { id, .. } => Some(format!("/jobs/{id}")),
Subject::Repository { name } => Some(format!(
"/history?{}",
serde_urlencoded::to_string([("repository", name)]).unwrap_or_default()
)),
Subject::Check { .. } => Some(format!(
"{}#doctor",
Page::of_section(Section::Config).path()
)),
Subject::Insight { .. } => Some(Page::of(View::Insights).path().to_owned()),
Subject::Host | Subject::Github | Subject::Unknown => None,
}
}
fn fix(fix: &Fix) -> Markup {
html! {
@match fix {
Fix::Command { command } => { code.fix-command { (command) } }
Fix::Open { view } => { a.hit href=(Page::of(*view).path()) { (fix.line()) } }
Fix::Config { .. } => { a.hit href=(Page::of_section(Section::Config).path()) { (fix.line()) } }
Fix::Text { .. } => { (fix.line()) }
}
}
}
fn attention_item(item: &AttentionItem, now: u64) -> Markup {
let href = subject_href(&item.subject);
html! {
li class=(format!("attention-item {}", tone_class(item.tone))) data-row tabindex="-1" {
span.tone-mark aria-hidden="true" {}
@if let Some(href) = &href {
a.attention-title.hit href=(href) { (item.title) }
} @else {
span.attention-title { (item.title) }
}
@if let Some(found) = &item.fix { span.attention-fix { (fix(found)) } }
@if let Some(since) = item.since { span.attention-since { (time_ago(since, now)) } }
}
}
}
pub(crate) fn attention(overview: &Overview) -> Markup {
html! {
@match &overview.attention {
None => {
section #attention .attention.unsupported aria-label="Needs attention" {
p.muted { (format::sentence(&Feature::Attention.unsupported())) "." }
}
}
Some(attention) => {
@match attention.items.first() {
None => { div #attention hidden {} }
Some(worst) => {
details #attention class=(format!("attention {}", tone_class(worst.tone)))
"data-signals:_attention__ifmissing"="false" data-attr:open="$_attention" {
summary "data-on:click__prevent"="$_attention = !$_attention" {
span.visually-hidden { "Needs attention: " }
span.attention-count { span.tone-mark aria-hidden="true" {} (attention.count()) }
span.attention-worst { (worst.title) }
@if let Some(more) = attention.more(1) { span.attention-rest { (more) } }
}
ul.attention-list {
@for item in &attention.items {
(attention_item(item, overview.now))
}
}
}
}
}
}
}
}
}
struct Link {
enter: String,
leave: String,
pointer_leave: String,
linked: String,
}
fn link(key: &str, repository: Option<&str>) -> Link {
let key = js(key);
Link {
enter: format!("$_slot = {key}"),
leave: format!("$_slot == {key} && ($_slot = '')"),
pointer_leave: format!("evt.pointerType == 'mouse' && $_slot == {key} && ($_slot = '')"),
linked: match repository {
Some(repository) => format!("$_slot == {key} || $_repo == {}", js(repository)),
None => format!("$_slot == {key}"),
},
}
}
pub(crate) fn budget(overview: &Overview, parts: &Parts) -> Markup {
let budget = &overview.status.budget;
let reading = budget.memory_reading();
html! {
div #budget .budget {
h2 #budget-title {
span.big { (reading.figure) }
" " span.reading-text { (reading.text) }
}
(parts.html("budget-readout", html! {
dl #budget-readout .readout {
@if let Some(cpu) = budget.cpu {
div.cpu-reserved {
dt.visually-hidden { "CPU" }
dd {
(cpu.line())
span.meter aria-hidden="true" style=(format!("--fill: {:.3}", crate::chart::ratio(cpu.in_use, cpu.budget).min(1.0))) {}
}
}
}
@for figure in budget.host_figures() {
div {
dt { (figure.label) }
dd {
(figure.value)
@if let Some(note) = &figure.note { span.figure-note { " " (note) } }
}
}
}
}
}))
}
}
}
#[derive(Debug, Clone, Copy)]
struct Share {
from: f64,
size: f64,
}
impl Share {
fn style(self) -> String {
format!("--from: {:.4}; --share: {:.4}", self.from, self.size)
}
}
fn block(fill: Option<(&str, f64)>, parts: &Parts) -> Markup {
html! {
span.lane-block aria-hidden="true" {
@if let Some((id, fill)) = fill {
(parts.html(id, html! { span.fill #(id) style=(format!("--fill: {fill:.3}")) {} }))
}
}
}
}
struct Strip {
whole: u64,
at: u64,
}
impl Strip {
fn take(&mut self, memory: u64) -> Share {
let share = Share {
from: crate::chart::ratio(self.at, self.whole),
size: crate::chart::ratio(memory, self.whole),
};
self.at = self.at.saturating_add(memory);
share
}
}
pub(crate) fn slots(overview: &Overview, parts: &Parts) -> Markup {
let status = &overview.status;
let bar = status.budget_parts();
let mut strip = Strip {
whole: bar.whole.max(1),
at: 0,
};
let mut shares = BTreeMap::new();
for part in &bar.slots {
shares.insert(
(part.profile, part.slot),
(strip.take(part.memory), part.memory),
);
}
let held: Vec<(&HeldPart, Share)> = bar
.held
.iter()
.map(|part| (part, strip.take(part.memory)))
.collect();
let free = bar
.free
.as_ref()
.map(|part| (part, strip.take(part.memory)));
let closed = bar
.closed
.as_ref()
.map(|part| (part, strip.take(part.memory)));
let label = format!(
"Memory budget of {}: {}",
status.budget.slice,
status.budget.memory_reading().line()
);
let barred = bar.slots.iter().filter(|part| part.memory > 0).count()
+ held.len()
+ usize::from(free.is_some())
+ usize::from(closed.is_some());
html! {
div #slots .slots {
h2.visually-hidden { "Slots" }
@if status.profiles.is_empty() {
p.muted { "No profiles in runnerd.toml, so no slots." }
}
div.lanes-fit style=(format!("--fit: {:.4}", lanes_fit(barred))) {
ol.lanes aria-label=(label) {
@for (index, profile) in status.profiles.iter().enumerate() {
@for slot in &profile.slots {
(lane(overview, profile, slot, shares.get(&(index, slot.slot)).copied(), parts))
}
}
@for (part, share) in &held {
@let class = match &part.kind {
HeldKind::Mirror => "mirror".to_owned(),
HeldKind::Seed { profile } => format!("seed {}", profile_class(status, profile)),
HeldKind::Shell { .. } => "shell".to_owned(),
};
@let line = format!("{} {}", format::bytes(part.memory), part.holder());
li class=(format!("lane part {class}")) style=(share.style()) aria-label=(line) title=(line) {
(block(None, parts))
span.lane-size { (super::block_size(part.memory)) }
span.lane-name { (part.name()) }
}
}
@if let Some((part, share)) = free {
li.lane.part.free style=(share.style()) aria-label=(part.reading.line()) title=(part.reading.line()) {
(block(None, parts))
span.lane-size { (part.reading.figure) }
span.lane-name { (part.name()) }
}
}
@if let Some((part, share)) = closed {
li.lane.part.closed style=(share.style()) aria-label=(part.reading.line()) title=(part.reading.line()) {
(block(None, parts))
span.lane-size { (part.reading.figure) }
span.lane-name { (part.kind.name()) }
}
}
}
}
}
}
}
const LANE_FLOOR: f64 = 2.5;
const LANE_GAP: f64 = 0.125;
const BAR_FROM: f64 = 44.0;
fn lanes_fit(barred: usize) -> f64 {
let lanes = f64::from(u32::try_from(barred).unwrap_or(u32::MAX));
let needed = lanes * LANE_FLOOR + (lanes - 1.0).max(0.0) * LANE_GAP;
if needed <= BAR_FROM {
1.0
} else {
BAR_FROM / needed
}
}
fn lane(
overview: &Overview,
profile: &ProfileStatus,
slot: &SlotStatus,
share: Option<(Share, u64)>,
parts: &Parts,
) -> Markup {
let class = profile_class(&overview.status, &profile.name);
let key = slot_id(&profile.name, slot.slot);
let job = overview.job_in(&profile.name, slot.slot);
let slot_state = Status::slot_state(profile, slot);
let state = slot_state.word();
let repository = slot
.runner
.as_ref()
.map(|runner| runner.repository.as_str());
let link = link(&key, repository);
let memory = job
.and_then(|job| overview.samples.get(&job.summary.id))
.and_then(|samples| samples.last())
.map(|sample| sample.memory);
let fill_id = format!("fill-{key}");
let style = share.map_or_else(
|| {
Share {
from: 1.0,
size: 0.0,
}
.style()
},
|(share, _)| share.style(),
);
let fill = share.and_then(|(_, reserved)| {
memory.map(|used| {
(
fill_id.as_str(),
crate::chart::ratio(used, reserved).min(1.0),
)
})
});
let empty = if share.is_none_or(|(_, reserved)| reserved == 0) {
" empty"
} else {
""
};
html! {
li #(key) class=(format!("lane slot {class} {state}{empty}")) style=(style) data-row
aria-label=(format!("{} {}: {}", profile.name, slot.slot, slot_state.line()))
data-on:pointerenter=(link.enter) data-on:focusin=(link.enter)
data-on:pointerleave=(link.pointer_leave) data-on:focusout=(link.leave) data-class:linked=(link.linked) {
(block(fill, parts))
span.lane-name { (profile.name) " " (slot.slot) }
@if let Some((_, reserved)) = share { span.lane-size { (super::block_size(reserved)) } }
span.lane-caps { (slot_caps(profile, job)) }
@match (&slot.runner, job) {
(Some(_), Some(job)) if slot_state.is_running() => { (running_job(overview, profile, job, &key, parts)) }
(Some(runner), _) => {
span.lane-what {
span.lane-state { (state) }
" " span.repo { (runner.repository) }
}
@let id = format!("{key}-waiting");
(parts.html(&id, html! { span.lane-since #(id) { (time_ago(runner.started_at, overview.now)) } }))
}
(None, _) => {
span.lane-what { span.lane-state { (state) } }
}
}
}
}
}
fn slot_caps(profile: &ProfileStatus, job: Option<&Job>) -> String {
let limits = job.map(|job| job.limits(Some(profile)));
let memory = limits
.and_then(|limits| limits.memory)
.map_or(profile.memory, |limit| limit.value);
let cpu = limits
.and_then(|limits| limits.cpu)
.map_or(u64::from(profile.cpus) * 1000, |limit| limit.value);
format!("{} · {}", format::bytes(memory), cpus(cpu))
}
fn running_job(
overview: &Overview,
profile: &ProfileStatus,
job: &Job,
key: &str,
parts: &Parts,
) -> Markup {
let summary = &job.summary;
let now = overview.now;
let started = summary
.timeline
.started_at
.unwrap_or(summary.timeline.queued_at);
let current = job
.steps
.iter()
.position(|step| step.status == "in_progress")
.or_else(|| {
job.steps
.iter()
.rposition(|step| step.status == "completed")
})
.map(|place| (place + 1, &job.steps[place]));
let samples = overview
.samples
.get(&summary.id)
.map_or(&[][..], Vec::as_slice);
let memory: Vec<(u64, u64)> = samples
.iter()
.map(|sample| (sample.at, sample.memory))
.collect();
let cpu: Vec<(u64, u64)> = samples
.iter()
.map(|sample| (sample.at, sample.cpu))
.collect();
let sparkline = |points, top, class: &'static str| {
Sparkline {
points,
start: started.min(now),
end: now,
window: SPARK_WINDOW,
top,
class,
live: Some(format!("{key}-{class}")),
}
.render(parts)
};
let limits = job.limits(Some(profile));
let last = samples.last();
let figure = |class: &str, text: String| {
let id = format!("{key}-{class}-now");
parts.html(&id, html! { span.figure-now #(id) { (text) } })
};
let elapsed = format!("{key}-elapsed");
html! {
a.lane-what.lane-job href=(format!("/jobs/{}", summary.id)) {
span.job-name { (summary.title().name) }
" " span.repo { (summary.repository) }
}
span.lane-step {
@if let Some((place, step)) = current {
span.step-count { (place) "/" (job.steps.len()) }
" " (step.name)
} @else {
"Setting up"
}
}
(parts.html(&elapsed, html! {
span.lane-since.elapsed #(elapsed) { span.visually-hidden { "Running for " } (format::duration(now.saturating_sub(started))) }
}))
span.lane-figure.memory {
span.visually-hidden { "Memory " }
(figure("memory", last.map_or("–".to_owned(), |sample| format::bytes(sample.memory))))
(sparkline(&memory, limits.memory.map_or(profile.memory, |limit| limit.value), "memory"))
}
span.lane-figure.cpu {
span.visually-hidden { "CPU " }
(figure("cpu", last.map_or("–".to_owned(), |sample| in_cores(sample.cpu))))
(sparkline(&cpu, limits.cpu.map_or(u64::from(profile.cpus) * 1000, |limit| limit.value), "cpu"))
}
}
}
pub(crate) fn host(overview: &Overview, parts: &Parts) -> Markup {
let status = &overview.status;
let now = overview.now;
let samples = &overview.host.samples;
let memory: Vec<(u64, u64)> = samples.iter().map(|s| (s.at, s.memory)).collect();
let cpu: Vec<(u64, u64)> = samples.iter().map(|s| (s.at, s.cpu)).collect();
let shown = |points: &[(u64, u64)]| {
let since = now.saturating_sub(HOST_WINDOW);
points
.iter()
.filter(|point| point.0 >= since)
.map(|point| point.1)
.max()
.unwrap_or(0)
};
let gap = overview.host.interval.max(1) * 3;
let memory_peak = shown(&memory);
let cpu_peak = shown(&cpu);
let (slice, interval) = (&status.budget.slice, overview.host.interval);
let up_to =
|limit: Option<String>| limit.map_or(String::new(), |limit| format!(", up to its {limit}"));
let memory_chart = TimeChart {
title: format!(
"Memory of {slice} over the last 30 minutes, sampled every {interval} s{}",
up_to(
status
.budget
.memory_max
.map(|max| format!("MemoryMax of {}", format::bytes(max)))
)
),
start: 0,
end: now,
window: Some(HOST_WINDOW),
live: Some("host-memory".to_owned()),
series: vec![Series {
label: "memory".to_owned(),
class: "memory",
points: memory,
area: true,
}],
limits: vec![],
value: format::bytes,
time: relative_clock,
gap,
};
let memory_top = status.budget.memory_max.map_or_else(
|| nice_top(memory_peak, Base::Binary),
|max| max.max(memory_peak),
);
let cpu_chart = TimeChart {
title: format!(
"CPU of {slice} over the last 30 minutes, sampled every {interval} s{}",
up_to(status.budget.slice_cpus.map(cpus))
),
start: 0,
end: now,
window: Some(HOST_WINDOW),
live: Some("host-cpu".to_owned()),
series: vec![Series {
label: "CPU".to_owned(),
class: "cpu",
points: cpu,
area: true,
}],
limits: vec![],
value: in_cores,
time: relative_clock,
gap,
};
let cpu_top = status.budget.slice_cpus.map_or_else(
|| nice_top(cpu_peak, Base::Decimal),
|cpus| cpus.max(cpu_peak),
);
html! {
div #host .host {
h2.visually-hidden { (slice) }
div.charts {
div.chart-card {
h3 {
"Memory"
(reading(parts, "host-memory-now", &overview.host.samples.last().map_or("–".to_owned(), |s| format::bytes(s.memory)), &format::bytes(memory_peak)))
}
(memory_chart.render(memory_top, parts))
}
div.chart-card {
h3 {
"CPU"
(reading(parts, "host-cpu-now", &overview.host.samples.last().map_or("–".to_owned(), |s| in_cores(s.cpu)), &format::cores_used(cpu_peak)))
}
(cpu_chart.render(cpu_top, parts))
}
}
}
}
}
fn reading(parts: &Parts, id: &str, now: &str, peak: &str) -> Markup {
parts.html(
id,
html! { span #(id) .reading { (now) span.muted { " · peak " (peak) } } },
)
}
fn relative_clock(at: u64) -> String {
format!("{} UTC", format::clock(at))
}
pub(crate) fn repositories(status: &Status) -> Markup {
repositories_noting(status, None)
}
fn repositories_noting(status: &Status, attention: Option<&Attention>) -> Markup {
let paused = status
.repositories
.iter()
.filter(|repository| repository.paused)
.count();
let mut every = Vec::new();
if status.repositories.len() > 1 {
if paused < status.repositories.len() {
every.push(("pause", "Pause all", "Pause all repositories"));
}
if paused > 0 {
every.push(("resume", "Resume all", "Resume all repositories"));
}
}
html! {
section #repositories .repositories aria-labelledby="repositories-title" {
div.section-head {
h2 #repositories-title { "Repositories" }
@if !every.is_empty() {
div.all {
@for (action, label, name) in every {
button.button-quiet type="button"
data-indicator:_busy_all=""
data-attr:aria-busy="$_busy_all && 'true'"
data-attr:disabled="$_busy_all"
data-on:click=(format!("@post('/v1/repositories/{action}')"))
aria-label=(name) { (label) }
}
}
}
}
@if status.repositories.is_empty() {
p.muted { "No repositories yet. Add a " code { "[[repositories]]" } " table to runnerd.toml." }
}
ul.repo-list {
@for repository in &status.repositories {
(repository_row_noting(status, repository, attention))
}
}
}
}
}
pub(crate) fn repository_row(status: &Status, repository: &RepositoryStatus) -> Markup {
repository_row_noting(status, repository, None)
}
fn repository_row_noting(
status: &Status,
repository: &RepositoryStatus,
attention: Option<&Attention>,
) -> Markup {
let notes: Vec<&AttentionItem> = attention
.map(|attention| {
attention
.items
.iter()
.filter(|item| matches!(&item.subject, Subject::Repository { name } if *name == repository.name))
.collect()
})
.unwrap_or_default();
let class = profile_class(status, repository.first_profile());
let (action, label) = if repository.paused {
("resume", "Resume")
} else {
("pause", "Pause")
};
let held: Vec<String> = status
.profiles
.iter()
.flat_map(|profile| {
profile.slots.iter().filter_map(|slot| {
slot.runner
.as_ref()
.filter(|runner| runner.repository == repository.name)
.map(|_| js(&slot_id(&profile.name, slot.slot)))
})
})
.collect();
let enter = format!("$_repo = {}", js(&repository.name));
let linked = format!(
"$_repo == {} || [{}].includes($_slot)",
js(&repository.name),
held.join(", ")
);
html! {
li #(repository_id(&repository.name)) class=(format!("repository {class}")) data-row
data-on:pointerenter=(enter) data-on:focusin=(enter)
data-on:pointerleave="evt.pointerType == 'mouse' && ($_repo = '')" data-on:focusout="$_repo = ''" data-class:linked=(linked) {
div.repo-name {
span.swatch aria-hidden="true" {}
a href=(format!("/history?repository={}", repository.name)) { (repository.name) }
}
div.repo-meta {
span { (repository.profiles()) }
@if repository.queued_jobs > 0 { span { (repository.queued_jobs) " queued" } }
@if repository.paused { span.badge.neutral { "paused" } }
}
@for item in ¬es {
p class=(format!("repo-note {}", tone_class(item.tone))) {
span.tone-mark aria-hidden="true" {} (item.title)
}
}
@let busy = format!("_busy_{}", repository_id(&repository.name).replace('-', "_"));
button.button-quiet type="button"
data-indicator=(busy)
data-attr:aria-busy=(format!("${busy} && 'true'"))
data-attr:disabled=(format!("${busy}"))
data-on:click=(format!("@post('/v1/repositories/{}/{action}')", repository.name))
aria-label=(format!("{label} {}", repository.name)) { (label) }
}
}
}
pub(crate) async fn read_recent(
daemon: &Client,
status: &Status,
) -> Result<Vec<JobSummary>, ClientError> {
let running = status
.profiles
.iter()
.flat_map(|profile| &profile.slots)
.filter(|slot| slot.runner.is_some())
.count();
let queued = u32::try_from(status.queued.len().saturating_add(running)).unwrap_or(u32::MAX);
let page: JobPage = daemon
.get_query(
"/v1/jobs",
&JobQuery {
limit: Some(RECENT.saturating_add(queued).min(MAX_JOBS)),
..JobQuery::default()
},
)
.await?;
Ok(page.jobs)
}
pub(crate) fn recent(overview: &Overview) -> Markup {
let queued = &overview.status.queued;
let latest: Vec<&JobSummary> = overview
.recent
.iter()
.filter(|job| {
!matches!(job.state, JobState::Queued | JobState::Running)
&& !queued.iter().any(|known| known.id == job.id)
})
.take(RECENT as usize)
.collect();
html! {
section #recent .recent aria-labelledby="recent-title" {
div.section-head {
h2 #recent-title { "Latest jobs" }
a href="/history" { "All history" }
}
@if latest.is_empty() {
p.muted { "No jobs yet. Jobs show here once a runner of this machine takes one." }
} @else {
ul.job-list {
@for job in latest {
li data-row data-class:linked=(format!("$_repo == {}", js(&job.repository))) {
a href=(format!("/jobs/{}", job.id)) {
(badge(job))
(job_name(&job.title()))
span.repo { (job.repository) }
span.when { (time_ago(job.timeline.queued_at, overview.now)) }
}
}
}
}
}
}
}
}
pub(crate) fn health(overview: &Overview) -> Markup {
let figures = overview
.status
.health(overview.now)
.figures(Some(&overview.day));
html! {
section #health .health aria-label="Health" {
dl.health-figures {
@for figure in &figures {
div class=(tone_class(figure.tone)) {
dt { (figure.label) }
dd {
@match figure.kind {
HealthKind::Waiting => { a.figure-main href="#queue" { (figure.value) } }
HealthKind::Failed => { a.figure-main href="/history?outcome=failure" { (figure.value) } }
HealthKind::Running | HealthKind::Wait => { span.figure-main { (figure.value) } }
}
@if let Some(of) = &figure.of { span.figure-of { " " (of) } }
}
@for note in &figure.notes {
dd.figure-note { (note) }
}
@if figure.kind == HealthKind::Wait { (wait_hours(&overview.day)) }
}
}
}
@if let Some(stopping) = overview.status.stopping_line() {
p.notice.tone-warn { "runnerd is " (stopping) "; it starts no new runners." }
}
@if overview.attention.is_none() && let Some(limited) = overview.status.github_line() {
p.notice.tone-warn { (limited) }
}
}
}
}
fn wait_hours(day: &Activity) -> Markup {
let since = day.until.saturating_sub(DAY);
let hours = day.wait_hours();
let longest = hours.iter().copied().max().unwrap_or(0);
html! {
@if longest > 0 {
dd.wait-hours aria-hidden="true" {
@for (index, wait) in hours.iter().enumerate() {
@let start = since + index as u64 * 3600;
span style=(format!("--h: {:.3}", crate::chart::ratio(*wait, longest)))
title=(format!("From {}: longest wait {}", relative_clock(start), format::duration(*wait))) {}
}
}
}
}
}
pub(crate) fn queue(overview: &Overview) -> Markup {
let queued = &overview.status.queued;
let more = queued.len().saturating_sub(QUEUED_SHOWN);
html! {
section #queue .queue aria-labelledby="queue-title" {
div.section-head {
h2 #queue-title { "Waiting" }
@if queued.len() > QUEUED_SHOWN_NARROW {
a.narrow-only[more == 0] href="/history?outcome=queued" { "All " (queued.len()) " queued" }
}
}
@if queued.is_empty() {
p.muted { "Nothing waiting: every queued job has a runner." }
} @else {
ol.queue-list {
@for job in queued.iter().take(QUEUED_SHOWN) {
(queued_row(overview, job))
}
}
}
}
}
}
fn queued_row(overview: &Overview, job: &QueuedJob) -> Markup {
let repository = js(&job.repository);
let enter = format!("$_repo = {repository}");
html! {
li data-row data-class:linked=(format!("$_repo == {repository}"))
data-on:pointerenter=(enter) data-on:focusin=(enter)
data-on:pointerleave="evt.pointerType == 'mouse' && ($_repo = '')"
data-on:focusout="$_repo = ''" {
a href=(job.url.clone().unwrap_or_else(|| format!("/jobs/{}", job.id))) {
span.waited {
@if job.queued_at > 0 {
span.visually-hidden { "Waited " }
(format::duration(overview.now.saturating_sub(job.queued_at)))
} @else {
"–"
}
}
(job_name(&job.title()))
span.repo {
(job.place(&overview.status))
@if let Some(branch) = &job.branch { " · " (branch) }
}
@if let Some(waiting) = &job.waiting {
span class=(format!("reason {}", reason_class(waiting.kind()))) { (waiting.reason(job, &overview.status, overview.now)) }
}
}
}
}
}
pub(crate) fn reason_class(kind: WaitKind) -> &'static str {
match kind {
WaitKind::Act => "act",
WaitKind::Soon => "soon",
WaitKind::Full => "full",
WaitKind::Other => "other",
}
}
fn job_name(title: &JobTitle<'_>) -> Markup {
html! {
span.job-name {
@if let Some(workflow) = title.workflow { span.workflow { (workflow) " / " } }
(title.name)
}
}
}