Controller server

Author: jsurrea

antares/Cargo.lock

@@ -7,9 +7,11 @@ edition = "2021"
 chrono = "0.4.38"
 rand = "0.8.5"
 tokio = { version = "1", features = ["full"] }
+hyper = { version = "1", features = ["full"] }
 serde = { version = "1", features = ["derive"] }
 toml = "0.8.19"
 async-trait = "0.1.88"
 tokio-tungstenite = "0.26.2"
 futures-util = "0.3.31"
 futures = "0.3.31"
+axum = "0.8.4"

antares/Cargo.toml

@@ -1,21 +1,36 @@
-[radar]
+[simulation]
+emission_interval = 20
+controller_bind_addr = "127.0.0.1:18900"
+
+[[simulation.initial_ships]]
+initial_position = [-50.0, 50.0]
+type = "line"
+angle = 0.785
+speed = 5.0
+
+[[simulation.initial_ships]]
+initial_position = [50.0, -50.0]
+type = "circle"
+radius = 20.0
+speed = 5.0
+
+[[simulation.initial_ships]]
+initial_position = [-50.0, -50.0]
+type = "random"
+max_speed = 20.0
 
-[radar.protocol]
-host = "0.0.0.0"
-num_workers_tci = 1
-num_workers_tdi = 1
+[[simulation.initial_ships]]
+initial_position = [50.0, 50.0]
+type = "stationary"
+
+[radar]
+bind_addr = "127.0.0.1:18950"
 
 [radar.detector]
 range = 100.0
 speed = 0.0
 angle = 0.0
 start_coordinates = [4.0, -72.0]
 
-[simulation]
-emission_interval = 20
-
-[simulation.ships]
-line = [{ initial_position = [-50.0, 50.0], angle = 0.785, speed = 5.0 }]
-circle = [{ initial_position = [50.0, -50.0], radius = 20.0, speed = 5.0 }]
-random = [{ initial_position = [-50.0, -50.0], max_speed = 20.0 }]
-stationary = [{ initial_position = [50.0, 50.0] }]
+[radar.broadcast]
+type = "tcp"

antares/assets/config.toml

@@ -3,31 +3,47 @@
 //! This module contains the Controller struct which is responsible for starting the simulation and radar.
 //!
 
