use super::context::{Context, Fiber, FiberState};
use dashmap::DashMap;
use sha2::{Digest, Sha256};
use std::any::Any;
use std::collections::HashSet;
use std::sync::{Arc, Mutex};
use std::time::Instant;
#[derive(Clone)]
pub struct CoeffectRequirement {
pub name: String,
pub optional: bool,
pub fallback: Option<Arc<dyn Any + Send + Sync>>,
}
impl CoeffectRequirement {
pub fn required(name: impl Into<String>) -> Self {
Self {
name: name.into(),
optional: false,
fallback: None,
}
}
pub fn optional_with_fallback(
name: impl Into<String>,
fallback: Arc<dyn Any + Send + Sync>,
) -> Self {
Self {
name: name.into(),
optional: true,
fallback: Some(fallback),
}
}
}
pub struct RegisteredFiberMeta {
pub spec_id: String,
pub fiber: Arc<Fiber>,
pub required: HashSet<String>,
pub optional: Vec<CoeffectRequirement>,
}
pub struct CoeffectBus {
pub context: Context,
fibers: Arc<DashMap<String, RegisteredFiberMeta>>,
pending_requirements: Arc<DashMap<String, HashSet<String>>>, lifecycle_errors: Mutex<Vec<String>>,
}
fn awaken(fiber: &Fiber) -> Result<(), String> {
fiber.transition_to(FiberState::Loading)?;
fiber.transition_to(FiberState::Active)
}
impl CoeffectBus {
pub fn new(context: Context) -> Self {
Self {
context,
fibers: Arc::new(DashMap::new()),
pending_requirements: Arc::new(DashMap::new()),
lifecycle_errors: Mutex::new(Vec::new()),
}
}
pub fn lifecycle_errors(&self) -> Vec<String> {
self.lifecycle_errors.lock().unwrap().clone()
}
fn note(&self, spec_id: &str, outcome: Result<(), String>) {
if let Err(error) = outcome {
self.lifecycle_errors.lock().unwrap().push(format!("{spec_id}: {error}"));
}
}
pub fn mount_service<T: Send + Sync + 'static>(&self, name: &str, service: Arc<T>) -> f64 {
let t0 = Instant::now();
self.context.services.insert(name.to_string(), service.clone());
for fiber in self.context.fibers.iter() {
if fiber.required_coeffects.contains(name) {
fiber.satisfy_coeffect(name);
}
}
if let Some((_, spec_ids)) = self.pending_requirements.remove(name) {
for spec_id in spec_ids {
if let Some(entry) = self.fibers.get(&spec_id) {
let meta = entry.value();
if meta.fiber.get_state() != FiberState::Pending {
continue;
}
let mut all_satisfied = true;
for req in &meta.required {
if !self.context.require(req) {
all_satisfied = false;
break;
}
}
if all_satisfied {
for opt in &meta.optional {
if !self.context.require(&opt.name) {
if let Some(ref fallback) = opt.fallback {
self.context.services.insert(opt.name.clone(), fallback.clone());
}
}
}
self.note(&spec_id, awaken(&meta.fiber));
} else {
for req in &meta.required {
if !self.context.require(req) {
self.pending_requirements
.entry(req.clone())
.or_default()
.insert(spec_id.clone());
}
}
}
}
}
}
let elapsed = t0.elapsed();
elapsed.as_secs_f64() * 1_000_000.0
}
pub fn unmount_service(&self, name: &str) -> Vec<Arc<Fiber>> {
self.context.services.remove(name);
let to_deactivate: Vec<(String, RegisteredFiberMeta)> = self
.fibers
.iter()
.filter(|e| e.value().required.contains(name) && e.value().fiber.get_state() == FiberState::Active)
.map(|e| {
let meta = e.value();
(
e.key().clone(),
RegisteredFiberMeta {
spec_id: meta.spec_id.clone(),
fiber: meta.fiber.clone(),
required: meta.required.clone(),
optional: meta.optional.clone(),
},
)
})
.collect();
let mut disposed = Vec::new();
for (spec_id, meta) in to_deactivate {
self.note(&spec_id, meta.fiber.dispose().map_err(|errors| errors.join("; ")));
disposed.push(meta.fiber.clone());
let fresh_id = format!("{}:rearmed:{}", meta.spec_id, self.context.fresh_id());
let fresh_fiber = Arc::new(Fiber::new(fresh_id, meta.required.iter().cloned().collect()));
self.pending_requirements
.entry(name.to_string())
.or_default()
.insert(spec_id.clone());
let new_meta = RegisteredFiberMeta {
spec_id: meta.spec_id.clone(),
fiber: fresh_fiber,
required: meta.required,
optional: meta.optional,
};
self.fibers.insert(spec_id, new_meta);
}
disposed
}
pub fn register_fiber(
&self,
spec_id: &str,
requirements: Vec<CoeffectRequirement>,
) -> Arc<Fiber> {
let mut required_set = HashSet::new();
let mut optional_list = Vec::new();
for req in requirements {
if req.optional {
optional_list.push(req);
} else {
required_set.insert(req.name);
}
}
let fiber = Arc::new(Fiber::new(spec_id, required_set.iter().cloned().collect()));
let meta = RegisteredFiberMeta {
spec_id: spec_id.to_string(),
fiber: fiber.clone(),
required: required_set.clone(),
optional: optional_list.clone(),
};
self.fibers.insert(spec_id.to_string(), meta);
let mut missing = Vec::new();
for req in &required_set {
if !self.context.require(req) {
missing.push(req.clone());
}
}
if !missing.is_empty() {
for m in missing {
self.pending_requirements
.entry(m)
.or_default()
.insert(spec_id.to_string());
}
return fiber;
}
for opt in &optional_list {
if !self.context.require(&opt.name) {
if let Some(ref fallback) = opt.fallback {
self.context.services.insert(opt.name.clone(), fallback.clone());
}
}
}
self.note(spec_id, awaken(&fiber));
fiber
}
pub fn get_fiber(&self, spec_id: &str) -> Option<Arc<Fiber>> {
self.fibers.get(spec_id).map(|e| e.fiber.clone())
}
pub fn compute_merkle_state_root(ctx: &Context) -> String {
let mut hasher = Sha256::new();
hasher.update(format!("scope:{}", ctx.scope_id).as_bytes());
let mut keys: Vec<String> = ctx.services.iter().map(|e| e.key().clone()).collect();
keys.sort();
for k in keys {
hasher.update(b"|svc:");
hasher.update(k.as_bytes());
}
hex::encode(hasher.finalize())
}
pub fn isolate_cut(&self, ctx: &Context, allowed: &[&str]) -> (Context, String) {
let child = ctx.isolate(allowed);
#[cfg(feature = "native")]
if let Some(pool) = child.get_service::<crate::services::sqlite_pool::InMemorySqlitePool>("sqlite_pool") {
let cloned = Arc::new(pool.clone_pool());
child.services.insert("sqlite_pool".to_string(), cloned);
}
let state_root = Self::compute_merkle_state_root(&child);
(child, state_root)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn awaken_refuses_a_disposed_fiber_and_leaves_it_disposed() {
let fiber = Fiber::new("gone", vec!["db".to_string()]);
fiber.dispose().unwrap();
let refused = awaken(&fiber).unwrap_err();
assert!(refused.starts_with("illegal fiber transition disposed -> loading"), "{refused}");
assert_eq!(fiber.get_state(), FiberState::Disposed);
}
#[test]
fn a_refused_activation_is_recorded_under_its_spec_id() {
let bus = CoeffectBus::new(Context::root());
let fiber = Fiber::new("gone", vec![]);
fiber.dispose().unwrap();
bus.note("live", awaken(&Fiber::new("live", vec!["db".to_string()])));
assert!(bus.lifecycle_errors().is_empty());
bus.note("gone", awaken(&fiber));
let errors = bus.lifecycle_errors();
assert_eq!(errors.len(), 1);
assert!(errors[0].starts_with("gone: illegal fiber transition disposed -> loading"), "{errors:?}");
}
}