continuo 0.11.0

Runtime service composition for multi-service Rust applications: typed component resolution, dependency-ordered lifecycle, reload, runnable tasks, graceful drain, and finalization.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

use std::any::Any;
use std::sync::Arc;

use async_trait::async_trait;

use super::Result;

/// Capability trait for components that produce a long-running runtime task.
///
/// `run()` is the only place in the lifecycle for long-running work: accept
/// loops, listeners, periodic tickers. It does not appear in `register()` or
/// `Bootable::boot()`.
///
/// `D` is the runnable's typed dependency set (the component's `Deps` for the
/// default single instance). The runtime resolves it before each admitted
/// generation, after checking scope and activation policy. Dormant services
/// do not require runtime dependencies until started. Each execution receives
/// shared handles; fleet dispatch clones those handles across its slots.
///
/// The supplied [`crate::RunContext`] belongs to one live service generation.
/// Observe its cancellation rather than the process shutdown token alone: the
/// runtime uses the same path for a targeted stop or restart and for
/// whole-process shutdown.
#[async_trait]
pub trait Runnable<S, D = ()>: Any + Send + Sync {
    /// Executor placement and poll scheduling for the next generation.
    ///
    /// The default preserves ambient Tokio execution. Override only when an
    /// installed execution driver implements the requested policy. This is
    /// independent of `Component::run_priority`, which orders service starts.
    /// The runtime samples and prepares this once at generation admission.
    /// Placement applies only to `run`; configuration, boot, validation,
    /// reload and provider finalization keep their lifecycle executor.
    fn execution_spec(
        &self,
        _state: &S,
    ) -> crate::ExecutionSpec {
        crate::ExecutionSpec::default()
    }

    /// Declare the service's current activation policy.
    ///
    /// The default is [`crate::ServiceStartPolicy::Automatic`]: exposing
    /// `Runnable` is already the component's opt-in to runtime ownership. The
    /// runtime re-evaluates this synchronous method when observing the
    /// service and before starting a generation.
    fn start_policy(
        &self,
        _state: &S,
    ) -> crate::ServiceStartPolicy {
        crate::ServiceStartPolicy::Automatic
    }

    /// Run one runtime-owned generation of this instance.
    ///
    /// An implementation that returns `Err` logs its own contextual details;
    /// the runtime attaches the component name and the lifecycle phase, and
    /// does not log non-critical runnable errors a second time.
    async fn run(
        self: Arc<Self>,
        deps: D,
        state: S,
        context: crate::RunContext,
    ) -> Result<()>;
}