use std::time::{Duration, SystemTime};
use tokio::time::Instant;
use crate::admission::Key;
use super::Purpose;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Origin {
Started {
purpose: Purpose,
behind: Option<u64>,
},
Adopted(Adoption),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Adoption {
Unknown,
Waited,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Listed {
Idle,
Unlisted,
Busy,
NewlyBusy(Mark),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(super) struct Mark {
pub(super) listing: u64,
pub(super) at: Instant,
}
impl Mark {
pub(super) fn ends(self, claim: Mark, floor: Duration) -> bool {
self.listing > claim.listing && self.at >= claim.at + floor
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct TakenJob {
id: u64,
found_at: Option<SystemTime>,
}
#[derive(Debug, Clone)]
pub(super) struct Engagement {
origin: Origin,
listing: Listed,
job: Option<TakenJob>,
key: Option<Key>,
cancel_by: Option<Instant>,
}
impl Engagement {
pub(super) fn started(purpose: Purpose, behind: Option<u64>) -> Self {
Self {
origin: Origin::Started { purpose, behind },
listing: Listed::Idle,
job: None,
key: None,
cancel_by: None,
}
}
pub(super) fn adopted(job: Option<u64>, cancel_by: Option<Instant>) -> Self {
Self {
origin: Origin::Adopted(Adoption::Unknown),
listing: Listed::Unlisted,
job: job.map(|id| TakenJob { id, found_at: None }),
key: None,
cancel_by,
}
}
pub(super) fn queued_listed(&mut self, listing: Mark, floor: Duration) {
if let Listed::NewlyBusy(mark) = self.listing
&& listing.ends(mark, floor)
{
self.listing = Listed::Busy;
}
}
pub(super) fn listed(&mut self, busy: bool, mark: Mark) {
self.listing = match (busy, self.listing) {
(false, _) => Listed::Idle,
(true, Listed::Idle | Listed::Unlisted) => Listed::NewlyBusy(mark),
(true, listed @ (Listed::Busy | Listed::NewlyBusy(_))) => listed,
};
if let Origin::Adopted(adoption) = &mut self.origin
&& !busy
&& self.job.is_none()
{
*adoption = Adoption::Waited;
}
}
pub(super) fn kept_busy(&mut self, mark: Mark) {
self.listing = match self.listing {
Listed::Idle => Listed::NewlyBusy(mark),
listed @ (Listed::Busy | Listed::NewlyBusy(_) | Listed::Unlisted) => listed,
};
}
pub(super) fn found(&mut self, job: u64, at: SystemTime) {
self.job = Some(TakenJob {
id: job,
found_at: Some(at),
});
}
pub(super) fn named_by_worker_log(&mut self, job: u64) {
if !self.runs(job) {
self.job = Some(TakenJob {
id: job,
found_at: None,
});
}
}
pub(super) fn keyed(&mut self, key: Key) {
self.key = Some(key);
}
pub(super) fn cancelled(&mut self, deadline: Instant) {
self.cancel_by = Some(deadline);
}
pub(super) fn listed_busy(&self) -> bool {
self.listing != Listed::Idle
}
pub(super) fn named_job(&self) -> Option<u64> {
self.job.map(|job| job.id)
}
pub(super) fn runs(&self, job: u64) -> bool {
self.named_job() == Some(job)
}
pub(super) fn engaged(&self) -> bool {
self.listed_busy() || self.job.is_some()
}
pub(super) fn claims_a_listed_job(&self) -> bool {
matches!(self.listing, Listed::NewlyBusy(_)) && self.job.is_none()
}
pub(super) fn goes_when_detaching(&self) -> bool {
self.job.is_none() && (!self.listed_busy() || !self.was_started_here())
}
pub(super) fn was_started_here(&self) -> bool {
self.purpose().is_some()
}
pub(super) fn purpose(&self) -> Option<Purpose> {
match self.origin {
Origin::Started { purpose, .. } => Some(purpose),
Origin::Adopted(_) => None,
}
}
pub(super) fn job_found_here(&self) -> Option<SystemTime> {
let started_here = match self.origin {
Origin::Started { .. } | Origin::Adopted(Adoption::Waited) => true,
Origin::Adopted(Adoption::Unknown) => false,
};
self.job
.and_then(|job| job.found_at)
.filter(|_| started_here)
}
pub(super) fn behind(&self) -> Option<u64> {
match self.origin {
Origin::Started { behind, .. } => behind,
Origin::Adopted(_) => None,
}
}
pub(super) fn key(&self) -> Option<&Key> {
self.key.as_ref()
}
pub(super) fn cancel_overdue(&self, now: Instant) -> bool {
self.cancel_by.is_some_and(|deadline| deadline <= now)
}
}
#[cfg(test)]
impl Engagement {
pub(super) fn job_found_at(&self) -> Option<SystemTime> {
self.job.and_then(|job| job.found_at)
}
pub(super) fn found_job_at(&mut self, at: SystemTime) {
if let Some(job) = &mut self.job {
job.found_at = Some(at);
}
}
pub(super) fn age_job_start(&mut self, by: Duration) {
if let Some(TakenJob {
found_at: Some(at), ..
}) = &mut self.job
{
*at -= by;
}
}
pub(super) fn set_listed_busy(&mut self) {
self.count_busy();
}
pub(super) fn has_taken(&mut self, job: u64) {
self.job = Some(TakenJob {
id: job,
found_at: self.job.and_then(|job| job.found_at),
});
self.count_busy();
}
fn count_busy(&mut self) {
if self.listing == Listed::Idle {
self.listing = Listed::Busy;
}
}
pub(super) fn unname(&mut self) {
self.job = None;
self.key = None;
self.listing = Listed::Idle;
}
pub(super) fn set_key(&mut self, key: Key) {
self.key = Some(key);
}
pub(super) fn age_mark(&mut self, by: Duration) {
if let Listed::NewlyBusy(mark) = &mut self.listing
&& let Some(at) = mark.at.checked_sub(by)
{
mark.at = at;
}
}
pub(super) fn is_cancelling(&self) -> bool {
self.cancel_by.is_some()
}
pub(super) fn expire_cancel(&mut self, now: Instant) {
if self.cancel_by.is_some() {
self.cancel_by = Some(now);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
const POLL: Duration = Duration::from_secs(15);
fn mark(start: Instant, listing: u64, secs: u64) -> Mark {
Mark {
listing,
at: start + Duration::from_secs(secs),
}
}
fn newly_busy(start: Instant) -> Engagement {
let mut engagement = Engagement::started(Purpose::Job, None);
engagement.listed(true, mark(start, 1, 0));
assert!(engagement.claims_a_listed_job(), "listing 1 marks it");
engagement
}
#[test]
fn runners_listings_that_show_it_busy_again_leave_its_mark_as_it_was() {
let start = Instant::now();
let mut engagement = newly_busy(start);
for (listing, secs) in [(2, 5), (3, 10)] {
engagement.listed(true, mark(start, listing, secs));
engagement.queued_listed(mark(start, listing, secs), POLL);
assert!(
engagement.claims_a_listed_job(),
"listing {listing}, {secs} s after the mark, may still show its job"
);
}
engagement.listed(true, mark(start, 4, 15));
engagement.queued_listed(mark(start, 4, 15), POLL);
assert!(
!engagement.claims_a_listed_job(),
"the first listing a poll interval after the first mark ends the claim"
);
assert!(engagement.listed_busy(), "it stays busy");
}
#[test]
fn only_a_later_listing_ends_the_claim_however_late_it_answers() {
let start = Instant::now();
let mut engagement = newly_busy(start);
engagement.queued_listed(mark(start, 1, 60), POLL);
assert!(
engagement.claims_a_listed_job(),
"the listing that marked it may still show its job"
);
}
#[test]
fn github_saying_a_newly_busy_runner_is_busy_keeps_its_mark() {
let start = Instant::now();
let mut engagement = newly_busy(start);
engagement.kept_busy(mark(start, 3, 10));
engagement.queued_listed(mark(start, 4, 15), POLL);
assert!(
!engagement.claims_a_listed_job(),
"the claim ends a poll interval after the first mark, not the refused removal"
);
}
}