coactor 0.1.0

An embedded distributed Actor framework for Rust applications
Documentation
use std::sync::Arc;
use std::sync::atomic::Ordering;

use super::core::{FENCED, RUNNING, SHUTTING_DOWN, STOPPED, ServerInner};
use crate::cluster::NodeRecord;
use crate::{ActorAddress, SendError, ServerError};

impl<S> ServerInner<S>
where
    S: Send + Sync + 'static,
{
    #[allow(dead_code)]
    pub(crate) fn has_authority(&self) -> bool {
        self.status.load(Ordering::Acquire) != FENCED
            && self
                .authority
                .as_ref()
                .is_none_or(|authority| authority.is_valid())
    }

    pub(crate) fn update_capacity_sample(&self, node: &mut NodeRecord) {
        let available = self.capacity.available_permits();
        node.sampled_at_unix_ms = crate::cluster::wall_time_millis();
        node.active_actor_count = self.max_active_actors.saturating_sub(available);
        node.max_actor_count = self.max_active_actors;
        node.pressured = available == 0;
        node.draining = self.status.load(Ordering::Acquire) != RUNNING;
    }

    pub async fn shutdown(self: &Arc<Self>) -> Result<(), ServerError> {
        tracing::debug!(
            lifecycle = "shutdown",
            error_category = "None",
            "CoActor runtime shutdown started"
        );
        let (mut completions, aborts) = {
            let actors = self.actors.lock();
            if self
                .status
                .compare_exchange(RUNNING, SHUTTING_DOWN, Ordering::AcqRel, Ordering::Acquire)
                .is_err()
            {
                return Ok(());
            }

            let mut completions = Vec::with_capacity(actors.len());
            let mut aborts = Vec::with_capacity(actors.len());
            for route in actors.values() {
                let _ = route.task.shutdown.send(true);
                completions.push(route.task.completed.clone());
                aborts.push(route.task.abort.clone());
            }
            (completions, aborts)
        };

        let wait = async {
            for completion in &mut completions {
                if !*completion.borrow() {
                    let _ = completion.wait_for(|completed| *completed).await;
                }
            }
        };
        let timed_out = tokio::time::timeout(self.shutdown_timeout, wait)
            .await
            .is_err();
        if timed_out {
            tracing::warn!(
                lifecycle = "shutdown",
                error_category = "ShutdownTimedOut",
                "CoActor runtime shutdown timed out"
            );
            for abort in aborts {
                abort.abort();
            }
            tokio::task::yield_now().await;
            self.actors.lock().clear();
        }
        self.terminate_all_sessions(SendError::RuntimeShuttingDown)
            .await;
        self.abort_inbound_tasks();
        self.status.store(STOPPED, Ordering::Release);
        tracing::debug!(
            lifecycle = "shutdown",
            error_category = "None",
            "CoActor runtime shutdown completed"
        );
        if timed_out {
            Err(ServerError::ShutdownTimedOut)
        } else {
            Ok(())
        }
    }

    pub async fn fence(self: &Arc<Self>) {
        let (completions, aborts) = {
            let actors = self.actors.lock();
            self.status.store(FENCED, Ordering::Release);
            let mut completions = Vec::with_capacity(actors.len());
            let mut aborts = Vec::with_capacity(actors.len());
            for route in actors.values() {
                route.task.abort.abort();
                completions.push(route.task.completed.clone());
                aborts.push(route.task.abort.clone());
            }
            (completions, aborts)
        };
        for abort in aborts {
            abort.abort();
        }
        tokio::task::yield_now().await;
        for mut completion in completions {
            if !*completion.borrow() {
                let _ = completion.wait_for(|completed| *completed).await;
            }
        }
        self.actors.lock().clear();
        self.terminate_all_sessions(SendError::NodeFenced).await;
        self.abort_inbound_tasks();
    }

    async fn terminate_all_sessions(&self, error: SendError) {
        let addresses: Vec<ActorAddress> = self.sessions.by_actor_addresses();
        for address in addresses {
            self.sessions.terminate_all(&address, error.clone()).await;
        }
    }
}