darpan 0.2.5

Linux developer service monitoring utility with auto-detection, real-time health checks, and interactive TUI for databases, APIs, Docker containers, and more
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use crate::config::{ConfigLoader, ProjectConfig, UserConfig};
use crate::core::{
    detector_registry::DetectorRegistry,
    pack_integration::PackIntegration,
    registry::ServiceRegistry,
    registry_builder::RegistryBuilder,
};
use crate::health::HealthCheckerRegistry;
use crate::logs::log_registry::LogStreamerRegistry;
use crate::packs::schema::ServicePack;
use anyhow::Result;
use std::path::PathBuf;
use tracing::info;

pub struct CoreEngine {
    project_path: PathBuf,
    registry: ServiceRegistry,
    user_config: UserConfig,
    project_config: Option<ProjectConfig>,
    detector_registry: DetectorRegistry,
    health_registry: HealthCheckerRegistry,
    log_registry: LogStreamerRegistry,
    service_packs: Vec<ServicePack>,
}

impl CoreEngine {
    pub fn new(project_path: PathBuf) -> Result<Self> {
        info!("Initializing Darpan for project: {:?}", project_path);
        
        let user_config = ConfigLoader::load_user_config()?;
        let project_config = ConfigLoader::load_project_config(&project_path)?;
        
        // Build registries with built-in components
        let mut detector_registry = RegistryBuilder::build_detector_registry(
            &user_config.detection.enabled_detectors,
            user_config.detection.port_range,
        );
        
        let mut health_registry = RegistryBuilder::build_health_registry(
            std::time::Duration::from_secs(user_config.health_checks.timeout),
        );
        
        let mut log_registry = RegistryBuilder::build_log_registry();
        
        // Load and integrate service packs
        let service_packs = PackIntegration::integrate_packs(
            &project_path,
            &mut detector_registry,
            &mut health_registry,
            &mut log_registry,
        )?;
        
        Ok(Self {
            project_path,
            registry: ServiceRegistry::new(),
            user_config,
            project_config,
            detector_registry,
            health_registry,
            log_registry,
            service_packs,
        })
    }

    pub async fn detect_services(&mut self) -> Result<()> {
        info!("Starting service detection");
        self.registry.clear();
        
        // Use detector registry to detect services
        let mut services = self
            .detector_registry
            .detect(&self.project_path, self.project_config.as_ref())
            .await?;
        
        // Apply pack defaults to detected services
        for service in &mut services {
            PackIntegration::apply_pack_defaults(service, &self.service_packs);
        }
        
        for service in services {
            self.registry.merge_or_update(service);
        }
        
        info!("Detection complete. Found {} services", self.registry.count());
        Ok(())
    }

    pub async fn check_health(&mut self) -> Result<()> {
        info!("Starting health checks");
        
        for service in self.registry.all_services_mut() {
            let health_result = self.health_registry.check(service).await;
            service.health_status = Some(health_result);
        }
        
        info!("Health checks complete");
        Ok(())
    }

    /// Get mutable access to detector registry for extension
    pub fn detector_registry_mut(&mut self) -> &mut DetectorRegistry {
        &mut self.detector_registry
    }

    /// Get mutable access to health registry for extension
    pub fn health_registry_mut(&mut self) -> &mut HealthCheckerRegistry {
        &mut self.health_registry
    }

    /// Get mutable access to log registry for extension
    pub fn log_registry_mut(&mut self) -> &mut LogStreamerRegistry {
        &mut self.log_registry
    }

    /// Get loaded service packs
    pub fn service_packs(&self) -> &[ServicePack] {
        &self.service_packs
    }

    pub async fn refresh(&mut self) -> Result<()> {
        self.detect_services().await?;
        self.check_health().await?;
        Ok(())
    }

    pub fn get_registry(&self) -> &ServiceRegistry {
        &self.registry
    }

    pub fn get_registry_mut(&mut self) -> &mut ServiceRegistry {
        &mut self.registry
    }

    pub fn project_path(&self) -> &PathBuf {
        &self.project_path
    }

    pub fn user_config(&self) -> &UserConfig {
        &self.user_config
    }

    pub fn project_config(&self) -> Option<&ProjectConfig> {
        self.project_config.as_ref()
    }
}