use core::{any::Any, future::Future, marker::PhantomData, time::Duration};
use std::{any::TypeId, collections::HashMap, sync::Arc, time::Instant};
use agnostic_lite::RuntimeLite;
use smol_bytes::Utf8Bytes;
use crate::{
Driven, Yielded,
drive::{
Attributes, Cadence, Drained, Drives, Enrolled, Failure, ItemId, Keeper, Lifecycle,
LifecycleTap, NodeName, Outbox, Party, Registries, Registry, RegistryDriver, Resident,
Resources, RetiredMirror, RetiredStore, RootKey, Shutdown, Streams, Taps, Unruntimed,
engine::{Clock, Join, engage},
lane::block_on,
registry::driver,
},
};
use super::{
App, AsyncTeardown, Cell, Declared, Farewell, LaunchError, Mount, Posted,
resources::released,
shutdown::Ignited,
teardown::{collected, farewell},
wiring::LaneMount,
};
#[cfg(test)]
mod tests;
type Start = Box<dyn FnOnce() -> Box<dyn Any + Send> + Send>;
pub struct Ignition<R = Unruntimed> {
ctx: Arc<Resources>,
cadences: Vec<Cadence>,
clock: Clock,
shutdown: Shutdown,
taps: Taps,
registries: Arc<Registries>,
senders: Vec<Box<dyn Any + Send>>,
bodies: Vec<std::thread::JoinHandle<()>>,
tasks: Vec<Join>,
starts: Vec<Start>,
halts: Vec<crate::Stopper>,
teardowns: Vec<Farewell>,
feeders: HashMap<TypeId, Box<dyn Any + Send>>,
lanes: HashMap<TypeId, (Box<dyn Any + Send>, Enrolled)>,
origins: HashMap<TypeId, Box<dyn Any + Send>>,
runtime: PhantomData<fn() -> R>,
}
const UNWIND_PATIENCE: Duration = Duration::from_secs(5);
impl<R> Ignition<R> {
pub(super) fn new(
ctx: Arc<Resources>,
cadences: Vec<Cadence>,
clock: Clock,
shutdown: Shutdown,
taps: Taps,
registries: Arc<Registries>,
senders: Vec<Box<dyn Any + Send>>,
) -> Self {
Self {
ctx,
cadences,
clock,
shutdown,
taps,
registries,
senders,
bodies: Vec::new(),
tasks: Vec::new(),
starts: Vec::new(),
halts: Vec::new(),
teardowns: Vec::new(),
feeders: HashMap::new(),
lanes: HashMap::new(),
origins: HashMap::new(),
runtime: PhantomData,
}
}
fn window(&self, mount: &Utf8Bytes, shutdown: crate::ShutdownSignal) -> super::Context {
super::Context::new(mount.clone())
.sharing(Arc::clone(&self.ctx))
.halting(shutdown)
}
pub fn resident<O, W, A, L, C, S, I, M>(
&mut self,
resident: Resident<O, W, A, L, C, S, I, M>,
enrolled: Enrolled,
) -> Result<(), LaunchError>
where
Resident<O, W, A, L, C, S, I, M>: Drives + Send + 'static,
O: Driven<M>,
A: Attributes<<O as Driven<M>>::Out>,
{
let name = Utf8Bytes::from(resident.name().as_str().to_owned());
let (stopper, halt) = crate::shutdown_signal();
let mut resident = resident;
resident.set_shutdown(halt);
self.halts.push(stopper);
let ignited = enrolled.mark();
self.engine(&name, ignited, move || {
let mut resident = resident;
let _: Drained = resident.run();
drop(resident);
enrolled.settle();
})
}
pub fn resident_declared<O, W, A, L, C, S, I, M>(
&mut self,
resident: Resident<O, W, A, L, C, S, I, M>,
enrolled: Enrolled,
) -> Result<(), LaunchError>
where
Resident<O, W, A, L, C, S, I, M>: Drives + Send + 'static,
O: Driven<M> + Declared,
A: Attributes<<O as Driven<M>>::Out>,
{
let name = Utf8Bytes::from(resident.name().as_str().to_owned());
let (stopper, halt) = crate::shutdown_signal();
let mut resident = resident;
resident.set_shutdown(halt);
self.halts.push(stopper);
let ignited = enrolled.mark();
self.engine(&name, ignited, move || {
let mut resident = resident;
let _: Drained = resident.run();
if O::TEARDOWN {
let operator = resident.into_operator();
enrolled.settle_parked(move || O::goodbye(operator));
return;
}
drop(resident);
enrolled.settle();
})
}
pub fn autonomous_declared<N>(
&mut self,
helm: crate::Helm<N, <N as Declared>::Mode>,
stopper: crate::Stopper,
enrolled: Enrolled,
) -> Result<(), LaunchError>
where
N: Declared + crate::Runs<<N as Declared>::Mode> + Send + 'static,
<N as crate::Runs<<N as Declared>::Mode>>::In: Send + 'static,
<N as crate::Runs<<N as Declared>::Mode>>::Out: Send + 'static,
<N as crate::Runs<<N as Declared>::Mode>>::Error: core::error::Error + Send + Sync + 'static,
{
let named = Utf8Bytes::from(helm.name().as_str().to_owned());
let ignited = enrolled.mark();
let taps = self.taps.clone();
let reported = named.clone();
self.engine(&named, ignited, move || {
let ended = helm.run();
super::origin::observed(&taps, NodeName::new(reported.as_str()), ended);
enrolled.settle();
})?;
self.halts.push(stopper);
Ok(())
}
pub fn origin<S>(
&mut self,
name: &str,
source: S,
giving: crate::Feed<S::Yield>,
eating: crate::Control<<S::Mutation as crate::MutationNode>::Command>,
halt: crate::ShutdownSignal,
enrolled: Enrolled,
) -> Result<(), LaunchError>
where
S: crate::Source + Send + 'static,
S::Yield: Send,
<S::Mutation as crate::MutationNode>::Command: Send,
S::Error: core::error::Error + Send + Sync + 'static,
{
let named = Utf8Bytes::from(name.to_owned());
let ctx = self.window(&named, halt);
let ignited = enrolled.mark();
let taps = self.taps.clone();
let reported = named.clone();
self.engine(&named, ignited, move || {
let ended = super::origin::drive_origin(source, ctx, giving, eating);
super::origin::observed(&taps, NodeName::new(reported.as_str()), ended);
enrolled.settle();
})
}
pub fn awaited_origin<S>(
&mut self,
name: &str,
source: S,
giving: crate::Feed<S::Yield>,
eating: crate::Control<<S::Mutation as crate::MutationNode>::Command>,
halt: crate::ShutdownSignal,
enrolled: Enrolled,
) -> Result<(), LaunchError>
where
S: crate::AsyncSource + Send + 'static,
S::Yield: Send,
<S::Mutation as crate::MutationNode>::Command: Send,
S::Error: core::error::Error + Send + Sync + 'static,
{
let named = Utf8Bytes::from(name.to_owned());
let ctx = self.window(&named, halt);
let ignited = enrolled.mark();
let taps = self.taps.clone();
let reported = named.clone();
self.engine(&named, ignited, move || {
let ended = super::origin::drive_awaited_origin(source, ctx, giving, eating);
super::origin::observed(&taps, NodeName::new(reported.as_str()), ended);
enrolled.settle();
})
}
pub fn origin_declared<S>(
&mut self,
name: &str,
origin: S,
depth: usize,
enrolled: Enrolled,
) -> Result<super::Mounted<super::Ordered<S>, super::Produced<S>>, LaunchError>
where
S: crate::DeclaredOrigin + super::Lived<<S as crate::DeclaredOrigin>::Mode> + Send + 'static,
super::Produced<S>: Send,
super::Ordered<S>: Send,
super::Died<S>: core::error::Error + Send + Sync + 'static,
{
let (giving, yielded) = crate::feed(depth);
let (commands, eating) = crate::control(depth);
let (stopper, halt) = crate::shutdown_signal();
let named = Utf8Bytes::from(name.to_owned());
let ctx = self.window(&named, halt);
let ignited = enrolled.mark();
let taps = self.taps.clone();
let reported = named.clone();
self.engine(&named, ignited, move || {
let ended = super::Lived::live(origin, ctx, giving, eating);
super::origin::observed(&taps, NodeName::new(reported.as_str()), ended);
enrolled.settle();
})?;
self.halts.push(stopper.joined());
Ok(super::Mounted::new(commands, yielded, stopper))
}
pub fn origin_bridged<S>(
&mut self,
name: &str,
origin: S,
consumer: Outbox<ItemId, super::Produced<S>>,
depth: usize,
enrolled: Enrolled,
) -> Result<super::Bridged<super::Ordered<S>>, LaunchError>
where
S: crate::DeclaredOrigin + super::Lived<<S as crate::DeclaredOrigin>::Mode> + Send + 'static,
super::Produced<S>: Send,
super::Ordered<S>: Send,
super::Died<S>: core::error::Error + Send + Sync + 'static,
{
let giving = crate::Feed::bridging(consumer);
let (commands, eating) = crate::control(depth);
let (stopper, halt) = crate::shutdown_signal();
let named = Utf8Bytes::from(name.to_owned());
let ctx = self.window(&named, halt);
let ignited = enrolled.mark();
let taps = self.taps.clone();
let reported = named.clone();
self.engine(&named, ignited, move || {
let ended = super::Lived::live(origin, ctx, giving, eating);
super::origin::observed(&taps, NodeName::new(reported.as_str()), ended);
enrolled.settle();
})?;
self.halts.push(stopper.joined());
Ok(super::Bridged::new(commands, stopper))
}
pub fn origin_kept<S>(
&mut self,
name: &str,
origin: S,
consumer: Outbox<ItemId, super::Produced<S>>,
depth: usize,
enrolled: Enrolled,
) -> Result<(), LaunchError>
where
S: crate::DeclaredOrigin + super::Lived<<S as crate::DeclaredOrigin>::Mode> + Send + 'static,
super::Produced<S>: Send,
super::Ordered<S>: Send,
super::Died<S>: core::error::Error + Send + Sync + 'static,
{
let bridged = self.origin_bridged::<S>(name, origin, consumer, depth, enrolled)?;
self.origins.insert(TypeId::of::<S>(), Box::new(bridged));
Ok(())
}
fn engine<F>(&mut self, name: &Utf8Bytes, ignited: Ignited, body: F) -> Result<(), LaunchError>
where
F: FnOnce() + Send + 'static,
{
let engine = std::thread::Builder::new()
.name(format!("ingraph-{}", name.as_str()))
.spawn(body);
let engine = match engine {
Ok(engine) => engine,
Err(error) => return Err(self.unwind(LaunchError::ignition(name.as_str(), error))),
};
ignited.ignite();
self.bodies.push(engine);
Ok(())
}
pub fn source<F, S>(&mut self, start: F)
where
F: FnOnce() -> S + Send + 'static,
S: Send + 'static,
{
self.starts.push(Box::new(move || Box::new(start())));
}
#[inline]
pub fn feeder<N>(&mut self, feeder: Outbox<ItemId, <Cell<N> as Mount<N>>::In>)
where
N: Declared,
Cell<N>: Mount<N>,
{
self.intake::<N, _>(feeder);
}
#[inline]
pub fn intake<N, T>(&mut self, feeder: Outbox<ItemId, T>)
where
N: Declared,
T: Send + 'static,
{
self.feeders.insert(TypeId::of::<N>(), Box::new(feeder));
}
#[inline]
pub fn lane_declared<N, X>(
&mut self,
mount: LaneMount<N, X, <N as Declared>::Mode>,
enrolled: Enrolled,
) where
N: Declared + Streams<<N as Declared>::Mode> + Send,
<N as Streams<<N as Declared>::Mode>>::In: Send + 'static,
<N as Streams<<N as Declared>::Mode>>::Out: Send + 'static,
X: Send + 'static,
{
self
.lanes
.insert(TypeId::of::<N>(), (Box::new(mount), enrolled));
}
pub fn teardown<T>(&mut self, name: &str, value: T)
where
T: AsyncTeardown + Send + 'static,
{
self.teardowns.push(Farewell::new(name.to_owned(), value));
}
#[inline]
#[must_use]
pub fn context(&self) -> &Resources {
&self.ctx
}
#[inline]
#[must_use]
pub const fn shutdown(&self) -> &Shutdown {
&self.shutdown
}
#[inline]
#[must_use]
pub fn bodies(&self) -> usize {
self.bodies.len() + self.tasks.len()
}
#[inline]
#[must_use]
pub fn sources(&self) -> usize {
self.starts.len()
}
#[must_use]
pub fn unwind(&mut self, error: LaunchError) -> LaunchError {
if !self.shutdown.parties().iter().any(Party::ignited) {
return error;
}
for party in self.shutdown.parties() {
party.announce();
}
for halt in self.halts.drain(..) {
halt.announce();
}
self.origins.clear();
self.starts.clear();
self.senders.clear();
Self::settle(&self.shutdown);
let mut abandoned = false;
for party in ignited(&self.shutdown) {
let observation = if party.settled() {
Lifecycle::<()>::Processed(()).erase()
} else {
abandoned = true;
Lifecycle::<()>::Failed(Failure::new(Abandoned(Utf8Bytes::from(
party.name().as_str().to_owned(),
))))
.erase()
};
self.taps.observe(party.name(), &observation);
}
if !abandoned {
let taps = self.taps.clone();
let mut chain = collected(&self.shutdown).chain;
chain.extend(core::mem::take(&mut self.teardowns));
let ctx = core::mem::replace(&mut self.ctx, Arc::new(Resources::new()));
block_on(async {
joined(self.tasks.drain(..)).await;
drop(farewell(chain, &taps).await);
drop(released(ctx, &taps).await);
});
for engine in self.bodies.drain(..) {
let _ = engine.join();
}
}
error
}
fn settle(shutdown: &Shutdown) {
let end = Instant::now() + UNWIND_PATIENCE;
while !ignited(shutdown).all(Party::finished) {
let Some(left) = end.checked_duration_since(Instant::now()) else {
return;
};
if !shutdown.park(Some(left)) {
return;
}
}
}
#[must_use]
pub fn into_app<I>(self) -> App<I> {
let Self {
ctx,
cadences,
clock,
shutdown,
taps,
registries,
senders,
bodies,
tasks,
starts,
halts,
teardowns,
feeders,
lanes,
origins,
runtime: _,
} = self;
let mut sources: Vec<Box<dyn Any + Send>> = starts.into_iter().map(|start| start()).collect();
if !cadences.is_empty() {
sources.push(clock(cadences));
}
App::new(
ctx, shutdown, taps, registries, senders, sources, halts, bodies, tasks, teardowns, feeders,
lanes, origins,
)
}
}
impl Ignition<Unruntimed> {
pub const PATIENCE: Duration = UNWIND_PATIENCE;
pub fn task<O, W, A, L, C, S, I, M>(
resident: Resident<O, W, A, L, C, S, I, M>,
enrolled: Enrolled,
) -> impl Future<Output = ()>
where
Resident<O, W, A, L, C, S, I, M>: Drives + Send + 'static,
O: Driven<M>,
A: Attributes<<O as Driven<M>>::Out>,
{
body(resident, enrolled)
}
pub fn task_saying_goodbye<O, W, A, L, C, S, I, M, G>(
resident: Resident<O, W, A, L, C, S, I, M>,
enrolled: Enrolled,
goodbye: G,
) -> impl Future<Output = ()>
where
G: FnOnce(O) -> Posted,
Resident<O, W, A, L, C, S, I, M>: Drives + Send + 'static,
O: Driven<M>,
A: Attributes<<O as Driven<M>>::Out>,
{
saying_goodbye(resident, enrolled, goodbye)
}
pub fn registry_driver<Root>(
&mut self,
registry: Arc<Registry<Root>>,
keys: Yielded<Root>,
head: Outbox<ItemId, Root>,
) where
Root: RootKey,
{
self.source(move || RegistryDriver::spawn(registry, keys, head));
}
}
impl<R> Ignition<R>
where
R: RuntimeLite,
{
pub fn spawn(&mut self, body: impl Future<Output = ()> + Send + 'static) {
self.tasks.push(engage::<R::Spawner, _>(body));
}
pub fn registry_driver<Root>(
&mut self,
registry: Arc<Registry<Root>>,
keys: Yielded<Root>,
head: Outbox<ItemId, Root>,
) where
Root: RootKey,
{
let (stopper, halt) = crate::shutdown_signal();
self.spawn(driver::body::<R, Root>(registry, keys, head, halt));
self.source(move || RegistryDriver::stopping(stopper));
}
#[must_use = "a refused seat leaves the acts going to whoever was already there"]
pub fn retired_ledger<Root>(
&mut self,
registry: &Arc<Registry<Root>>,
store: Arc<dyn RetiredStore<Root>>,
mirror: Arc<RetiredMirror<Root>>,
) -> bool
where
Root: RootKey,
{
let Some(body) = Keeper::seated(registry, store, mirror) else {
return false;
};
self.spawn(body.run());
true
}
}
fn ignited(shutdown: &Shutdown) -> impl Iterator<Item = &Party> {
shutdown.parties().iter().filter(|party| party.ignited())
}
fn body<O, W, A, L, C, S, I, M>(
resident: Resident<O, W, A, L, C, S, I, M>,
enrolled: Enrolled,
) -> impl Future<Output = ()>
where
Resident<O, W, A, L, C, S, I, M>: Drives + Send + 'static,
O: Driven<M>,
A: Attributes<<O as Driven<M>>::Out>,
{
enrolled.mark().ignite();
async move {
let mut resident = resident;
let _: Drained = resident.run_async().await;
drop(resident);
enrolled.settle();
}
}
fn saying_goodbye<O, W, A, L, C, S, I, M, G>(
resident: Resident<O, W, A, L, C, S, I, M>,
enrolled: Enrolled,
goodbye: G,
) -> impl Future<Output = ()>
where
G: FnOnce(O) -> Posted,
Resident<O, W, A, L, C, S, I, M>: Drives + Send + 'static,
O: Driven<M>,
A: Attributes<<O as Driven<M>>::Out>,
{
enrolled.mark().ignite();
async move {
let mut resident = resident;
let _: Drained = resident.run_async().await;
let operator = resident.into_operator();
enrolled.settle_saying(goodbye(operator));
}
}
pub(super) async fn joined(tasks: impl IntoIterator<Item = Join>) {
for task in tasks {
task.await;
}
}
#[derive(Debug)]
struct Abandoned(Utf8Bytes);
impl core::fmt::Display for Abandoned {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(
f,
"`{}` had not settled when the launch unwound, and was abandoned where it stood",
self.0.as_str()
)
}
}
impl core::error::Error for Abandoned {}
impl<R> core::fmt::Debug for Ignition<R> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("Ignition")
.field("resources", &self.ctx.len())
.field("cadences", &self.cadences.len())
.field("parties", &self.shutdown.len())
.field("senders", &self.senders.len())
.field("bodies", &self.bodies.len())
.field("tasks", &self.tasks.len())
.field("sources", &self.starts.len())
.field("teardowns", &self.teardowns.len())
.finish()
}
}