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;
}
}
}