feat: support reconnects in shutdowns initiated via CLI tool (#250)

* Create hotfix-cli readme

* Rename executable from hotfix-cli to hotfix

* Fix issue with session not reconnecting correctly even though it was explicitly requested

* Support the explicit reconnect flag in shutdown API

Author: davidsteiner

crates/hotfix-cli/Cargo.toml

@@ -1,15 +1,20 @@
 [package]
 name = "hotfix-cli"
+description = "CLI tool for the HotFIX engine"
 version = "0.1.0"
 authors.workspace = true
 edition.workspace = true
 license.workspace = true
-readme.workspace = true
+readme = "README.md"
 homepage.workspace = true
 repository.workspace = true
 keywords.workspace = true
 categories.workspace = true
 
+[[bin]]
+name = "hotfix"
+path = "src/main.rs"
+
 [dependencies]
 anyhow.workspace = true
 clap = { workspace = true, features = ["derive", "env"] }

crates/hotfix-cli/README.md

@@ -0,0 +1,32 @@
+<div align="center">
+
+# hotfix-cli
+
+**CLI tool for the HotFIX engine.**
+
+</div>
+
+This crate is part of the [hotfix](https://github.com/hotfix-rs/hotfix) project.
+
+It provides a CLI client for the [web interface](https://crates.io/crates/hotfix-web) of the hotfix FIX engine
+which supports fetching session state and sending admin commands to the running session.
+
+## Installation
+
+You can either install the tool using `cargo install hotfix-cli` or use it as a library in your own project.
+
+## How to use it
+
+You need to have a running hotfix FIX engine instance with the web interface exposed using the
+[hotfix-web](https://crates.io/crates/hotfix-web) crate.
+
+The tool tries to connect to the web interface using the default address `http://localhost:9881`.
+You can override this using either the explicit CLI argument `--url` or the environment variable `HOTFIX_CLI_URL`.
+
+With everything set up, you can use the tool to run commands, e.g.
+
+```shell
+hotfix session-info
+```
+
+For the full list of available commands, run `hotfix --help`.

crates/hotfix-cli/src/lib.rs

@@ -1,7 +1,7 @@
 use anyhow::{Context, Result};
 use clap::{Parser, Subcommand};
 use owo_colors::OwoColorize;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 
 #[derive(Parser)]
 #[command(name = "hotfix")]
@@ -29,7 +29,11 @@ pub enum Command {
     /// Request a reset on next logon
     Reset,
     /// Shutdown the session
-    Shutdown,
+    Shutdown {
+        /// Whether to reconnect after shutdown
+        #[arg(long, default_value_t = true, action = clap::ArgAction::Set)]
+        reconnect: bool,
+    },
 }
 
 #[derive(Debug, Deserialize)]
@@ -49,6 +53,11 @@ pub struct SessionInfo {
     pub status: String,
 }
 
+#[derive(Debug, Serialize)]
+pub struct ShutdownRequest {
+    pub reconnect: bool,
+}
+
 pub async fn run(cli: Cli) -> Result<()> {
     let client = reqwest::Client::new();
     let base_url = cli.url.trim_end_matches('/');
@@ -125,10 +134,12 @@ pub async fn run(cli: Cli) -> Result<()> {
                 );
             }
         }
-        Command::Shutdown => {
+        Command::Shutdown { reconnect } => {
             let url = format!("{}/api/shutdown", base_url);
+            let body = ShutdownRequest { reconnect };
             let response = client
                 .post(&url)
+                .json(&body)
                 .send()
                 .await
                 .context("Failed to send shutdown request")?;
@@ -235,7 +246,7 @@ mod tests {
 
         let cli = Cli {
             url: mock_server.uri(),
-            command: Command::Shutdown,
+            command: Command::Shutdown { reconnect: true },
         };
 
         let result = run(cli).await;
@@ -279,7 +290,7 @@ mod tests {
 
         let cli = Cli {
             url: mock_server.uri(),
-            command: Command::Shutdown,
+            command: Command::Shutdown { reconnect: true },
         };
 
         let result = run(cli).await;

crates/hotfix-cli/tests/integration.rs

@@ -2,7 +2,7 @@ use assert_cmd::assert::OutputAssertExt;
 use assert_cmd::cargo_bin;
 use predicates::prelude::*;
 use std::process::Command;
-use wiremock::matchers::{method, path};
+use wiremock::matchers::{body_json, method, path};
 use wiremock::{Mock, MockServer, ResponseTemplate};
 
 #[tokio::test]
@@ -17,7 +17,7 @@ async fn test_cli_health_command_integration() {
         .mount(&mock_server)
         .await;
 
-    let mut cmd = Command::new(cargo_bin!());
+    let mut cmd = Command::new(cargo_bin!("hotfix"));
     cmd.arg("--url")
         .arg(mock_server.uri())
         .arg("health")
@@ -43,7 +43,7 @@ async fn test_cli_session_info_command_integration() {
         .mount(&mock_server)
         .await;
 
-    let mut cmd = Command::new(cargo_bin!());
+    let mut cmd = Command::new(cargo_bin!("hotfix"));
     cmd.arg("--url")
         .arg(mock_server.uri())
         .arg("session-info")
@@ -67,7 +67,7 @@ async fn test_cli_reset_command_integration() {
         .mount(&mock_server)
         .await;
 
-    let mut cmd = Command::new(cargo_bin!());
+    let mut cmd = Command::new(cargo_bin!("hotfix"));
     cmd.arg("--url")
         .arg(mock_server.uri())
         .arg("reset")
@@ -82,11 +82,12 @@ async fn test_cli_shutdown_command_integration() {
 
     Mock::given(method("POST"))
         .and(path("/api/shutdown"))
+        .and(body_json(serde_json::json!({"reconnect": true})))
         .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({})))
         .mount(&mock_server)
         .await;
 
-    let mut cmd = Command::new(cargo_bin!());
+    let mut cmd = Command::new(cargo_bin!("hotfix"));
     cmd.arg("--url")
         .arg(mock_server.uri())
         .arg("shutdown")
@@ -95,9 +96,31 @@ async fn test_cli_shutdown_command_integration() {
         .stdout(predicate::str::contains("Shutdown requested successfully"));
 }
 
+#[tokio::test]
+async fn test_cli_shutdown_command_with_reconnect_false() {
+    let mock_server = MockServer::start().await;
+
+    Mock::given(method("POST"))
+        .and(path("/api/shutdown"))
+        .and(body_json(serde_json::json!({"reconnect": false})))
+        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({})))
+        .mount(&mock_server)
+        .await;
+
+    let mut cmd = Command::new(cargo_bin!("hotfix"));
+    cmd.arg("--url")
+        .arg(mock_server.uri())
+        .arg("shutdown")
+        .arg("--reconnect")
+        .arg("false")
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("Shutdown requested successfully"));
+}
+
 #[tokio::test]
 async fn test_cli_help_command() {
-    let mut cmd = Command::new(cargo_bin!());
+    let mut cmd = Command::new(cargo_bin!("hotfix"));
     cmd.arg("--help")
         .assert()
         .success()
@@ -120,7 +143,7 @@ async fn test_cli_error_handling() {
         .mount(&mock_server)
         .await;
 
-    let mut cmd = Command::new(cargo_bin!());
+    let mut cmd = Command::new(cargo_bin!("hotfix"));
     cmd.arg("--url")
         .arg(mock_server.uri())
         .arg("reset")
@@ -141,7 +164,7 @@ async fn test_cli_with_env_var() {
         .mount(&mock_server)
         .await;
 
-    let mut cmd = Command::new(cargo_bin!());
+    let mut cmd = Command::new(cargo_bin!("hotfix"));
     cmd.env("HOTFIX_WEB_URL", mock_server.uri())
         .arg("health")
         .assert()

crates/hotfix-web/src/endpoints/admin/shutdown.rs

@@ -3,11 +3,18 @@ use crate::error::AppResult;
 use crate::session_controller::SessionController;
 use axum::Json;
 use axum::extract::State;
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+pub(crate) struct ShutdownRequest {
+    pub reconnect: bool,
+}
 
 pub(crate) async fn shutdown<C: SessionController>(
     State(state): State<AppState<C>>,
+    Json(payload): Json<ShutdownRequest>,
 ) -> AppResult<Json<()>> {
-    state.controller.shutdown(true).await?;
+    state.controller.shutdown(payload.reconnect).await?;
 
     Ok(Json(()))
 }

crates/hotfix-web/src/lib.rs

@@ -193,6 +193,19 @@ mod tests {
             self.request(Method::POST, path).await
         }
 
+        async fn post_json(&mut self, path: &str, json: Value) -> TestResponse {
+            let body = serde_json::to_string(&json).unwrap();
+            let request = Request::builder()
+                .method(Method::POST)
+                .uri(path)
+                .header("Content-Type", "application/json")
+                .body(Body::from(body))
+                .unwrap();
+
+            let response = self.router.clone().oneshot(request).await.unwrap();
+            TestResponse::new(response).await
+        }
+
         async fn request(&mut self, method: Method, path: &str) -> TestResponse {
             let request = Request::builder()
                 .method(method)
@@ -309,7 +322,9 @@ mod tests {
         };
         let mut ctx = TestContext::with_config(config);
 
-        let response = ctx.post("/api/shutdown").await;
+        let response = ctx
+            .post_json("/api/shutdown", serde_json::json!({"reconnect": true}))
+            .await;
 
         response.assert_status(StatusCode::OK);
         let state = ctx.get_state();
@@ -321,6 +336,27 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn test_shutdown_endpoint_calls_shutdown_without_reconnect() {
+        let config = RouterConfig {
+            enable_admin_endpoints: true,
+        };
+        let mut ctx = TestContext::with_config(config);
+
+        let response = ctx
+            .post_json("/api/shutdown", serde_json::json!({"reconnect": false}))
+            .await;
+
+        response.assert_status(StatusCode::OK);
+        let state = ctx.get_state();
+        assert!(state.shutdown_called, "Shutdown should have been called");
+        assert_eq!(
+            state.shutdown_reconnect,
+            Some(false),
+            "Shutdown should be called with reconnect=false"
+        );
+    }
+
     #[tokio::test]
     async fn test_admin_endpoints_disabled_by_default() {
         let mut ctx = TestContext::new(); // Default config has admin disabled