feat(client-cli): implement download of Cardano node distribution to retrieve the snapshot-converter binary

Author: dlachaume

Cargo.lock

@@ -38,6 +38,13 @@ indicatif = { version = "0.17.11", features = ["tokio"] }
 mithril-cli-helper = { path = "../internal/mithril-cli-helper" }
 mithril-client = { path = "../mithril-client", features = ["fs", "unstable"] }
 mithril-doc = { path = "../internal/mithril-doc" }
+reqwest = { workspace = true, features = [
+    "default",
+    "gzip",
+    "zstd",
+    "deflate",
+    "brotli"
+] }
 serde = { workspace = true }
 serde_json = { workspace = true }
 slog = { workspace = true, features = [
@@ -52,3 +59,4 @@ tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
 
 [dev-dependencies]
 mithril-common = { path = "../mithril-common", features = ["test_tools"] }
+mockall = { workspace = true }

mithril-client-cli/Cargo.toml

@@ -0,0 +1,123 @@
+use anyhow::anyhow;
+use serde::Deserialize;
+
+use mithril_client::MithrilResult;
+
+pub const ASSET_PLATFORM_LINUX: &str = "linux";
+pub const ASSET_PLATFORM_MACOS: &str = "macos";
+pub const ASSET_PLATFORM_WINDOWS: &str = "win64";
+
+#[derive(Debug, Clone, Deserialize, Eq, PartialEq)]
+pub struct GitHubAsset {
+    pub name: String,
+    pub browser_download_url: String,
+}
+
+#[derive(Debug, Default, Clone, Deserialize)]
+pub struct GitHubRelease {
+    pub assets: Vec<GitHubAsset>,
+    pub prerelease: bool,
+}
+
+impl GitHubRelease {
+    pub fn get_asset_for_os(&self, target_os: &str) -> MithrilResult<Option<&GitHubAsset>> {
+        let os_in_asset_name = match target_os {
+            "linux" => ASSET_PLATFORM_LINUX,
+            "macos" => ASSET_PLATFORM_MACOS,
+            "windows" => ASSET_PLATFORM_WINDOWS,
+            _ => return Err(anyhow!("Unsupported platform: {}", target_os)),
+        };
+
+        let asset = self
+            .assets
+            .iter()
+            .find(|asset| asset.name.contains(os_in_asset_name));
+
+        Ok(asset)
+    }
+
+    #[cfg(test)]
+    pub fn dummy_with_all_supported_assets() -> Self {
+        GitHubRelease {
+            assets: vec![
+                GitHubAsset {
+                    name: format!("asset-name-{}.tar.gz", ASSET_PLATFORM_LINUX),
+                    browser_download_url: "https://release-assets.com/linux".to_string(),
+                },
+                GitHubAsset {
+                    name: format!("asset-name-{}.tar.gz", ASSET_PLATFORM_MACOS),
+                    browser_download_url: "https://release-assets.com/macos".to_string(),
+                },
+                GitHubAsset {
+                    name: format!("asset-name-{}.zip", ASSET_PLATFORM_WINDOWS),
+                    browser_download_url: "https://release-assets.com/windows".to_string(),
+                },
+            ],
+            ..GitHubRelease::default()
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+
+    fn dummy_asset(os: &str) -> GitHubAsset {
+        GitHubAsset {
+            name: format!("asset-name-{}.whatever", os),
+            browser_download_url: format!("https://release-assets.com/{}", os),
+        }
+    }
+
+    #[test]
+    fn returns_expected_asset_for_each_supported_platform() {
+        let release = GitHubRelease {
+            assets: vec![
+                dummy_asset(ASSET_PLATFORM_LINUX),
+                dummy_asset(ASSET_PLATFORM_MACOS),
+                dummy_asset(ASSET_PLATFORM_WINDOWS),
+            ],
+            ..GitHubRelease::default()
+        };
+
+        {
+            let asset = release.get_asset_for_os("linux").unwrap();
+            assert_eq!(asset, Some(&dummy_asset(ASSET_PLATFORM_LINUX)));
+        }
+
+        {
+            let asset = release.get_asset_for_os("macos").unwrap();
+            assert_eq!(asset, Some(&dummy_asset(ASSET_PLATFORM_MACOS)));
+        }
+
+        {
+            let asset = release.get_asset_for_os("windows").unwrap();
+            assert_eq!(asset, Some(&dummy_asset(ASSET_PLATFORM_WINDOWS)));
+        }
+    }
+
+    #[test]
+    fn returns_none_when_asset_is_missing() {
+        let release = GitHubRelease {
+            assets: vec![dummy_asset(ASSET_PLATFORM_LINUX)],
+            ..GitHubRelease::default()
+        };
+
+        let asset = release.get_asset_for_os("macos").unwrap();
+
+        assert!(asset.is_none());
+    }
+
+    #[test]
+    fn fails_for_unsupported_platform() {
+        let release = GitHubRelease {
+            assets: vec![dummy_asset(ASSET_PLATFORM_LINUX)],
+            ..GitHubRelease::default()
+        };
+
+        release
+            .get_asset_for_os("unsupported")
+            .expect_err("Should have failed for unsupported platform");
+    }
+}

mithril-client-cli/src/commands/tools/github_release_retriever/github_release.rs

@@ -0,0 +1,27 @@
+use async_trait::async_trait;
+
+use mithril_client::MithrilResult;
+
+use super::github_release::GitHubRelease;
+
+/// Trait for interacting with the GitHub API to retrieve Cardano node release.
+#[cfg_attr(test, mockall::automock)]
+#[async_trait]
+pub trait GitHubReleaseRetriever {
+    /// Retrieves a release by its tag.
+    async fn get_release_by_tag(
+        &self,
+        owner: &str,
+        repo: &str,
+        tag: &str,
+    ) -> MithrilResult<GitHubRelease>;
+
+    /// Retrieves the latest release.
+    async fn get_latest_release(&self, owner: &str, repo: &str) -> MithrilResult<GitHubRelease>;
+
+    /// Retrieves the prerelease.
+    async fn get_prerelease(&self, owner: &str, repo: &str) -> MithrilResult<GitHubRelease>;
+
+    /// Retrieves all available releases.
+    async fn get_all_releases(&self, owner: &str, repo: &str) -> MithrilResult<Vec<GitHubRelease>>;
+}

mithril-client-cli/src/commands/tools/github_release_retriever/interface.rs

@@ -0,0 +1,7 @@
+mod github_release;
+mod interface;
+mod reqwest;
+
+pub use github_release::*;
+pub use interface::*;
+pub use reqwest::*;

mithril-client-cli/src/commands/tools/github_release_retriever/mod.rs

@@ -0,0 +1,93 @@
+use anyhow::{anyhow, Context};
+use async_trait::async_trait;
+use reqwest::{Client, IntoUrl};
+use serde::de::DeserializeOwned;
+
+use mithril_client::MithrilResult;
+
+use super::{GitHubRelease, GitHubReleaseRetriever};
+
+pub struct ReqwestGitHubApiClient {
+    client: Client,
+}
+
+impl ReqwestGitHubApiClient {
+    pub fn new() -> MithrilResult<Self> {
+        let client = Client::builder()
+            .user_agent("mithril-client")
+            .build()
+            .context("Failed to build Reqwest GitHub API client")?;
+
+        Ok(Self { client })
+    }
+
+    async fn download<U: IntoUrl, T: DeserializeOwned>(&self, source_url: U) -> MithrilResult<T> {
+        let url = source_url
+            .into_url()
+            .with_context(|| "Given `source_url` is not a valid Url")?;
+        let response = self
+            .client
+            .get(url.clone())
+            .send()
+            .await
+            .with_context(|| format!("Failed to send request to GitHub API: {}", url))?;
+        let body = response.text().await?;
+        let parsed_body = serde_json::from_str::<T>(&body)
+            .with_context(|| format!("Failed to parse response from GitHub API: {:?}", body))?;
+
+        Ok(parsed_body)
+    }
+}
+
+#[async_trait]
+impl GitHubReleaseRetriever for ReqwestGitHubApiClient {
+    async fn get_release_by_tag(
+        &self,
+        organization: &str,
+        repository: &str,
+        tag: &str,
+    ) -> MithrilResult<GitHubRelease> {
+        let url =
+            format!("https://api.github.com/repos/{organization}/{repository}/releases/tags/{tag}");
+        let release = self.download(url).await?;
+
+        Ok(release)
+    }
+
+    async fn get_latest_release(
+        &self,
+        organization: &str,
+        repository: &str,
+    ) -> MithrilResult<GitHubRelease> {
+        let url =
+            format!("https://api.github.com/repos/{organization}/{repository}/releases/latest");
+        let release = self.download(url).await?;
+
+        Ok(release)
+    }
+
+    async fn get_prerelease(
+        &self,
+        organization: &str,
+        repository: &str,
+    ) -> MithrilResult<GitHubRelease> {
+        let releases = self.get_all_releases(organization, repository).await?;
+        let prerelease = releases
+            .into_iter()
+            .find(|release| release.prerelease)
+            .ok_or_else(|| anyhow!("No prerelease found"))?;
+
+        Ok(prerelease)
+    }
+
+    async fn get_all_releases(
+        &self,
+        organization: &str,
+        repository: &str,
+    ) -> MithrilResult<Vec<GitHubRelease>> {
+        let url = format!("https://api.github.com/repos/{organization}/{repository}/releases");
+        let releases = self.download(url).await?;
+
+        Ok(releases)
+    }
+}

mithril-client-cli/src/commands/tools/github_release_retriever/reqwest.rs

@@ -0,0 +1,23 @@
+mod reqwest_http_downloader;
+
+pub use reqwest_http_downloader::*;
+
+use async_trait::async_trait;
+use mithril_client::MithrilResult;
+use reqwest::Url;
+use std::path::{Path, PathBuf};
+
+/// Trait for downloading a file over HTTP from a URL,
+/// saving it to a target directory with the given filename.
+///
+/// Returns the path to the downloaded file.
+#[cfg_attr(test, mockall::automock)]
+#[async_trait]
+pub trait HttpDownloader {
+    async fn download_file(
+        &self,
+        url: Url,
+        download_dir: &Path,
+        filename: &str,
+    ) -> MithrilResult<PathBuf>;
+}

mithril-client-cli/src/commands/tools/http_downloader/mod.rs

@@ -0,0 +1,53 @@
+use std::{
+    fs::File,
+    io::Write,
+    path::{Path, PathBuf},
+};
+
+use anyhow::Context;
+use async_trait::async_trait;
+use reqwest::{Client, Url};
+
+use mithril_client::MithrilResult;
+
+use super::HttpDownloader;
+
+/// [ReqwestHttpDownloader] is an implementation of the [HttpDownloader].
+pub struct ReqwestHttpDownloader {
+    client: Client,
+}
+
+impl ReqwestHttpDownloader {
+    /// Creates a new instance of [ReqwestHttpDownloader].
+    pub fn new() -> MithrilResult<Self> {
+        let client = Client::builder()
+            .build()
+            .with_context(|| "Failed to build Reqwest HTTP client")?;
+
+        Ok(Self { client })
+    }
+}
+
+#[async_trait]
+impl HttpDownloader for ReqwestHttpDownloader {
+    async fn download_file(
+        &self,
+        url: Url,
+        download_dir: &Path,
+        filename: &str,
+    ) -> MithrilResult<PathBuf> {
+        let response = self
+            .client
+            .get(url.clone())
+            .send()
+            .await
+            .with_context(|| format!("Failed to download file from URL: {}", url))?;
+
+        let bytes = response.bytes().await?;
+        let download_filepath = download_dir.join(filename);
+        let mut file = File::create(&download_filepath)?;
+        file.write_all(&bytes)?;
+
+        Ok(download_filepath)
+    }
+}

mithril-client-cli/src/commands/tools/http_downloader/reqwest_http_downloader.rs

@@ -3,12 +3,14 @@
 //! Provides utility subcommands such as converting restored InMemory UTxO-HD ledger snapshot
 //! to different flavors (Legacy, LMDB).
 
+mod github_release_retriever;
+mod http_downloader;
 mod snapshot_converter;
 
-use mithril_client::MithrilResult;
 pub use snapshot_converter::*;
 
 use clap::Subcommand;
+use mithril_client::MithrilResult;
 
 /// Tools commands
 #[derive(Subcommand, Debug, Clone)]