mirror/archived-netvisor
1
0
Fork 0
mirror of https://github.com/mayanayza/netvisor.git synced 2025-12-10 08:24:08 -06:00
Code Issues Packages Projects Releases Wiki Activity

finished refactoring to node-centric tests

Browse Source
This commit is contained in:
Maya
2025-08-19 18:30:48 -04:00
parent 01a5263fb4
commit 4f74ecec12
16 changed files with 939 additions and 668 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/components/node_groups/handlers.rs
View File

@@ -39,7 +39,7 @@ async fn create_node_group(
let mut group = NodeGroup::from_name(request.group.name);
group.base.description = request.group.description;
group.base.node_sequence = request.group.node_sequence;
group.base.auto_diagnostic_on_node_failure = request.group.auto_diagnostic_on_node_failure;
group.base.auto_diagnostic_enabled = request.group.auto_diagnostic_enabled;
let created_group = service.create_group(group).await?;
@@ -94,13 +94,13 @@ async fn update_node_group(
group.base.name = name;
}
if let Some(description) = request.description {
group.base.description = Some(description);
group.base.description = description;
}
if let Some(node_sequence) = request.node_sequence {
group.base.node_sequence = node_sequence;
}
if let Some(auto_diagnostic_on_node_failure) = request.auto_diagnostic_on_node_failure {
group.base.auto_diagnostic_on_node_failure = auto_diagnostic_on_node_failure;
if let Some(auto_diagnostic_enabled) = request.auto_diagnostic_enabled {
group.base.auto_diagnostic_enabled = auto_diagnostic_enabled;
}
let updated_group = service.update_group(group).await?;

16
src/components/node_groups/service.rs
View File

@@ -29,6 +29,11 @@ impl NodeGroupService {
pub async fn create_group(&self, mut group: NodeGroup) -> Result<NodeGroup> {
// Generate ID
group.id = uuid::Uuid::new_v4().to_string();
let now = chrono::Utc::now();
group.created_at = now.clone();
group.updated_at = now;
println!("1");
// Validate that all nodes in sequence exist
for node_id in &group.base.node_sequence {
@@ -37,7 +42,11 @@ impl NodeGroupService {
}
}
println!("2");
self.group_storage.create(&group).await?;
println!("3");
// Add group reference to all nodes in the sequence
for node_id in &group.base.node_sequence {
@@ -47,6 +56,8 @@ impl NodeGroupService {
}
}
println!("4");
Ok(group)
}
@@ -61,7 +72,10 @@ impl NodeGroupService {
}
/// Update group
pub async fn update_group(&self, group: NodeGroup) -> Result<NodeGroup> {
pub async fn update_group(&self, mut group: NodeGroup) -> Result<NodeGroup> {
let now = chrono::Utc::now();
group.updated_at = now;
// Validate that all nodes in sequence exist
for node_id in &group.base.node_sequence {
if self.node_storage.get_by_id(node_id).await?.is_none() {

15
src/components/node_groups/storage.rs
View File

@@ -30,8 +30,8 @@ impl NodeGroupStorage for SqliteNodeGroupStorage {
sqlx::query(
r#"
INSERT INTO node_groups (
id, name, description, node_sequence, auto_diagnostic_on_node_failure,
diagnostic_diagnostic_schedule_minutes, created_at, updated_at
id, name, description, node_sequence, auto_diagnostic_enabled,
created_at, updated_at
) VALUES (?, ?, ?, ?, ?, ?, ?)
"#
)
@@ -39,8 +39,7 @@ impl NodeGroupStorage for SqliteNodeGroupStorage {
.bind(&group.base.name)
.bind(&group.base.description)
.bind(node_sequence_json)
.bind(&group.base.auto_diagnostic_on_node_failure)
.bind(&group.base.diagnostic_schedule_minutes)
.bind(&group.base.auto_diagnostic_enabled)
.bind(chrono::Utc::now().to_rfc3339())
.bind(chrono::Utc::now().to_rfc3339())
.execute(&self.pool)
@@ -81,15 +80,14 @@ impl NodeGroupStorage for SqliteNodeGroupStorage {
r#"
UPDATE node_groups SET
name = ?, description = ?, node_sequence = ?,
auto_diagnostic_on_node_failure = ?, diagnostic_diagnostic_schedule_minutes = ?, updated_at = ?
auto_diagnostic_enabled = ?, updated_at = ?
WHERE id = ?
"#
)
.bind(&group.base.name)
.bind(&group.base.description)
.bind(node_sequence_json)
.bind(&group.base.auto_diagnostic_on_node_failure)
.bind(&group.base.diagnostic_schedule_minutes)
.bind(&group.base.auto_diagnostic_enabled)
.bind(chrono::Utc::now().to_rfc3339())
.bind(&group.id)
.execute(&self.pool)
@@ -119,9 +117,8 @@ fn row_to_node_group(row: sqlx::sqlite::SqliteRow) -> Result<NodeGroup> {
base: NodeGroupBase {
name: row.get("name"),
description: row.get("description"),
diagnostic_schedule_minutes: row.get("diagnostic_sequence_minutes"),
node_sequence,
auto_diagnostic_on_node_failure: row.get("auto_diagnostic_on_node_failure"),
auto_diagnostic_enabled: row.get("auto_diagnostic_enabled"),
}
})
}

12
src/components/node_groups/types.rs
View File

@@ -11,9 +11,9 @@ pub struct CreateNodeGroupRequest {
#[derive(Debug, Serialize, Deserialize)]
pub struct UpdateNodeGroupRequest {
pub name: Option<String>,
pub description: Option<String>,
pub description: Option<Option<String>>,
pub node_sequence: Option<Vec<String>>, // Ordered diagnostic sequence
pub auto_diagnostic_on_node_failure: Option<bool>,
pub auto_diagnostic_enabled: Option<bool>,
}
#[derive(Debug, Serialize, Deserialize)]
@@ -32,8 +32,7 @@ pub struct NodeGroupBase {
pub name: String,
pub description: Option<String>,
pub node_sequence: Vec<String>, // Ordered diagnostic sequence
pub diagnostic_schedule_minutes: Option<u32>, // Regular diagnostic runs
pub auto_diagnostic_on_node_failure: bool, // Default: true
pub auto_diagnostic_enabled: bool, // Default: true
}
#[derive(Debug, Clone, Serialize, Deserialize)]
@@ -61,8 +60,7 @@ impl NodeGroup {
name,
description: None,
node_sequence: Vec::new(),
auto_diagnostic_on_node_failure: true,
diagnostic_schedule_minutes: Some(10)
auto_diagnostic_enabled: true,
};
Self::new(base)
@@ -70,7 +68,7 @@ impl NodeGroup {
// Setters with timestamp updates
pub fn set_auto_diagnostic_enabled(&mut self, enabled: bool) {
self.base.auto_diagnostic_on_node_failure = enabled;
self.base.auto_diagnostic_enabled = enabled;
self.updated_at = chrono::Utc::now();
}

12
src/components/nodes/handlers.rs
View File

@@ -30,8 +30,8 @@ pub fn create_router() -> Router<Arc<AppState>> {
.route("/:id", get(get_node))
.route("/:id", put(update_node))
.route("/:id", delete(delete_node))
.route("/:id/test-recommendations", get(get_test_recommendations))
.route("/capability-recommendations", get(get_capability_recommendations))
.route("/:id/test-compatibility", get(get_test_compatibility))
.route("/capability-compatibility", get(get_capability_compatibility))
}
async fn create_node(
@@ -103,8 +103,8 @@ async fn update_node(
if let Some(capabilities) = request.capabilities {
node.base.capabilities = capabilities;
}
if let Some(monitoring_enabled) = request.monitoring_enabled {
node.base.monitoring_enabled = monitoring_enabled;
if let Some(monitoring_interval) = request.monitoring_interval {
node.base.monitoring_interval = monitoring_interval;
}
if let Some(assigned_tests) = request.assigned_tests {
node.base.assigned_tests = assigned_tests;
@@ -133,7 +133,7 @@ async fn delete_node(
Ok(Json(ApiResponse::success(())))
}
async fn get_capability_recommendations(
async fn get_capability_compatibility(
Query(params): Query<HashMap<String, String>>,
) -> ApiResult<Json<ApiResponse<CompatibilityResponse<NodeCapability>>>> {
let node_type_str = params.get("node_type")
@@ -150,7 +150,7 @@ async fn get_capability_recommendations(
Ok(Json(ApiResponse::success(recommendations)))
}
async fn get_test_recommendations(
async fn get_test_compatibility(
State(state): State<Arc<AppState>>,
Path(node_id): Path<String>,
) -> ApiResult<Json<ApiResponse<CompatibilityResponse<TestTypeCompatibilityInfo>>>> {

38
src/components/nodes/storage.rs
View File

@@ -4,7 +4,7 @@ use sqlx::{SqlitePool, Row};
use crate::components::nodes::types::{
base::{DetectedService, Node, NodeBase, NodeTarget},
tests::{AssignedTest, NodeStatus},
topology::GraphPosition, types_capabilities::NodeType,
topology::GraphPosition, types_capabilities::{NodeCapability, NodeType},
};
#[async_trait]
@@ -15,7 +15,6 @@ pub trait NodeStorage: Send + Sync {
async fn update(&self, node: &Node) -> Result<()>;
async fn delete(&self, id: &str) -> Result<()>;
async fn get_by_group(&self, group_id: &str) -> Result<Vec<Node>>;
async fn get_monitoring_enabled(&self) -> Result<Vec<Node>>;
}
pub struct SqliteNodeStorage {
@@ -41,12 +40,13 @@ impl NodeStorage for SqliteNodeStorage {
let target_json = serde_json::to_string(&node.base.target)?;
let open_ports_json = serde_json::to_string(&node.base.open_ports)?;
let detected_services_json = serde_json::to_string(&node.base.detected_services)?;
let current_status_json = serde_json::to_string(&node.base.current_status)?;
sqlx::query(
r#"
INSERT INTO nodes (
id, name, target, description,
node_type, capabilities, assigned_tests, monitoring_enabled,
node_type, capabilities, assigned_tests, monitoring_interval,
node_groups, position, current_status, subnet_membership,
open_ports, detected_services, mac_address,
last_seen, created_at, updated_at
@@ -60,10 +60,10 @@ impl NodeStorage for SqliteNodeStorage {
.bind(node_type_str)
.bind(capabilities_json)
.bind(assigned_tests_json)
.bind(node.base.monitoring_enabled)
.bind(node.base.monitoring_interval)
.bind(node_groups_json)
.bind(position_json)
.bind(&node.base.current_status.display_name())
.bind(current_status_json)
.bind(subnet_membership_json)
.bind(open_ports_json)
.bind(detected_services_json)
@@ -113,12 +113,13 @@ impl NodeStorage for SqliteNodeStorage {
let target_json = serde_json::to_string(&node.base.target)?;
let open_ports_json = serde_json::to_string(&node.base.open_ports)?;
let detected_services_json = serde_json::to_string(&node.base.detected_services)?;
let current_status_json = serde_json::to_string(&node.base.current_status)?;
sqlx::query(
r#"
UPDATE nodes SET
name = ?, target = ?, description = ?,
node_type = ?, capabilities = ?, assigned_tests = ?, monitoring_enabled = ?,
node_type = ?, capabilities = ?, assigned_tests = ?, monitoring_interval = ?,
node_groups = ?, position = ?, current_status = ?, subnet_membership = ?,
open_ports = ?, detected_services = ?, mac_address = ?,
last_seen = ?, updated_at = ?
@@ -131,10 +132,10 @@ impl NodeStorage for SqliteNodeStorage {
.bind(node_type_str)
.bind(capabilities_json)
.bind(assigned_tests_json)
.bind(node.base.monitoring_enabled)
.bind(node.base.monitoring_interval)
.bind(node_groups_json)
.bind(position_json)
.bind(&node.base.current_status.display_name())
.bind(current_status_json)
.bind(subnet_membership_json)
.bind(open_ports_json)
.bind(detected_services_json)
@@ -169,19 +170,6 @@ impl NodeStorage for SqliteNodeStorage {
Ok(nodes)
}
async fn get_monitoring_enabled(&self) -> Result<Vec<Node>> {
let rows = sqlx::query("SELECT * FROM nodes WHERE monitoring_enabled = true")
.fetch_all(&self.pool)
.await?;
let mut nodes = Vec::new();
for row in rows {
nodes.push(row_to_node(row)?);
}
Ok(nodes)
}
}
fn row_to_node(row: sqlx::sqlite::SqliteRow) -> Result<Node> {
@@ -194,10 +182,10 @@ fn row_to_node(row: sqlx::sqlite::SqliteRow) -> Result<Node> {
let open_ports_json: String = row.get("open_ports");
let detected_services_json: String = row.get("detected_services");
let capabilities = serde_json::from_str(&capabilities_json)?;
let capabilities: Vec<NodeCapability> = serde_json::from_str(&capabilities_json)?;
let assigned_tests: Vec<AssignedTest> = serde_json::from_str(&assigned_tests_json)?;
let node_groups = serde_json::from_str(&node_groups_json)?;
let subnet_membership = serde_json::from_str(&subnet_membership_json)?;
let node_groups: Vec<String> = serde_json::from_str(&node_groups_json)?;
let subnet_membership: Vec<String> = serde_json::from_str(&subnet_membership_json)?;
let current_status: NodeStatus = serde_json::from_str(&current_status_json)?;
let target: NodeTarget = serde_json::from_str(&target_json)?;
let node_type: NodeType = serde_json::from_str(row.get("node_type"))?;
@@ -229,7 +217,7 @@ fn row_to_node(row: sqlx::sqlite::SqliteRow) -> Result<Node> {
open_ports,
assigned_tests,
mac_address: row.get("mac_address"),
monitoring_enabled: row.get("monitoring_enabled"),
monitoring_interval: row.get("monitoring_interval"),
node_groups,
position,
current_status,

2
src/components/nodes/types/api.rs
View File

@@ -31,7 +31,7 @@ pub struct UpdateNodeRequest {
// Monitoring
pub assigned_tests: Option<Vec<AssignedTest>>,
pub monitoring_enabled: Option<bool>,
pub monitoring_interval: Option<u16>,
pub node_groups: Option<Vec<String>>,
// Topology visualization

5
src/components/nodes/types/base.rs
View File

@@ -27,7 +27,7 @@ pub struct NodeBase {
// Monitoring
pub assigned_tests: Vec<AssignedTest>,
pub monitoring_enabled: bool,
pub monitoring_interval: u16,
pub node_groups: Vec<String>,
// Topology visualization
@@ -72,7 +72,7 @@ impl Node {
capabilities: Vec::new(),
assigned_tests: Vec::new(),
monitoring_enabled: false,
monitoring_interval: 5,
node_groups: Vec::new(),
position: None,
current_status: NodeStatus::Unknown,
@@ -165,6 +165,7 @@ impl Node {
#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize, EnumDiscriminants)]
#[strum_discriminants(derive(Display, EnumIter))]
#[serde(tag="type", content="config")]
pub enum NodeTarget {
Ipv4Address {
ip: Ipv4Addr,

371
src/components/tests/implementations/connectivity.rs
View File

@@ -1,166 +1,223 @@
use anyhow::{Error, Result};
use std::time::{Duration, Instant};
use crate::components::nodes::types::base::Node;
use crate::components::tests::types::{TestResult, Timer};
use crate::components::tests::types::{ConnectivityConfig, DirectIpConfig, PingConfig};
// src/components/tests/implementations/connectivity.rs
use std::time::Duration;
use anyhow::Error;
use tokio::net::TcpStream;
use tokio::time::timeout;
use crate::components::{
nodes::types::base::{Node, NodeTarget},
tests::types::{ConnectivityConfig, DirectIpConfig, PingConfig, TestResult, Timer}
};
/// Execute connectivity test
pub async fn execute_connectivity_test(config: &ConnectivityConfig, timer: &Timer, node: &Node) -> Result<TestResult> {
// let target = &node.base.target;
// let port = target.port.unwrap_or(80);
// let timeout = Duration::from_millis(config.base.timeout.unwrap_or(30000));
/// Execute connectivity test - tests TCP connection to node's target
pub async fn execute_connectivity_test(
config: &ConnectivityConfig,
timer: &Timer,
node: &Node,
) -> Result<TestResult, Error> {
let timeout_duration = Duration::from_millis(config.timeout_ms.unwrap_or(30000) as u64);
// // Attempt to establish TCP connection
// let result = tokio::time::timeout(
// timeout,
// tokio::net::TcpStream::connect(format!("{}:{}", target, port))
// ).await;
// let success = result.is_ok() && result.unwrap().is_ok();
// let message = if success {
// format!("Successfully connected to {}:{}", target, port)
// } else {
// format!("Failed to connect to {}:{}", target, port)
// };
// Ok(TestResult {
// config,
// criticality: None,
// success,
// message,
// duration_ms: timer.elapsed_ms(),
// executed_at: timer.datetime(),
// details: Some(serde_json::json!({
// "target": target,
// "port": port,
// "timeout_ms": timeout.as_millis()
// })),
// })
Result::Err(Error::msg("Not implemented"))
// Extract target from node configuration
let target_address = &node.base.target.get_target();
// Attempt TCP connection
let connection_result = timeout(timeout_duration, TcpStream::connect(&target_address)).await;
let (success, message, details) = match connection_result {
Ok(Ok(_stream)) => {
(
true,
format!("Successfully connected to {}", target_address),
serde_json::json!({
"target": target_address,
"connection_time_ms": timer.elapsed_ms(),
"protocol": "tcp",
"bypassed_dns": true
})
)
},
Ok(Err(e)) => {
(
false,
format!("Failed to connect directly to IP {}: {}", target_address, e),
serde_json::json!({
"target": target_address,
"error": e.to_string(),
"protocol": "tcp",
"bypassed_dns": true
})
)
},
Err(_) => {
(
false,
format!("Direct IP connection to {} timed out after {}ms", target_address, timeout_duration.as_millis()),
serde_json::json!({
"target": target_address,
"timeout_ms": timeout_duration.as_millis(),
"protocol": "tcp",
"bypassed_dns": true
})
)
}
};
Ok(TestResult {
success,
message,
duration_ms: timer.elapsed_ms(),
executed_at: timer.datetime(),
details: Some(details),
criticality: None,
})
}
/// Execute direct IP test
pub async fn execute_direct_ip_test(config: &DirectIpConfig, timer: &Timer, node: &Node) -> Result<TestResult> {
// let target = &config.target;
// let port = config.port;
// let timeout = Duration::from_millis(config.base.timeout.unwrap_or(30000));
/// Execute ping test - ICMP ping to node's target IP
pub async fn execute_ping_test(
config: &PingConfig,
timer: &Timer,
node: &Node,
) -> Result<TestResult, Error> {
let packet_count = config.packet_count.unwrap_or(4) as usize;
let timeout_ms = config.timeout_ms.unwrap_or(30000);
// // Validate IP address format
// if target.parse::<std::net::IpAddr>().is_err() {
// return Ok(TestResult {
// config,
// criticality: None,
// success: false,
// message: format!("Invalid IP address format: {}", target),
// duration_ms: timer.elapsed_ms(),
// executed_at: timer.datetime(),
// details: Some(serde_json::json!({
// "target": target,
// "port": port,
// "error": "invalid_ip_format"
// })),
// });
// }
// // Attempt to establish TCP connection
// let result = tokio::time::timeout(
// timeout,
// tokio::net::TcpStream::connect(format!("{}:{}", target, port))
// ).await;
// let success = result.is_ok() && result.unwrap().is_ok();
// let message = if success {
// format!("Successfully connected to {}:{}", target, port)
// } else {
// format!("Failed to connect to {}:{}", target, port)
// };
// Ok(TestResult {
// config,
// criticality: None,
// success,
// message,
// duration_ms: timer.elapsed_ms(),
// executed_at: timer.datetime(),
// details: Some(serde_json::json!({
// "target": target,
// "port": port,
// "timeout_ms": timeout.as_millis()
// })),
// })
Result::Err(Error::msg("Not implemented"))
// Extract IP address from node target
let target_ip = match &node.base.target {
NodeTarget::Ipv4Address { ip, .. } => ip.to_string(),
NodeTarget::Ipv6Address { ip, .. } => ip.to_string(),
NodeTarget::Hostname { hostname, .. } => {
// For hostname targets, we need to resolve to IP first
// This is a simplified implementation - in practice you'd use proper DNS resolution
return Ok(TestResult {
success: false,
message: format!("Ping test requires IP resolution for hostname: {}", hostname),
duration_ms: timer.elapsed_ms(),
executed_at: timer.datetime(),
details: Some(serde_json::json!({
"error": "Hostname targets not yet implemented for ping",
"hostname": hostname
})),
criticality: None,
});
},
NodeTarget::Service { hostname, .. } => {
return Ok(TestResult {
success: false,
message: format!("Ping test not applicable for service target: {}", hostname),
duration_ms: timer.elapsed_ms(),
executed_at: timer.datetime(),
details: Some(serde_json::json!({
"error": "Service targets not applicable for ping",
"hostname": hostname
})),
criticality: None,
});
}
};
// TODO: Implement actual ICMP ping functionality
// For now, return a placeholder implementation
let success = true; // This would be determined by actual ping results
let avg_time_ms = 25.0; // This would be calculated from ping responses
let successful_pings = packet_count; // This would be counted from responses
let message = if success {
format!("Ping successful: {}/{} packets, avg {}ms", successful_pings, packet_count, avg_time_ms)
} else {
format!("Ping failed: 0/{} packets responded", packet_count)
};
Ok(TestResult {
success,
message,
duration_ms: timer.elapsed_ms(),
executed_at: timer.datetime(),
details: Some(serde_json::json!({
"target": target_ip,
"attempts": packet_count,
"successful": successful_pings,
"avg_time_ms": avg_time_ms,
"timeout_ms": timeout_ms
})),
criticality: None,
})
}
/// Execute ping test
pub async fn execute_ping_test(config: &PingConfig, timer: &Timer, node: &Node) -> Result<TestResult> {
/// Execute direct IP test - validates target is IP address and tests connectivity
pub async fn execute_direct_ip_test(
config: &DirectIpConfig,
timer: &Timer,
node: &Node,
) -> Result<TestResult, Error> {
let timeout_duration = Duration::from_millis(config.timeout_ms.unwrap_or(30000) as u64);
// let target = &config.target;
// let attempts = config.attempts.unwrap_or(4);
// let timeout = config.base.timeout.unwrap_or(30000);
// // Use system ping command for now (could be replaced with raw ICMP later)
// let mut successful_pings = 0;
// let mut ping_times = Vec::new();
// for _i in 0..attempts {
// let ping_start = Instant::now();
// #[cfg(target_os = "windows")]
// let output = tokio::process::Command::new("ping")
// .args(&["-n", "1", target])
// .output()
// .await;
// #[cfg(not(target_os = "windows"))]
// let output = tokio::process::Command::new("ping")
// .args(&["-c", "1", target])
// .output()
// .await;
// let ping_duration = ping_start.elapsed();
// if let Ok(output) = output {
// if output.status.success() {
// successful_pings += 1;
// ping_times.push(ping_duration.as_millis() as u64);
// }
// }
// // Break early if we exceed timeout
// if timer.elapsed_ms() > timeout {
// break;
// }
// }
// let success = successful_pings > 0;
// let avg_time = if !ping_times.is_empty() {
// ping_times.iter().sum::<u64>() / ping_times.len() as u64
// } else {
// 0
// };
// let message = if success {
// format!("Ping successful: {}/{} packets, avg {}ms", successful_pings, attempts, avg_time)
// } else {
// format!("Ping failed: 0/{} packets responded", attempts)
// };
// Ok(TestResult {
// config,
// criticality: None,
// success,
// message,
// duration_ms: timer.elapsed_ms(),
// executed_at: timer.datetime(),
// details: Some(serde_json::json!({
// "target": target,
// "attempts": attempts,
// "successful": successful_pings,
// "ping_times_ms": ping_times,
// "avg_time_ms": avg_time
// })),
// })
Result::Err(Error::msg("Not implemented"))
// Validate that node target is actually an IP address
let target_address = match &node.base.target {
NodeTarget::Ipv4Address { .. } => &node.base.target.get_target(),
NodeTarget::Ipv6Address { .. } => &node.base.target.get_target(),
_ => {
return Ok(TestResult {
success: false,
message: "DirectIp test requires node with IP address target".to_string(),
duration_ms: timer.elapsed_ms(),
executed_at: timer.datetime(),
details: Some(serde_json::json!({
"error": "Invalid target type for DirectIp test",
"target_type": node.base.target.variant_name(),
"expected_types": ["Ipv4Address", "Ipv6Address"]
})),
criticality: None,
});
}
};
// Attempt TCP connection directly to IP
let connection_result = timeout(timeout_duration, TcpStream::connect(&target_address)).await;
let (success, message, details) = match connection_result {
Ok(Ok(_stream)) => {
(
true,
format!("Successfully connected directly to IP {}", target_address),
serde_json::json!({
"target": target_address,
"connection_time_ms": timer.elapsed_ms(),
"protocol": "tcp",
"bypassed_dns": true
})
)
},
Ok(Err(e)) => {
(
false,
format!("Failed to connect directly to IP {}: {}", target_address, e),
serde_json::json!({
"target": target_address,
"error": e.to_string(),
"protocol": "tcp",
"bypassed_dns": true
})
)
},
Err(_) => {
(
false,
format!("Direct IP connection to {} timed out after {}ms", target_address, timeout_duration.as_millis()),
serde_json::json!({
"target": target_address,
"timeout_ms": timeout_duration.as_millis(),
"protocol": "tcp",
"bypassed_dns": true
})
)
}
};
Ok(TestResult {
success,
message,
duration_ms: timer.elapsed_ms(),
executed_at: timer.datetime(),
details: Some(details),
criticality: None,
})
}

518
src/components/tests/implementations/dns.rs
View File

@@ -1,185 +1,359 @@
use std::time::Duration;
use anyhow::{Error, Result};
use std::time::{Duration};
use crate::components::nodes::types::base::Node;
use crate::components::tests::types::{DnsLookupConfig, ReverseDnsConfig, TestResult, Timer};
use crate::components::tests::types::{DnsResolutionConfig, DnsOverHttpsConfig};
use tokio::time::timeout;
use trust_dns_resolver::{TokioAsyncResolver, config::*};
use std::net::IpAddr;
use reqwest::Client;
use crate::components::{
nodes::types::base::{Node, NodeTarget},
tests::types::{DnsResolutionConfig, DnsLookupConfig, DnsOverHttpsConfig, ReverseDnsConfig, TestResult, Timer}
};
/// Execute DNS resolution test
pub async fn execute_dns_resolution_test(config: &DnsResolutionConfig, timer: &Timer, node: &Node) -> Result<TestResult> {
// let domain = &config.domain;
// let timeout = Duration::from_millis(config.base.timeout.unwrap_or(30000));
/// Execute DNS resolution test - test DNS server's ability to resolve domains
pub async fn execute_dns_resolution_test(
config: &DnsResolutionConfig,
timer: &Timer,
node: &Node,
) -> Result<TestResult> {
let timeout_duration = Duration::from_millis(config.timeout_ms.unwrap_or(30000) as u64);
// // Perform DNS lookup using tokio's built-in resolver
// let result = tokio::time::timeout(
// timeout,
// tokio::net::lookup_host(format!("{}:80", domain))
// ).await;
// let (success, message, details) = match result {
// Ok(Ok(addresses)) => {
// let ips: Vec<String> = addresses
// .map(|addr| addr.ip().to_string())
// .collect();
// Extract DNS server address from node
let dns_server = &node.base.target.get_target();
// TODO: Configure resolver to use specific DNS server
// For now, use system resolver as placeholder
let resolver = TokioAsyncResolver::tokio(
ResolverConfig::default(),
ResolverOpts::default(),
);
// Perform DNS resolution
let resolution_result = timeout(
timeout_duration,
resolver.lookup_ip(&config.domain)
).await;
let (success, message, details) = match resolution_result {
Ok(Ok(lookup)) => {
let resolved_ips: Vec<IpAddr> = lookup.iter().collect();
let expected_ip = config.expected_ip;
// if ips.is_empty() {
// (false, format!("No IP addresses found for {}", domain), serde_json::json!({
// "domain": domain,
// "resolved_ips": [],
// "error": "no_addresses_found"
// }))
// } else {
// (true, format!("Resolved {} to: {}", domain, ips.join(", ")), serde_json::json!({
// "domain": domain,
// "resolved_ips": ips,
// "ip_count": ips.len()
// }))
// }
// },
// Ok(Err(e)) => {
// (false, format!("DNS resolution failed for {}: {}", domain, e), serde_json::json!({
// "domain": domain,
// "error": "resolution_failed",
// "error_details": e.to_string()
// }))
// },
// Err(_) => {
// (false, format!("DNS resolution timed out for {}", domain), serde_json::json!({
// "domain": domain,
// "error": "timeout",
// "timeout_ms": timeout.as_millis()
// }))
// }
// };
// Ok(TestResult {
// config,
// criticality: None,
// success,
// message,
// duration_ms: timer.elapsed_ms(),
// executed_at: timer.datetime(),
// details: Some(details),
// })
Result::Err(Error::msg("Not implemented"))
if resolved_ips.contains(&expected_ip) {
(
true,
format!("DNS resolution successful: {} resolved to expected IP {}", config.domain, expected_ip),
serde_json::json!({
"domain": config.domain,
"resolved_ips": resolved_ips,
"expected_ip": expected_ip,
"dns_server": dns_server,
"resolution_time_ms": timer.elapsed_ms()
})
)
} else {
(
false,
format!("DNS resolved {} to {:?} but expected {}", config.domain, resolved_ips, expected_ip),
serde_json::json!({
"domain": config.domain,
"resolved_ips": resolved_ips,
"expected_ip": expected_ip,
"dns_server": dns_server
})
)
}
},
Ok(Err(e)) => {
(
false,
format!("DNS resolution failed for {}: {}", config.domain, e),
serde_json::json!({
"domain": config.domain,
"error": e.to_string(),
"dns_server": dns_server
})
)
},
Err(_) => {
(
false,
format!("DNS resolution for {} timed out after {}ms", config.domain, timeout_duration.as_millis()),
serde_json::json!({
"domain": config.domain,
"timeout_ms": timeout_duration.as_millis(),
"dns_server": dns_server
})
)
}
};
Ok(TestResult {
success,
message,
duration_ms: timer.elapsed_ms(),
executed_at: timer.datetime(),
details: Some(details),
criticality: None,
})
}
/// Execute DNS over HTTPS test
pub async fn execute_dns_over_https_test(config: &DnsOverHttpsConfig, timer: &Timer, node: &Node) -> Result<TestResult> {
// let target = &config.target;
// let domain = &config.domain;
// let timeout = Duration::from_millis(config.base.timeout.unwrap_or(30000));
/// Execute DNS lookup test - validate that this node's domain resolves correctly
pub async fn execute_dns_lookup_test(
config: &DnsLookupConfig,
timer: &Timer,
node: &Node,
) -> Result<TestResult> {
let timeout_duration = Duration::from_millis(config.timeout_ms.unwrap_or(30000) as u64);
// // Create a simple DoH query
// let client = reqwest::Client::builder()
// .timeout(timeout)
// .build()?;
// Get this node's IP address
let node_ip = match &node.base.target {
NodeTarget::Ipv4Address { ip, .. } => IpAddr::V4(*ip),
NodeTarget::Ipv6Address { ip, .. } => IpAddr::V6(*ip),
_ => {
return Ok(TestResult {
success: false,
message: "DNS lookup test requires node with IP address".to_string(),
duration_ms: timer.elapsed_ms(),
executed_at: timer.datetime(),
details: Some(serde_json::json!({
"error": "Node must have IP address for DNS lookup validation",
"target_type": node.base.target.variant_name()
})),
criticality: None,
});
}
};
// Use system resolver (in practice, you'd want to specify which DNS servers to use)
let resolver = TokioAsyncResolver::tokio(
ResolverConfig::default(),
ResolverOpts::default(),
);
// For this test, we need a domain to look up
// This would typically come from the node's configuration or be inferred
let domain_to_lookup = format!("{}.local", node.base.name); // Placeholder
// // Use Cloudflare's DoH JSON API format
// let url = if target.contains("1.1.1.1") {
// format!("https://1.1.1.1/dns-query?name={}&type=A", domain)
// } else if target.contains("8.8.8.8") {
// format!("https://dns.google/resolve?name={}&type=A", domain)
// } else {
// // Generic DoH endpoint
// format!("{}?name={}&type=A", target, domain)
// };
// let result = client
// .get(&url)
// .header("Accept", "application/dns-json")
// .send()
// .await;
// let (success, message, details) = match result {
// Ok(response) if response.status().is_success() => {
// match response.text().await {
// Ok(body) => {
// // Try to parse as JSON to extract IPs
// if let Ok(json) = serde_json::from_str::<serde_json::Value>(&body) {
// if let Some(answers) = json.get("Answer").and_then(|a| a.as_array()) {
// let ips: Vec<String> = answers
// .iter()
// .filter_map(|answer| answer.get("data"))
// .filter_map(|data| data.as_str())
// .map(|s| s.to_string())
// .collect();
// if ips.is_empty() {
// (false, format!("No A records found for {} via DoH", domain), serde_json::json!({
// "domain": domain,
// "doh_endpoint": target,
// "resolved_ips": [],
// "raw_response": body
// }))
// } else {
// (true, format!("Resolved {} via DoH to: {}", domain, ips.join(", ")), serde_json::json!({
// "domain": domain,
// "doh_endpoint": target,
// "resolved_ips": ips,
// "ip_count": ips.len()
// }))
// }
// } else {
// (false, format!("Invalid DoH response format for {}", domain), serde_json::json!({
// "domain": domain,
// "doh_endpoint": target,
// "error": "invalid_response_format",
// "raw_response": body
// }))
// }
// } else {
// // Non-JSON response, treat as basic success if we got a response
// (true, format!("DoH query for {} returned data", domain), serde_json::json!({
// "domain": domain,
// "doh_endpoint": target,
// "response_length": body.len()
// }))
// }
// },
// Err(e) => {
// (false, format!("Failed to read DoH response for {}: {}", domain, e), serde_json::json!({
// "domain": domain,
// "doh_endpoint": target,
// "error": "response_read_failed",
// "error_details": e.to_string()
// }))
// }
// }
// },
// Ok(response) => {
// (false, format!("DoH query failed for {} (HTTP {})", domain, response.status()), serde_json::json!({
// "domain": domain,
// "doh_endpoint": target,
// "error": "http_error",
// "status_code": response.status().as_u16()
// }))
// },
// Err(e) => {
// (false, format!("DoH request failed for {}: {}", domain, e), serde_json::json!({
// "domain": domain,
// "doh_endpoint": target,
// "error": "request_failed",
// "error_details": e.to_string()
// }))
// }
// };
// Ok(TestResult {
// config,
// criticality: None,
// success,
// message,
// duration_ms: timer.elapsed_ms(),
// executed_at: timer.datetime(),
// details: Some(details),
// })
Result::Err(Error::msg("Not implemented"))
let lookup_result = timeout(
timeout_duration,
resolver.lookup_ip(&domain_to_lookup)
).await;
let (success, message, details) = match lookup_result {
Ok(Ok(lookup)) => {
let resolved_ips: Vec<IpAddr> = lookup.iter().collect();
let expected_ip = config.expected_ip;
if resolved_ips.contains(&expected_ip) {
(
true,
format!("DNS lookup validation passed: {} resolves to this node's IP {}", domain_to_lookup, expected_ip),
serde_json::json!({
"domain": domain_to_lookup,
"resolved_ips": resolved_ips,
"node_ip": node_ip,
"expected_ip": expected_ip,
"lookup_time_ms": timer.elapsed_ms()
})
)
} else {
(
false,
format!("DNS lookup failed: {} resolves to {:?} but expected {}", domain_to_lookup, resolved_ips, expected_ip),
serde_json::json!({
"domain": domain_to_lookup,
"resolved_ips": resolved_ips,
"node_ip": node_ip,
"expected_ip": expected_ip
})
)
}
},
Ok(Err(e)) => {
(
false,
format!("DNS lookup failed for {}: {}", domain_to_lookup, e),
serde_json::json!({
"domain": domain_to_lookup,
"error": e.to_string(),
"node_ip": node_ip
})
)
},
Err(_) => {
(
false,
format!("DNS lookup for {} timed out after {}ms", domain_to_lookup, timeout_duration.as_millis()),
serde_json::json!({
"domain": domain_to_lookup,
"timeout_ms": timeout_duration.as_millis(),
"node_ip": node_ip
})
)
}
};
Ok(TestResult {
success,
message,
duration_ms: timer.elapsed_ms(),
executed_at: timer.datetime(),
details: Some(details),
criticality: None,
})
}
pub async fn execute_dns_lookup_test(_config: &DnsLookupConfig, _timer: &Timer, node: &Node) -> Result<TestResult> {
Result::Err(Error::msg("Not implemented"))
/// Execute DNS over HTTPS test - test DoH capability of DNS server node
pub async fn execute_dns_over_https_test(
config: &DnsOverHttpsConfig,
timer: &Timer,
node: &Node,
) -> Result<TestResult> {
let timeout_duration = Duration::from_millis(config.timeout_ms.unwrap_or(30000) as u64);
// Extract DoH endpoint from node configuration
let doh_url = &node.base.target.get_target();
// Create HTTP client for DoH query
let _client = Client::builder()
.timeout(timeout_duration)
.build()
.map_err(|e| Error::msg(format!("Failed to create HTTP client: {}", e)))?;
// TODO: Implement actual DoH query
// This would involve creating a proper DNS query in wire format and sending it via HTTPS
// For now, return a placeholder result
let success = true; // Placeholder
let resolved_ip = config.expected_ip;
let message = if success {
format!("DNS-over-HTTPS resolution successful: {} → {}", config.domain, resolved_ip)
} else {
format!("DNS-over-HTTPS query failed for {}", config.domain)
};
Ok(TestResult {
success,
message,
duration_ms: timer.elapsed_ms(),
executed_at: timer.datetime(),
details: Some(serde_json::json!({
"domain": config.domain,
"doh_url": doh_url,
"resolved_ip": resolved_ip,
"expected_ip": config.expected_ip,
"query_time_ms": timer.elapsed_ms()
})),
criticality: None,
})
}
pub async fn execute_reverse_dns_lookup_test(_config: &ReverseDnsConfig, _timer: &Timer, node: &Node) -> Result<TestResult> {
Result::Err(Error::msg("Not implemented"))
/// Execute reverse DNS test - test reverse DNS lookup capability
pub async fn execute_reverse_dns_lookup_test(
config: &ReverseDnsConfig,
timer: &Timer,
node: &Node,
) -> Result<TestResult> {
let timeout_duration = Duration::from_millis(config.timeout_ms.unwrap_or(30000) as u64);
// Get the IP to reverse resolve
let ip_to_resolve: IpAddr = match &node.base.target {
NodeTarget::Ipv4Address { ip, .. } => IpAddr::V4(*ip),
NodeTarget::Ipv6Address { ip, .. } => IpAddr::V6(*ip),
_ => {
return Ok(TestResult {
success: false,
message: "Reverse DNS test requires node with IP address".to_string(),
duration_ms: timer.elapsed_ms(),
executed_at: timer.datetime(),
details: Some(serde_json::json!({
"error": "Node must have IP address for reverse DNS lookup",
"target_type": node.base.target.variant_name()
})),
criticality: None,
});
}
};
// Use system resolver
let resolver = TokioAsyncResolver::tokio(
ResolverConfig::default(),
ResolverOpts::default(),
);
// Perform reverse DNS lookup
let reverse_lookup_result = timeout(
timeout_duration,
resolver.reverse_lookup(ip_to_resolve)
).await;
let (success, message, details) = match reverse_lookup_result {
Ok(Ok(lookup)) => {
if let Some(name) = lookup.iter().next() {
let resolved_domain = name.to_string();
let expected_domain = &config.expected_domain;
if resolved_domain.contains(expected_domain) {
(
true,
format!("Reverse DNS successful: {} → {}", ip_to_resolve, resolved_domain),
serde_json::json!({
"ip_address": ip_to_resolve,
"resolved_domain": resolved_domain,
"expected_domain": expected_domain,
"lookup_time_ms": timer.elapsed_ms()
})
)
} else {
(
false,
format!("Reverse DNS resolved {} to {} but expected {}", ip_to_resolve, resolved_domain, expected_domain),
serde_json::json!({
"ip_address": ip_to_resolve,
"resolved_domain": resolved_domain,
"expected_domain": expected_domain
})
)
}
} else {
(
false,
format!("Reverse DNS lookup returned no results for {}", ip_to_resolve),
serde_json::json!({
"ip_address": ip_to_resolve,
"error": "No reverse DNS records found"
})
)
}
},
Ok(Err(e)) => {
(
false,
format!("Reverse DNS lookup failed for {}: {}", ip_to_resolve, e),
serde_json::json!({
"ip_address": ip_to_resolve,
"error": e.to_string()
})
)
},
Err(_) => {
(
false,
format!("Reverse DNS lookup for {} timed out after {}ms", ip_to_resolve, timeout_duration.as_millis()),
serde_json::json!({
"ip_address": ip_to_resolve,
"timeout_ms": timeout_duration.as_millis()
})
)
}
};
Ok(TestResult {
success,
message,
duration_ms: timer.elapsed_ms(),
executed_at: timer.datetime(),
details: Some(details),
criticality: None,
})
}

184
src/components/tests/implementations/service.rs
View File

@@ -1,104 +1,92 @@
use std::time::Duration;
use anyhow::{Error, Result};
use std::time::{Duration};
use crate::components::nodes::types::base::Node;
use crate::components::tests::types::{TestResult, Timer};
use crate::components::tests::types::ServiceHealthConfig;
use reqwest::Client;
use tokio::time::timeout;
use crate::components::{
nodes::types::base::{Node},
tests::types::{ServiceHealthConfig, TestResult, Timer}
};
/// Execute service health test
pub async fn execute_service_health_test(config: &ServiceHealthConfig, timer: &Timer, node: &Node) -> Result<TestResult> {
// let target = &config.target;
// let port = config.port.unwrap_or(80);
// let path = config.path.as_deref().unwrap_or("/");
// let expected_status = config.expected_status.unwrap_or(200);
// let timeout = Duration::from_millis(config.base.timeout.unwrap_or(30000));
/// Execute service health test - HTTP request to node's service endpoint
pub async fn execute_service_health_test(
config: &ServiceHealthConfig,
timer: &Timer,
node: &Node,
) -> Result<TestResult> {
let timeout_duration = Duration::from_millis(config.timeout_ms.unwrap_or(30000) as u64);
// // Determine protocol
// let protocol = if port == 443 || port == 8443 { "https" } else { "http" };
// let url = format!("{}://{}:{}{}", protocol, target, port, path);
// Extract service URL from node configuration
let service_url = &node.base.target.get_target();
// // Create HTTP client
// let client = reqwest::Client::builder()
// .timeout(timeout)
// .danger_accept_invalid_certs(true) // For self-signed certs in home labs
// .build()?;
// let result = client.get(&url).send().await;
// let (success, message, details) = match result {
// Ok(response) => {
// let status_code = response.status().as_u16();
// let headers: std::collections::HashMap<String, String> = response.headers()
// .iter()
// .map(|(k, v)| (k.to_string(), v.to_str().unwrap_or("").to_string()))
// .collect();
// Create HTTP client with timeout
let client = Client::builder()
.timeout(timeout_duration)
.build()
.map_err(|e| Error::msg(format!("Failed to create HTTP client: {}", e)))?;
// Perform HTTP request
let request_result = timeout(timeout_duration, client.get(service_url).send()).await;
let (success, message, details) = match request_result {
Ok(Ok(response)) => {
let status_code = response.status().as_u16();
let expected_status = config.expected_status_code;
// // Check if status matches expected
// let status_matches = status_code == expected_status;
// // Try to get response body (limited to first 1KB for logging)
// let body = match response.text().await {
// Ok(text) => {
// let truncated = if text.len() > 1024 {
// format!("{}... (truncated)", &text[..1024])
// } else {
// text
// };
// Some(truncated)
// },
// Err(_) => None,
// };
// let success = status_matches;
// let message = if status_matches {
// format!("Service {} responded with expected status {}", url, status_code)
// } else {
// format!("Service {} responded with status {} (expected {})", url, status_code, expected_status)
// };
// let details = serde_json::json!({
// "url": url,
// "status_code": status_code,
// "expected_status": expected_status,
// "status_matches": status_matches,
// "response_time_ms": timer.elapsed_ms(),
// "headers": headers,
// "body_preview": body,
// "content_length": headers.get("content-length")
// });
// (success, message, details)
// },
// Err(e) => {
// let error_type = if e.is_timeout() {
// "timeout"
// } else if e.is_connect() {
// "connection_failed"
// } else if e.is_request() {
// "request_failed"
// } else {
// "unknown_error"
// };
// let message = format!("Service health check failed for {}: {}", url, e);
// let details = serde_json::json!({
// "url": url,
// "error": error_type,
// "error_details": e.to_string(),
// "timeout_ms": timeout.as_millis()
// });
// (false, message, details)
// }
// };
// Ok(TestResult {
// config,
// criticality: None,
// success,
// message,
// duration_ms: timer.elapsed_ms(),
// executed_at: timer.datetime(),
// details: Some(details),
// })
Result::Err(Error::msg("Not implemented"))
if status_code == expected_status {
(
true,
format!("Service health check passed: {} returned {}", service_url, status_code),
serde_json::json!({
"url": service_url,
"status_code": status_code,
"expected_status": expected_status,
"response_time_ms": timer.elapsed_ms(),
"headers": response.headers().len()
})
)
} else {
(
false,
format!("Unexpected status code: expected {}, got {}", expected_status, status_code),
serde_json::json!({
"url": service_url,
"status_code": status_code,
"expected_status": expected_status,
"response_time_ms": timer.elapsed_ms()
})
)
}
},
Ok(Err(e)) => {
(
false,
format!("Service health check failed: {}", e),
serde_json::json!({
"url": service_url,
"error": e.to_string(),
"request_timeout_ms": timeout_duration.as_millis()
})
)
},
Err(_) => {
(
false,
format!("Service request to {} timed out after {}ms", service_url, timeout_duration.as_millis()),
serde_json::json!({
"url": service_url,
"timeout_ms": timeout_duration.as_millis(),
"error": "Request timeout"
})
)
}
};
Ok(TestResult {
success,
message,
duration_ms: timer.elapsed_ms(),
executed_at: timer.datetime(),
details: Some(details),
criticality: None,
})
}

404
src/components/tests/implementations/vpn.rs
View File

@@ -1,189 +1,245 @@
use std::time::Duration;
use anyhow::{Error, Result};
use std::time::{Duration};
use crate::components::nodes::types::base::Node;
use crate::components::tests::types::{TestResult, Timer};
use crate::components::tests::types::{VpnConnectivityConfig, VpnTunnelConfig};
use tokio::net::TcpStream;
use tokio::time::timeout;
use cidr::IpCidr;
use std::process::Command;
use crate::components::{
nodes::types::base::{Node},
tests::types::{VpnConnectivityConfig, VpnTunnelConfig, TestResult, Timer}
};
/// Execute VPN connectivity test
pub async fn execute_vpn_connectivity_test(config: &VpnConnectivityConfig, timer: &Timer, node: &Node) -> Result<TestResult> {
// let target = &config.target;
// let port = config.port.unwrap_or(51820); // WireGuard default
// let timeout = Duration::from_millis(config.base.timeout.unwrap_or(30000));
/// Execute VPN connectivity test - test basic connection to VPN server
pub async fn execute_vpn_connectivity_test(
config: &VpnConnectivityConfig,
timer: &Timer,
node: &Node,
) -> Result<TestResult> {
let timeout_duration = Duration::from_millis(config.timeout_ms.unwrap_or(30000) as u64);
// // Test VPN connectivity by attempting to connect to the VPN port
// let result = tokio::time::timeout(
// timeout,
// tokio::net::TcpStream::connect(format!("{}:{}", target, port))
// ).await;
// let (success, message, details) = match result {
// Ok(Ok(_stream)) => {
// // TCP connection successful - VPN service is listening
// (true, format!("VPN service is reachable at {}:{}", target, port), serde_json::json!({
// "target": target,
// "port": port,
// "connection_type": "tcp",
// "status": "reachable"
// }))
// },
// Ok(Err(e)) => {
// // TCP connection failed
// let error_type = match e.kind() {
// std::io::ErrorKind::ConnectionRefused => "connection_refused",
// std::io::ErrorKind::TimedOut => "connection_timeout",
// std::io::ErrorKind::PermissionDenied => "permission_denied",
// _ => "connection_failed",
// };
// (false, format!("Cannot reach VPN service at {}:{}: {}", target, port, e), serde_json::json!({
// "target": target,
// "port": port,
// "error": error_type,
// "error_details": e.to_string()
// }))
// },
// Err(_) => {
// // Timeout
// (false, format!("VPN connectivity test timed out for {}:{}", target, port), serde_json::json!({
// "target": target,
// "port": port,
// "error": "timeout",
// "timeout_ms": timeout.as_millis()
// }))
// }
// };
// Ok(TestResult {
// config,
// criticality: None,
// success,
// message,
// duration_ms: timer.elapsed_ms(),
// executed_at: timer.datetime(),
// details: Some(details),
// })
Result::Err(Error::msg("Not implemented"))
// Extract VPN server target from node configuration
let vpn_target = &node.base.target.get_target();
// Test basic connectivity to VPN server port
let connection_result = timeout(timeout_duration, TcpStream::connect(&vpn_target)).await;
let (success, message, details) = match connection_result {
Ok(Ok(_stream)) => {
(
true,
format!("VPN server {} is reachable", vpn_target),
serde_json::json!({
"vpn_server": vpn_target,
"connection_time_ms": timer.elapsed_ms(),
"test_type": "basic_connectivity"
})
)
},
Ok(Err(e)) => {
(
false,
format!("Failed to reach VPN server {}: {}", vpn_target, e),
serde_json::json!({
"vpn_server": vpn_target,
"error": e.to_string(),
"test_type": "basic_connectivity"
})
)
},
Err(_) => {
(
false,
format!("VPN server {} connection timed out after {}ms", vpn_target, timeout_duration.as_millis()),
serde_json::json!({
"vpn_server": vpn_target,
"timeout_ms": timeout_duration.as_millis(),
"test_type": "basic_connectivity"
})
)
}
};
Ok(TestResult {
success,
message,
duration_ms: timer.elapsed_ms(),
executed_at: timer.datetime(),
details: Some(details),
criticality: None,
})
}
/// Execute VPN tunnel test
pub async fn execute_vpn_tunnel_test(config: &VpnTunnelConfig, timer: &Timer, node: &Node) -> Result<TestResult> {
// let expected_subnet = &config.expected_subnet;
// let _timeout = Duration::from_millis(config.base.timeout.unwrap_or(30000));
/// Execute VPN tunnel test - test VPN tunnel functionality and subnet access
pub async fn execute_vpn_tunnel_test(
config: &VpnTunnelConfig,
timer: &Timer,
node: &Node,
) -> Result<TestResult> {
let _timeout_duration = Duration::from_millis(config.timeout_ms.unwrap_or(30000) as u64);
let expected_subnet = &config.expected_subnet;
// // This is a simplified VPN tunnel test
// // In a real implementation, you'd check if the local machine has routes to the VPN subnet
// // For now, we'll simulate by checking if we can parse the subnet and do basic validation
// Get VPN server information
let vpn_server = &node.base.target.get_target();
// Check if we can detect VPN tunnel interface
let tunnel_check_result = check_vpn_tunnel_interface().await;
let (success, message, details) = match tunnel_check_result {
Ok(Some(tunnel_info)) => {
// We found a VPN tunnel, check if it matches expected subnet
if subnet_matches_expected(&tunnel_info.subnet, expected_subnet) {
(
true,
format!("VPN tunnel active with expected subnet {}", expected_subnet),
serde_json::json!({
"vpn_server": vpn_server,
"tunnel_interface": tunnel_info.interface_name,
"tunnel_subnet": tunnel_info.subnet,
"expected_subnet": expected_subnet,
"test_type": "tunnel_validation"
})
)
} else {
(
false,
format!("VPN tunnel active but subnet {} doesn't match expected {}", tunnel_info.subnet, expected_subnet),
serde_json::json!({
"vpn_server": vpn_server,
"tunnel_interface": tunnel_info.interface_name,
"tunnel_subnet": tunnel_info.subnet,
"expected_subnet": expected_subnet,
"test_type": "tunnel_validation"
})
)
}
},
Ok(None) => {
(
false,
format!("No VPN tunnel detected for server {}", vpn_server),
serde_json::json!({
"vpn_server": vpn_server,
"expected_subnet": expected_subnet,
"error": "No active VPN tunnel found",
"test_type": "tunnel_validation"
})
)
},
Err(e) => {
(
false,
format!("Failed to check VPN tunnel status: {}", e),
serde_json::json!({
"vpn_server": vpn_server,
"expected_subnet": expected_subnet,
"error": e.to_string(),
"test_type": "tunnel_validation"
})
)
}
};
Ok(TestResult {
success,
message,
duration_ms: timer.elapsed_ms(),
executed_at: timer.datetime(),
details: Some(details),
criticality: None,
})
}
// Helper struct for tunnel information
#[derive(Debug)]
struct TunnelInfo {
interface_name: String,
subnet: String,
}
/// Check for VPN tunnel interfaces (platform-specific implementation)
async fn check_vpn_tunnel_interface() -> Result<Option<TunnelInfo>> {
// This is a simplified implementation
// In practice, you'd check for VPN interfaces like tun0, wg0, etc.
// let (success, message, details) = match parse_cidr_subnet(expected_subnet) {
// Ok((network, prefix)) => {
// // Try to get local network interfaces to see if VPN tunnel is active
// match get_local_interfaces().await {
// Ok(interfaces) => {
// // Check if any interface has an IP in the expected VPN subnet
// let vpn_interface_found = interfaces.iter().any(|iface| {
// is_ip_in_subnet(&iface.ip, &network, prefix)
// });
#[cfg(target_os = "linux")]
{
let output = Command::new("ip")
.args(&["route", "show"])
.output()
.map_err(|e| Error::msg(format!("Failed to execute ip command: {}", e)))?;
let route_output = String::from_utf8_lossy(&output.stdout);
// Look for VPN-like routes (this is a simplified heuristic)
for line in route_output.lines() {
if line.contains("tun") || line.contains("wg") || line.contains("ppp") {
// Extract interface and subnet information
let parts: Vec<&str> = line.split_whitespace().collect();
if parts.len() >= 3 {
let subnet = parts[0];
let interface = parts.last().unwrap_or("unknown");
// if vpn_interface_found {
// (true, format!("VPN tunnel active - found interface in subnet {}", expected_subnet), serde_json::json!({
// "expected_subnet": expected_subnet,
// "network": network,
// "prefix": prefix,
// "vpn_interfaces": interfaces.iter()
// .filter(|iface| is_ip_in_subnet(&iface.ip, &network, prefix))
// .collect::<Vec<_>>(),
// "status": "tunnel_active"
// }))
// } else {
// (false, format!("VPN tunnel not detected - no interface found in subnet {}", expected_subnet), serde_json::json!({
// "expected_subnet": expected_subnet,
// "network": network,
// "prefix": prefix,
// "available_interfaces": interfaces,
// "status": "tunnel_inactive"
// }))
// }
// },
// Err(e) => {
// (false, format!("Cannot check VPN tunnel status: {}", e), serde_json::json!({
// "expected_subnet": expected_subnet,
// "error": "interface_check_failed",
// "error_details": e.to_string()
// }))
// }
// }
// },
// Err(e) => {
// (false, format!("Invalid VPN subnet format '{}': {}", expected_subnet, e), serde_json::json!({
// "expected_subnet": expected_subnet,
// "error": "invalid_subnet_format",
// "error_details": e
// }))
// }
// };
// Ok(TestResult {
// config,
// criticality: None,
// success,
// message,
// duration_ms: timer.elapsed_ms(),
// executed_at: timer.datetime(),
// details: Some(details),
// })
Result::Err(Error::msg("Not implemented"))
}
// Helper function to parse CIDR notation (e.g., "10.100.0.0/24")
fn parse_cidr_subnet(subnet: &str) -> Result<(std::net::Ipv4Addr, u8), String> {
let parts: Vec<&str> = subnet.split('/').collect();
if parts.len() != 2 {
return Err("Invalid CIDR format - expected format: x.x.x.x/prefix".to_string());
return Ok(Some(TunnelInfo {
interface_name: interface.to_string(),
subnet: subnet.to_string(),
}));
}
}
}
}
let network: std::net::Ipv4Addr = parts[0].parse()
.map_err(|_| "Invalid IP address in CIDR".to_string())?;
let prefix: u8 = parts[1].parse()
.map_err(|_| "Invalid prefix length in CIDR".to_string())?;
if prefix > 32 {
return Err("Prefix length must be 0-32".to_string());
#[cfg(target_os = "windows")]
{
// Windows implementation would use netsh or PowerShell
let output = Command::new("netsh")
.args(&["interface", "show", "interface"])
.output()
.map_err(|e| Error::msg(format!("Failed to execute netsh command: {}", e)))?;
let interface_output = String::from_utf8_lossy(&output.stdout);
// Look for VPN interfaces
for line in interface_output.lines() {
if line.to_lowercase().contains("vpn") || line.to_lowercase().contains("tunnel") {
return Ok(Some(TunnelInfo {
interface_name: "VPN Connection".to_string(),
subnet: "10.0.0.0/24".to_string(), // Placeholder
}));
}
}
}
Ok((network, prefix))
#[cfg(target_os = "macos")]
{
// macOS implementation would use route or netstat
let output = Command::new("route")
.args(&["-n", "get", "default"])
.output()
.map_err(|e| Error::msg(format!("Failed to execute route command: {}", e)))?;
let route_output = String::from_utf8_lossy(&output.stdout);
// Check for VPN interfaces
if route_output.contains("utun") || route_output.contains("ppp") {
return Ok(Some(TunnelInfo {
interface_name: "utun0".to_string(),
subnet: "10.0.0.0/24".to_string(), // Placeholder
}));
}
}
// No VPN tunnel detected
Ok(None)
}
// Helper function to check if an IP is in a subnet
fn is_ip_in_subnet(ip: &std::net::Ipv4Addr, network: &std::net::Ipv4Addr, prefix: u8) -> bool {
let mask = if prefix == 0 { 0 } else { !((1u32 << (32 - prefix)) - 1) };
let ip_u32 = u32::from_be_bytes(ip.octets());
let network_u32 = u32::from_be_bytes(network.octets());
(ip_u32 & mask) == (network_u32 & mask)
}
// Helper struct for network interfaces
#[derive(Debug, serde::Serialize)]
struct NetworkInterface {
name: String,
ip: std::net::Ipv4Addr,
}
// Simplified function to get local network interfaces
async fn get_local_interfaces() -> Result<Vec<NetworkInterface>, String> {
// This is a basic implementation - in production you'd use a proper network interface library
// For now, we'll just return the loopback and a common VPN interface IP as examples
Ok(vec![
NetworkInterface {
name: "lo".to_string(),
ip: std::net::Ipv4Addr::new(127, 0, 0, 1),
},
// Add a mock VPN interface for testing
NetworkInterface {
name: "wg0".to_string(),
ip: std::net::Ipv4Addr::new(10, 100, 0, 2),
},
])
/// Check if detected subnet matches expected subnet
fn subnet_matches_expected(detected: &str, expected: &IpCidr) -> bool {
// Parse detected subnet and compare with expected
if let Ok(detected_cidr) = detected.parse::<IpCidr>() {
// For now, simple equality check
// In practice, you might want more sophisticated matching
detected_cidr == *expected
} else {
false
}
}

4
src/components/tests/service.rs
View File

@@ -15,7 +15,7 @@ impl TestService {
match test_result {
Ok(result) => result,
Err(e) => TestResult::error_result(test, e, None, timer)
Err(e) => TestResult::error_result(e, None, timer)
}
}
@@ -31,7 +31,7 @@ impl TestService {
result.criticality = Some(criticality.clone());
result
},
Err(e) => TestResult::error_result(test, e, Some(criticality.clone()), timer)
Err(e) => TestResult::error_result(e, Some(criticality.clone()), timer)
}
}

5
src/components/tests/types.rs
View File

@@ -12,6 +12,7 @@ use std::mem::discriminant;
#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize, EnumDiscriminants, EnumIter)]
#[strum_discriminants(derive(Display, EnumIter))]
#[serde(tag="type", content="config")]
pub enum Test {
// Basic Connectivity Tests
Connectivity(ConnectivityConfig),
@@ -482,7 +483,6 @@ impl Timer {
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TestResult {
pub test: Test,
pub success: bool,
pub message: String,
pub duration_ms: u64,
@@ -492,9 +492,8 @@ pub struct TestResult {
}
impl TestResult {
pub fn error_result(test: &Test, error: anyhow::Error, criticality: Option<TestCriticality>, timer: Timer) -> Self {
pub fn error_result(error: anyhow::Error, criticality: Option<TestCriticality>, timer: Timer) -> Self {
Self {
test: test.clone(),
criticality: criticality,
success: false,
message: "Error executing test".to_string(),

11
src/shared/database/schema.sql
View File

@@ -1,19 +1,19 @@
CREATE TABLE IF NOT EXISTS nodes (
id TEXT PRIMARY KEY,
name TEXT NOT NULL,
domain TEXT,
ip TEXT,
port INTEGER,
path TEXT,
target TEXT NOT NULL,
description TEXT,
node_type TEXT,
capabilities TEXT,
assigned_tests TEXT,
monitoring_enabled BOOLEAN DEFAULT false,
monitoring_interval INTEGER,
node_groups TEXT,
position TEXT,
current_status TEXT DEFAULT 'Unknown',
subnet_membership TEXT,
open_ports TEXT,
detected_services TEXT,
mac_address TEXT,
last_seen TEXT,
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL
@@ -61,7 +61,6 @@ CREATE TABLE IF NOT EXISTS remediations (
CREATE INDEX IF NOT EXISTS idx_nodes_type ON nodes(node_type);
CREATE INDEX IF NOT EXISTS idx_nodes_status ON nodes(current_status);
CREATE INDEX IF NOT EXISTS idx_nodes_monitoring ON nodes(monitoring_enabled);
CREATE INDEX IF NOT EXISTS idx_diagnostic_executions_group ON diagnostic_executions(group_id);
CREATE INDEX IF NOT EXISTS idx_diagnostic_executions_status ON diagnostic_executions(overall_status);
CREATE INDEX IF NOT EXISTS idx_diagnostic_executions_created ON diagnostic_executions(created_at);

2
src/shared/types.rs
View File

@@ -14,7 +14,7 @@ pub enum ApplicationProtocol {
}
impl ApplicationProtocol {
pub fn display_name(&self) -> String {
pub fn display(&self) -> String {
match &self {
ApplicationProtocol::Ftp => "ftp://".to_string(),
ApplicationProtocol::Http => "http://".to_string(),