wip(client-cli)

Author: jpraynaud

internal/mithril-aggregator-discovery/src/model.rs

@@ -25,6 +25,12 @@ impl MithrilNetwork {
     }
 }
 
+impl From<String> for MithrilNetwork {
+    fn from(name: String) -> Self {
+        MithrilNetwork::new(name)
+    }
+}
+
 /// Representation of an aggregator endpoint
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct AggregatorEndpoint {

mithril-client-cli/src/commands/tools/aggregator_discovery.rs

@@ -0,0 +1,27 @@
+use clap::Parser;
+
+use mithril_client::{AggregatorDiscoveryType, ClientBuilder, MithrilNetwork, MithrilResult};
+
+/// Clap command to select an aggregator from the available ones with automatic discovery.
+#[derive(Parser, Debug, Clone)]
+pub struct AggregatorSelectCommand {
+    /// Path to the Cardano node database directory.
+    #[clap(long)]
+    network: MithrilNetwork,
+}
+
+impl AggregatorSelectCommand {
+    /// Main command execution
+    pub async fn execute(&self) -> MithrilResult<()> {
+        let aggregator_endpoints =
+            ClientBuilder::new(AggregatorDiscoveryType::Automatic(self.network.to_owned()))
+                .with_default_aggregator_discoverer()
+                .discover_aggregator(&self.network)?;
+
+        for endpoint in aggregator_endpoints.iter() {
+            println!("Discovered aggregator endpoint: {:?}", endpoint);
+        }
+
+        Ok(())
+    }
+}

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

@@ -3,8 +3,10 @@
 //! Provides utility subcommands such as converting restored InMemory UTxO-HD ledger snapshot
 //! to different flavors (Legacy, LMDB).
 
+mod aggregator_discovery;
 mod snapshot_converter;
 
+pub use aggregator_discovery::*;
 pub use snapshot_converter::*;
 
 use anyhow::anyhow;
@@ -18,13 +20,17 @@ pub enum ToolsCommands {
     /// UTxO-HD related commands
     #[clap(subcommand, name = "utxo-hd")]
     UTxOHD(UTxOHDCommands),
+    /// Aggregator discovery related commands
+    #[clap(subcommand, name = "aggregator-discovery")]
+    AggregatorDiscovery(AggregatorDiscoveryCommands),
 }
 
 impl ToolsCommands {
     /// Execute Tools command
     pub async fn execute(&self) -> MithrilResult<()> {
         match self {
             Self::UTxOHD(cmd) => cmd.execute().await,
+            Self::AggregatorDiscovery(cmd) => cmd.execute().await,
         }
     }
 }
@@ -52,3 +58,20 @@ impl UTxOHDCommands {
         }
     }
 }
+
+/// Aggregator discovery related commands
+#[derive(Subcommand, Debug, Clone)]
+pub enum AggregatorDiscoveryCommands {
+    /// Select an aggregator from the available ones with automatic discovery
+    #[clap(arg_required_else_help = false)]
+    Select(AggregatorSelectCommand),
+}
+
+impl AggregatorDiscoveryCommands {
+    /// Execute Aggregator discovery command
+    pub async fn execute(&self) -> MithrilResult<()> {
+        match self {
+            Self::Select(cmd) => cmd.execute().await,
+        }
+    }
+}

mithril-client/src/client.rs

@@ -9,8 +9,8 @@ use std::collections::HashMap;
 use std::sync::Arc;
 
 use mithril_aggregator_discovery::{
-    AggregatorDiscoverer, CapableAggregatorDiscoverer, HttpConfigAggregatorDiscoverer,
-    MithrilNetwork, RequiredAggregatorCapabilities,
+    AggregatorDiscoverer, AggregatorEndpoint, CapableAggregatorDiscoverer,
+    HttpConfigAggregatorDiscoverer, MithrilNetwork, RequiredAggregatorCapabilities,
 };
 use mithril_common::api_version::APIVersionProvider;
 use mithril_common::{MITHRIL_CLIENT_TYPE_HEADER, MITHRIL_ORIGIN_TAG_HEADER};
