use super::disposable::DisposableList;
use crate::layer0::fiber_transitions::{self as lifecycle, FiberBypass};
pub use crate::layer0::fiber_transitions::FiberState;
use dashmap::DashMap;
use std::any::Any;
use std::collections::HashSet;
use std::sync::{Arc, Mutex};
pub struct FiberTable {
pub profile: &'static str,
pub valid: fn(&FiberState, &FiberState) -> bool,
pub allowed: &'static [(&'static str, &'static [&'static str])],
pub bypasses: &'static [FiberBypass],
}
pub const TABLE: FiberTable = FiberTable {
profile: lifecycle::PROFILE,
valid: lifecycle::valid_transition,
allowed: lifecycle::PUBLISHED_TRANSITIONS,
bypasses: lifecycle::BYPASSES,
};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FiberEvent {
pub to: FiberState,
pub bypass: Option<&'static FiberBypass>,
}
impl FiberEvent {
pub fn to(to: FiberState) -> Self {
Self { to, bypass: None }
}
pub fn bypass(bypass: &'static FiberBypass, to: FiberState) -> Self {
Self { to, bypass: Some(bypass) }
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FiberEffect {
UnwindDisposables,
}
const NO_EFFECTS: &[FiberEffect] = &[];
const UNWIND: &[FiberEffect] = &[FiberEffect::UnwindDisposables];
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Moved {
pub state: FiberState,
pub effects: &'static [FiberEffect],
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Illegal {
pub profile: &'static str,
pub from: FiberState,
pub to: FiberState,
pub allowed: &'static [&'static str],
}
impl std::fmt::Display for Illegal {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
"illegal fiber transition {} -> {} under the {} profile; allowed targets: {:?}",
self.from.published_name(),
self.to.published_name(),
self.profile,
self.allowed
)
}
}
#[inline]
pub fn step(table: &FiberTable, state: &FiberState, event: FiberEvent) -> Result<Moved, Illegal> {
let FiberEvent { to, bypass } = event;
let effects = if let Some(bypass) = bypass {
let fires = table.bypasses.contains(bypass)
&& bypass.sources.contains(&state.name())
&& bypass.targets.contains(&to.name());
fires.then_some(if bypass.drains { UNWIND } else { NO_EFFECTS })
} else {
(table.valid)(state, &to).then_some(NO_EFFECTS)
};
let Some(effects) = effects else {
let allowed = table
.allowed
.iter()
.find(|(from, _)| *from == state.published_name())
.map_or(NO_TARGETS, |(_, targets)| *targets);
return Err(Illegal { profile: table.profile, from: state.clone(), to, allowed });
};
Ok(Moved { state: to, effects })
}
fn store(state: &mut FiberState, event: FiberEvent) -> Result<&'static [FiberEffect], Illegal> {
let moved = step(&TABLE, state, event)?;
*state = moved.state;
Ok(moved.effects)
}
const NO_TARGETS: &[&str] = &[];
const DISPOSAL_ERRORS: &str = "Disposal errors encountered";
pub struct Fiber {
pub id: String,
state: Mutex<FiberState>,
pub required_coeffects: HashSet<String>,
pub satisfied_coeffects: Mutex<HashSet<String>>,
pub disposables: Mutex<DisposableList>,
pub clm_ast: Mutex<Option<serde_json::Value>>,
}
impl Fiber {
pub fn new(id: impl Into<String>, required_coeffects: Vec<String>) -> Self {
let coeffects_set: HashSet<String> = required_coeffects.into_iter().collect();
Self {
id: id.into(),
state: Mutex::new(lifecycle::initial_state(coeffects_set.is_empty())),
required_coeffects: coeffects_set,
satisfied_coeffects: Mutex::new(HashSet::new()),
disposables: Mutex::new(DisposableList::new()),
clm_ast: Mutex::new(None),
}
}
pub fn profile(&self) -> &'static str {
TABLE.profile
}
fn fire(&self, event: FiberEvent) -> Result<&'static [FiberEffect], Illegal> {
store(&mut self.state.lock().unwrap(), event)
}
pub fn try_activate(&self) -> bool {
let mut state = self.state.lock().unwrap();
if *state != FiberState::Pending && *state != FiberState::Loading {
return *state == FiberState::Active;
}
let satisfied = self.satisfied_coeffects.lock().unwrap();
self.required_coeffects.is_subset(&satisfied)
&& store(&mut state, FiberEvent::to(FiberState::Active)).is_ok()
}
pub fn satisfy_coeffect(&self, coeffect: &str) -> bool {
self.satisfied_coeffects.lock().unwrap().insert(coeffect.to_string());
self.try_activate()
}
pub fn register_disposable<F>(&self, cleanup: F)
where
F: FnOnce() -> Result<(), String> + Send + 'static,
{
self.disposables.lock().unwrap().push(cleanup);
}
pub fn transition_to(&self, new_state: FiberState) -> Result<(), String> {
self.fire(FiberEvent::to(new_state)).map(drop).map_err(|refused| refused.to_string())
}
pub fn get_state(&self) -> FiberState {
self.state.lock().unwrap().clone()
}
pub fn pause(&self) -> Result<(), String> {
self.transition_to(FiberState::Paused)
}
pub fn activate(&self) -> Result<(), String> {
self.transition_to(FiberState::Active)
}
pub fn suspend(&self) -> Result<(), String> {
self.transition_to(FiberState::Suspended)
}
pub fn resume(&self) -> Result<(), String> {
self.transition_to(FiberState::Active)
}
pub fn unwind_disposables(&self) -> Result<(), Vec<String>> {
let disposers = std::mem::take(&mut *self.disposables.lock().unwrap());
disposers.dispose()
}
pub fn set_ast(&self, ast: serde_json::Value) {
*self.clm_ast.lock().unwrap() = Some(ast);
}
pub fn get_ast(&self) -> Option<serde_json::Value> {
self.clm_ast.lock().unwrap().clone()
}
pub fn dispose(&self) -> Result<(), Vec<String>> {
let fired = self.fire(FiberEvent::bypass(&lifecycle::RUST_DISPOSE, FiberState::Unloading));
if let Err(refused) = &fired {
if refused.from == FiberState::Disposed {
return Ok(());
}
}
let effects = fired.map_err(|refused| vec![refused.to_string()])?;
let unwound = if effects.contains(&FiberEffect::UnwindDisposables) {
self.unwind_disposables()
} else {
Ok(())
};
let end = if unwound.is_ok() {
FiberState::Disposed
} else {
FiberState::Failed(DISPOSAL_ERRORS.to_string())
};
let sealed = self.fire(FiberEvent::to(end)).map(drop).map_err(|refused| vec![refused.to_string()]);
unwound.and(sealed)
}
}
pub type IdSource = Arc<dyn Fn() -> String + Send + Sync>;
#[derive(Clone)]
pub struct Context {
pub scope_id: String,
pub services: Arc<DashMap<String, Arc<dyn Any + Send + Sync>>>,
pub fibers: Arc<DashMap<String, Arc<Fiber>>>,
ids: IdSource,
}
impl Context {
pub fn root() -> Self {
Self::root_with_ids(Arc::new(crate::utils::clock_hex_id))
}
pub fn root_with_ids(ids: IdSource) -> Self {
Self {
scope_id: "root".to_string(),
services: Arc::new(DashMap::new()),
fibers: Arc::new(DashMap::new()),
ids,
}
}
pub fn fresh_id(&self) -> String {
(self.ids)()
}
pub fn user(&self, did: &str) -> Self {
Self {
scope_id: format!("{}/user:{}", self.scope_id, did),
services: self.services.clone(),
fibers: self.fibers.clone(),
ids: self.ids.clone(),
}
}
pub fn channel(&self, channel_id: &str) -> Self {
Self {
scope_id: format!("{}/channel:{}", self.scope_id, channel_id),
services: self.services.clone(),
fibers: self.fibers.clone(),
ids: self.ids.clone(),
}
}
pub fn isolate(&self, allowed_coeffects: &[&str]) -> Self {
let isolated_services = Arc::new(DashMap::new());
let allowed_set: HashSet<&str> = allowed_coeffects.iter().copied().collect();
for entry in self.services.iter() {
if allowed_set.contains(entry.key().as_str()) {
isolated_services.insert(entry.key().clone(), entry.value().clone());
}
}
Self {
scope_id: format!("{}/isolate:{}", self.scope_id, self.fresh_id()),
services: isolated_services,
fibers: Arc::new(DashMap::new()),
ids: self.ids.clone(),
}
}
pub fn mask(&self, denied_coeffects: &[&str]) -> Self {
let masked_services = Arc::new(DashMap::new());
let denied_set: HashSet<&str> = denied_coeffects.iter().copied().collect();
for entry in self.services.iter() {
if !denied_set.contains(entry.key().as_str()) {
masked_services.insert(entry.key().clone(), entry.value().clone());
}
}
Self {
scope_id: format!("{}/mask:{}", self.scope_id, self.fresh_id()),
services: masked_services,
fibers: Arc::new(DashMap::new()),
ids: self.ids.clone(),
}
}
pub fn require(&self, coeffect: &str) -> bool {
self.services.contains_key(coeffect)
}
pub fn provide<T: Send + Sync + 'static>(&self, name: &str, service: T) {
self.register_service(name, service);
}
pub fn register_service<T: Send + Sync + 'static>(&self, name: &str, service: T) {
self.services.insert(name.to_string(), Arc::new(service));
for fiber in self.fibers.iter() {
if fiber.required_coeffects.contains(name) {
fiber.satisfy_coeffect(name);
}
}
}
pub fn get_service<T: Send + Sync + 'static>(&self, name: &str) -> Option<Arc<T>> {
self.services
.get(name)
.and_then(|any_arc| any_arc.clone().downcast::<T>().ok())
}
#[cfg(any(feature = "native", feature = "db"))]
pub fn mount_mcard_fs(&self, fs: crate::mcard_fs::MCardFileSystem) {
self.provide("mcard_fs", fs);
}
#[cfg(any(feature = "native", feature = "db"))]
pub fn mcard_fs(&self) -> Option<Arc<crate::mcard_fs::MCardFileSystem>> {
self.get_service::<crate::mcard_fs::MCardFileSystem>("mcard_fs")
}
#[cfg(any(feature = "native", feature = "db"))]
pub fn mount_ephemeral_mcard_fs(
&self,
fiber_id: &str,
prefix: &str,
) -> Result<crate::mcard_fs::MCardFileSystem, String> {
let fs = self.mcard_fs().ok_or_else(|| "mcard_fs service not mounted in context".to_string())?;
let fiber = self.get_fiber(fiber_id).ok_or_else(|| format!("fiber '{}' not found", fiber_id))?;
fs.ephemeral_mount(&fiber, prefix)
.map_err(|e| e.to_string())
}
pub fn spawn_fiber(&self, id: &str, required_coeffects: Vec<String>) -> Arc<Fiber> {
let fiber = Arc::new(Fiber::new(id, required_coeffects));
for coeffect in &fiber.required_coeffects {
if self.services.contains_key(coeffect) {
fiber.satisfy_coeffect(coeffect);
}
}
self.fibers.insert(id.to_string(), fiber.clone());
fiber
}
pub fn get_fiber(&self, id: &str) -> Option<Arc<Fiber>> {
self.fibers.get(id).map(|f| f.clone())
}
pub fn list_fibers(&self) -> Vec<Arc<Fiber>> {
self.fibers.iter().map(|entry| entry.value().clone()).collect()
}
pub fn create_fiber(&self, id: &str, required_coeffects: Vec<String>) -> Result<Arc<Fiber>, String> {
Ok(self.spawn_fiber(id, required_coeffects))
}
pub fn remove_fiber(&self, id: &str) -> Option<Arc<Fiber>> {
self.fibers.remove(id).map(|(_, f)| f)
}
pub fn dispose(&self) -> Result<(), Vec<String>> {
let mut errors = Vec::new();
for fiber in self.fibers.iter() {
if let Err(mut e) = fiber.dispose() {
errors.append(&mut e);
}
}
if errors.is_empty() {
Ok(())
} else {
Err(errors)
}
}
}
#[cfg(test)]
#[path = "context_tests.rs"]
mod tests;