deepstrike-core 0.2.43

Cross-language agent runtime kernel — pure computation, zero I/O
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

use crate::scheduler::tcb::TaskLifecycle;
use crate::types::policy::SignalDisposition;
use crate::types::signal::{RuntimeSignal, Urgency};

/// Default attention policy based on signal urgency.
pub struct UrgencyBasedPolicy;

impl UrgencyBasedPolicy {
    pub fn evaluate(&self, signal: &RuntimeSignal, lifecycle: TaskLifecycle) -> SignalDisposition {
        if lifecycle.is_terminal() {
            return SignalDisposition::Queue;
        }

        match signal.urgency {
            Urgency::Critical => {
                if matches!(lifecycle, TaskLifecycle::Running | TaskLifecycle::Suspended) {
                    SignalDisposition::InterruptNow
                } else {
                    SignalDisposition::Run
                }
            }
            Urgency::High => {
                if matches!(lifecycle, TaskLifecycle::Running | TaskLifecycle::Suspended) {
                    SignalDisposition::Interrupt
                } else {
                    SignalDisposition::Run
                }
            }
            Urgency::Normal => {
                if matches!(lifecycle, TaskLifecycle::Ready) {
                    SignalDisposition::Run
                } else {
                    SignalDisposition::Queue
                }
            }
            Urgency::Low => SignalDisposition::Observe,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::scheduler::tcb::TaskLifecycle;
    use crate::types::result::TerminationReason;
    use crate::types::signal::{SignalSource, SignalType};

    #[test]
    fn critical_signal_interrupts_running() {
        let policy = UrgencyBasedPolicy;
        let signal = RuntimeSignal::new(
            SignalSource::Gateway,
            SignalType::Alert,
            Urgency::Critical,
            "fire",
        );
        assert_eq!(
            policy.evaluate(&signal, TaskLifecycle::Running),
            SignalDisposition::InterruptNow
        );
    }

    #[test]
    fn low_signal_observed() {
        let policy = UrgencyBasedPolicy;
        let signal =
            RuntimeSignal::new(SignalSource::Cron, SignalType::Event, Urgency::Low, "tick");
        assert_eq!(
            policy.evaluate(&signal, TaskLifecycle::Ready),
            SignalDisposition::Observe
        );
    }

    #[test]
    fn normal_signal_runs_an_idle_nonterminal_task() {
        let policy = UrgencyBasedPolicy;
        let signal = RuntimeSignal::new(
            SignalSource::Cron,
            SignalType::Job,
            Urgency::Normal,
            "work ready",
        );

        assert_eq!(
            policy.evaluate(&signal, TaskLifecycle::Ready),
            SignalDisposition::Run
        );
        assert_eq!(
            policy.evaluate(&signal, TaskLifecycle::Running),
            SignalDisposition::Queue
        );
    }

    #[test]
    fn terminal_task_queues_signal_for_host_decision() {
        let policy = UrgencyBasedPolicy;
        let signal = RuntimeSignal::new(
            SignalSource::Gateway,
            SignalType::Alert,
            Urgency::Critical,
            "late signal",
        );

        assert_eq!(
            policy.evaluate(&signal, TaskLifecycle::Done(TerminationReason::Completed),),
            SignalDisposition::Queue
        );
    }
}