glowbarn 2.0.0

Multi-Sensor Anomaly Detection System - High Performance Native Application
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

// Copyright (c) 2026 bad-antics
// Licensed under the MIT License. See LICENSE file in the project root.
// https://github.com/bad-antics/glowbarn-rs

//! Event bus for inter-component communication

use std::sync::Arc;
use tokio::sync::{broadcast, mpsc};
use serde::{Deserialize, Serialize};
use chrono::{DateTime, Utc};

use crate::sensors::SensorReading;
use crate::detection::Detection;

/// Event types in the system
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum EventType {
    SensorReading,
    Detection,
    Alert,
    SystemStatus,
    Error,
}

/// Generic event wrapper
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Event {
    pub id: u64,
    pub event_type: EventType,
    pub timestamp: DateTime<Utc>,
    pub payload: EventPayload,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum EventPayload {
    Reading(SensorReading),
    Detection(Detection),
    Alert { level: String, message: String },
    Status { key: String, value: String },
    Error { code: u32, message: String },
}

/// Central event bus for pub/sub communication
pub struct EventBus {
    reading_tx: broadcast::Sender<SensorReading>,
    detection_tx: broadcast::Sender<Detection>,
    event_tx: broadcast::Sender<Event>,
    event_counter: std::sync::atomic::AtomicU64,
}

impl EventBus {
    pub fn new(capacity: usize) -> Self {
        let (reading_tx, _) = broadcast::channel(capacity);
        let (detection_tx, _) = broadcast::channel(capacity);
        let (event_tx, _) = broadcast::channel(capacity);
        
        Self {
            reading_tx,
            detection_tx,
            event_tx,
            event_counter: std::sync::atomic::AtomicU64::new(0),
        }
    }
    
    pub fn publish_reading(&self, reading: SensorReading) {
        let _ = self.reading_tx.send(reading.clone());
        self.publish_event(EventType::SensorReading, EventPayload::Reading(reading));
    }
    
    pub fn publish_detection(&self, detection: Detection) {
        let _ = self.detection_tx.send(detection.clone());
        self.publish_event(EventType::Detection, EventPayload::Detection(detection));
    }
    
    pub fn publish_alert(&self, level: &str, message: &str) {
        self.publish_event(
            EventType::Alert,
            EventPayload::Alert {
                level: level.to_string(),
                message: message.to_string(),
            },
        );
    }
    
    pub fn publish_error(&self, code: u32, message: &str) {
        self.publish_event(
            EventType::Error,
            EventPayload::Error {
                code,
                message: message.to_string(),
            },
        );
    }
    
    fn publish_event(&self, event_type: EventType, payload: EventPayload) {
        let id = self.event_counter.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
        let event = Event {
            id,
            event_type,
            timestamp: Utc::now(),
            payload,
        };
        let _ = self.event_tx.send(event);
    }
    
    pub fn subscribe_readings(&self) -> broadcast::Receiver<SensorReading> {
        self.reading_tx.subscribe()
    }
    
    pub fn subscribe_detections(&self) -> broadcast::Receiver<Detection> {
        self.detection_tx.subscribe()
    }
    
    pub fn subscribe_events(&self) -> broadcast::Receiver<Event> {
        self.event_tx.subscribe()
    }
}