@@ -294,8 +294,7 @@ impl ClientBuilder {
             None => {
                 return Err(anyhow!(
                     "The genesis verification key must be provided to build the client with the 'with_genesis_verification_key' function"
-                )
-                .into());
+                ));
             }
         };
 
@@ -405,40 +404,47 @@ impl ClientBuilder {
         })
     }
 
+    /// Discover available aggregator endpoints for the given Mithril network and required capabilities.
+    pub fn discover_aggregator(
+        &self,
+        network: &MithrilNetwork,
+    ) -> MithrilResult<impl Iterator<Item = AggregatorEndpoint>> {
+        match self.aggregator_discoverer.clone() {
+            Some(discoverer) => {
+                let discoverer = if let Some(capabilities) = &self.aggregator_capabilities {
+                    Arc::new(CapableAggregatorDiscoverer::new(
+                        capabilities.to_owned(),
+                        discoverer.clone(),
+                    )) as Arc<dyn AggregatorDiscoverer>
+                } else {
+                    discoverer as Arc<dyn AggregatorDiscoverer>
+                };
+                tokio::task::block_in_place(move || {
+                    tokio::runtime::Handle::current().block_on(async move {
+                        discoverer
+                            .get_available_aggregators(network.to_owned())
+                            .await
+                            .with_context(|| "Discovering aggregator endpoint failed")
+                    })
+                })
+            }
+            None => Err(anyhow!(
+                "The aggregator discoverer must be provided to build the client with automatic discovery using the 'with_aggregator_discoverer' function"
+            )),
+        }
+    }
+
     fn build_aggregator_client(
         &self,
         logger: Logger,
     ) -> Result<AggregatorHTTPClient, anyhow::Error> {
         let aggregator_endpoint = match self.aggregator_discovery {
             AggregatorDiscoveryType::Url(ref url) => url.clone(),
-            AggregatorDiscoveryType::Automatic(ref network) => {
-                match self.aggregator_discoverer.clone() {
-                    Some(discoverer) => {
-                        let discoverer = if let Some(capabilities) = &self.aggregator_capabilities {
-                            Arc::new(CapableAggregatorDiscoverer::new(
-                                capabilities.to_owned(),
-                                discoverer.clone(),
-                            )) as Arc<dyn AggregatorDiscoverer>
-                        } else {
-                            discoverer as Arc<dyn AggregatorDiscoverer>
-                        };
-                        tokio::task::block_in_place(move || {
-                            tokio::runtime::Handle::current().block_on(async move {
-                                discoverer
-                                    .get_available_aggregators(network.to_owned())
-                                    .await
-                                    .with_context(|| "Discovering aggregator endpoint failed")?
-                                    .next()
-                                    .ok_or(anyhow!("No aggregator was available through discovery"))
-                            })
-                        })?
-                        .into()
-                    }
-                    None => {
-                        return Err(anyhow!("The aggregator discoverer must be provided to build the client with automatic discovery using the 'with_aggregator_discoverer' function").into());
-                    }
-                }
-            }
+            AggregatorDiscoveryType::Automatic(ref network) => self
+                .discover_aggregator(network)?
+                .next()
+                .ok_or_else(|| anyhow!("No aggregator was available through discovery"))?
+                .into(),
         };
         let endpoint_url = Url::parse(&aggregator_endpoint).with_context(|| {
             format!("Invalid aggregator endpoint, it must be a correctly formed url: '{aggregator_endpoint}'")

mithril-client/src/type_alias.rs

@@ -89,3 +89,6 @@ pub mod common {
 
 /// Required capabilities for an aggregator.
 pub use mithril_aggregator_discovery::RequiredAggregatorCapabilities;
+
+/// Mithril network
+pub use mithril_aggregator_discovery::MithrilNetwork;