feature: Add a route for immutable-files-restored

Author: sfauvel

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

@@ -6,7 +6,7 @@ use crate::http_server::routes::router::RouterState;
 pub fn routes(
     router_state: &RouterState,
 ) -> impl Filter<Extract = (impl warp::Reply,), Error = warp::Rejection> + Clone {
-    post_statistics(router_state)
+    post_statistics(router_state).or(post_cardano_database_immutable_files_restored(router_state))
 }
 
 /// POST /statistics/snapshot
@@ -22,12 +22,27 @@ fn post_statistics(
         .and_then(handlers::post_snapshot_statistics)
 }
 
+/// POST /statistics/cardano-database/immutable-files-restored
+fn post_cardano_database_immutable_files_restored(
+    router_state: &RouterState,
+) -> impl Filter<Extract = (impl warp::Reply,), Error = warp::Rejection> + Clone {
+    warp::path!("statistics" / "cardano-database" / "immutable-files-restored")
+        .and(warp::post())
+        .and(warp::body::json())
+        .and(middlewares::with_logger(router_state))
+        .and(middlewares::with_event_transmitter(router_state))
+        .and(middlewares::with_metrics_service(router_state))
+        .and_then(handlers::post_cardano_database_immutable_files_restored)
+}
+
 mod handlers {
     use slog::warn;
     use std::{convert::Infallible, sync::Arc};
     use warp::http::StatusCode;
 
-    use mithril_common::messages::SnapshotDownloadMessage;
+    use mithril_common::messages::{
+        CardanoDatabaseImmutableFilesRestoredMessage, SnapshotDownloadMessage,
+    };
 
     use crate::event_store::{EventMessage, TransmitterService};
     use crate::http_server::routes::reply;
@@ -60,13 +75,53 @@ mod handlers {
             Ok(_) => Ok(reply::empty(StatusCode::CREATED)),
         }
     }
+
+    pub async fn post_cardano_database_immutable_files_restored(
+        message: CardanoDatabaseImmutableFilesRestoredMessage,
+        logger: slog::Logger,
+        event_transmitter: Arc<TransmitterService<EventMessage>>,
+        metrics_service: Arc<MetricsService>,
+    ) -> Result<impl warp::Reply, Infallible> {
+        metrics_service
+            .get_cardano_database_immutable_files_restored()
+            .increment();
+
+        transmit_event_message(
+            message,
+            logger,
+            event_transmitter,
+            "cardano_database_immutable_files_restored",
+        )
+        .await
+    }
+
+    async fn transmit_event_message(
+        message: CardanoDatabaseImmutableFilesRestoredMessage,
+        logger: slog::Logger,
+        event_transmitter: Arc<TransmitterService<EventMessage>>,
+        action: &str,
+    ) -> Result<impl warp::Reply, Infallible> {
+        let headers: Vec<(&str, &str)> = Vec::new();
+
+        let message = EventMessage::new("HTTP::statistics", action, &message, headers);
+
+        match event_transmitter.try_send(message.clone()) {
+            Err(e) => {
+                warn!(logger, "Event message error"; "error" => ?e);
+                Ok(reply::internal_server_error(e))
+            }
+            Ok(_) => Ok(reply::empty(StatusCode::CREATED)),
+        }
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    use mithril_common::messages::SnapshotDownloadMessage;
+    use mithril_common::messages::{
+        CardanoDatabaseImmutableFilesRestoredMessage, SnapshotDownloadMessage,
+    };
     use mithril_common::test_utils::apispec::APISpec;
 
     use std::sync::Arc;
@@ -151,4 +206,124 @@ mod tests {
                 .get()
         );
     }
