use std::collections::{BTreeMap, BTreeSet};
use std::time::Duration;
use tokio::time::Instant;
use super::RepositoryState;
const DRAIN_FAILING_FOR: Duration = Duration::from_hours(1);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(super) enum RunnersListing {
RateLimited,
Failed { gone: bool },
Answered { left: bool },
}
#[derive(Debug, Default)]
struct Drain {
clean_once: bool,
failing_since: Option<Instant>,
}
impl Drain {
fn on(&mut self, listing: RunnersListing) -> bool {
match listing {
RunnersListing::RateLimited => {
self.failing_since = None;
false
}
RunnersListing::Failed { gone } => {
let since = *self.failing_since.get_or_insert_with(Instant::now);
gone || since.elapsed() >= DRAIN_FAILING_FOR
}
RunnersListing::Answered { left } => {
self.failing_since = None;
if left {
self.clean_once = false;
return false;
}
let ended = self.clean_once;
self.clean_once = true;
ended
}
}
}
}
#[derive(Debug)]
enum Presence {
Listed(RepositoryState),
Draining(Drain),
}
impl Presence {
fn listed() -> Self {
Self::Listed(RepositoryState::default())
}
fn draining() -> Self {
Self::Draining(Drain::default())
}
}
#[derive(Debug)]
pub(super) struct Repositories(BTreeMap<String, Presence>);
impl Repositories {
pub(super) fn new(names: impl IntoIterator<Item = String>) -> Self {
Self(
names
.into_iter()
.map(|name| (name, Presence::listed()))
.collect(),
)
}
pub(super) fn listed(&self, name: &str) -> Option<&RepositoryState> {
match self.0.get(name) {
Some(Presence::Listed(state)) => Some(state),
Some(Presence::Draining(_)) | None => None,
}
}
pub(super) fn listed_mut(&mut self, name: &str) -> Option<&mut RepositoryState> {
match self.0.get_mut(name) {
Some(Presence::Listed(state)) => Some(state),
Some(Presence::Draining(_)) | None => None,
}
}
pub(super) fn iter_listed(&self) -> impl Iterator<Item = (&String, &RepositoryState)> {
self.0.iter().filter_map(|(name, presence)| match presence {
Presence::Listed(state) => Some((name, state)),
Presence::Draining(_) => None,
})
}
pub(super) fn iter_listed_mut(
&mut self,
) -> impl Iterator<Item = (&String, &mut RepositoryState)> {
self.0
.iter_mut()
.filter_map(|(name, presence)| match presence {
Presence::Listed(state) => Some((name, state)),
Presence::Draining(_) => None,
})
}
pub(super) fn listed_names(&self) -> impl Iterator<Item = &String> {
self.iter_listed().map(|(name, _)| name)
}
pub(super) fn is_known(&self, name: &str) -> bool {
self.0.contains_key(name)
}
pub(super) fn runners_to_list(&self) -> Vec<String> {
let draining = self.0.iter().filter_map(|(name, presence)| match presence {
Presence::Listed(_) => None,
Presence::Draining(_) => Some(name),
});
self.listed_names().chain(draining).cloned().collect()
}
pub(super) fn reload(&mut self, names: &BTreeSet<String>) {
for (name, presence) in &mut self.0 {
match (names.contains(name), &presence) {
(true, Presence::Draining(_)) => *presence = Presence::listed(),
(false, Presence::Listed(_)) => *presence = Presence::draining(),
(true, Presence::Listed(_)) | (false, Presence::Draining(_)) => {}
}
}
for name in names {
self.0.entry(name.clone()).or_insert_with(Presence::listed);
}
}
pub(super) fn found_running(&mut self, name: &str) {
self.0
.entry(name.to_owned())
.or_insert_with(Presence::draining);
}
pub(super) fn runners_listed(&mut self, name: &str, listing: RunnersListing) -> bool {
let Some(Presence::Draining(drain)) = self.0.get_mut(name) else {
return false;
};
let ended = drain.on(listing);
if ended {
self.0.remove(name);
}
ended
}
}