chore: switch from backoff to backon (#3227)

## Description

`backoff` is no longer maintained, upgrade path in cargo-deny indicates
switching to `backon`.

## Notes & open questions

There are some options in `backon` for using sleepers in the retry that
are Wasm compatible: https://docs.rs/backon/1.4.0/backon/#sleep

I'm curious if we should be taking advantage.

Further questions:
~how do I resolve the `paste` cargo-deny issue?~
I don't: added `paste` and `humantime` advisories to the "allow" list

## Change checklist
<!-- Remove any that are not relevant. -->
- [x] Self-review.

---------

Co-authored-by: “ramfox” <“[email protected]”>

Author: ramfox

Cargo.lock

@@ -19,5 +19,6 @@ allow = [
 
 [advisories]
 ignore = [
-    "RUSTSEC-2024-0384", # unmaintained, no upgrade available
+  "RUSTSEC-2024-0384", # unmaintained, no upgrade available
+  "RUSTSEC-2024-0436", # paste
 ]

deny.toml

@@ -25,7 +25,7 @@ aead = { version = "0.5.2", features = ["bytes"] }
 anyhow = { version = "1" }
 atomic-waker = "1.1.2"
 concurrent-queue = "2.5"
-backoff = { version = "0.4.0", features = ["futures"] }
+backon = { version = "1.4" }
 bytes = "1.7"
 crypto_box = { version = "0.9.1", features = ["serde", "chacha20"] }
 data-encoding = "2.2"

iroh/Cargo.toml

@@ -38,7 +38,7 @@ use std::{
 };
 
 use anyhow::{anyhow, Result};
-use backoff::exponential::{ExponentialBackoff, ExponentialBackoffBuilder};
+use backon::{BackoffBuilder, ExponentialBuilder, Retryable};
 use bytes::{Bytes, BytesMut};
 use iroh_base::{NodeId, PublicKey, RelayUrl, SecretKey};
 use iroh_metrics::{inc, inc_by};
@@ -404,9 +404,10 @@ impl ActiveRelayActor {
     /// connections.  It currently does not ever return `Err` as the retries continue
     /// forever.
     fn dial_relay(&self) -> BoxFuture<Result<Client>> {
-        let backoff: ExponentialBackoff<backoff::SystemClock> = ExponentialBackoffBuilder::new()
-            .with_initial_interval(Duration::from_millis(10))
-            .with_max_interval(Duration::from_secs(5))
+        let backoff = ExponentialBuilder::new()
+            .with_min_delay(Duration::from_millis(10))
+            .with_max_delay(Duration::from_secs(5))
+            .without_max_times()
             .build();
         let connect_fn = {
             let client_builder = self.relay_client_builder.clone();
@@ -417,41 +418,31 @@ impl ActiveRelayActor {
                         Ok(Ok(client)) => Ok(client),
                         Ok(Err(err)) => {
                             warn!("Relay connection failed: {err:#}");
-                            Err(err.into())
+                            Err(err)
                         }
                         Err(_) => {
                             warn!(?CONNECT_TIMEOUT, "Timeout connecting to relay");
-                            Err(anyhow!("Timeout").into())
+                            Err(anyhow!("Timeout"))
                         }
                     }
                 }
             }
         };
 
-        // We implement our own `Sleeper` here, so that we can use the `backoff`
+        // We implement our own `Sleeper` here, so that we can use the `backon`
         // crate with our own implementation of `time::sleep` (from `n0_future`)
         // that works in browsers.
         struct Sleeper;
 
-        impl backoff::future::Sleeper for Sleeper {
+        impl backon::Sleeper for Sleeper {
             type Sleep = time::Sleep;
 
             fn sleep(&self, dur: Duration) -> Self::Sleep {
                 time::sleep(dur)
             }
         }
 
-        // Because we're using a lower-level backoff API, we need to provide a
-        // backoff::Notify implementation. By default backoff has one that
-        // doesn't do anything, but it doesn't expose that API. So we implement
-        // it here ourselves.
-        struct NoopNotify;
-
-        impl<E> backoff::Notify<E> for NoopNotify {
-            fn notify(&mut self, _: E, _: Duration) {}
-        }
-
-        let retry_fut = backoff::future::Retry::new(Sleeper, backoff, NoopNotify, connect_fn);
+        let retry_fut = connect_fn.retry(backoff).sleep(Sleeper);
         Box::pin(retry_fut)
     }