+
+    mod post_cardano_database_immutable_files_restored {
+        use tokio::sync::mpsc::UnboundedReceiver;
+        use warp::hyper::body::Bytes;
+
+        use crate::{event_store::EventMessage, DependencyContainer};
+
+        use super::*;
+
+        const HTTP_METHOD: Method = Method::POST;
+        const PATH: &str = "/statistics/cardano-database/immutable-files-restored";
+
+        async fn setup_dependencies() -> (Arc<DependencyContainer>, UnboundedReceiver<EventMessage>)
+        {
+            let config = Configuration::new_sample();
+            let mut builder = DependenciesBuilder::new_with_stdout_logger(config);
+            let rx = builder.get_event_transmitter_receiver().await.unwrap();
+            let dependency_manager = Arc::new(builder.build_dependency_container().await.unwrap());
+            (dependency_manager, rx)
+        }
+
+        async fn send_request(
+            dependency_manager: &Arc<DependencyContainer>,
+            message: &CardanoDatabaseImmutableFilesRestoredMessage,
+        ) -> warp::http::Response<Bytes> {
+            request()
+                .method(HTTP_METHOD.as_str())
+                .json(message)
+                .path(PATH)
+                .reply(&setup_router(RouterState::new_with_dummy_config(
+                    dependency_manager.clone(),
+                )))
+                .await
+        }
+
+        #[tokio::test]
+        async fn conform_to_open_api_when_created() {
+            let (dependency_manager, _rx) = setup_dependencies().await;
+
+            let message = CardanoDatabaseImmutableFilesRestoredMessage::dummy();
+
+            let response = send_request(&dependency_manager, &message).await;
+
+            let result = APISpec::verify_conformity(
+                APISpec::get_all_spec_files(),
+                HTTP_METHOD.as_str(),
+                PATH,
+                "application/json",
+                &message,
+                &response,
+                &StatusCode::CREATED,
+            );
+
+            result.unwrap();
+        }
+
+        #[tokio::test]
+        async fn conform_to_open_api_when_server_error() {
+            let (dependency_manager, mut rx) = setup_dependencies().await;
+            rx.close();
+
+            let message = CardanoDatabaseImmutableFilesRestoredMessage::dummy();
+            let response = request()
+                .method(HTTP_METHOD.as_str())
+                .json(&message)
+                .path(PATH)
+                .reply(&setup_router(RouterState::new_with_dummy_config(
+                    dependency_manager.clone(),
+                )))
+                .await;
+
+            APISpec::verify_conformity(
+                APISpec::get_all_spec_files(),
+                HTTP_METHOD.as_str(),
+                PATH,
+                "application/json",
+                &message,
+                &response,
+                &StatusCode::INTERNAL_SERVER_ERROR,
+            )
+            .unwrap();
+        }
+
+        #[tokio::test]
+        async fn should_send_event() {
+            let (dependency_manager, mut rx) = setup_dependencies().await;
+
+            send_request(
+                &dependency_manager,
+                &CardanoDatabaseImmutableFilesRestoredMessage::dummy(),
+            )
+            .await;
+
+            let _ = rx.try_recv().unwrap();
+        }
+
+        #[tokio::test]
+        async fn increments_metric() {
+            let (dependency_manager, _rx) = setup_dependencies().await;
+
+            let initial_counter_value = dependency_manager
+                .metrics_service
+                .get_cardano_database_immutable_files_restored()
+                .get();
+
+            send_request(
+                &dependency_manager,
+                &CardanoDatabaseImmutableFilesRestoredMessage::dummy(),
+            )
+            .await;
+
+            assert_eq!(
+                initial_counter_value + 1,
+                dependency_manager
+                    .metrics_service
+                    .get_cardano_database_immutable_files_restored()
+                    .get()
+            );
+        }
+    }
 }

mithril-aggregator/src/metrics/service.rs

@@ -18,6 +18,22 @@ build_metrics_service!(
         "mithril_aggregator_cardano_db_total_restoration_since_startup",
         "Number of Cardano immutable files full restorations since startup on a Mithril aggregator node"
     ),
