mecha10-core 0.8.0

Mecha10 core runtime and foundational types
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

//! Node execution context
//!
//! Provides a high-level API for nodes to interact with the framework,
//! including type-safe pub/sub, configuration access, and lifecycle management.
//!
//! This module has been refactored into smaller sub-modules for better organization:
//! - `infra_config`: Infrastructure configuration types
//! - `receiver`: Message receiver wrapper
//! - `builder`: Builder for constructing a `Context`
//! - `lifecycle`: Construction, instance naming, shutdown, logging span
//! - `config`: Infrastructure configuration loading (Redis URLs, control plane)
//! - `node_config`: Node-level configuration loading with environment fallback
//! - `pubsub`: Type-safe and raw publish/subscribe methods
//! - `aggregation`: Pattern-based topic discovery and aggregated subscriptions
//! - `topics`: Convenience helpers for well-known topic categories
//! - `state_mgmt`: Access to the per-node persistent state manager

mod aggregation;
mod builder;
mod config;
mod infra_config;
mod lifecycle;
mod node_config;
mod pubsub;
mod receiver;
mod state_mgmt;
mod topics;

pub use builder::ContextBuilder;
pub use infra_config::{BridgeConfig, InfrastructureConfig, MinioConfig, MlflowConfig, PostgresConfig, RedisConfig};
pub use node_config::split_base_and_custom;
pub use receiver::Receiver;

use std::sync::Arc;
use tokio::sync::RwLock;

pub struct Context {
    node_id: String,

    instance: Option<String>,

    #[cfg(feature = "messaging")]
    message_bus: Arc<RwLock<mecha10_messaging::MessageBus>>,

    #[cfg(feature = "messaging")]
    control_plane_bus: Arc<RwLock<Option<mecha10_messaging::MessageBus>>>,

    #[cfg(feature = "messaging")]
    redis_bridge: Arc<RwLock<Option<crate::redis_bridge::RedisBridge>>>,

    shutdown: Arc<RwLock<bool>>,

    state_manager: Arc<RwLock<Option<Arc<crate::state::ConcreteStateManager>>>>,
}
impl Clone for Context {
    fn clone(&self) -> Self {
        Self {
            node_id: self.node_id.clone(),
            instance: self.instance.clone(),
            #[cfg(feature = "messaging")]
            message_bus: Arc::clone(&self.message_bus),
            #[cfg(feature = "messaging")]
            control_plane_bus: Arc::clone(&self.control_plane_bus),
            #[cfg(feature = "messaging")]
            redis_bridge: Arc::clone(&self.redis_bridge),
            shutdown: Arc::clone(&self.shutdown),
            state_manager: Arc::clone(&self.state_manager),
        }
    }
}