enhancement(core): add configurable per-child restart types for supervisors

Author: tobz

lib/saluki-core/src/runtime/mod.rs

@@ -63,7 +63,7 @@ mod dedicated;
 pub use self::dedicated::{RuntimeConfiguration, RuntimeMode};
 
 mod restart;
-pub use self::restart::{RestartMode, RestartStrategy};
+pub use self::restart::{RestartMode, RestartStrategy, RestartType};
 
 mod supervisor;
 pub use self::supervisor::{

lib/saluki-core/src/runtime/restart.rs

@@ -74,6 +74,55 @@ impl Default for RestartStrategy {
     }
 }
 
+/// Restart policy for an individual child process.
+///
+/// Where [`RestartStrategy`] governs supervisor-wide behavior (which children are restarted together,
+/// and how often before the supervisor gives up), the restart policy governs whether an _individual_
+/// child is eligible for restart at all, based on how it exited. This mirrors the per-child restart
+/// configuration in Erlang/OTP.
+///
+/// The default is [`Permanent`][Self::Permanent], which preserves the supervisor's historical behavior
+/// of always restarting a child that exits.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
+pub enum RestartType {
+    /// The child is always restarted, whether it exits normally or abnormally.
+    ///
+    /// This suits long-lived processes that are always expected to be running.
+    #[default]
+    Permanent,
+
+    /// The child is restarted only if it exits abnormally.
+    ///
+    /// An abnormal exit is an error, panic, or forced abort. A normal exit (the child's future
+    /// resolves with `Ok(())`) is treated as intentional, and the child is not restarted.
+    Transient,
+
+    /// The child is never restarted, regardless of how it exits.
+    ///
+    /// This suits short-lived, on-demand children -- for example, one task per network connection --
+    /// whose termination is a normal part of operation.
+    ///
+    /// > **Note:** Mixing `Temporary` children into a non-dynamic supervisor that uses
+    /// > [`RestartMode::OneForAll`] is not yet fully supported: a one-for-all restart triggered by a
+    /// > sibling will currently restart temporary children as well. Temporary children are intended for
+    /// > one-for-one supervision (including the dynamic supervisor).
+    Temporary,
+}
+
+impl RestartType {
+    /// Returns whether a child with this restart policy should be restarted, given how it exited.
+    ///
+    /// `abnormal` indicates the child exited due to an error, panic, or forced abort, rather than
+    /// completing normally.
+    pub(super) fn should_restart(self, abnormal: bool) -> bool {
+        match self {
+            Self::Permanent => true,
+            Self::Transient => abnormal,
+            Self::Temporary => false,
+        }
+    }
+}
+
 pub(super) enum RestartAction {
     /// Execute a restart with the given mode.
     Restart(RestartMode),