calandria 0.0.1-rc.2

Bounded reactor framework for explicit single-owner systems
Documentation
//! Ownership-safe static reactor-group validation and startup.

use std::{num::NonZeroUsize, sync::mpsc, thread::Thread};

use crate::{Clock, Duty, Reactor, Waiter};

use super::{
    GroupControl, ReactorGroup, ReactorGroupLimits, ReactorGroupMember, ReactorGroupSpawnError,
    ReactorGroupSpawnFailure, ReactorId, ReactorSlot, StartGate, SupervisorAssets, WorkerJoin,
    WorkerResult, bounded_ingress, reactor_slot, spawn_supervisor, spawn_worker,
    worker::take_reactor,
};

impl<D, C, W, T> ReactorGroup<D, C, W, T>
where
    D: Duty + Send + 'static,
    D::Error: Send + 'static,
    C: Clock + Send + 'static,
    C::Error: Send + 'static,
    W: Waiter<D> + Send + 'static,
    W::Error: Send + 'static,
    T: Send + 'static,
{
    /// Starts a bounded static topology under one fail-closed supervisor.
    pub fn spawn(
        limits: ReactorGroupLimits,
        name: impl Into<String>,
        members: Vec<ReactorGroupMember<D, C, W, T>>,
    ) -> Result<Self, ReactorGroupSpawnError<D, C, W, T>> {
        if let Err(failure) = validate(limits, &members) {
            return Err(ReactorGroupSpawnError::new(failure, members));
        }
        let reactors = NonZeroUsize::new(members.len())
            .unwrap_or_else(|| panic!("validated reactor group became empty"));
        let name = name.into();
        let (reactors_to_start, senders): (Vec<_>, Vec<_>) = members
            .into_iter()
            .map(|member| {
                let (_id, reactor, ingress) = member.into_parts();
                (reactor, ingress)
            })
            .unzip();
        let controls = reactors_to_start
            .iter()
            .map(Reactor::control)
            .collect::<Vec<_>>();
        let slots = reactors_to_start
            .into_iter()
            .map(reactor_slot)
            .collect::<Vec<_>>();
        let (ingress, closer) = bounded_ingress(senders);
        let control = GroupControl::new(controls, closer);
        let gate = StartGate::new();
        let (completed, completions) = mpsc::sync_channel(reactors.get());
        let mut pending = Pending {
            slots,
            ingress,
            control,
            gate,
            workers: Vec::with_capacity(reactors.get()),
            threads: Vec::with_capacity(reactors.get()),
        };

        for index in 0..reactors.get() {
            let id = ReactorId::from_position(index);
            let worker = spawn_worker(
                id,
                format!("{name}-{index}"),
                pending.slots[index].clone(),
                pending.gate.clone(),
                completed.clone(),
                pending.control.clone(),
            );
            match worker {
                Ok(worker) => pending.push(worker),
                Err(source) => {
                    drop(completed);
                    return Err(pending.abort(ReactorGroupSpawnFailure::ReactorThread {
                        reactor: id,
                        source,
                    }));
                }
            }
        }
        drop(completed);

        let assets = SupervisorAssets::new(
            core::mem::take(&mut pending.workers),
            completions,
            pending.control.admission(),
        );
        let supervisor = match spawn_supervisor(format!("{name}-supervisor"), assets) {
            Ok(supervisor) => supervisor,
            Err((source, assets)) => {
                pending.workers = assets.into_workers();
                return Err(pending.abort(ReactorGroupSpawnFailure::SupervisorThread { source }));
            }
        };

        pending.gate.start();
        Ok(Self {
            limits,
            reactors,
            ingress: pending.ingress,
            control: pending.control,
            threads: pending.threads.into_boxed_slice(),
            supervisor,
        })
    }
}

struct Pending<D, C, W, T>
where
    D: Duty,
    C: Clock,
    W: Waiter<D>,
{
    slots: Vec<ReactorSlot<D, C, W>>,
    ingress: super::ReactorGroupHandle<T>,
    control: GroupControl<T>,
    gate: StartGate,
    workers: Vec<WorkerJoin<D, C, W>>,
    threads: Vec<Thread>,
}

impl<D, C, W, T> Pending<D, C, W, T>
where
    D: Duty,
    C: Clock,
    W: Waiter<D>,
{
    fn push(&mut self, worker: WorkerJoin<D, C, W>) {
        self.threads.push(worker.thread().clone());
        self.workers.push(worker);
    }

    fn abort(self, failure: ReactorGroupSpawnFailure) -> ReactorGroupSpawnError<D, C, W, T> {
        self.gate.abort();
        for worker in self.workers {
            let result = worker
                .join()
                .unwrap_or_else(|_| panic!("aborted reactor worker panicked"));
            assert!(matches!(result, WorkerResult::Aborted));
        }
        drop(self.control);
        let reactors = self.slots.iter().map(take_reactor).collect::<Vec<_>>();
        let senders = self.ingress.into_senders();
        let members = reactors
            .into_iter()
            .zip(senders)
            .enumerate()
            .map(|(position, (reactor, ingress))| {
                ReactorGroupMember::from_parts(ReactorId::from_position(position), reactor, ingress)
            })
            .collect();
        ReactorGroupSpawnError::new(failure, members)
    }
}

fn validate<D, C, W, T>(
    limits: ReactorGroupLimits,
    members: &[ReactorGroupMember<D, C, W, T>],
) -> Result<(), ReactorGroupSpawnFailure> {
    let actual = members.len();
    if actual == 0 {
        return Err(ReactorGroupSpawnFailure::Empty);
    }
    if actual > limits.reactors().get() {
        return Err(ReactorGroupSpawnFailure::Capacity {
            limit: limits.reactors(),
            actual,
        });
    }
    for (position, member) in members.iter().enumerate() {
        let expected = ReactorId::from_position(position);
        if member.id() != expected {
            return Err(ReactorGroupSpawnFailure::Identity {
                expected,
                actual: member.id(),
            });
        }
    }
    Ok(())
}