continuo 0.12.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

use super::*;

struct FirstDomain;
struct SecondDomain;

fn owner() -> ExecutionOwner {
    ExecutionOwner::of::<FirstDomain>("instance")
}

#[test]
fn named_domains_own_runtime_names_and_remain_type_scoped() {
    let name: Arc<str> = String::from("configured-instance").into();
    let retained = Arc::downgrade(&name);
    let domain = ExecutionDomain::named::<FirstDomain>(name.clone());
    drop(name);
    assert!(retained.upgrade().is_some());
    assert_eq!(
        domain,
        ExecutionDomain::named::<FirstDomain>("configured-instance")
    );
    assert_ne!(
        domain,
        ExecutionDomain::named::<SecondDomain>("configured-instance")
    );
    assert_ne!(domain, ExecutionDomain::of::<FirstDomain>());
    drop(domain);
    assert!(retained.upgrade().is_none());
}

#[test]
fn domains_share_by_marker_type_not_by_service_identity() {
    assert_eq!(
        ExecutionDomain::of::<FirstDomain>(),
        ExecutionDomain::of::<FirstDomain>()
    );
    assert_ne!(
        ExecutionDomain::of::<FirstDomain>(),
        ExecutionDomain::of::<SecondDomain>()
    );
}

#[test]
fn application_policy_converts_without_domain_names_in_continuo() {
    struct BatchPolicy;
    impl From<BatchPolicy> for ExecutionSpec {
        fn from(_: BatchPolicy) -> Self {
            Self::default()
                .with_executor(ExecutorSpec::Shared(ExecutionDomain::of::<
                    FirstDomain,
                >()))
                .with_scheduling(SchedulingPolicy::Priority(PollPriority::Low))
        }
    }
    let spec: ExecutionSpec = BatchPolicy.into();
    assert_eq!(
        spec.executor,
        ExecutorSpec::Shared(ExecutionDomain::of::<FirstDomain>())
    );
    assert_eq!(spec.scheduling, SchedulingPolicy::Priority(PollPriority::Low));
    assert!(ExecutionPlan::prepare(&owner(), spec.clone(), None).is_err());
}

#[test]
fn direct_context_retains_ambient_execution_and_cancellation() {
    let cancellation = tokio_util::sync::CancellationToken::new();
    let context = RunContext::new(cancellation.clone());
    assert!(context.identity().is_none());
    assert!(context.child().identity().is_none());
    assert_eq!(context.execution_spec(), ExecutionSpec::default());
    assert!(context.execution_executor().is_none());
    cancellation.cancel();
    assert!(context.clone().is_cancelled());
}

#[test]
fn scheduling_and_placement_each_require_explicit_support() {
    let base = ExecutionSpec::default();
    for spec in [
        base.clone().with_executor(ExecutorSpec::Dedicated(
            ExecutorKind::CurrentThread,
        )),
        base.clone().with_executor(ExecutorSpec::Dedicated(
            ExecutorKind::MultiThread {
                threads: NonZeroUsize::new(2).unwrap(),
            },
        )),
        base.clone()
            .with_scheduling(SchedulingPolicy::Priority(PollPriority::Normal)),
        base.clone().with_scheduling(SchedulingPolicy::Weighted(
            NonZeroUsize::new(2).unwrap(),
        )),
    ] {
        assert!(ExecutionPlan::prepare(&owner(), spec.clone(), None).is_err());
    }
}