kindly_guard_server/
component_selector.rs

1// Copyright 2025 Kindly Software Inc.
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//! Component selector for choosing between standard and enhanced implementations
15//! This provides the abstraction layer that hides the implementation details
16
17use crate::audit::{AuditLogger, AuditLoggerFactory, DefaultAuditLoggerFactory};
18use crate::config::Config;
19#[cfg(feature = "enhanced")]
20use crate::enhanced_impl::EnhancedComponentFactory;
21use crate::neutralizer::{create_neutralizer, ThreatNeutralizer};
22#[cfg(feature = "enhanced")]
23use crate::permissions::EnhancedPermissionManager;
24use crate::permissions::{
25    default_tool_definitions, ClientPermissions, PermissionRules, StandardPermissionManager,
26    ThreatLevel, ToolPermissionManager,
27};
28use crate::plugins::{DefaultPluginManagerFactory, PluginManagerFactory, PluginManagerTrait};
29use crate::resilience::{
30    create_bulkhead, create_circuit_breaker, create_retry_strategy, DynBulkhead,
31};
32use crate::standard_impl::StandardFactory;
33use crate::storage::{DefaultStorageFactory, StorageProvider, StorageProviderFactory};
34#[cfg(feature = "enhanced")]
35use crate::telemetry::enhanced::EnhancedTelemetryFactory;
36use crate::telemetry::{
37    standard::StandardTelemetryFactory, TelemetryProvider, TelemetryProviderFactory,
38};
39use crate::traits::{
40    CorrelationEngine, EnhancedScanner, RateLimiter, SecurityComponentFactory,
41    SecurityEventProcessor,
42};
43use crate::traits::{DynCircuitBreaker, DynRetryStrategy};
44use anyhow::Result;
45use std::sync::Arc;
46
47/// Selects appropriate component implementations based on configuration
48pub struct ComponentSelector {
49    factory: Box<dyn SecurityComponentFactory>,
50}
51
52impl ComponentSelector {
53    /// Create a new component selector
54    pub fn new(config: &Config) -> Self {
55        // Choose factory based on event processor configuration
56        #[cfg(feature = "enhanced")]
57        let factory: Box<dyn SecurityComponentFactory> = if config.is_event_processor_enabled() {
58            tracing::info!("Performance mode: ENABLED");
59            tracing::debug!("Advanced analytics active");
60            Box::new(EnhancedComponentFactory)
61        } else {
62            tracing::info!("Performance mode: STANDARD");
63            Box::new(StandardFactory)
64        };
65
66        #[cfg(not(feature = "enhanced"))]
67        let factory: Box<dyn SecurityComponentFactory> = {
68            if config.is_event_processor_enabled() {
69                tracing::warn!("Enhanced mode requested but not available - using standard mode");
70            }
71            tracing::info!("Performance mode: STANDARD");
72            Box::new(StandardFactory)
73        };
74
75        Self { factory }
76    }
77
78    /// Create event processor
79    pub fn create_event_processor(
80        &self,
81        config: &Config,
82        storage: Arc<dyn StorageProvider>,
83    ) -> Result<Arc<dyn SecurityEventProcessor>> {
84        self.factory.create_event_processor(config, storage)
85    }
86
87    /// Create scanner
88    pub fn create_scanner(&self, config: &Config) -> Result<Arc<dyn EnhancedScanner>> {
89        self.factory.create_scanner(config)
90    }
91
92    /// Create correlation engine
93    pub fn create_correlation_engine(
94        &self,
95        config: &Config,
96        storage: Arc<dyn StorageProvider>,
97    ) -> Result<Arc<dyn CorrelationEngine>> {
98        self.factory.create_correlation_engine(config, storage)
99    }
100
101    /// Create rate limiter
102    pub fn create_rate_limiter(
103        &self,
104        config: &Config,
105        storage: Arc<dyn StorageProvider>,
106    ) -> Result<Arc<dyn RateLimiter>> {
107        self.factory.create_rate_limiter(config, storage)
108    }
109
110    /// Check if enhanced mode is active
111    pub const fn is_enhanced_mode(&self, config: &Config) -> bool {
112        config.is_event_processor_enabled()
113    }
114}
115
116/// Global component manager for easy access
117pub struct ComponentManager {
118    event_processor: Arc<dyn SecurityEventProcessor>,
119    scanner: Arc<dyn EnhancedScanner>,
120    correlation_engine: Arc<dyn CorrelationEngine>,
121    rate_limiter: Arc<dyn RateLimiter>,
122    permission_manager: Arc<dyn ToolPermissionManager>,
123    telemetry_provider: Arc<dyn TelemetryProvider>,
124    storage_provider: Arc<dyn StorageProvider>,
125    plugin_manager: Arc<dyn PluginManagerTrait>,
126    audit_logger: Arc<dyn AuditLogger>,
127    threat_neutralizer: Arc<dyn ThreatNeutralizer>,
128    circuit_breaker: Arc<dyn DynCircuitBreaker>,
129    retry_strategy: Arc<dyn DynRetryStrategy>,
130    bulkhead: Arc<dyn DynBulkhead>,
131    enhanced_mode: bool,
132}
133
134impl ComponentManager {
135    /// Create a new component manager with all components
136    pub fn new(config: &Config) -> Result<Self> {
137        let selector = ComponentSelector::new(config);
138
139        // Create permission rules
140        let permission_rules = PermissionRules {
141            default_permissions: ClientPermissions {
142                max_threat_level: ThreatLevel::Medium,
143                ..Default::default()
144            },
145            tools: default_tool_definitions(),
146            category_rules: Default::default(),
147            global_deny_list: Default::default(),
148        };
149
150        // Create permission manager based on mode
151        #[cfg(feature = "enhanced")]
152        let permission_manager: Arc<dyn ToolPermissionManager> =
153            if config.is_event_processor_enabled() {
154                Arc::new(EnhancedPermissionManager::new(permission_rules))
155            } else {
156                Arc::new(StandardPermissionManager::new(permission_rules))
157            };
158
159        #[cfg(not(feature = "enhanced"))]
160        let permission_manager: Arc<dyn ToolPermissionManager> =
161            Arc::new(StandardPermissionManager::new(permission_rules));
162
163        // Create storage provider first
164        let storage_factory = DefaultStorageFactory;
165        let storage_provider = storage_factory.create(&config.storage)?;
166
167        // Create event processor with storage
168        let event_processor = selector.create_event_processor(config, storage_provider.clone())?;
169
170        // Create telemetry provider
171        #[cfg(feature = "enhanced")]
172        let telemetry_factory: Box<dyn TelemetryProviderFactory> =
173            if config.is_event_processor_enabled() {
174                Box::new(EnhancedTelemetryFactory::new(event_processor.clone()))
175            } else {
176                Box::new(StandardTelemetryFactory)
177            };
178
179        #[cfg(not(feature = "enhanced"))]
180        let telemetry_factory: Box<dyn TelemetryProviderFactory> =
181            Box::new(StandardTelemetryFactory);
182
183        let telemetry_provider = telemetry_factory.create(&config.telemetry)?;
184
185        // Create plugin manager
186        let plugin_factory = DefaultPluginManagerFactory;
187        let plugin_manager = plugin_factory.create(&config.plugins)?;
188
189        // Create audit logger
190        let audit_factory = DefaultAuditLoggerFactory;
191        let audit_logger = audit_factory.create(&config.audit)?;
192
193        // Create rate limiter first (needed by neutralizer)
194        let rate_limiter = selector.create_rate_limiter(config, storage_provider.clone())?;
195
196        // Create threat neutralizer with rate limiting
197        let threat_neutralizer =
198            create_neutralizer(&config.neutralization, Some(rate_limiter.clone()));
199
200        // Create resilience components
201        let circuit_breaker = create_circuit_breaker(config)?;
202        let retry_strategy = create_retry_strategy(config)?;
203        let bulkhead = create_bulkhead(config)?;
204
205        Ok(Self {
206            event_processor,
207            scanner: selector.create_scanner(config)?,
208            correlation_engine: selector
209                .create_correlation_engine(config, storage_provider.clone())?,
210            rate_limiter,
211            permission_manager,
212            telemetry_provider,
213            storage_provider,
214            plugin_manager,
215            audit_logger,
216            threat_neutralizer,
217            circuit_breaker,
218            retry_strategy,
219            bulkhead,
220            enhanced_mode: selector.is_enhanced_mode(config),
221        })
222    }
223
224    /// Get event processor
225    pub fn event_processor(&self) -> &Arc<dyn SecurityEventProcessor> {
226        &self.event_processor
227    }
228
229    /// Get scanner
230    pub fn scanner(&self) -> &Arc<dyn EnhancedScanner> {
231        &self.scanner
232    }
233
234    /// Get correlation engine
235    pub fn correlation_engine(&self) -> &Arc<dyn CorrelationEngine> {
236        &self.correlation_engine
237    }
238
239    /// Get rate limiter
240    pub fn rate_limiter(&self) -> &Arc<dyn RateLimiter> {
241        &self.rate_limiter
242    }
243
244    /// Get permission manager
245    pub fn permission_manager(&self) -> &Arc<dyn ToolPermissionManager> {
246        &self.permission_manager
247    }
248
249    /// Get telemetry provider
250    pub fn telemetry_provider(&self) -> &Arc<dyn TelemetryProvider> {
251        &self.telemetry_provider
252    }
253
254    /// Get storage provider
255    pub fn storage_provider(&self) -> &Arc<dyn StorageProvider> {
256        &self.storage_provider
257    }
258
259    /// Get plugin manager
260    pub fn plugin_manager(&self) -> &Arc<dyn PluginManagerTrait> {
261        &self.plugin_manager
262    }
263
264    /// Get audit logger
265    pub fn audit_logger(&self) -> &Arc<dyn AuditLogger> {
266        &self.audit_logger
267    }
268
269    /// Get threat neutralizer
270    pub fn threat_neutralizer(&self) -> &Arc<dyn ThreatNeutralizer> {
271        &self.threat_neutralizer
272    }
273
274    /// Get circuit breaker
275    pub fn circuit_breaker(&self) -> &Arc<dyn DynCircuitBreaker> {
276        &self.circuit_breaker
277    }
278
279    /// Get retry strategy
280    pub fn retry_strategy(&self) -> &Arc<dyn DynRetryStrategy> {
281        &self.retry_strategy
282    }
283
284    /// Get bulkhead
285    pub fn bulkhead(&self) -> &Arc<dyn DynBulkhead> {
286        &self.bulkhead
287    }
288
289    /// Check if running in enhanced mode
290    pub const fn is_enhanced_mode(&self) -> bool {
291        self.enhanced_mode
292    }
293
294    /// Get performance description for logging
295    pub const fn performance_description(&self) -> &'static str {
296        if self.enhanced_mode {
297            "optimized performance mode"
298        } else {
299            "standard performance mode"
300        }
301    }
302}
kindly_guard_server/component_selector.rs

kindly_guard_server/
component_selector.rs
