use rusqlite::{Connection, params};
use super::read;
use crate::api;
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct RunJobs {
pub jobs: Vec<api::JobSummary>,
pub more: bool,
}
pub(super) fn run_jobs(
db: &Connection,
repository: &str,
run: u64,
except: u64,
limit: usize,
) -> rusqlite::Result<RunJobs> {
let mut statement = db.prepare_cached(
"SELECT id FROM jobs WHERE repository = ?1 AND run_id = ?2 AND id != ?3 \
ORDER BY run_attempt DESC, id LIMIT ?4",
)?;
let ids = statement
.query_map(
params![
repository,
run,
except,
i64::try_from(limit).unwrap_or(i64::MAX).saturating_add(1)
],
|row| row.get::<_, u64>(0),
)?
.collect::<rusqlite::Result<Vec<u64>>>()?;
let more = ids.len() > limit;
let mut jobs = Vec::new();
for id in ids.into_iter().take(limit) {
jobs.extend(read::summary(db, id)?);
}
Ok(RunJobs { jobs, more })
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RunnerFault {
pub job: u64,
pub repository: String,
pub run: u64,
pub attempt: u32,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Claim {
Claimed,
Taken,
Unstored,
}
#[derive(Debug)]
pub(super) struct ClaimKey {
pub(super) repository: String,
pub(super) run: u64,
pub(super) attempt: u32,
}
pub(super) const CLAIM_KEPT_MS: u64 = 24 * 60 * 60 * 1000;
const FAULTS_MAX: u32 = 500;
pub(super) fn runner_faults(db: &Connection, since: u64) -> rusqlite::Result<Vec<RunnerFault>> {
db.prepare_cached(
"SELECT id, repository, run_id, run_attempt FROM jobs WHERE runner_fault = 1 AND state = 'completed' \
AND rerun_at IS NULL AND run_id != 0 AND coalesce(finished_at, queued_at) >= ?1 AND NOT EXISTS \
(SELECT 1 FROM rerun_claims c WHERE c.repository = jobs.repository AND c.run_id = jobs.run_id \
AND c.attempt = jobs.run_attempt) ORDER BY id LIMIT ?2",
)?
.query_map(params![since, FAULTS_MAX], |row| {
Ok(RunnerFault {
job: row.get(0)?,
repository: row.get(1)?,
run: row.get(2)?,
attempt: row.get(3)?,
})
})?
.collect()
}