use std::collections::HashMap;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Mutex;
use std::time::{Duration, Instant};
use datumesh_core::Request;
use crate::envelope::Reply;
struct Job {
request: Request,
created: Instant,
result: Option<Reply>,
completed: Option<Instant>,
first_served: Option<Instant>,
}
pub(crate) enum Poll {
Running(Request, u64),
Done(Reply),
Unknown,
}
pub(crate) struct Jobs {
map: Mutex<HashMap<String, Job>>,
ttl: Duration,
max: usize,
ewma_ms: AtomicU64,
pub(crate) created: AtomicU64,
pub(crate) completed: AtomicU64,
}
impl Jobs {
pub(crate) fn new(ttl: Duration, max: usize) -> Jobs {
Jobs {
map: Mutex::new(HashMap::new()),
ttl,
max,
ewma_ms: AtomicU64::new(1000),
created: AtomicU64::new(0),
completed: AtomicU64::new(0),
}
}
fn lock(&self) -> std::sync::MutexGuard<'_, HashMap<String, Job>> {
self.map.lock().unwrap_or_else(|p| p.into_inner())
}
fn expired(&self, j: &Job, now: Instant) -> bool {
match (j.first_served, j.completed) {
(Some(s), _) => now.duration_since(s) > self.ttl,
(None, Some(c)) => now.duration_since(c) > self.ttl,
(None, None) => false,
}
}
pub(crate) fn create(&self, request: Request) -> Option<String> {
let mut b = [0u8; 32];
getrandom::fill(&mut b).ok()?;
let id = datumesh_core::lexical::to_hex(&b);
let now = Instant::now();
let mut m = self.lock();
if m.len() >= self.max {
m.retain(|_, j| !self.expired(j, now));
if m.len() >= self.max {
return None;
}
}
m.insert(id.clone(), Job { request, created: now, result: None, completed: None, first_served: None });
self.created.fetch_add(1, Ordering::Relaxed);
Some(id)
}
pub(crate) fn complete(&self, id: &str, reply: Reply) {
let now = Instant::now();
let mut m = self.lock();
if let Some(j) = m.get_mut(id) {
let ms = now.duration_since(j.created).as_millis() as u64;
let old = self.ewma_ms.load(Ordering::Relaxed);
self.ewma_ms.store((old * 3 + ms) / 4, Ordering::Relaxed);
j.result = Some(reply);
j.completed = Some(now);
self.completed.fetch_add(1, Ordering::Relaxed);
}
}
pub(crate) fn estimate(&self, elapsed: u64) -> u64 {
let mean = self.ewma_ms.load(Ordering::Relaxed).div_ceil(1000);
mean.saturating_sub(elapsed).max(1)
}
pub(crate) fn poll(&self, id: &str) -> Poll {
let now = Instant::now();
let mut m = self.lock();
let Some(j) = m.get_mut(id) else { return Poll::Unknown };
if self.expired(j, now) {
m.remove(id);
return Poll::Unknown;
}
match &j.result {
Some(r) => {
j.first_served.get_or_insert(now);
Poll::Done(r.clone())
}
None => Poll::Running(j.request.clone(), now.duration_since(j.created).as_secs()),
}
}
pub(crate) fn poll_peek(&self, id: &str) -> Poll {
let m = self.lock();
match m.get(id) {
None => Poll::Unknown,
Some(j) => match &j.result {
Some(r) => Poll::Done(r.clone()),
None => Poll::Running(j.request.clone(), j.created.elapsed().as_secs()),
},
}
}
pub(crate) fn counts(&self) -> (usize, usize) {
let m = self.lock();
(m.len(), m.values().filter(|j| j.result.is_none()).count())
}
}