refactor(test-lab): switch to v2 endpoint with CardanoDatabase signed_entity_type for aggregator stress test

Author: turmelclem

mithril-test-lab/mithril-end-to-end/src/bin/load-aggregator/main.rs

@@ -36,7 +36,7 @@ async fn main() -> StdResult<()> {
     reporter.start("stress tests bootstrap");
     // configure a dummy immutable db
     let cardano_db = DummyCardanoDbBuilder::new("load-tester")
-        .with_immutables(&[1, 2, 3])
+        .with_immutables(&[0, 1, 2])
         .with_legacy_ledger_snapshots(&[533])
         .append_immutable_trio()
         .build();
@@ -226,7 +226,7 @@ async fn main_scenario(
         .unwrap();
 
     info!(
-        ">> Send the Signer Signatures payloads for CardanoImmutableFiles({:?})",
+        ">> Send the Signer Signatures payloads for CardanoDatabase({:?})",
         current_beacon
     );
     parameters.reporter.start("signatures registration");

mithril-test-lab/mithril-end-to-end/src/stress_test/aggregator_helpers.rs

@@ -15,7 +15,7 @@ pub async fn bootstrap_aggregator(
     current_epoch: &mut Epoch,
 ) -> StdResult<Aggregator> {
     info!(">> Launch Aggregator");
-    let signed_entity_types = vec!["CardanoImmutableFilesFull".to_string()];
+    let signed_entity_types = vec!["CardanoDatabase".to_string()];
     let chain_observer_type = "cardano-cli";
 
     let mut aggregator = Aggregator::new(&AggregatorConfig {

mithril-test-lab/mithril-end-to-end/src/stress_test/fake_client.rs

@@ -5,7 +5,10 @@ use async_recursion::async_recursion;
 use indicatif::{ProgressBar, ProgressDrawTarget};
 use mithril_common::{
     StdResult,
-    messages::{CertificateMessage, SnapshotListItemMessage, SnapshotListMessage},
+    messages::{
+        CardanoDatabaseSnapshotListItemMessage, CardanoDatabaseSnapshotListMessage,
+        CertificateMessage,
+    },
 };
 use reqwest::StatusCode;
 use slog_scope::warn;
@@ -47,12 +50,12 @@ pub enum LoadError {
 pub async fn download_latest_snasphot(
     http_client: Arc<reqwest::Client>,
     endpoint: &str,
-) -> StdResult<SnapshotListItemMessage> {
-    let http_request = http_client.get(format!("{endpoint}/artifact/snapshots"));
+) -> StdResult<CardanoDatabaseSnapshotListItemMessage> {
+    let http_request = http_client.get(format!("{endpoint}/artifact/cardano-database"));
     let response = http_request.send().await;
-    let snapshots: SnapshotListMessage = match response {
+    let snapshots: CardanoDatabaseSnapshotListMessage = match response {
         Ok(response) => match response.status() {
-            StatusCode::OK => Ok(serde_json::from_str::<SnapshotListMessage>(
+            StatusCode::OK => Ok(serde_json::from_str::<CardanoDatabaseSnapshotListMessage>(
                 &response.text().await.unwrap(),
             )
             .expect("this error should never happen")),
@@ -67,8 +70,8 @@ pub async fn download_latest_snasphot(
 
     let last_snapshot = snapshots.first().ok_or(LoadError::EmptySnapshotList)?;
     let http_request = http_client.get(format!(
-        "{}/artifact/snapshot/{}",
-        endpoint, last_snapshot.digest
+        "{}/artifact/cardano-database/{}",
+        endpoint, last_snapshot.hash
     ));
     let response = http_request.send().await;
     match response {

mithril-test-lab/mithril-end-to-end/src/stress_test/payload_builder.rs

@@ -114,21 +114,25 @@ pub async fn compute_immutable_files_signatures(
             let beacon = CardanoDbBeacon::new(*epoch, immutable_file_number);
             let digester =
                 CardanoImmutableDigester::new("devnet".to_string(), None, slog_scope::logger());
-            let digest = digester
-                .compute_digest(cardano_db.get_immutable_dir(), &beacon)
+            let merkle_tree = digester
+                .compute_merkle_tree(cardano_db.get_immutable_dir(), &beacon)
                 .await
                 .with_context(|| {
                     format!(
                         "Payload Builder can not compute digest of '{}'",
                         cardano_db.get_immutable_dir().display()
                     )
                 })?;
+            let merkle_root = merkle_tree.compute_root()?.to_hex();
             let signers_fixture = signers_fixture.clone();
 
             let signatures = tokio::task::spawn_blocking(move || -> Vec<_> {
                 let cardano_immutable_files_full_message = {
                     let mut message = ProtocolMessage::new();
-                    message.set_message_part(ProtocolMessagePartKey::SnapshotDigest, digest);
+                    message.set_message_part(
+                        ProtocolMessagePartKey::CardanoDatabaseMerkleRoot,
+                        merkle_root,
+                    );
                     message.set_message_part(
                         ProtocolMessagePartKey::NextAggregateVerificationKey,
                         signers_fixture.compute_and_encode_avk(),
@@ -148,7 +152,7 @@ pub async fn compute_immutable_files_signatures(
                     .sign_all(&cardano_immutable_files_full_message)
                     .into_iter()
                     .map(|s| RegisterSignatureMessageHttp {
-                        signed_entity_type: SignedEntityType::CardanoImmutableFilesFull(
+                        signed_entity_type: SignedEntityType::CardanoDatabase(
                             CardanoDbBeacon::new(*epoch, immutable_file_number),
                         ),
                         party_id: s.party_id.clone(),

mithril-test-lab/mithril-end-to-end/src/stress_test/wait.rs

@@ -10,8 +10,8 @@ use mithril_common::{
     StdResult,
     entities::Epoch,
     messages::{
-        CertificateListItemMessage, EpochSettingsMessage, MithrilStakeDistributionListItemMessage,
-        SnapshotListItemMessage,
+        CardanoDatabaseSnapshotListItemMessage, CertificateListItemMessage, EpochSettingsMessage,
+        MithrilStakeDistributionListItemMessage,
     },
 };
 
@@ -163,13 +163,15 @@ pub async fn for_immutable_files_artifacts(
     aggregator: &Aggregator,
     total: usize,
     timeout: Duration,
-) -> StdResult<SnapshotListItemMessage> {
-    let url = &format!("{}/artifact/snapshots", aggregator.endpoint());
+) -> StdResult<CardanoDatabaseSnapshotListItemMessage> {
+    let url = &format!("{}/artifact/cardano-database", aggregator.endpoint());
     spin_while_waiting!(
         {
-            request_first_list_item_with_expected_size::<SnapshotListItemMessage>(url, total)
-                .await
-                .map_err(|e| anyhow!(e).context("Request first snapshot failure"))
+            request_first_list_item_with_expected_size::<CardanoDatabaseSnapshotListItemMessage>(
+                url, total,
+            )
+            .await
+            .map_err(|e| anyhow!(e).context("Request first snapshot failure"))
         },
         timeout,
         format!("Waiting for immutable files artifacts"),