feat: rudimentary dashboard for session state (#175)

* Add status crate to create a home for status-related endpoints

* Add status service to example app

* Flip dependency structure so that hotfix-status depends on hotfix as an add-on

* Add endpoint to get session info

* Add endpoint for static assets

* Add dashboard endpoint with static HTML

* Refactor status API and pages structure

* Make UI functionality properly dependent on UI feature flag

* Show session info in dashboard

* Improve dashboard style

* Add custom app error struct

Author: davidsteiner

Cargo.lock

@@ -18,10 +18,18 @@ categories = ["finance", "encoding", "parsing"]
 
 [workspace.dependencies]
 anyhow = "^1.0.75"
+askama = "0.14"
+async-trait = "0.1.89"
+axum = "^0.8"
 chrono = "^0.4"
 chrono-tz = "^0.10"
+displaydoc = "0.2"
+mime_guess = "2.0.5"
+rust-embed = "8.7"
 serde = "^1.0.177"
 thiserror = "1"
+tokio = { version = "^1" }
+tokio-rustls = "^0.26"
 toml = "^0.8.8"
 tracing = "^0.1.37"
 

Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+name = "hotfix-status"
+description = "Status endpoints and an option web-based dashboard for the HotFIX engine"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+readme.workspace = true
+homepage.workspace = true
+repository.workspace = true
+keywords.workspace = true
+categories.workspace = true
+
+[lints]
+workspace = true
+
+[features]
+ui = ["askama", "mime_guess", "rust-embed"]
+
+[dependencies]
+askama = { workspace = true, features = ["serde_json"], optional = true }
+async-trait = { workspace = true }
+axum = { workspace = true }
+chrono = { workspace = true }
+displaydoc = { workspace = true }
+hotfix = { version = "0.0.25", path = "../hotfix" }
+mime_guess = { workspace = true, optional = true }
+rust-embed = { workspace = true, features = ["axum-ex"], optional = true }
+serde = { workspace = true, features = ["derive"] }
+thiserror = { workspace = true }

crates/hotfix-status/Cargo.toml

@@ -0,0 +1,37 @@
+use crate::AppState;
+use crate::data_provider::DataProvider;
+use axum::extract::State;
+use axum::routing::get;
+use axum::{Json, Router};
+use hotfix::session::SessionInfo;
+use serde::Serialize;
+
+pub fn build_api_router<P: DataProvider + 'static>() -> Router<AppState<P>> {
+    Router::new()
+        .route("/health", get(get_health))
+        .route("/session-info", get(get_session_info))
+}
+
+#[derive(Debug, Serialize)]
+struct HealthStatusResponse {
+    status: String,
+}
+
+async fn get_health() -> Json<HealthStatusResponse> {
+    Json(HealthStatusResponse {
+        status: "healthy".to_string(),
+    })
+}
+
+#[derive(Debug, Serialize)]
+struct SessionInfoResponse {
+    session_info: SessionInfo,
+}
+
+async fn get_session_info<P: DataProvider>(
+    State(state): State<AppState<P>>,
+) -> Json<SessionInfoResponse> {
+    let session_info = state.data_provider.get_session_info().await;
+
+    Json(SessionInfoResponse { session_info })
+}

crates/hotfix-status/assets/tailwind.js

@@ -0,0 +1,19 @@
+use hotfix::message::FixMessage;
+use hotfix::session::{SessionInfo, SessionRef};
+
+#[async_trait::async_trait]
+pub trait DataProvider: Clone + Send + Sync {
+    async fn get_session_info(&self) -> SessionInfo;
+}
+
+#[derive(Clone)]
+pub struct SessionDataProvider<M> {
+    pub(crate) session_ref: SessionRef<M>,
+}
+
+#[async_trait::async_trait]
+impl<M: FixMessage> DataProvider for SessionDataProvider<M> {
+    async fn get_session_info(&self) -> SessionInfo {
+        self.session_ref.get_session_info().await
+    }
+}

crates/hotfix-status/src/api.rs

@@ -0,0 +1,17 @@
+use axum::http::StatusCode;
+use axum::response::{IntoResponse, Response};
+
+#[derive(Debug, displaydoc::Display, thiserror::Error)]
+pub enum AppError {
+    #[cfg(feature = "ui")]
+    /// could not render the template
+    Render(#[from] askama::Error),
+}
+
+pub type AppResult<T> = Result<T, AppError>;
+
+impl IntoResponse for AppError {
+    fn into_response(self) -> Response {
+        (StatusCode::INTERNAL_SERVER_ERROR, self.to_string()).into_response()
+    }
+}

crates/hotfix-status/src/data_provider.rs

@@ -0,0 +1,33 @@
+mod api;
+mod data_provider;
+mod error;
+#[cfg(feature = "ui")]
+mod ui;
+
+use crate::api::build_api_router;
+use crate::data_provider::SessionDataProvider;
+use axum::Router;
+use hotfix::message::FixMessage;
+use hotfix::session::SessionRef;
+
+#[derive(Clone)]
+struct AppState<P> {
+    data_provider: P,
+}
+
+#[cfg(feature = "ui")]
+pub fn build_router<M: FixMessage>(session_ref: SessionRef<M>) -> Router {
+    let data_provider = SessionDataProvider { session_ref };
+    let state = AppState { data_provider };
+    Router::new()
+        .nest("/api", build_api_router())
+        .merge(ui::builder_ui_router())
+        .with_state(state)
+}
+
+#[cfg(not(feature = "ui"))]
+pub fn build_router<M: FixMessage>(session_ref: SessionRef<M>) -> Router {
+    let data_provider = SessionDataProvider { session_ref };
+    let state = AppState { data_provider };
+    Router::new().nest("/api", build_api_router(state))
+}

crates/hotfix-status/src/error.rs

@@ -0,0 +1,15 @@
+use crate::AppState;
+use crate::data_provider::DataProvider;
+use crate::ui::assets::static_handler;
+use crate::ui::dashboard::dashboard_handler;
+use axum::Router;
+use axum::routing::get;
+
+mod assets;
+mod dashboard;
+
+pub fn builder_ui_router<P: DataProvider + 'static>() -> Router<AppState<P>> {
+    Router::new()
+        .route("/", get(dashboard_handler))
+        .route("/static/{*file}", get(static_handler))
+}

crates/hotfix-status/src/lib.rs

@@ -0,0 +1,36 @@
+use axum::http::{StatusCode, Uri, header};
+use axum::response::{IntoResponse, Response};
+use rust_embed::Embed;
+
+#[derive(Embed)]
+#[folder = "assets/"]
+struct Assets;
+
+pub(crate) async fn static_handler(uri: Uri) -> impl IntoResponse {
+    let mut path = uri.path().trim_start_matches('/').to_string();
+
+    if path.starts_with("static/") {
+        path = path.replace("static/", "");
+    }
+
+    StaticFile(path)
+}
+
+pub(crate) struct StaticFile<T>(pub T);
+
+impl<T> IntoResponse for StaticFile<T>
+where
+    T: Into<String>,
+{
+    fn into_response(self) -> Response {
+        let path = self.0.into();
+
+        match Assets::get(path.as_str()) {
+            Some(content) => {
+                let mime = mime_guess::from_path(path).first_or_octet_stream();
+                ([(header::CONTENT_TYPE, mime.as_ref())], content.data).into_response()
+            }
+            None => (StatusCode::NOT_FOUND, "404 Not Found").into_response(),
+        }
+    }
+}