lenso 0.4.1

Rust authoring facade for Lenso vNext Modules.
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

use std::{cell::Cell, cell::RefCell, time::Duration};

use lenso::prelude::*;
use lenso_app_plan::{ModuleInstancePlan, ResolvedAppPlan};
use lenso_kernel::ShutdownOutcome;
use lenso_test::TestApp;

thread_local! {
    static ACTIVATION_FAILS: Cell<bool> = const { Cell::new(false) };
    static TASKS: RefCell<Option<ManagedTasks>> = const { RefCell::new(None) };
    static TASK_OBSERVED_CANCELLATION: Cell<bool> = const { Cell::new(false) };
    static DEACTIVATE_OBSERVED_INACTIVE: Cell<bool> = const { Cell::new(false) };
}

#[module(consumer, lifecycle)]
#[derive(Clone, Debug)]
struct Worker {
    #[tasks]
    tasks: ManagedTasks,
}

impl Lifecycle for Worker {
    async fn activate(&self, _context: ActivateContext) -> Result<(), RuntimeFailure> {
        std::future::ready(()).await;
        assert!(self.tasks.is_active());
        TASKS.with(|tasks| tasks.replace(Some(self.tasks.clone())));
        if ACTIVATION_FAILS.get() {
            return Err(RuntimeFailure::ModuleFailure {
                detail: "configured activation failure".to_owned(),
            });
        }
        let cancellation = self
            .tasks
            .cancellation()
            .expect("activation connected tasks");
        self.tasks
            .spawn_local(async move {
                cancellation.cancelled().await;
                TASK_OBSERVED_CANCELLATION.set(true);
            })
            .expect("the active generation should admit managed work");
        Ok(())
    }

    async fn deactivate(&self, _context: DeactivateContext) -> Result<(), RuntimeFailure> {
        std::future::ready(()).await;
        DEACTIVATE_OBSERVED_INACTIVE.set(!self.tasks.is_active());
        assert!(matches!(
            self.tasks.spawn_local(async {}),
            Err(ManagedTasksError::Inactive)
        ));
        Ok(())
    }
}

fn plan() -> ResolvedAppPlan {
    ResolvedAppPlan::new(vec![ModuleInstancePlan::new("worker", "lenso")], Vec::new())
}

fn reset() {
    ACTIVATION_FAILS.set(false);
    TASKS.with(RefCell::take);
    TASK_OBSERVED_CANCELLATION.set(false);
    DEACTIVATE_OBSERVED_INACTIVE.set(false);
}

#[test]
fn task_field_tracks_activation_failure_cancellation_and_deactivation() {
    reset();
    ACTIVATION_FAILS.set(true);
    let error = TestApp::builder(plan())
        .with_linked_factories()
        .start()
        .unwrap_err();
    assert!(matches!(error, RuntimeFailure::ModuleFailure { .. }));
    TASKS.with(|tasks| {
        assert!(!tasks.borrow().as_ref().unwrap().is_active());
    });

    reset();
    let app = TestApp::builder(plan())
        .with_linked_factories()
        .start()
        .unwrap();
    TASKS.with(|tasks| assert!(tasks.borrow().as_ref().unwrap().is_active()));
    assert_eq!(app.shutdown(Duration::from_secs(1)), ShutdownOutcome::Clean);
    assert!(TASK_OBSERVED_CANCELLATION.get());
    assert!(DEACTIVATE_OBSERVED_INACTIVE.get());
    TASKS.with(|tasks| {
        assert!(!tasks.borrow().as_ref().unwrap().is_active());
    });
}