integrate docker and implement state tracking for server lifecycle management

src/proxy.rs

@@ -1,25 +1,48 @@
-use std::error::Error;
+use anyhow::Result;
 use tokio::io::copy_bidirectional;
 use tokio::net::{TcpListener, TcpStream};
 
-pub async fn run_proxy(listen_addr: String, server_addr: String) -> Result<(), Box<dyn Error>> {
+use crate::state::{ServerState, SharedServerState};
+
+pub async fn run_proxy(
+    listen_addr: String,
+    server_addr: String,
+    motd_server_addr: String,
+    state: SharedServerState,
+) -> Result<()> {
     println!("Listening on {}", listen_addr);
-    println!("Proxying to {}", server_addr);
+    println!("Server backend: {}", server_addr);
+    println!("MOTD backend: {}", motd_server_addr);
 
     let listener = TcpListener::bind(&listen_addr).await?;
 
-    while let Ok((mut inbound, _)) = listener.accept().await {
+    while let Ok((mut inbound, client_addr)) = listener.accept().await {
         let server_addr = server_addr.clone();
+        let motd_server_addr = motd_server_addr.clone();
+        let state = state.clone();
 
         tokio::spawn(async move {
-            match TcpStream::connect(&server_addr).await {
+            let current_state = state.get().await;
+
+            let backend = match current_state {
+                ServerState::Running { .. } => {
+                    println!("Client {} -> server (Running)", client_addr);
+                    server_addr
+                }
+                _ => {
+                    println!("Client {} -> MOTD (state: {:?})", client_addr, current_state);
+                    motd_server_addr
+                }
+            };
+
+            match TcpStream::connect(&backend).await {
                 Ok(mut outbound) => {
                     if let Err(e) = copy_bidirectional(&mut inbound, &mut outbound).await {
-                        println!("Failed to transfer; error={e}");
+                        eprintln!("Failed to transfer; error={}", e);
                     }
                 }
                 Err(e) => {
-                    println!("Failed to connect to server; error={e}");
+                    eprintln!("Failed to connect to backend {}; error={}", backend, e);
                 }
             }
         });