jelq

//! The live runs. The table is only locked long enough to find a run, and each run has its own

//! lock, so one slow turn never holds up anyone else's.

use std::{

    collections::HashMap,

    sync::{Arc, Mutex, MutexGuard, PoisonError, RwLock, TryLockError},

    time::{Duration, Instant},

};

use crate::game::Run;

pub type Slot = Arc<Mutex<Run>>;

#[derive(Default)]

pub struct Registry {

    runs: RwLock<HashMap<String, Slot>>,

}

/// A panic mid-request must not take the run down with it, so a poisoned lock is recovered.

pub fn hold(slot: &Slot) -> MutexGuard<'_, Run> {

    slot.lock().unwrap_or_else(PoisonError::into_inner)

}

impl Registry {

    pub fn get(&self, id: &str) -> Option<Slot> {

        self.read().get(id).cloned()

    }

    pub fn len(&self) -> usize {

        self.read().len()

    }

    pub fn insert(&self, run: Run) {

        let id = run.id.clone();

        self.write().insert(id, Arc::new(Mutex::new(run)));

    }

    pub fn remove(&self, id: &str) {

        self.write().remove(id);

    }

    pub fn contains(&self, id: &str) -> bool {

        self.read().contains_key(id)

    }

    /// Every live run, each visited under its own lock.

    pub fn each<T>(&self, mut visit: impl FnMut(&Run) -> T) -> Vec<T> {

        let slots: Vec<Slot> = self.read().values().cloned().collect();

        slots.iter().map(|slot| visit(&hold(slot))).collect()

    }

    /// Takes out the runs nobody has touched for `ttl`, and hands them back for the record.

    pub fn evict_idle(&self, now: Instant, ttl: Duration) -> Vec<Slot> {

        let mut runs = self.write();

        let idle: Vec<String> = runs

            .iter()

            .filter(|(_, slot)| {

                let idle = |run: &Run| now.duration_since(run.last_seen) >= ttl;

                match slot.try_lock() {

                    Ok(run) => idle(&run),

                    Err(TryLockError::Poisoned(poisoned)) => idle(&poisoned.into_inner()),

                    Err(TryLockError::WouldBlock) => false,

                }

            })

            .map(|(id, _)| id.clone())

            .collect();

        idle.iter().filter_map(|id| runs.remove(id)).collect()

    }

    fn read(&self) -> std::sync::RwLockReadGuard<'_, HashMap<String, Slot>> {

        self.runs.read().unwrap_or_else(PoisonError::into_inner)

    }

    fn write(&self) -> std::sync::RwLockWriteGuard<'_, HashMap<String, Slot>> {

        self.runs.write().unwrap_or_else(PoisonError::into_inner)

    }

}