fix[simulation] :: prevent infinite loops via input validation

engine/main.rs

@@ -25,8 +25,10 @@ fn build_api(
             move |params: SimulationParams| {
                 let time_step = params.time_step.unwrap_or(0.1);
                 let duration = params.duration.unwrap_or(10.0);
-                simulation_manager.start_simulation(time_step, duration);
-                "Simulation started!"
+                match simulation_manager.start_simulation(time_step, duration) {
+                    Ok(()) => "Simulation started!",
+                    Err(_) => "Failed to start simulation",
+                }
             }
         })
         .or(warp::path("stop").and(warp::get()).map({

engine/managers/simulation_manager.rs

@@ -1,8 +1,17 @@
 use crate::physics::physics_engine::PhysicsEngine;
+use std::sync::atomic::{AtomicU32, Ordering};
 use std::sync::{Arc, Mutex};
 use std::thread;
 use std::time::Duration;
 
+const MAX_SIMULATIONS: usize = 5;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SimulationStartError {
+    InvalidParameters,
+    MaxSimulationsReached,
+}
+
 #[derive(Clone, Debug, PartialEq)]
 pub enum SimulationState {
     Running,
@@ -63,6 +72,7 @@ impl Simulation {
 #[derive(Clone)]
 pub struct SimulationManager {
     simulations: Arc<Mutex<Vec<Arc<Mutex<Simulation>>>>>,
+    next_id: Arc<AtomicU32>,
 }
 
 impl Default for SimulationManager {
@@ -75,15 +85,26 @@ impl SimulationManager {
     pub fn new() -> Self {
         SimulationManager {
             simulations: Arc::new(Mutex::new(Vec::new())),
+            next_id: Arc::new(AtomicU32::new(1)),
         }
     }
 
     /// Starts a new simulation with the given time step and duration.
     /// This method spawns a new thread to run the simulation.
-    pub fn start_simulation(&self, time_step: f32, duration: f32) {
+    pub fn start_simulation(
+        &self,
+        time_step: f32,
+        duration: f32,
+    ) -> Result<(), SimulationStartError> {
+        if time_step <= 0.0 || duration <= 0.0 {
+            return Err(SimulationStartError::InvalidParameters);
+        }
         let mut simulations = self.simulations.lock().unwrap();
+        if simulations.len() >= MAX_SIMULATIONS {
+            return Err(SimulationStartError::MaxSimulationsReached);
+        }
         let new_simulation = Arc::new(Mutex::new(Simulation::new(
-            simulations.len() as u32 + 1,
+            self.next_id.fetch_add(1, Ordering::Relaxed),
             time_step,
             duration,
         )));
@@ -95,14 +116,15 @@ impl SimulationManager {
             }
         });
         simulations.push(Arc::clone(&new_simulation));
+        Ok(())
     }
 
     pub fn stop_simulation(&self) {
         let mut simulations = self.simulations.lock().unwrap();
-        if let Some(sim_arc) = simulations.last() {
+        for sim_arc in simulations.iter() {
             sim_arc.lock().unwrap().state = SimulationState::Stopped;
         }
-        simulations.pop();
+        simulations.clear();
     }
 
     pub fn get_simulations(&self) -> Vec<Simulation> {

examples/basic_simulation.rs

@@ -8,7 +8,7 @@ fn main() {
     let manager = SimulationManager::new();
 
     // Start a simulation
-    manager.start_simulation(0.01, 2.0); // 0.01s time step, 2s duration
+    let _ = manager.start_simulation(0.01, 2.0); // 0.01s time step, 2s duration
 
     // Wait for simulation to complete
     thread::sleep(Duration::from_secs(3));

tests/e2e_tests.rs

@@ -31,7 +31,7 @@ mod e2e_tests {
                 move |params: SimulationParams| {
                     let time_step = params.time_step.unwrap_or(0.1);
                     let duration = params.duration.unwrap_or(10.0);
-                    simulation_manager.start_simulation(time_step, duration);
+                    let _ = simulation_manager.start_simulation(time_step, duration);
                     "Simulation started!"
                 }
             })

tests/sdk_tests.rs

@@ -38,7 +38,7 @@ fn test_physics_engine_simulate() {
 #[test]
 fn test_simulation_manager_start_simulation() {
     let manager = SimulationManager::new();
-    manager.start_simulation(0.01, 0.1); // Very short simulation
+    let _ = manager.start_simulation(0.01, 0.1); // Very short simulation
     std::thread::sleep(std::time::Duration::from_millis(200)); // Wait for completion
     let _simulations = manager.get_simulations();
     // Note: This test is timing-dependent and may be flaky

tests/simulation_tests.rs

@@ -26,7 +26,7 @@ mod tests {
                     move |params: SimulationParams| {
                         let time_step = params.time_step.unwrap_or(0.1);
                         let duration = params.duration.unwrap_or(10.0);
-                        simulation_manager.start_simulation(time_step, duration);
+                        let _ = simulation_manager.start_simulation(time_step, duration);
                         "Simulation started!"
                     }
                 });