Struct ModuleAdapter 

pub struct ModuleAdapter { /* private fields */ }

Adapts an existing start_module(Arc<JanusState>) -> Result<()> function into a JanusService that the supervisor can manage.

Shutdown Bridging

When the supervisor cancels this service’s CancellationToken, the adapter calls state.request_shutdown() to signal the inner module through its existing shutdown pathway. This avoids having to rewrite every service to accept a CancellationToken directly — they continue polling state.is_shutdown_requested() as before.

Shared-State Shutdown Invariant

Because JanusState is shared across all modules, request_shutdown() sets a global AtomicBool. This is safe under the current supervisor model because:

1. The supervisor propagates cancellation to all services at once (child tokens of the same root), so if one bridge fires they all do.
2. When a service fails on its own (returns Err), the bridge task is aborted before it can call request_shutdown(), keeping the flag false for the restart.
3. The supervisor checks cancel.is_cancelled() before each restart attempt, so a stale true flag never leads to a restart loop.

If per-module independent restart semantics are ever needed (e.g., restarting one module while others keep running), this must be refactored to use a per-adapter shutdown signal instead of the global JanusState flag.

Error Propagation

Errors returned by the inner start_module are converted to anyhow::Error and bubbled up to the supervisor, which then applies the configured RestartPolicy.

Implementations

impl ModuleAdapter

pub fn new<F>( name: &str, state: Arc<JanusState>, start_fn: F, policy: RestartPolicy, ) -> Self

where F: Fn(Arc<JanusState>) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> + Send + Sync + 'static,

Create a new adapter.

Arguments

• name — Service name for the supervisor (e.g., "forward", "data", "cns").
• state — Shared JanusState that the module uses for configuration, health reporting, and shutdown signalling.
• start_fn — A closure or function pointer matching the start_module signature. Must be Send + Sync + 'static.
• policy — How the supervisor should handle failures.

Example

let adapter = ModuleAdapter::new(
    "forward",
    state.clone(),
    |s| Box::pin(janus_forward::start_module(s)),
    RestartPolicy::OnFailure,
);

pub fn on_failure<F>(name: &str, state: Arc<JanusState>, start_fn: F) -> Self

where F: Fn(Arc<JanusState>) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> + Send + Sync + 'static,

Create an adapter with the default RestartPolicy::OnFailure.

pub fn one_shot<F>(name: &str, state: Arc<JanusState>, start_fn: F) -> Self

where F: Fn(Arc<JanusState>) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> + Send + Sync + 'static,

Create an adapter that never restarts (one-shot module).

pub fn always_restart<F>( name: &str, state: Arc<JanusState>, start_fn: F, ) -> Self

where F: Fn(Arc<JanusState>) -> Pin<Box<dyn Future<Output = Result<()>> + Send>> + Send + Sync + 'static,

Create an adapter that always restarts (even on clean exit).

Trait Implementations

impl Debug for ModuleAdapter

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl JanusService for ModuleAdapter

fn name(&self) -> &str

Returns the unique name of the service for logging, metrics, and supervisor identification.

fn restart_policy(&self) -> RestartPolicy

The restart policy for this service.

fn run<'life0, 'async_trait>( &'life0 self, cancel: CancellationToken, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

The main execution loop of the service.