Refactor client api version

Author: jpraynaud

Cargo.lock

@@ -20,6 +20,7 @@ futures = "0.3"
 hex = "0.4.3"
 mithril-common = { path = "../mithril-common" }
 reqwest = { version = "0.11", features = ["json", "stream"] }
+semver = "1.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 slog = { version = "2.7.0", features = ["max_level_trace", "release_max_level_debug"] }

mithril-client/Cargo.toml

@@ -2,11 +2,7 @@ use std::{error::Error, fmt::Display, sync::Arc};
 
 use clap::Parser;
 use config::{builder::DefaultState, ConfigBuilder};
-use mithril_common::{
-    api_version::APIVersionProvider,
-    entities::Epoch,
-    era::{EraChecker, SupportedEra},
-};
+use mithril_common::api_version::APIVersionProvider;
 use serde::Serialize;
 use slog_scope::debug;
 
@@ -41,17 +37,10 @@ impl DownloadCommand {
             .map_err(|e| format!("configuration deserialize error: {e}"))?;
         debug!("{:?}", config);
         let runtime = Runtime::new(config.network.clone());
-        // TODO: This does not allow the client to handle an upgraded API version of a new supported era after the switch
-        // In order to do so, we should retrieve the list of supported versions from the API Version provider and test them sequentially until one hopefully succeeds
-        let era_checker = Arc::new(EraChecker::new(
-            SupportedEra::eras().first().unwrap().to_owned(),
-            Epoch(0),
-        ));
-        let api_version_provider = Arc::new(APIVersionProvider::new(era_checker.clone()));
         let aggregator_handler = AggregatorHTTPClient::new(
             config.network.clone(),
             config.aggregator_endpoint,
-            api_version_provider,
+            APIVersionProvider::compute_all_versions_sorted()?,
         );
         let (from, to) = runtime
             .download_snapshot(

mithril-client/src/aggregator.rs

@@ -3,11 +3,7 @@ use std::{error::Error, sync::Arc};
 use clap::Parser;
 use cli_table::{print_stdout, WithTitle};
 use config::{builder::DefaultState, ConfigBuilder};
-use mithril_common::{
-    api_version::APIVersionProvider,
-    entities::Epoch,
-    era::{EraChecker, SupportedEra},
-};
+use mithril_common::api_version::APIVersionProvider;
 use slog_scope::debug;
 
 use crate::{AggregatorHTTPClient, Config, Runtime};
@@ -34,17 +30,10 @@ impl ListCommand {
             .map_err(|e| format!("configuration deserialize error: {e}"))?;
         debug!("{:?}", config);
         let runtime = Runtime::new(config.network.clone());
-        // TODO: This does not allow the client to handle an upgraded API version of a new supported era after the switch
-        // In order to do so, we should retrieve the list of supported versions from the API Version provider and test them sequentially until one hopefully succeeds
-        let era_checker = Arc::new(EraChecker::new(
-            SupportedEra::eras().first().unwrap().to_owned(),
-            Epoch(0),
-        ));
-        let api_version_provider = Arc::new(APIVersionProvider::new(era_checker.clone()));
         let aggregator_handler = AggregatorHTTPClient::new(
             config.network.clone(),
             config.aggregator_endpoint,
-            api_version_provider,
+            APIVersionProvider::compute_all_versions_sorted()?,
         );
         let snapshot_list_items = runtime.list_snapshots(Arc::new(aggregator_handler)).await?;
 

mithril-client/src/commands/download.rs

@@ -9,8 +9,6 @@ use mithril_common::{
         cache::ImmutableFileDigestCacheProvider,
         cache::JsonImmutableFileDigestCacheProviderBuilder, CardanoImmutableDigester,
     },
-    entities::Epoch,
-    era::{EraChecker, SupportedEra},
 };
 use slog_scope::{debug, warn};
 use std::{error::Error, path::Path, sync::Arc};
@@ -52,17 +50,10 @@ impl RestoreCommand {
             .map_err(|e| format!("configuration deserialize error: {e}"))?;
         debug!("{:?}", config);
         let mut runtime = Runtime::new(config.network.clone());
-        let era_checker = Arc::new(EraChecker::new(
-            SupportedEra::eras().first().unwrap().to_owned(),
-            Epoch(0),
-        ));
-        // TODO: This does not allow the client to handle an upgraded API version of a new supported era after the switch
-        // In order to do so, we should retrieve the list of supported versions from the API Version provider and test them sequentially until one hopefully succeeds
-        let api_version_provider = Arc::new(APIVersionProvider::new(era_checker.clone()));
         let aggregator_handler = AggregatorHTTPClient::new(
             config.clone().network,
             config.clone().aggregator_endpoint,
-            api_version_provider,
+            APIVersionProvider::compute_all_versions_sorted()?,
         );
         let certificate_verifier = Box::new(MithrilCertificateVerifier::new(slog_scope::logger()));
         let genesis_verification_key = key_decode_hex(&config.genesis_verification_key)?;

mithril-client/src/commands/list.rs

@@ -3,11 +3,7 @@ use std::{error::Error, sync::Arc};
 use clap::Parser;
 use cli_table::{print_stdout, WithTitle};
 use config::{builder::DefaultState, ConfigBuilder};
-use mithril_common::{
-    api_version::APIVersionProvider,
-    entities::Epoch,
-    era::{EraChecker, SupportedEra},
-};
+use mithril_common::api_version::APIVersionProvider;
 use slog_scope::debug;
 
 use crate::{convert_to_field_items, AggregatorHTTPClient, Config, Runtime};
@@ -37,17 +33,10 @@ impl ShowCommand {
             .map_err(|e| format!("configuration deserialize error: {e}"))?;
         debug!("{:?}", config);
         let runtime = Runtime::new(config.network.clone());
-        // TODO: This does not allow the client to handle an upgraded API version of a new supported era after the switch
-        // In order to do so, we should retrieve the list of supported versions from the API Version provider and test them sequentially until one hopefully succeeds
-        let era_checker = Arc::new(EraChecker::new(
-            SupportedEra::eras().first().unwrap().to_owned(),
-            Epoch(0),
-        ));
-        let api_version_provider = Arc::new(APIVersionProvider::new(era_checker.clone()));
         let aggregator_handler = AggregatorHTTPClient::new(
             config.network.clone(),
             config.aggregator_endpoint,
-            api_version_provider,
+            APIVersionProvider::compute_all_versions_sorted()?,
         );
         let snapshot = runtime
             .show_snapshot(Arc::new(aggregator_handler), &self.digest)

mithril-client/src/commands/restore.rs

@@ -75,6 +75,16 @@ impl APIVersionProvider {
         Ok(VersionReq::parse(&version_req)?)
     }
 
+    /// Compute all the sorted list of all versions
+    pub fn compute_all_versions_sorted() -> Result<Vec<Version>, APIVersionProviderError> {
+        let mut versions = Vec::new();
+        for version_raw in get_open_api_versions_mapping().into_values() {
+            versions.push(Version::parse(&version_raw)?)
+        }
+        versions.sort();
+        Ok(versions)
+    }
+
     /// Update open api versions. Test only
     #[cfg(any(test, feature = "test_only"))]
     pub fn update_open_api_versions(
@@ -170,4 +180,12 @@ mod test {
                 .to_string()
         )
     }
+
+    #[test]
+    fn test_compute_all_versions_sorted() {
+        let all_versions_sorted = APIVersionProvider::compute_all_versions_sorted()
+            .expect("Computing the list of all sorted versions should not fail");
+
+        assert!(!all_versions_sorted.is_empty());
+    }
 }