Merge pull request #1270 from input-output-hk/damien/1103/add-custom-response-on-aggregator-endpoint-call

Add a JSON message response on aggregator root endpoint calls

Author: dlachaume

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-aggregator"
-version = "0.3.105"
+version = "0.3.106"
 description = "A Mithril Aggregator server"
 authors = { workspace = true }
 edition = { workspace = true }

mithril-aggregator/Cargo.toml

@@ -7,7 +7,7 @@ use crate::{
     SignerRegisterer, VerificationKeyStorer,
 };
 
-use mithril_common::BeaconProvider;
+use mithril_common::{api_version::APIVersionProvider, BeaconProvider};
 use std::convert::Infallible;
 use std::sync::Arc;
 use warp::Filter;
@@ -88,3 +88,10 @@ pub fn with_verification_key_store(
 ) -> impl Filter<Extract = (Arc<dyn VerificationKeyStorer>,), Error = Infallible> + Clone {
     warp::any().map(move || dependency_manager.verification_key_store.clone())
 }
+
+/// With API version provider
+pub fn with_api_version_provider(
+    dependency_manager: Arc<DependencyContainer>,
+) -> impl Filter<Extract = (Arc<APIVersionProvider>,), Error = Infallible> + Clone {
+    warp::any().map(move || dependency_manager.api_version_provider.clone())
+}

mithril-aggregator/src/http_server/routes/middlewares.rs

@@ -3,6 +3,7 @@ mod certificate_routes;
 mod epoch_routes;
 mod middlewares;
 mod reply;
+mod root_routes;
 pub mod router;
 mod signatures_routes;
 mod signer_routes;

mithril-aggregator/src/http_server/routes/mod.rs

@@ -0,0 +1,117 @@
+use crate::DependencyContainer;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+use warp::Filter;
+
+use super::middlewares;
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+pub struct RootRouteMessage {
+    pub open_api_version: String,
+    pub documentation_url: String,
+}
+
+pub fn routes(
+    dependency_manager: Arc<DependencyContainer>,
+) -> impl Filter<Extract = (impl warp::Reply,), Error = warp::Rejection> + Clone {
+    root(dependency_manager)
+}
+
+/// GET /
+fn root(
+    dependency_manager: Arc<DependencyContainer>,
+) -> impl Filter<Extract = (impl warp::Reply,), Error = warp::Rejection> + Clone {
+    warp::path::end()
+        .and(middlewares::with_api_version_provider(dependency_manager))
+        .and_then(handlers::root)
+}
+
+mod handlers {
+    use mithril_common::api_version::APIVersionProvider;
+    use reqwest::StatusCode;
+    use slog_scope::{debug, warn};
+
+    use crate::http_server::routes::{
+        reply::{self, json},
+        root_routes::RootRouteMessage,
+    };
+    use std::{convert::Infallible, sync::Arc};
+
+    /// Root
+    pub async fn root(
+        api_version_provider: Arc<APIVersionProvider>,
+    ) -> Result<impl warp::Reply, Infallible> {
+        debug!("⇄ HTTP SERVER: root");
+
+        match api_version_provider.compute_current_version() {
+            Ok(open_api_version) => Ok(json(
+                &RootRouteMessage {
+                    open_api_version: open_api_version.to_string(),
+                    documentation_url: env!("CARGO_PKG_HOMEPAGE").to_string(),
+                },
+                StatusCode::OK,
+            )),
+            Err(err) => {
+                warn!("root::error"; "error" => ?err);
+                Ok(reply::internal_server_error(err.to_string()))
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::http_server::SERVER_BASE_PATH;
+    use crate::{initialize_dependencies, DependencyContainer};
+    use reqwest::StatusCode;
+    use std::sync::Arc;
+    use warp::http::Method;
+    use warp::test::request;
+    use warp::Filter;
+
+    use super::*;
+
+    fn setup_router(
+        dependency_manager: Arc<DependencyContainer>,
+    ) -> impl Filter<Extract = (impl warp::Reply,), Error = warp::Rejection> + Clone {
+        let cors = warp::cors()
+            .allow_any_origin()
+            .allow_headers(vec!["content-type"])
+            .allow_methods(vec![Method::GET, Method::POST, Method::OPTIONS]);
+
+        warp::any()
+            .and(warp::path(SERVER_BASE_PATH))
+            .and(routes(dependency_manager).with(cors))
+    }
+
+    #[tokio::test]
+    async fn test_root_route_ok() {
+        let method = Method::GET.as_str();
+        let path = "/";
+        let dependency_manager = initialize_dependencies().await;
+        let expected_open_api_version = dependency_manager
+            .api_version_provider
+            .clone()
+            .compute_current_version()
+            .unwrap()
+            .to_string();
+
+        let response = request()
+            .method(method)
+            .path(&format!("/{SERVER_BASE_PATH}{path}"))
+            .reply(&setup_router(Arc::new(dependency_manager)))
+            .await;
+
+        let response_body: RootRouteMessage = serde_json::from_slice(response.body()).unwrap();
+
+        assert_eq!(response.status(), StatusCode::OK);
+
+        assert_eq!(
+            response_body,
+            RootRouteMessage {
+                open_api_version: expected_open_api_version,
+                documentation_url: env!("CARGO_PKG_HOMEPAGE").to_string(),
+            }
+        );
+    }
+}

mithril-aggregator/src/http_server/routes/root_routes.rs

@@ -1,6 +1,6 @@
 use crate::http_server::routes::{
-    artifact_routes, certificate_routes, epoch_routes, signatures_routes, signer_routes,
-    statistics_routes,
+    artifact_routes, certificate_routes, epoch_routes, root_routes, signatures_routes,
+    signer_routes, statistics_routes,
 };
 use crate::http_server::SERVER_BASE_PATH;
 use crate::DependencyContainer;
@@ -15,6 +15,8 @@ use warp::http::Method;
 use warp::reject::Reject;
 use warp::{Filter, Rejection, Reply};
 
+use super::middlewares;
+
 #[derive(Debug)]
 pub struct VersionMismatchError;
 
@@ -36,7 +38,7 @@ pub fn routes(
 
     warp::any()
         .and(header_must_be(
-            dependency_manager.clone().api_version_provider.clone(),
+            dependency_manager.api_version_provider.clone(),
         ))
         .and(warp::path(SERVER_BASE_PATH))
         .and(
@@ -51,10 +53,11 @@ pub fn routes(
                 .or(signatures_routes::routes(dependency_manager.clone()))
                 .or(epoch_routes::routes(dependency_manager.clone()))
                 .or(statistics_routes::routes(dependency_manager.clone()))
+                .or(root_routes::routes(dependency_manager.clone()))
                 .with(cors),
         )
         .recover(handle_custom)
-        .and(warp::any().map(move || dependency_manager.clone().api_version_provider.clone()))
+        .and(middlewares::with_api_version_provider(dependency_manager))
         .map(|reply, api_version_provider: Arc<APIVersionProvider>| {
             warp::reply::with_header(
                 reply,