zerodds-corba-ccm 1.0.0-rc.1

OMG CCM 4.0 — Component Container, CIF, CIDL-Modell, TimerEventService. Migrationspfad fuer CORBA-Bestandscode auf den ZeroDDS-Bus.
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 ZeroDDS Contributors

//! CIF — Component Implementation Framework (Spec §8).
//!
//! Vier Executor-Modi (Spec §8.1.4):
//!
//! | Mode | Verwendung | Lifecycle |
//! |---|---|---|
//! | Session | one-instance-per-session | session-scoped |
//! | Service | stateless | per-request |
//! | Process | long-running per-process | process-scoped |
//! | Entity | persistent | persistent |
//!
//! Component-Executor implementiert die Component-Method-Logik;
//! Home-Executor verwaltet Lifecycle-Calls (`ccm_activate` etc.).

use alloc::boxed::Box;
use alloc::string::String;
use alloc::vec::Vec;

use crate::context::ComponentContext;

/// Allgemeines Executor-Trait (alle vier Modi).
pub trait ComponentExecutor: Send + Sync {
    /// `set_session_context` / `set_service_context` etc. — der
    /// Container injiziert den Context vor dem ersten Method-Call
    /// (Spec §8.1.5).
    fn set_context(&mut self, context: Box<dyn ComponentContext>);

    /// `ccm_activate` — Spec §8.1.5.4.
    fn ccm_activate(&mut self) -> Result<(), CifError> {
        Ok(())
    }

    /// `ccm_passivate` — Spec §8.1.5.5.
    fn ccm_passivate(&mut self) -> Result<(), CifError> {
        Ok(())
    }

    /// `ccm_remove` — Spec §8.1.5.6.
    fn ccm_remove(&mut self) -> Result<(), CifError> {
        Ok(())
    }
}

/// CIF-spezifische Fehler.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum CifError {
    /// `CCMException` — generischer Fehler aus dem Executor.
    CcmException(String),
}

/// Session-Executor — Spec §8.1.4.1.
pub trait SessionExecutor: ComponentExecutor {
    /// Marker-Method, dass der Executor Session-Mode hat.
    fn session_marker(&self) {}
}

/// Keyed-Executor — Spec §8.1.4.4 (Entity).
pub trait KeyedExecutor: ComponentExecutor {
    /// Liefert den Primary-Key des Entity-Executors.
    fn primary_key(&self) -> Vec<u8>;
}

/// ExecutorLocator — Spec §8.1.6.
///
/// Vom Container aufgerufen, um pro Method-Call den passenden
/// Executor zu bekommen. Bei Session/Process: cached; bei Service:
/// transient.
pub trait ExecutorLocator: Send + Sync {
    /// Vor dem Method-Call.
    ///
    /// # Errors
    /// CIF-Fehler, falls der Locator den Executor nicht liefern kann.
    fn obtain_executor(&self, oid: &[u8]) -> Result<Box<dyn ComponentExecutor>, CifError>;
}

#[cfg(test)]
#[allow(clippy::expect_used, clippy::unwrap_used, clippy::panic)]
mod tests {
    use super::*;
    use core::sync::atomic::{AtomicUsize, Ordering};

    struct LoggingContext {
        log: alloc::sync::Arc<AtomicUsize>,
    }

    impl ComponentContext for LoggingContext {
        fn get_caller_principal(&self) -> Option<alloc::vec::Vec<u8>> {
            self.log.fetch_add(1, Ordering::Relaxed);
            None
        }
    }

    struct DemoExecutor {
        ctx: Option<Box<dyn ComponentContext>>,
        activations: AtomicUsize,
        passivations: AtomicUsize,
    }

    impl ComponentExecutor for DemoExecutor {
        fn set_context(&mut self, c: Box<dyn ComponentContext>) {
            self.ctx = Some(c);
        }
        fn ccm_activate(&mut self) -> Result<(), CifError> {
            self.activations.fetch_add(1, Ordering::Relaxed);
            Ok(())
        }
        fn ccm_passivate(&mut self) -> Result<(), CifError> {
            self.passivations.fetch_add(1, Ordering::Relaxed);
            Ok(())
        }
    }

    impl SessionExecutor for DemoExecutor {}

    #[test]
    fn lifecycle_calls_increment_counters() {
        let mut e = DemoExecutor {
            ctx: None,
            activations: AtomicUsize::new(0),
            passivations: AtomicUsize::new(0),
        };
        e.set_context(Box::new(LoggingContext {
            log: alloc::sync::Arc::new(AtomicUsize::new(0)),
        }));
        assert!(e.ctx.is_some());
        e.ccm_activate().unwrap();
        e.ccm_activate().unwrap();
        e.ccm_passivate().unwrap();
        assert_eq!(e.activations.load(Ordering::Relaxed), 2);
        assert_eq!(e.passivations.load(Ordering::Relaxed), 1);
    }

    #[test]
    fn cif_error_carries_diagnostic() {
        let e = CifError::CcmException("permission denied".into());
        match e {
            CifError::CcmException(s) => assert_eq!(s, "permission denied"),
        }
    }
}