rustfs_notify/
services.rs1use crate::{
16 Event,
17 bucket_config_manager::NotifyBucketConfigManager,
18 config_manager::NotifyConfigManager,
19 integration::NotificationMetrics,
20 notification_system_subscriber::NotificationSystemSubscriberView,
21 notifier::{EventNotifier, SharedNotifyTargetList},
22 pipeline::{LiveEventHistory, NotifyPipeline},
23 registry::TargetRegistry,
24 rule_engine::NotifyRuleEngine,
25 runtime_facade::NotifyRuntimeFacade,
26 runtime_view::NotifyRuntimeView,
27 status_view::NotifyStatusView,
28};
29use rustfs_config::server_config::Config;
30use rustfs_targets::ReplayWorkerManager;
31use std::sync::Arc;
32use tokio::sync::{RwLock, Semaphore, broadcast};
33
34#[derive(Clone)]
35pub struct NotifyServices {
36 pub bucket_config_manager: NotifyBucketConfigManager,
37 pub config_manager: NotifyConfigManager,
38 pub pipeline: NotifyPipeline,
39 pub runtime_facade: NotifyRuntimeFacade,
40 pub runtime_view: NotifyRuntimeView,
41 pub status_view: NotifyStatusView,
42}
43
44impl NotifyServices {
45 #[allow(clippy::too_many_arguments)]
46 pub fn new(
47 notifier: Arc<EventNotifier>,
48 rule_engine: NotifyRuleEngine,
49 target_list: SharedNotifyTargetList,
50 registry: Arc<TargetRegistry>,
51 config: Arc<RwLock<Config>>,
52 stream_cancellers: Arc<RwLock<ReplayWorkerManager>>,
53 concurrency_limiter: Arc<Semaphore>,
54 metrics: Arc<NotificationMetrics>,
55 subscriber_view: Arc<NotificationSystemSubscriberView>,
56 live_event_sender: broadcast::Sender<Arc<Event>>,
57 live_event_history: Arc<RwLock<LiveEventHistory>>,
58 ) -> Self {
59 let runtime_view = NotifyRuntimeView::new(target_list.clone(), stream_cancellers.clone());
60 let runtime_facade = NotifyRuntimeFacade::new_with_dispatch_gate(
61 target_list,
62 stream_cancellers,
63 notifier.dispatch_gate(),
64 concurrency_limiter,
65 metrics.clone(),
66 );
67 let config_manager = NotifyConfigManager::new(config, registry, rule_engine.clone(), runtime_facade.clone());
68 let bucket_config_manager = NotifyBucketConfigManager::new(notifier.clone(), rule_engine, subscriber_view);
69 let pipeline = NotifyPipeline::new(notifier, live_event_sender, live_event_history);
70 let status_view = NotifyStatusView::new(metrics);
71
72 Self {
73 bucket_config_manager,
74 config_manager,
75 pipeline,
76 runtime_facade,
77 runtime_view,
78 status_view,
79 }
80 }
81}
82
83#[cfg(test)]
84mod tests {
85 use super::NotifyServices;
86 use crate::{
87 integration::NotificationMetrics, notification_system_subscriber::NotificationSystemSubscriberView,
88 notifier::EventNotifier, pipeline::LiveEventHistory, registry::TargetRegistry, rule_engine::NotifyRuleEngine,
89 };
90 use rustfs_config::server_config::Config;
91 use rustfs_targets::ReplayWorkerManager;
92 use std::sync::Arc;
93 use tokio::sync::{RwLock, Semaphore, broadcast};
94
95 #[tokio::test]
96 async fn services_build_empty_runtime_views() {
97 let metrics = Arc::new(NotificationMetrics::new());
98 let rule_engine = NotifyRuleEngine::new();
99 let notifier = Arc::new(EventNotifier::new(metrics.clone(), rule_engine.clone()));
100 let target_list = notifier.target_list();
101 let registry = Arc::new(TargetRegistry::new());
102 let config = Arc::new(RwLock::new(Config::default()));
103 let stream_cancellers = Arc::new(RwLock::new(ReplayWorkerManager::new()));
104 let concurrency_limiter = Arc::new(Semaphore::new(4));
105 let subscriber_view = Arc::new(NotificationSystemSubscriberView::new());
106 let (live_event_sender, _) = broadcast::channel(16);
107 let live_event_history = Arc::new(RwLock::new(LiveEventHistory::default()));
108
109 let services = NotifyServices::new(
110 notifier,
111 rule_engine,
112 target_list,
113 registry,
114 config,
115 stream_cancellers,
116 concurrency_limiter,
117 metrics,
118 subscriber_view,
119 live_event_sender,
120 live_event_history,
121 );
122
123 assert!(services.runtime_view.get_active_targets().await.is_empty());
124 assert_eq!(services.status_view.snapshot_metrics().events_sent_total, 0);
125 }
126}