continuo 0.10.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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

//! Typed dependencies: what a component requires in order to boot and run.

use std::any::{Any, TypeId};
use std::fmt;
use std::sync::Arc;

use super::{Registry, Result};

/// The dependencies a component declares through `Component::Deps`.
///
/// A dependency is a hard requirement: the component cannot boot or run
/// without it. `Arc<T>` requires `T` to be registered and, when `T` is itself
/// a component, orders it before the dependent. `Option<Arc<T>>` takes the
/// same ordering when `T` is present and resolves to `None` when it is not.
/// Tuples combine up to eight dependencies; `()` declares none.
///
/// A component that merely uses another when it happens to be there, and
/// serves without it, does not declare it here. It resolves the value at the
/// point of use and expresses a preferred start order through `run_priority`.
///
/// Resolution happens once before `Bootable::boot` and once before each run
/// generation, in the registry, after every dependency has had its chance to
/// be registered. A missing dependency is one error naming the component and
/// the missing type.
pub trait Resolve<S>: Clone + Send + Sync + Sized + 'static {
    /// The types this value requires. The registry turns registered
    /// components among them into ordering edges.
    fn dependencies(into: &mut Vec<TypeId>);

    /// Resolve the value from the registry.
    fn resolve(registry: &Registry<S>) -> Result<Self>;
}

/// A dependency named by `Component::Deps` that is not registered.
#[derive(Debug)]
pub struct MissingDependency {
    dependency: &'static str,
}

impl MissingDependency {
    /// The type name of the dependency.
    pub fn dependency(&self) -> &'static str {
        self.dependency
    }
}

impl fmt::Display for MissingDependency {
    fn fmt(
        &self,
        f: &mut fmt::Formatter<'_>,
    ) -> fmt::Result {
        write!(f, "`{}` is not registered", self.dependency)
    }
}

impl std::error::Error for MissingDependency {}

impl<S: 'static> Resolve<S> for () {
    fn dependencies(_: &mut Vec<TypeId>) {}

    fn resolve(_: &Registry<S>) -> Result<Self> {
        Ok(())
    }
}

impl<S: 'static, T: Any + Send + Sync> Resolve<S> for Arc<T> {
    fn dependencies(into: &mut Vec<TypeId>) {
        into.push(TypeId::of::<T>());
    }

    fn resolve(registry: &Registry<S>) -> Result<Self> {
        registry.resolve::<T>().ok_or_else(|| {
            MissingDependency { dependency: std::any::type_name::<T>() }.into()
        })
    }
}

impl<S: 'static, T: Any + Send + Sync> Resolve<S> for Option<Arc<T>> {
    fn dependencies(into: &mut Vec<TypeId>) {
        into.push(TypeId::of::<T>());
    }

    fn resolve(registry: &Registry<S>) -> Result<Self> {
        Ok(registry.resolve::<T>())
    }
}

macro_rules! resolve_tuple {
    ($($member:ident),+) => {
        impl<S: 'static, $($member: Resolve<S>),+> Resolve<S> for ($($member,)+) {
            fn dependencies(into: &mut Vec<TypeId>) {
                $($member::dependencies(into);)+
            }

            fn resolve(registry: &Registry<S>) -> Result<Self> {
                Ok(($($member::resolve(registry)?,)+))
            }
        }
    };
}

resolve_tuple!(A);
resolve_tuple!(A, B);
resolve_tuple!(A, B, C);
resolve_tuple!(A, B, C, D);
resolve_tuple!(A, B, C, D, E);
resolve_tuple!(A, B, C, D, E, F);
resolve_tuple!(A, B, C, D, E, F, G);
resolve_tuple!(A, B, C, D, E, F, G, H);