chore: replace backoff by backon library (#4984)

Co-authored-by: hanabi1224 <[email protected]>

Cargo.toml

@@ -18,7 +18,7 @@ async-fs = "2"
 async-trait = "0.1"
 asynchronous-codec = "0.7"
 axum = "0.7"
-backoff = { version = "0.4", features = ['tokio'] }
+backon = "1.2.0"
 base64 = "0.22"
 bigdecimal = "=0.4.2" # TODO(forest): https://github.com/ChainSafe/forest/issues/4035
 blake2b_simd = "1.0"

deny.toml

@@ -79,10 +79,6 @@ ignore = [
   # Instant is unmaintained, but there is a replacement in
   # the pipeline - see
   # https://github.com/libp2p/rust-libp2p/pull/5674
-  # We will likele need to get rid of `backoff` dependency
-  # in favour of something that is maintained too - see
-  # https://github.com/ihrwein/backoff/pull/70. Last commit
-  # to master was 3 years ago.
   "RUSTSEC-2024-0384",
 ]
 # If this is true, then cargo deny will use the git executable to fetch advisory database.

src/beacon/drand.rs

@@ -15,11 +15,13 @@ use crate::shim::version::NetworkVersion;
 use crate::utils::net::global_http_client;
 use anyhow::Context as _;
 use async_trait::async_trait;
+use backon::{ExponentialBuilder, Retryable};
 use bls_signatures::Serialize as _;
 use itertools::Itertools as _;
 use lru::LruCache;
 use parking_lot::RwLock;
 use serde::{Deserialize as SerdeDeserialize, Serialize as SerdeSerialize};
+use tracing::debug;
 use url::Url;
 
 /// Environmental Variable to ignore `Drand`. Lotus parallel is
@@ -378,12 +380,15 @@ impl Beacon for DrandBeacon {
                         anyhow::Ok(server.join(&format!("{}/public/{round}", self.hash))?)
                     })
                     .try_collect()?;
-                Ok(
-                    backoff::future::retry(backoff::ExponentialBackoff::default(), || async {
-                        Ok(fetch_entry(urls.iter().cloned()).await?)
+                Ok((|| fetch_entry(urls.iter().cloned()))
+                    .retry(ExponentialBuilder::default())
+                    .notify(|err, dur| {
+                        debug!(
+                            "retrying fetch_entry {err} after {}",
+                            humantime::format_duration(dur)
+                        );
                     })
-                    .await?,
-                )
+                    .await?)
             }
         }
     }

src/utils/proofs_api/paramfetch.rs

@@ -11,7 +11,6 @@ use std::{
     io::{self, ErrorKind},
     path::{Path, PathBuf},
     sync::Arc,
-    time::Duration,
 };
 
 use crate::{
@@ -22,7 +21,7 @@ use crate::{
     },
 };
 use anyhow::{bail, Context};
-use backoff::{future::retry, ExponentialBackoffBuilder};
+use backon::{ExponentialBuilder, Retryable};
 use futures::{stream::FuturesUnordered, AsyncWriteExt, TryStreamExt};
 use tokio::fs::{self};
 use tracing::{debug, info, warn};
@@ -156,16 +155,16 @@ async fn fetch_params_ipfs_gateway(path: &Path, info: &ParameterData) -> anyhow:
         "Fetching param file {path} from {gateway}",
         path = path.display()
     );
-    let backoff = ExponentialBackoffBuilder::default()
-        // Up to 30 minutes for downloading the file. This may be drastic,
-        // but the gateway proved to be unreliable at times and we
-        // don't want to get stuck here. Better to fail fast and retry.
-        .with_max_elapsed_time(Some(Duration::from_secs(60 * 30)))
-        .build();
-    let result = retry(backoff, || async {
-        Ok(download_ipfs_file_trustlessly(&info.cid, &gateway, path).await?)
-    })
-    .await;
+    let result = (|| download_ipfs_file_trustlessly(&info.cid, &gateway, path))
+        .retry(ExponentialBuilder::default())
+        .notify(|err, dur| {
+            debug!(
+                "retrying download_ipfs_file_trustlessly {err} after {}",
+                humantime::format_duration(dur)
+            );
+        })
+        .await;
+
     debug!(
         "Done fetching param file {path} from {gateway}",
         path = path.display(),
@@ -176,13 +175,15 @@ async fn fetch_params_ipfs_gateway(path: &Path, info: &ParameterData) -> anyhow:
 /// Downloads the parameter file from Cloudflare R2 to the given path. It wraps the [`download_from_cloudflare`] function with a retry and timeout mechanisms.
 async fn fetch_params_cloudflare(name: &str, path: &Path) -> anyhow::Result<()> {
     info!("Fetching param file {name} from Cloudflare R2 {CLOUDFLARE_PROOF_PARAMETER_DOMAIN}");
-    let backoff = ExponentialBackoffBuilder::default()
-        .with_max_elapsed_time(Some(Duration::from_secs(60 * 30)))
-        .build();
-    let result = retry(backoff, || async {
-        Ok(download_from_cloudflare(name, path).await?)
-    })
-    .await;
+    let result = (|| download_from_cloudflare(name, path))
+        .retry(ExponentialBuilder::default())
+        .notify(|err, dur| {
+            debug!(
+                "retrying download_from_cloudflare {err} after {}",
+                humantime::format_duration(dur)
+            );
+        })
+        .await;
     debug!(
         "Done fetching param file {} from Cloudflare",
         path.display()