use serde::{Deserialize, Serialize};
use super::{JobList, JobPage, JobQuery, JobSummary};
use crate::api::{RecordNote, RecordState, Tone};
pub const JOB_SEARCH_MAX: usize = 100;
pub const JOBS_PAGE_DEFAULT: u32 = 50;
pub const JOBS_PAGE_MAX: u32 = 500;
pub const JOBS_PAGE_BYTES: u64 = 1 << 20;
pub const JOB_TEXT_MAX: usize = 1024;
pub const JOB_LABELS_MAX: usize = 4096;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum JobSort {
Queued,
Wait,
Run,
Memory,
}
impl JobSort {
pub fn key(self, job: &JobSummary) -> Option<u64> {
let timeline = &job.timeline;
match self {
JobSort::Queued => Some(timeline.queued_at),
JobSort::Wait => timeline
.started_at
.map(|started| started.saturating_sub(timeline.queued_at)),
JobSort::Run if job.state.is_final() => {
let (started, finished) = (timeline.started_at?, timeline.finished_at?);
Some(finished.saturating_sub(started))
}
JobSort::Memory if job.state.is_final() => job.metrics.memory_peak,
JobSort::Run | JobSort::Memory => None,
}
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum SortOrder {
#[default]
Desc,
Asc,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum RecordFilter {
Any,
Kept,
Removed,
Skipped,
}
impl RecordFilter {
pub fn admits(self, mark: Option<RecordMark>) -> bool {
match (self, mark) {
(RecordFilter::Any, mark) => mark.is_some(),
(RecordFilter::Kept, Some(RecordMark::Kept))
| (RecordFilter::Removed, Some(RecordMark::Removed))
| (RecordFilter::Skipped, Some(RecordMark::Skipped)) => true,
_ => false,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum RecordMark {
Kept,
Removed,
Skipped,
#[serde(other)]
Unknown,
}
impl RecordMark {
pub fn of(note: &RecordNote) -> RecordMark {
match note.state() {
RecordState::Skipped { .. } => RecordMark::Skipped,
RecordState::Removed { .. } | RecordState::Gone { .. } => RecordMark::Removed,
RecordState::Kept { .. } => RecordMark::Kept,
}
}
pub fn words(self) -> Option<&'static str> {
match self {
RecordMark::Kept => Some("record kept"),
RecordMark::Removed => Some("record removed"),
RecordMark::Skipped => Some("no record"),
RecordMark::Unknown => None,
}
}
pub fn tone(self) -> Tone {
match self {
RecordMark::Kept => Tone::Neutral,
RecordMark::Removed | RecordMark::Skipped | RecordMark::Unknown => Tone::Quiet,
}
}
}
impl RecordFilter {
pub const ALL: [RecordFilter; 4] = [
RecordFilter::Any,
RecordFilter::Kept,
RecordFilter::Removed,
RecordFilter::Skipped,
];
pub fn words(self) -> &'static str {
match self {
RecordFilter::Any => "any record",
RecordFilter::Kept => "record kept",
RecordFilter::Removed => "record removed",
RecordFilter::Skipped => "no record",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct JobOrder {
pub sort: JobSort,
pub order: SortOrder,
}
impl JobOrder {
pub const NEWEST: JobOrder = JobOrder {
sort: JobSort::Queued,
order: SortOrder::Desc,
};
pub const ALL: [JobOrder; 8] = [
JobOrder::NEWEST,
JobOrder::of_sort(JobSort::Wait, SortOrder::Desc),
JobOrder::of_sort(JobSort::Run, SortOrder::Desc),
JobOrder::of_sort(JobSort::Memory, SortOrder::Desc),
JobOrder::of_sort(JobSort::Queued, SortOrder::Asc),
JobOrder::of_sort(JobSort::Wait, SortOrder::Asc),
JobOrder::of_sort(JobSort::Run, SortOrder::Asc),
JobOrder::of_sort(JobSort::Memory, SortOrder::Asc),
];
const fn of_sort(sort: JobSort, order: SortOrder) -> JobOrder {
JobOrder { sort, order }
}
pub fn of(query: &JobQuery) -> JobOrder {
JobOrder {
sort: query.sort.unwrap_or(JobSort::Queued),
order: query.order.unwrap_or_default(),
}
}
pub fn pages(self) -> bool {
self == JobOrder::NEWEST
}
pub fn words(self) -> &'static str {
match (self.sort, self.order) {
(JobSort::Queued, SortOrder::Desc) => "newest first",
(JobSort::Queued, SortOrder::Asc) => "oldest first",
(JobSort::Wait, SortOrder::Desc) => "longest wait first",
(JobSort::Wait, SortOrder::Asc) => "shortest wait first",
(JobSort::Run, SortOrder::Desc) => "longest run first",
(JobSort::Run, SortOrder::Asc) => "shortest run first",
(JobSort::Memory, SortOrder::Desc) => "largest memory peak first",
(JobSort::Memory, SortOrder::Asc) => "smallest memory peak first",
}
}
pub fn apply(self, query: &mut JobQuery) {
let default = self.pages();
query.sort = (!default).then_some(self.sort);
query.order = (!default).then_some(self.order);
if !default {
query.before = None;
}
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub enum JobRange {
Day,
Week,
Month,
#[default]
All,
}
impl JobRange {
pub const ALL: [JobRange; 4] = [
JobRange::Day,
JobRange::Week,
JobRange::Month,
JobRange::All,
];
pub fn words(self) -> &'static str {
match self {
JobRange::Day => "last 24 hours",
JobRange::Week => "last 7 days",
JobRange::Month => "last 30 days",
JobRange::All => "all kept",
}
}
pub fn since(self, now: u64) -> Option<u64> {
let days = match self {
JobRange::Day => 1,
JobRange::Week => 7,
JobRange::Month => 30,
JobRange::All => return None,
};
Some(now.saturating_sub(days * 24 * 3600))
}
pub fn timeline(self, now: u64) -> super::TimelineQuery {
let longest = now.saturating_sub(super::TIMELINE_WINDOW_MAX);
super::TimelineQuery {
since: Some(self.since(now).map_or(longest, |since| since.max(longest))),
until: None,
}
}
}
impl JobQuery {
pub fn check(&self) -> Result<(), String> {
if let Some(q) = &self.q {
if q.is_empty() || q.len() > JOB_SEARCH_MAX {
return Err(format!(
"a search is 1 to {JOB_SEARCH_MAX} bytes; leave q out to list every job"
));
}
if q.chars().any(char::is_control) {
return Err("a search has no control characters".to_owned());
}
}
if self.cursor.is_some() {
return Err(
"a sorted list is one page, its first jobs; narrow it with a search or the filters"
.to_owned(),
);
}
if self.before.is_some() && !self.pages() {
return Err(
"before pages the list newest first; a sorted list is one page, which a search or the filters \
narrow"
.to_owned(),
);
}
Ok(())
}
pub fn pages(&self) -> bool {
self.sort.is_none_or(|sort| sort == JobSort::Queued)
&& self.order.unwrap_or_default() == SortOrder::Desc
}
pub fn page_size(&self) -> u32 {
self.limit
.unwrap_or(JOBS_PAGE_DEFAULT)
.clamp(1, JOBS_PAGE_MAX)
}
pub fn admits(&self, job: &JobSummary) -> bool {
let equal = |want: &Option<String>, have: Option<&str>| {
want.as_deref().is_none_or(|want| have == Some(want))
};
let queued = job.timeline.queued_at;
equal(&self.repository, Some(&job.repository))
&& self.state.is_none_or(|state| state == job.state)
&& equal(&self.conclusion, job.conclusion.as_deref())
&& equal(&self.workflow, job.workflow.as_deref())
&& equal(&self.name, Some(&job.name))
&& equal(&self.branch, job.branch.as_deref())
&& self.since.is_none_or(|since| queued >= since)
&& self.until.is_none_or(|until| queued < until)
&& self
.record
.is_none_or(|record| record.admits(job.record_mark))
&& self.q.as_deref().is_none_or(|q| {
let q = q.to_ascii_lowercase();
[
Some(job.name.as_str()),
job.workflow.as_deref(),
job.branch.as_deref(),
]
.into_iter()
.flatten()
.any(|text| text.to_ascii_lowercase().contains(&q))
})
}
fn order(&self, jobs: &mut [&JobSummary]) {
let order = self.order.unwrap_or_default();
let by_id = |a: &JobSummary, b: &JobSummary| match order {
SortOrder::Desc => b.id.cmp(&a.id),
SortOrder::Asc => a.id.cmp(&b.id),
};
match self.sort.unwrap_or(JobSort::Queued) {
JobSort::Queued => jobs.sort_by(|a, b| by_id(a, b)),
sort => jobs.sort_by(|a, b| {
let keyed = match (sort.key(a), sort.key(b)) {
(Some(a_key), Some(b_key)) => match order {
SortOrder::Desc => b_key.cmp(&a_key),
SortOrder::Asc => a_key.cmp(&b_key),
},
(a_key, b_key) => a_key.is_none().cmp(&b_key.is_none()),
};
keyed.then_with(|| by_id(a, b))
}),
}
}
pub fn page(&self, jobs: &[JobSummary]) -> Result<JobList, String> {
self.check()?;
let mut listed: Vec<&JobSummary> = jobs
.iter()
.filter(|job| self.admits(job))
.filter(|job| self.before.is_none_or(|before| job.id < before))
.collect();
self.order(&mut listed);
let size = usize::try_from(self.page_size()).unwrap_or(usize::MAX);
let mut page = Vec::new();
let mut shortened = Vec::new();
let mut bytes = 0;
for job in listed.iter().take(size) {
let (shown, cut) = listed_text(job);
let row = row_bytes(&shown);
if !page.is_empty() && bytes + row > JOBS_PAGE_BYTES {
break;
}
bytes += row;
if cut {
shortened.push(shown.id);
}
page.push(shown);
}
let total = u64::try_from(listed.len()).unwrap_or(u64::MAX);
let more = listed.len() > page.len();
Ok(self.answer(page, more, total, shortened))
}
pub fn answer(
&self,
jobs: Vec<JobSummary>,
more: bool,
total: u64,
shortened: Vec<u64>,
) -> JobList {
let pages = self.pages();
let next = jobs.last().filter(|_| more && pages).map(|last| last.id);
let mut applied = self.clone();
applied.limit = Some(self.page_size());
applied.order = Some(self.order.unwrap_or_default());
JobList {
page: JobPage { jobs, next },
total: (!pages).then_some(total),
shortened,
applied: Some(applied),
}
}
}
fn cut(text: &str) -> &str {
&text[..text.floor_char_boundary(JOB_TEXT_MAX)]
}
fn listed_text(job: &JobSummary) -> (JobSummary, bool) {
let cut_option = |text: &Option<String>| text.as_deref().map(|text| cut(text).to_owned());
let labels_fit = labels_bytes(&job.labels) <= JOB_LABELS_MAX;
let listed = JobSummary {
repository: cut(&job.repository).to_owned(),
name: cut(&job.name).to_owned(),
workflow: cut_option(&job.workflow),
branch: cut_option(&job.branch),
url: cut_option(&job.url),
labels: if labels_fit {
job.labels.clone()
} else {
Vec::new()
},
..job.clone()
};
let shortened = !labels_fit || row_bytes(&listed) != row_bytes(job);
(listed, shortened)
}
fn labels_bytes(labels: &[String]) -> usize {
2 + labels.len().saturating_sub(1)
+ labels
.iter()
.map(|label| json_string_len(label))
.sum::<usize>()
}
pub fn row_bytes(job: &JobSummary) -> u64 {
let text = |text: Option<&str>| text.map_or(0, str::len);
u64::try_from(
job.repository.len()
+ text(job.workflow.as_deref())
+ job.name.len()
+ text(job.branch.as_deref())
+ text(job.url.as_deref())
+ labels_bytes(&job.labels),
)
.unwrap_or(u64::MAX)
}
fn json_string_len(text: &str) -> usize {
2 + text
.chars()
.map(|character| match character {
'"' | '\\' | '\n' | '\r' | '\t' | '\u{8}' | '\u{c}' => 2,
control if u32::from(control) < 0x20 => 6,
other => other.len_utf8(),
})
.sum::<usize>()
}
impl JobList {
pub fn understood(&self) -> bool {
self.applied.is_some()
}
pub fn unread_words(&self) -> Option<String> {
(!self.understood()).then(|| {
format!(
"{}; this is every job, newest first",
crate::api::Feature::JobSearch.unsupported()
)
})
}
pub fn shown_line(&self) -> Option<String> {
self.shown_words()
.map(|shown| format!("{shown}; a search or the filters narrow it"))
}
pub fn none_words() -> &'static str {
"no jobs match"
}
pub fn shown_words(&self) -> Option<String> {
let total = self.total?;
let shown = u64::try_from(self.page.jobs.len()).unwrap_or(u64::MAX);
if shown >= total {
return None;
}
let query = self.applied.as_ref()?;
Some(format!(
"{shown} of {total} jobs, {}",
JobOrder::of(query).words()
))
}
}
#[cfg(test)]
#[cfg(any(feature = "host", feature = "client"))]
mod tests;