darpan 0.2.2

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

use crate::models::Service;
use std::process::Command;
use tracing::trace;

/// Get network statistics for a service
pub struct NetworkMonitor;

impl NetworkMonitor {
    /// Get count of active connections for a service port
    pub fn get_active_connections(service: &Service) -> Option<usize> {
        // Use ss (socket statistics) to count connections
        let output = Command::new("ss")
            .args(&["-tn", &format!("sport = :{}", service.port)])
            .output()
            .ok()?;

        if output.status.success() {
            let stdout = String::from_utf8_lossy(&output.stdout);
            // Count non-header lines
            let count = stdout.lines().skip(1).count();
            trace!("Service {} on port {} has {} active connections", service.name, service.port, count);
            Some(count)
        } else {
            None
        }
    }

    /// Get count of listening sockets for a service port
    pub fn is_port_listening(port: u16) -> bool {
        let output = Command::new("ss")
            .args(&["-tln", &format!("sport = :{}", port)])
            .output();

        if let Ok(output) = output {
            if output.status.success() {
                let stdout = String::from_utf8_lossy(&output.stdout);
                let has_listener = stdout.lines().skip(1).any(|line| {
                    line.contains(&format!(":{}", port)) && line.contains("LISTEN")
                });
                trace!("Port {} listening: {}", port, has_listener);
                return has_listener;
            }
        }
        false
    }

    /// Get process network activity statistics
    pub fn get_process_stats(pid: u32) -> Option<ProcessNetStats> {
        // Read from /proc/<pid>/net/tcp and /proc/<pid>/net/tcp6
        let tcp_path = format!("/proc/{}/net/tcp", pid);
        let tcp6_path = format!("/proc/{}/net/tcp6", pid);

        let mut established = 0;
        let mut listen = 0;

        // Parse TCP connections
        if let Ok(content) = std::fs::read_to_string(&tcp_path) {
            for line in content.lines().skip(1) {
                let parts: Vec<&str> = line.split_whitespace().collect();
                if parts.len() > 3 {
                    match parts[3] {
                        "01" => established += 1, // ESTABLISHED
                        "0A" => listen += 1,      // LISTEN
                        _ => {}
                    }
                }
            }
        }

        // Parse TCP6 connections
        if let Ok(content) = std::fs::read_to_string(&tcp6_path) {
            for line in content.lines().skip(1) {
                let parts: Vec<&str> = line.split_whitespace().collect();
                if parts.len() > 3 {
                    match parts[3] {
                        "01" => established += 1,
                        "0A" => listen += 1,
                        _ => {}
                    }
                }
            }
        }

        if established > 0 || listen > 0 {
            Some(ProcessNetStats {
                established_connections: established,
                listening_sockets: listen,
            })
        } else {
            None
        }
    }
}

#[derive(Debug, Clone)]
pub struct ProcessNetStats {
    pub established_connections: usize,
    pub listening_sockets: usize,
}