Skip to main content

rustfs_notify/
services.rs

1// Copyright 2024 RustFS Team
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use 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}