-use super::{Config, Radar, Simulation};
+use super::{Config, Radar, ShipConfig, Simulation};
+use std::sync::Arc;
 use tokio::sync::mpsc;
 
 pub struct Controller {
-    radar: Radar,
-    simulation: Simulation,
+    radar: Arc<Radar>,
+    simulation: Arc<Simulation>,
 }
 
 impl Controller {
     pub fn new(config: Config) -> Controller {
         Controller {
-            radar: Radar::new(config.radar),
-            simulation: Simulation::new(config.simulation),
+            radar: Arc::new(Radar::new(config.radar)),
+            simulation: Arc::new(Simulation::new(config.simulation)),
         }
     }
 
-    pub async fn run(self) {
+    pub async fn run(&self) {
         let (wave_sender, wave_receiver) = mpsc::channel(100);
-        let Controller { radar, simulation } = self;
 
-        tokio::spawn(simulation.start(wave_sender));
-        tokio::spawn(radar.start(wave_receiver));
+        let simulation = Arc::clone(&self.simulation);
+        let radar = Arc::clone(&self.radar);
+
+        tokio::spawn(async move {
+            simulation.start(wave_sender).await;
+        });
+
+        tokio::spawn(async move {
+            radar.start(wave_receiver).await;
+        });
 
         tokio::signal::ctrl_c()
             .await
             .expect("failed to listen for Ctrl+C");
     }
+
+    pub fn reset_simulation(&self) {
+        self.simulation.reset();
+    }
+
+    pub fn add_ship(&self, ship_data: ShipConfig) {
+        self.simulation.add_ship(ship_data);
+    }
 }

antares/src/controller.rs

@@ -13,3 +13,4 @@ use simulation::{Simulation, SimulationConfig, Wave};
 
 pub use config::Config;
 pub use controller::Controller;
+pub use simulation::ShipConfig;

antares/src/lib.rs

@@ -1,7 +1,11 @@
+use antares::ShipConfig;
 use antares::{Config, Controller};
-use std::{env, fs, process};
+use axum::{extract::State, routing::post, Json, Router};
+use std::{env, fs, net::SocketAddr, process, sync::Arc};
+use tokio::task;
 
-fn main() {
+#[tokio::main]
+async fn main() {
     let args: Vec<String> = env::args().collect();
 
     if args.len() != 2 {
@@ -19,6 +23,31 @@ fn main() {
         process::exit(1);
     });
 
-    let controller = Controller::new(config);
-    controller.run();
+    let controller_bind_addr = config.simulation.controller_bind_addr.clone();
+    let controller = Arc::new(Controller::new(config));
+
+    let controller_clone = Arc::clone(&controller);
+    task::spawn(async move {
+        controller_clone.run().await;
+    });
+
+    let app = Router::new()
+        .route("/simulation/reset", post(reset_simulation))
+        .route("/simulation/ships", post(add_ship))
+        .with_state(controller);
+
+    let addr: SocketAddr = controller_bind_addr.parse().unwrap();
+    let listener = tokio::net::TcpListener::bind(&addr).await.unwrap();
+    println!("🚢 Controller server running on {addr}");
+    axum::serve(listener, app.into_make_service())
+        .await
+        .unwrap();
+}
+
+async fn reset_simulation(State(controller): State<Arc<Controller>>) {
+    controller.reset_simulation();
+}
+
+async fn add_ship(State(controller): State<Arc<Controller>>, Json(payload): Json<ShipConfig>) {
+    controller.add_ship(payload);
 }

antares/src/main.rs

@@ -4,6 +4,7 @@ use serde::Deserialize;
 pub struct RadarConfig {
     pub detector: DetectorConfig,
     pub broadcast: BroadcastConfig,
+    pub bind_addr: String,
 }
 
 #[derive(Debug, Deserialize, Clone)]
@@ -17,6 +18,6 @@ pub struct DetectorConfig {
 #[derive(Debug, Deserialize)]
 #[serde(tag = "type", rename_all = "lowercase")]
 pub enum BroadcastConfig {
-    Tcp { bind_addr: String },
-    WebSocket { bind_addr: String },
+    Tcp,
+    WebSocket,
 }

antares/src/radar/config.rs

@@ -13,7 +13,7 @@ impl Radar {
         Self { config }
     }
 
-    pub async fn start(self, wave_receiver: mpsc::Receiver<Wave>) {
+    pub async fn start(&self, wave_receiver: mpsc::Receiver<Wave>) {
         let (plot_sender, plot_receiver) = mpsc::channel(100);
         let (track_sender, mut track_receiver) = mpsc::channel(100);
 
@@ -22,9 +22,9 @@ impl Radar {
         Tracker::start(plot_receiver, track_sender);
 
         let broadcaster: Arc<dyn Broadcaster> = match &self.config.broadcast {
-            BroadcastConfig::Tcp { bind_addr } => Arc::new(TcpBroadcaster::new(bind_addr.clone())),
-            BroadcastConfig::WebSocket { bind_addr } => {
-                Arc::new(WebSocketBroadcaster::new(bind_addr.clone()))
+            BroadcastConfig::Tcp => Arc::new(TcpBroadcaster::new(self.config.bind_addr.clone())),
+            BroadcastConfig::WebSocket => {
+                Arc::new(WebSocketBroadcaster::new(self.config.bind_addr.clone()))
             }
         };
 

antares/src/radar/radar.rs

@@ -1,40 +1,45 @@
+use super::{
+    CircleMovement, LineMovement, MovementStrategy, RandomMovement, Ship, StationaryMovement,
+};
 use serde::Deserialize;
 
 #[derive(Debug, Deserialize)]
 pub struct SimulationConfig {
     pub emission_interval: u64,
-    pub ships: ShipsConfig,
+    pub initial_ships: Vec<ShipConfig>,
+    pub controller_bind_addr: String,
 }
 
 #[derive(Debug, Deserialize)]
-pub struct ShipsConfig {
-    pub line: Vec<LineMovementConfig>,
-    pub circle: Vec<CircleMovementConfig>,
-    pub random: Vec<RandomMovementConfig>,
-    pub stationary: Vec<StationaryMovementConfig>,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct LineMovementConfig {
+pub struct ShipConfig {
     pub initial_position: (f64, f64),
-    pub angle: f64,
-    pub speed: f64,
+    #[serde(flatten)]
+    pub movement: MovementType,
 }
 
 #[derive(Debug, Deserialize)]
-pub struct CircleMovementConfig {
-    pub initial_position: (f64, f64),
-    pub radius: f64,
-    pub speed: f64,
+#[serde(tag = "type", rename_all = "lowercase")]
+pub enum MovementType {
+    Line { angle: f64, speed: f64 },
+    Circle { radius: f64, speed: f64 },
+    Random { max_speed: f64 },
+    Stationary,
 }
 
-#[derive(Debug, Deserialize)]
-pub struct RandomMovementConfig {
-    pub initial_position: (f64, f64),
-    pub max_speed: f64,
-}
+pub fn build_ship_from_config(id: u64, config: ShipConfig, emission_interval: u64) -> Ship {
+    let movement_strategy: Box<dyn MovementStrategy> = match config.movement {
+        MovementType::Line { angle, speed } => Box::new(LineMovement::new(angle, speed)),
+        MovementType::Circle { radius, speed } => {
+            Box::new(CircleMovement::new(radius, speed, emission_interval))
+        }
+        MovementType::Random { max_speed } => Box::new(RandomMovement::new(max_speed)),
+        MovementType::Stationary => Box::new(StationaryMovement {}),
+    };
 
-#[derive(Debug, Deserialize)]
-pub struct StationaryMovementConfig {
-    pub initial_position: (f64, f64),
+    Ship {
+        id,
+        position: config.initial_position,
+        emission_interval,
+        movement_strategy,
+    }
 }

antares/src/simulation/config.rs

@@ -1,5 +1,5 @@
 use super::Wave;
 
 pub trait Emitter {
-    fn emit(&mut self) -> Wave;
+    fn emit(&self) -> Wave;
 }