panic on failed API request

Author: erhant

compute/src/node/diagnostic.rs

@@ -111,15 +111,19 @@ impl DriaComputeNode {
                     "Could not dial to RPC at: {}: {err:?}\nWill get a new RPC node.",
                     self.dria_rpc.addr,
                 );
-                self.dria_rpc = DriaRPC::new(self.dria_rpc.network).await;
-
-                // now dial this new RPC again
-                if let Err(err) = self
-                    .dial_with_timeout(self.dria_rpc.peer_id, self.dria_rpc.addr.clone())
-                    .await
-                {
-                    // worst-case we cant dial this one too, just leave it for the next diagnostic
-                    log::error!("Could not dial the new RPC: {err:?}\nWill try again in the next diagnostic refresh.");
+                if let Ok(new_rpc) = DriaRPC::new(self.dria_rpc.network).await {
+                    self.dria_rpc = new_rpc;
+
+                    // now dial this new RPC again
+                    if let Err(err) = self
+                        .dial_with_timeout(self.dria_rpc.peer_id, self.dria_rpc.addr.clone())
+                        .await
+                    {
+                        // worst-case we cant dial this one too, just leave it for the next diagnostic
+                        log::error!("Could not dial the new RPC: {err:?}\nWill try again in the next diagnostic refresh.");
+                    }
+                } else {
+                    log::error!("Could not get a new RPC node!\nWill try again in the next diagnostic refresh.");
                 }
             } else {
                 log::info!("Successfully dialled to RPC at: {}", self.dria_rpc.addr);

compute/src/node/mod.rs

@@ -71,7 +71,9 @@ impl DriaComputeNode {
         let keypair = secret_to_keypair(&config.secret_key);
 
         // get available rpc node
-        let dria_nodes = DriaRPC::new(config.network_type).await;
+        let dria_nodes = DriaRPC::new(config.network_type)
+            .await
+            .expect("could not get RPC to connect to");
 
         // we are using the major.minor version as the P2P version
         // so that patch versions do not interfere with the protocol

compute/src/utils/rpc.rs

@@ -1,6 +1,6 @@
 use dkn_p2p::libp2p::{multiaddr::Protocol, Multiaddr, PeerId};
 use dkn_p2p::DriaNetworkType;
-use eyre::Result;
+use eyre::{Context, OptionExt, Result};
 use std::fmt::Debug;
 
 /// The connected RPC node, as per the Star network topology.
@@ -13,23 +13,23 @@ pub struct DriaRPC {
 
 impl DriaRPC {
     /// Creates a new `AvailableNodes` struct for the given network type.
-    pub async fn new(network: DriaNetworkType) -> Self {
-        let addr = refresh_rpc_addr(&network)
-            .await
-            .expect("could not get RPC address");
+    ///
+    /// Will panic if anything goes wrong.
+    pub async fn new(network: DriaNetworkType) -> Result<Self> {
+        let addr = refresh_rpc_addr(&network).await?;
         let peer_id = addr
             .iter()
             .find_map(|p| match p {
                 Protocol::P2p(peer_id) => Some(peer_id),
                 _ => None,
             })
-            .expect("returned address does not contain a peer id");
+            .ok_or_eyre("did not find peer ID within the returned RPC address")?;
 
-        Self {
+        Ok(Self {
             addr,
             peer_id,
             network,
-        }
+        })
     }
 }
 
@@ -51,7 +51,10 @@ async fn refresh_rpc_addr(network: &DriaNetworkType) -> Result<Multiaddr> {
 
     // make the request
     let response = reqwest::get(url).await?;
-    let response_body = response.json::<DriaNodesApiResponse>().await?;
+    let response_body = response
+        .json::<DriaNodesApiResponse>()
+        .await
+        .wrap_err("could not parse API response")?;
 
     Ok(response_body.rpc)
 }