feat(core): introduce status_kind in the Context

CHANGELOG.md

@@ -8,6 +8,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased] - ReleaseDate
 ### Added
+- core: `Context::status_kind` API, now actors can read `ActorStatusKind` from the context.
+- core: `is_*` methods on `ActorStatusKind` for each variant.
 - Specify MSRV as 1.76.
 - logger: log truncation up to the `max_line_size` configuration parameter ([#128]).
 - core: directly accept never returning functions in `ActorGroup::exec()` ([#127]).

elfo-core/src/actor.rs

@@ -1,4 +1,7 @@
-use std::{fmt, mem, sync::Arc};
+use std::{
+    fmt, mem,
+    sync::{atomic, Arc},
+};
 
 use futures_intrusive::sync::ManualResetEvent;
 use metrics::{decrement_gauge, increment_counter, increment_gauge};
@@ -7,6 +10,7 @@ use serde::{Deserialize, Serialize};
 use tracing::{error, info, warn};
 
 use crate::{
+    atomic_status_kind::AtomicActorStatusKind,
     envelope::Envelope,
     errors::{SendError, TrySendError},
     group::TerminationPolicy,
@@ -96,6 +100,7 @@ impl fmt::Display for ActorStatus {
 /// A list specifying statuses of actors. It's used with the [`ActorStatus`].
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[non_exhaustive]
+#[repr(u8)]
 pub enum ActorStatusKind {
     Normal,
     Initializing,
@@ -105,6 +110,32 @@ pub enum ActorStatusKind {
     Failed,
 }
 
+impl ActorStatusKind {
+    pub const fn is_normal(&self) -> bool {
+        matches!(self, Self::Normal)
+    }
+
+    pub const fn is_initializing(&self) -> bool {
+        matches!(self, Self::Initializing)
+    }
+
+    pub const fn is_terminating(&self) -> bool {
+        matches!(self, Self::Terminating)
+    }
+
+    pub const fn is_terminated(&self) -> bool {
+        matches!(self, Self::Terminated)
+    }
+
+    pub const fn is_alarming(&self) -> bool {
+        matches!(self, Self::Alarming)
+    }
+
+    pub const fn is_failed(&self) -> bool {
+        matches!(self, Self::Failed)
+    }
+}
+
 impl ActorStatusKind {
     fn as_str(&self) -> &'static str {
         match self {
@@ -182,6 +213,7 @@ pub(crate) struct Actor {
     termination_policy: TerminationPolicy,
     mailbox: Mailbox,
     request_table: RequestTable,
+    status_kind: AtomicActorStatusKind,
     control: RwLock<Control>,
     finished: ManualResetEvent, // TODO: remove in favor of `status_subscription`?
     status_subscription: Arc<SubscriptionManager>,
@@ -206,6 +238,7 @@ impl Actor {
         status_subscription: Arc<SubscriptionManager>,
     ) -> Self {
         Actor {
+            status_kind: AtomicActorStatusKind::from(ActorStatusKind::Initializing),
             meta,
             termination_policy,
             mailbox: Mailbox::new(mailbox_config),
@@ -306,8 +339,15 @@ impl Actor {
         self.control.write().restart_policy = policy;
     }
 
+    pub(crate) fn status_kind(&self) -> ActorStatusKind {
+        self.status_kind.load(atomic::Ordering::Acquire)
+    }
+
     // Note that this method should be called inside a right scope.
     pub(crate) fn set_status(&self, status: ActorStatus) {
+        self.status_kind
+            .store(status.kind(), atomic::Ordering::Release);
+
         let mut control = self.control.write();
         let prev_status = mem::replace(&mut control.status, status.clone());
 

elfo-core/src/atomic_status_kind.rs

@@ -0,0 +1,29 @@
+use std::mem;
+use std::sync::atomic::{self, AtomicU8};
+
+use crate::ActorStatusKind;
+
+#[derive(Debug)]
+#[repr(transparent)]
+pub(crate) struct AtomicActorStatusKind(AtomicU8);
+
+impl From<ActorStatusKind> for AtomicActorStatusKind {
+    fn from(value: ActorStatusKind) -> Self {
+        Self(AtomicU8::new(value as _))
+    }
+}
+
+impl AtomicActorStatusKind {
+    pub(crate) fn store(&self, kind: ActorStatusKind, ordering: atomic::Ordering) {
+        self.0.store(kind as u8, ordering);
+    }
+
+    pub(crate) fn load(&self, ordering: atomic::Ordering) -> ActorStatusKind {
+        let result = self.0.load(ordering);
+
+        // SAFETY: `ActorStatusKind` has `#[repr(u8)]` annotation. The only
+        // place where value may be changed is `Self::store`, which consumes `ActorStatusKind`, thus,
+        // guarantees that possibly invalid value cannot be stored
+        unsafe { mem::transmute::<u8, ActorStatusKind>(result) }
+    }
+}

elfo-core/src/context.rs

@@ -26,6 +26,7 @@ use crate::{
     routers::Singleton,
     scope,
     source::{SourceHandle, Sources, UnattachedSource},
+    ActorStatusKind,
 };
 
 use self::stats::Stats;
@@ -105,6 +106,30 @@ impl<C, K> Context<C, K> {
         ward!(self.actor.as_ref().and_then(|o| o.as_actor())).set_status(status);
     }
 
+    /// Gets the actor's status kind.
+    ///
+    /// # Example
+    /// ```
+    /// # use elfo_core as elfo;
+    /// # fn exec(ctx: elfo::Context) {
+    /// // if actor is terminating.
+    /// assert!(ctx.status_kind().is_terminating());
+    /// // if actor is alarming.
+    /// assert!(ctx.status_kind().is_alarming());
+    /// // and so on...
+    /// # }
+    /// ```
+    /// # Panics
+    /// - Panics when called on pruned context.
+    pub fn status_kind(&self) -> ActorStatusKind {
+        self.actor
+            .as_ref()
+            .expect("called `status_kind()` on pruned context")
+            .as_actor()
+            .expect("invariant")
+            .status_kind()
+    }
+
     /// Overrides the group's default mailbox capacity, which set in the config.
     ///
     /// Note: after restart the actor will be created from scratch, so this

elfo-core/src/lib.rs

@@ -76,6 +76,8 @@ mod supervisor;
 mod telemetry;
 mod thread;
 
+mod atomic_status_kind;
+
 #[doc(hidden)]
 pub mod _priv {
     pub mod node {