+    cardano_database_immutable_files_restored:MetricCounter(
+        "mithril_aggregator_cardano_db_immutable_files_restored_since_startup",
+        "Number of Cardano immutable files restored since startup on a Mithril aggregator node"
+    ),
+    cardano_database_ancillary_files_restored:MetricCounter(
+        "mithril_aggregator_cardano_db_ancillary_files_restored_since_startup",
+        "Number of Cardano ancillary files restored since startup on a Mithril aggregator node"
+    ),
+    cardano_database_full_restoration_since_startup:MetricCounter(
+        "mithril_aggregator_cardano_db_full_restoration_since_startup",
+        "Number of full Cardano database restoration since startup on a Mithril aggregator node"
+    ),
+    cardano_database_partial_restoration_since_startup:MetricCounter(
+        "mithril_aggregator_cardano_db_partial_restoration_since_startup",
+        "Number of partial Cardano database restoration since startup on a Mithril aggregator node"
+    ),
     artifact_detail_cardano_database_total_served_since_startup:MetricCounter(
         "mithril_aggregator_artifact_detail_cardano_database_total_served_since_startup",
         "Number of Cardano database artifact details served since startup on a Mithril aggregator node"

mithril-common/src/messages/cardano_database_immutable_files_restored.rs

@@ -0,0 +1,42 @@
+use serde::{Deserialize, Serialize};
+
+/// Message structure of an immutable files restoration
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct CardanoDatabaseImmutableFilesRestoredMessage {
+    /// Number of immutable files restored.
+    pub nb_immutable_files: u64,
+}
+
+impl CardanoDatabaseImmutableFilesRestoredMessage {
+    /// Return a dummy test entity (test-only).
+    pub fn dummy() -> Self {
+        Self {
+            nb_immutable_files: 34,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const CURRENT_JSON: &str = r#"{
+        "nb_immutable_files": 62
+        },
+    }"#;
+
+    fn golden_message_current() -> SnapshotMessage {
+        SnapshotMessage {
+            nb_immutable_files: 62,
+        }
+    }
+
+    #[test]
+    fn test_current_json_deserialized_into_current_message() {
+        let json = CURRENT_JSON;
+        let message: CardanoDatabaseImmutableFilesRestoredMessage =
+            serde_json::from_str(json).unwrap();
+
+        assert_eq!(golden_message_current(), message);
+    }
+}

mithril-common/src/messages/mod.rs

@@ -4,6 +4,7 @@ mod aggregator_features;
 mod aggregator_status;
 mod cardano_database;
 mod cardano_database_digest_list;
+mod cardano_database_immutable_files_restored;
 mod cardano_database_list;
 mod cardano_stake_distribution;
 mod cardano_stake_distribution_list;
@@ -32,6 +33,7 @@ pub use cardano_database::{ArtifactsLocationsMessagePart, CardanoDatabaseSnapsho
 pub use cardano_database_digest_list::{
     CardanoDatabaseDigestListItemMessage, CardanoDatabaseDigestListMessage,
 };
+pub use cardano_database_immutable_files_restored::CardanoDatabaseImmutableFilesRestoredMessage;
 pub use cardano_database_list::{
     CardanoDatabaseSnapshotListItemMessage, CardanoDatabaseSnapshotListMessage,
 };

openapi.yaml

@@ -746,6 +746,26 @@ paths:
               schema:
                 $ref: "#/components/schemas/Error"
 
+  /statistics/cardano-database/immutable-files-restored:
+    post:
+      summary: Records immutable files restored event
+      description: Records immutable files restored event
+      requestBody:
+        description: Immutable files restored message
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/CardanoDatabaseImmutableFilesRestoredMessage"
+      responses:
+        "201":
+          description: Event successfully recorded
+        default:
+          description: Record event bad request
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/Error"
 components:
   schemas:
     AggregatorStatusMessage:
@@ -1880,6 +1900,21 @@ components:
             "cardano_node_version": "1.0.0"
           }
 
+    CardanoDatabaseImmutableFilesRestoredMessage:
+      description: CardanoDatabaseImmutableFilesRestoredMessage represents a Cardano database immutable files restored event
+      type: object
+      additionalProperties: false
+      required:
+        - nb_immutable_files
+      properties:
+        nb_immutable_files:
+          description: Number of immutable files restored
+          type: integer
+      examples:
+        - {
+            "nb_immutable_files": 15
+          }
+
     CardanoDatabaseArtifactsLocationsMessagePart:
       description: CardanoDatabaseArtifactsLocationsMessagePart represents the locations of the Cardano database artifacts
       type: object