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

Author: dlachaume

Cargo.lock

@@ -38,6 +38,7 @@ 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 }
 serde = { workspace = true }
 serde_json = { workspace = true }
 slog = { workspace = true, features = [
@@ -52,3 +53,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,29 @@
+mod reqwest_github_api_client;
+
+pub use reqwest_github_api_client::*;
+
+use crate::commands::tools::github_release::GitHubRelease;
+use async_trait::async_trait;
+use mithril_client::MithrilResult;
+
+/// Trait for interacting with the GitHub API to retrieve Cardano node release.
+#[cfg_attr(test, mockall::automock)]
+#[async_trait]
+pub trait GitHubApiClient {
+    /// 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_api_client/mod.rs

@@ -0,0 +1,114 @@
+use anyhow::{anyhow, Context};
+use async_trait::async_trait;
+use reqwest::{Client, Url};
+
+use mithril_client::MithrilResult;
+
+use crate::commands::tools::github_release::GitHubRelease;
+
+use super::GitHubApiClient;
+
+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_trait]
+impl GitHubApiClient 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 url = Url::parse(&url)
+            .with_context(|| format!("Failed to parse URL for GitHub API: {}", url))?;
+
+        let response = self
+            .client
+            .get(url.clone())
+            .send()
+            .await
+            .with_context(|| format!("Failed to send request to GitHub API: {}", url))?;
+
+        let response = response.text().await?;
+        let release: GitHubRelease = serde_json::from_str(&response)
+            .with_context(|| format!("Failed to parse response from GitHub API: {:?}", response))?;
+
+        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 url = Url::parse(&url)
+            .with_context(|| format!("Failed to parse URL for GitHub API: {}", url))?;
+
+        let response = self
+            .client
+            .get(url.clone())
+            .send()
+            .await
+            .with_context(|| format!("Failed to send request to GitHub API: {}", url))?;
+
+        let response = response.text().await?;
+        let release: GitHubRelease = serde_json::from_str(&response)
+            .with_context(|| format!("Failed to parse response from GitHub API: {:?}", response))?;
+
+        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.is_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 url = Url::parse(&url)
+            .with_context(|| format!("Failed to parse URL for GitHub API: {}", url))?;
+
+        let response = self
+            .client
+            .get(url.clone())
+            .send()
+            .await
+            .with_context(|| format!("Failed to send request to GitHub API: {}", url))?;
+
+        let response = response.text().await?;
+        let releases: Vec<GitHubRelease> = serde_json::from_str(&response)
+            .with_context(|| format!("Failed to parse response from GitHub API: {:?}", response))?;
+
+        Ok(releases)
+    }
+}

mithril-client-cli/src/commands/tools/github_api_client/reqwest_github_api_client.rs

@@ -0,0 +1,141 @@
+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 is_prerelease(&self) -> bool {
+        self.prerelease
+    }
+
+    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_linux_asset() -> GitHubAsset {
+        GitHubAsset {
+            name: format!("asset-name-{}.tar.gz", ASSET_PLATFORM_LINUX),
+            browser_download_url: "https://release-assets.com/linux".to_string(),
+        }
+    }
+
+    fn dummy_macos_asset() -> GitHubAsset {
+        GitHubAsset {
+            name: format!("asset-name-{}.tar.gz", ASSET_PLATFORM_MACOS),
+            browser_download_url: "https://release-assets.com/macos".to_string(),
+        }
+    }
+
+    fn dummy_windows_asset() -> GitHubAsset {
+        GitHubAsset {
+            name: format!("asset-name-{}.zip", ASSET_PLATFORM_WINDOWS),
+            browser_download_url: "https://release-assets.com/windows".to_string(),
+        }
+    }
+
+    #[test]
+    fn returns_expected_asset_for_each_supported_platform() {
+        let release = GitHubRelease {
+            assets: vec![
+                dummy_linux_asset(),
+                dummy_macos_asset(),
+                dummy_windows_asset(),
+            ],
+            ..GitHubRelease::default()
+        };
+
+        {
+            let asset = release.get_asset_for_os("linux").unwrap();
+            assert_eq!(asset, Some(&dummy_linux_asset()));
+        }
+
+        {
+            let asset = release.get_asset_for_os("macos").unwrap();
+            assert_eq!(asset, Some(&dummy_macos_asset()));
+        }
+
+        {
+            let asset = release.get_asset_for_os("windows").unwrap();
+            assert_eq!(asset, Some(&dummy_windows_asset()));
+        }
+    }
+
+    #[test]
+    fn returns_none_when_asset_is_missing() {
+        let release = GitHubRelease {
+            assets: vec![dummy_linux_asset()],
+            ..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_linux_asset()],
+            ..GitHubRelease::default()
+        };
+
+        release
+            .get_asset_for_os("unsupported")
+            .expect_err("Should have failed for unsupported platform");
+    }
+}

mithril-client-cli/src/commands/tools/github_release.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(
+        &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(
+        &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)
+    }
+}