use std::{
collections::HashMap,
sync::{
Arc,
Mutex,
atomic::{
AtomicU32,
Ordering,
},
},
};
use crate::{
cas::CasEntry,
config::{
CasConfig,
ServiceConfig,
},
emmg::EmmgListeners,
error::Error,
event::{
CasStatus,
EmmgPortStatus,
},
lock_ext::MutexExt,
service::Service,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub struct CasRef(u32);
impl CasRef {
#[cfg(test)]
pub fn new(id: u32) -> Self {
Self(id)
}
}
#[derive(Clone)]
pub struct Simulcrypt {
inner: Arc<Inner>,
}
impl Default for Simulcrypt {
fn default() -> Self {
Self::new()
}
}
pub struct Inner {
next_cas_id: AtomicU32,
cas_by_config_id: Mutex<HashMap<String, CasRef>>,
cas: Mutex<HashMap<CasRef, Arc<CasEntry>>>,
leases: Mutex<HashMap<CasRef, usize>>,
emmg: EmmgListeners,
pub topology: Mutex<()>,
}
#[must_use = "the CAS is removed when the lease drops"]
pub struct CasLease {
inner: Arc<Inner>,
cas: CasRef,
}
impl CasLease {
#[must_use]
pub fn cas(&self) -> CasRef {
self.cas
}
}
impl std::fmt::Debug for CasLease {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_tuple("CasLease").field(&self.cas).finish()
}
}
impl Drop for CasLease {
fn drop(&mut self) {
let _topology = self.inner.topology.lock_or_recover();
let mut leases = self.inner.leases.lock_or_recover();
let Some(count) = leases.get_mut(&self.cas) else {
return;
};
*count -= 1;
if *count > 0 {
return;
}
leases.remove(&self.cas);
drop(leases);
let Some(entry) = self.inner.cas.lock_or_recover().remove(&self.cas) else {
return;
};
self.inner
.cas_by_config_id
.lock_or_recover()
.retain(|_, cas_ref| *cas_ref != self.cas);
entry.detach(&self.inner.emmg, self.cas);
}
}
impl Inner {
pub fn cas_entry(&self, cas_ref: CasRef) -> Result<Arc<CasEntry>, Error> {
self.cas
.lock_or_recover()
.get(&cas_ref)
.cloned()
.ok_or(Error::UnknownCas)
}
}
impl Simulcrypt {
#[must_use]
pub fn new() -> Self {
Self {
inner: Arc::new(Inner {
next_cas_id: AtomicU32::new(0),
cas_by_config_id: Mutex::new(HashMap::new()),
cas: Mutex::new(HashMap::new()),
leases: Mutex::new(HashMap::new()),
emmg: EmmgListeners::default(),
topology: Mutex::new(()),
}),
}
}
pub fn acquire_cas(&self, cfg: CasConfig) -> Result<CasLease, Error> {
let _topology = self.inner.topology.lock_or_recover();
let cas = self.upsert(cfg)?;
*self.inner.leases.lock_or_recover().entry(cas).or_default() += 1;
Ok(CasLease {
inner: Arc::clone(&self.inner),
cas,
})
}
fn upsert(&self, cfg: CasConfig) -> Result<CasRef, Error> {
let existing = self
.inner
.cas_by_config_id
.lock_or_recover()
.get(&cfg.id)
.copied();
if let Some(cas_ref) = existing {
self.inner
.cas_entry(cas_ref)?
.update(&self.inner.emmg, cas_ref, cfg)?;
return Ok(cas_ref);
}
let emmg = match &cfg.emmg {
Some(emmg) => Some(self.inner.emmg.register(&cfg, emmg)?),
None => None,
};
let cas_ref = CasRef(self.inner.next_cas_id.fetch_add(1, Ordering::Relaxed));
let config_id = cfg.id.clone();
let entry = CasEntry::new(cfg, emmg);
self.inner
.cas
.lock_or_recover()
.insert(cas_ref, Arc::clone(&entry));
self.inner
.cas_by_config_id
.lock_or_recover()
.insert(config_id, cas_ref);
entry.ensure_running(cas_ref);
Ok(cas_ref)
}
pub fn open_service(&self, cfg: &ServiceConfig) -> Result<Service, Error> {
Service::open(&self.inner, cfg)
}
#[must_use]
pub fn status(&self) -> Vec<CasStatus> {
let entries: Vec<_> = self
.inner
.cas
.lock_or_recover()
.iter()
.map(|(cas, entry)| (*cas, Arc::clone(entry)))
.collect();
entries
.into_iter()
.map(|(cas, entry)| entry.status(cas))
.collect()
}
#[cfg(test)]
pub fn entry(&self, cas: CasRef) -> Arc<CasEntry> {
self.inner.cas_entry(cas).expect("registered CAS")
}
#[must_use]
pub fn emmg_status(&self) -> Vec<EmmgPortStatus> {
self.inner.emmg.status()
}
}