You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@opendal.apache.org by xu...@apache.org on 2024/08/26 10:03:47 UTC

(opendal) 01/01: chore: Bump backon to 1.0.0

This is an automated email from the ASF dual-hosted git repository.

xuanwo pushed a commit to branch upgrade-backon
in repository https://gitbox.apache.org/repos/asf/opendal.git

commit 5b4aa8d9262203568b2e4bcb67a749da41aab07c
Author: Xuanwo <gi...@xuanwo.io>
AuthorDate: Mon Aug 26 18:03:31 2024 +0800

    chore: Bump backon to 1.0.0
    
    Signed-off-by: Xuanwo <gi...@xuanwo.io>
---
 core/Cargo.lock                      |   6 +-
 core/Cargo.toml                      | 132 +++++++++++++++++------------------
 core/src/layers/retry.rs             |  82 ++++++++++------------
 core/src/services/dropbox/backend.rs |   4 +-
 core/src/services/gcs/core.rs        |   2 +-
 5 files changed, 106 insertions(+), 120 deletions(-)

diff --git a/core/Cargo.lock b/core/Cargo.lock
index 906f6a1a6e..6d4fd7cd95 100644
--- a/core/Cargo.lock
+++ b/core/Cargo.lock
@@ -1052,13 +1052,11 @@ dependencies = [
 
 [[package]]
 name = "backon"
-version = "0.4.4"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d67782c3f868daa71d3533538e98a8e13713231969def7536e8039606fc46bf0"
+checksum = "7ce0a7701f0bdc87db4e2b4cb0b566eff073f71248b95eafc1d991f576ebe3af"
 dependencies = [
  "fastrand 2.1.1",
- "futures-core",
- "pin-project",
  "tokio",
 ]
 
diff --git a/core/Cargo.toml b/core/Cargo.toml
index c84e255c93..63ad0224c9 100644
--- a/core/Cargo.toml
+++ b/core/Cargo.toml
@@ -53,16 +53,16 @@ default = ["reqwest/rustls-tls", "executors-tokio", "services-memory"]
 #
 # You should never enable this feature unless you are developing opendal.
 tests = [
-  "dep:rand",
-  "dep:sha2",
-  "dep:dotenvy",
-  "layers-blocking",
-  "services-azblob",
-  "services-fs",
-  "services-http",
-  "services-memory",
-  "internal-tokio-rt",
-  "services-s3",
+    "dep:rand",
+    "dep:sha2",
+    "dep:dotenvy",
+    "layers-blocking",
+    "services-azblob",
+    "services-fs",
+    "services-http",
+    "services-memory",
+    "internal-tokio-rt",
+    "services-s3",
 ]
 
 # Enable path cache.
@@ -104,20 +104,20 @@ services-aliyun-drive = []
 services-alluxio = []
 services-atomicserver = ["dep:atomic_lib"]
 services-azblob = [
-  "dep:sha2",
-  "dep:reqsign",
-  "reqsign?/services-azblob",
-  "reqsign?/reqwest_request",
+    "dep:sha2",
+    "dep:reqsign",
+    "reqsign?/services-azblob",
+    "reqsign?/reqwest_request",
 ]
 services-azdls = [
-  "dep:reqsign",
-  "reqsign?/services-azblob",
-  "reqsign?/reqwest_request",
+    "dep:reqsign",
+    "reqsign?/services-azblob",
+    "reqsign?/reqwest_request",
 ]
 services-azfile = [
-  "dep:reqsign",
-  "reqsign?/services-azblob",
-  "reqsign?/reqwest_request",
+    "dep:reqsign",
+    "reqsign?/services-azblob",
+    "reqsign?/reqwest_request",
 ]
 services-b2 = []
 services-cacache = ["dep:cacache"]
@@ -125,9 +125,9 @@ services-chainsafe = []
 services-cloudflare-kv = []
 services-compfs = ["dep:compio"]
 services-cos = [
-  "dep:reqsign",
-  "reqsign?/services-tencent",
-  "reqsign?/reqwest_request",
+    "dep:reqsign",
+    "reqsign?/services-tencent",
+    "reqsign?/reqwest_request",
 ]
 services-d1 = []
 services-dashmap = ["dep:dashmap"]
@@ -138,9 +138,9 @@ services-foundationdb = ["dep:foundationdb"]
 services-fs = ["tokio/fs", "internal-tokio-rt"]
 services-ftp = ["dep:suppaftp", "dep:bb8", "dep:async-tls"]
 services-gcs = [
-  "dep:reqsign",
-  "reqsign?/services-google",
-  "reqsign?/reqwest_request",
+    "dep:reqsign",
+    "reqsign?/services-google",
+    "reqsign?/reqwest_request",
 ]
 services-gdrive = ["internal-path-cache"]
 services-ghac = []
@@ -163,15 +163,15 @@ services-mongodb = ["dep:mongodb"]
 services-monoiofs = ["dep:monoio", "dep:flume"]
 services-mysql = ["dep:mysql_async"]
 services-obs = [
-  "dep:reqsign",
-  "reqsign?/services-huaweicloud",
-  "reqsign?/reqwest_request",
+    "dep:reqsign",
+    "reqsign?/services-huaweicloud",
+    "reqsign?/reqwest_request",
 ]
 services-onedrive = []
 services-oss = [
-  "dep:reqsign",
-  "reqsign?/services-aliyun",
-  "reqsign?/reqwest_request",
+    "dep:reqsign",
+    "reqsign?/services-aliyun",
+    "reqsign?/reqwest_request",
 ]
 services-pcloud = []
 services-persy = ["dep:persy", "internal-tokio-rt"]
@@ -181,10 +181,10 @@ services-redis = ["dep:redis", "redis?/tokio-rustls-comp"]
 services-redis-native-tls = ["services-redis", "redis?/tokio-native-tls-comp"]
 services-rocksdb = ["dep:rocksdb", "internal-tokio-rt"]
 services-s3 = [
-  "dep:reqsign",
-  "reqsign?/services-aws",
-  "reqsign?/reqwest_request",
-  "dep:crc32c",
+    "dep:reqsign",
+    "reqsign?/services-aws",
+    "reqsign?/reqwest_request",
+    "dep:crc32c",
 ]
 services-seafile = []
 services-sftp = ["dep:openssh", "dep:openssh-sftp-client", "dep:bb8"]
@@ -226,17 +226,17 @@ async-tls = { version = "0.13.0", optional = true }
 # Required dependencies
 anyhow = { version = "1.0.30", features = ["std"] }
 async-trait = "0.1.68"
-backon = "0.4.4"
+backon = { version = "1", features = ["tokio-sleep"] }
 base64 = "0.22"
 bytes = "1.6"
 chrono = { version = "0.4.28", default-features = false, features = [
-  "clock",
-  "std",
+    "clock",
+    "std",
 ] }
 flagset = "0.4"
 futures = { version = "0.3", default-features = false, features = [
-  "std",
-  "async-await",
+    "std",
+    "async-await",
 ] }
 http = "1.1"
 log = "0.4"
@@ -246,7 +246,7 @@ once_cell = "1"
 percent-encoding = "2"
 quick-xml = { version = "0.36", features = ["serialize", "overlapped-lists"] }
 reqwest = { version = "0.12.2", features = [
-  "stream",
+    "stream",
 ], default-features = false }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
@@ -277,8 +277,8 @@ bb8-postgres = { version = "0.8.1", optional = true }
 tokio-postgres = { version = "0.7.8", optional = true }
 # for services-cacache
 cacache = { version = "13.0", default-features = false, features = [
-  "tokio-runtime",
-  "mmap",
+    "tokio-runtime",
+    "mmap",
 ], optional = true }
 # for services-dashmap
 dashmap = { version = "6", optional = true }
@@ -286,8 +286,8 @@ dashmap = { version = "6", optional = true }
 etcd-client = { version = "0.14", optional = true, features = ["tls"] }
 # for services-foundationdb
 foundationdb = { version = "0.9.0", features = [
-  "embedded-fdb-include",
-  "fdb-7_3",
+    "embedded-fdb-include",
+    "fdb-7_3",
 ], optional = true }
 # for services-hdfs
 hdrs = { version = "0.3.2", optional = true, features = ["async_file"] }
@@ -303,13 +303,13 @@ moka = { version = "0.12", optional = true, features = ["future", "sync"] }
 mongodb = { version = "3", optional = true }
 # for services-mysql
 mysql_async = { version = "0.34", default-features = false, features = [
-  "default-rustls",
+    "default-rustls",
 ], optional = true }
 # for services-sftp
 openssh = { version = "0.10.0", optional = true }
 openssh-sftp-client = { version = "0.14.0", optional = true, features = [
-  "openssh",
-  "tracing",
+    "openssh",
+    "tracing",
 ] }
 # for services-persy
 persy = { version = "1.4.6", optional = true }
@@ -317,9 +317,9 @@ persy = { version = "1.4.6", optional = true }
 redb = { version = "2", optional = true }
 # for services-redis
 redis = { version = "0.26", features = [
-  "cluster-async",
-  "tokio-comp",
-  "connection-manager",
+    "cluster-async",
+    "tokio-comp",
+    "connection-manager",
 ], optional = true }
 # for services-rocksdb
 rocksdb = { version = "0.21", default-features = false, optional = true }
@@ -329,9 +329,9 @@ rusqlite = { version = "0.32", optional = true, features = ["bundled"] }
 sled = { version = "0.34.7", optional = true }
 # for services-ftp
 suppaftp = { version = "6", default-features = false, features = [
-  "async-secure",
-  "rustls",
-  "async-rustls",
+    "async-secure",
+    "rustls",
+    "async-rustls",
 ], optional = true }
 # for services-tikv
 tikv-client = { version = "0.3.0", optional = true, default-features = false }
@@ -341,20 +341,20 @@ hdfs-native = { version = "0.10", optional = true }
 surrealdb = { version = "1.3.0", optional = true, features = ["protocol-http"] }
 # for services-compfs
 compio = { version = "0.11.0", optional = true, features = [
-  "runtime",
-  "bytes",
-  "polling",
-  "dispatcher",
+    "runtime",
+    "bytes",
+    "polling",
+    "dispatcher",
 ] }
 # for services-s3
 crc32c = { version = "0.6.6", optional = true }
 # for services-monoiofs
 flume = { version = "0.11", optional = true }
 monoio = { version = "0.2.4", optional = true, features = [
-  "sync",
-  "mkdirat",
-  "unlinkat",
-  "renameat",
+    "sync",
+    "mkdirat",
+    "unlinkat",
+    "renameat",
 ] }
 
 # Layers
@@ -390,7 +390,7 @@ dotenvy = "0.15"
 fastrace = { version = "0.7", features = ["enable"] }
 libtest-mimic = "0.7"
 opentelemetry = { version = "0.24", default-features = false, features = [
-  "trace",
+    "trace",
 ] }
 pretty_assertions = "1"
 rand = "0.8"
@@ -398,6 +398,6 @@ sha2 = "0.10"
 size = "0.4"
 tokio = { version = "1.27", features = ["fs", "macros", "rt-multi-thread"] }
 tracing-subscriber = { version = "0.3", features = [
-  "env-filter",
-  "tracing-log",
+    "env-filter",
+    "tracing-log",
 ] }
diff --git a/core/src/layers/retry.rs b/core/src/layers/retry.rs
index be10e0c87e..dc8905af65 100644
--- a/core/src/layers/retry.rs
+++ b/core/src/layers/retry.rs
@@ -111,7 +111,7 @@ pub struct RetryLayer<I = DefaultRetryInterceptor> {
 impl<I> Clone for RetryLayer<I> {
     fn clone(&self) -> Self {
         Self {
-            builder: self.builder.clone(),
+            builder: self.builder,
             notify: self.notify.clone(),
         }
     }
@@ -226,7 +226,7 @@ impl<A: Access, I: RetryInterceptor> Layer<A> for RetryLayer<I> {
     fn layer(&self, inner: A) -> Self::LayeredAccess {
         RetryAccessor {
             inner: Arc::new(inner),
-            builder: self.builder.clone(),
+            builder: self.builder,
             notify: self.notify.clone(),
         }
     }
@@ -293,7 +293,7 @@ impl<A: Access, I: RetryInterceptor> LayeredAccess for RetryAccessor<A, I> {
 
     async fn create_dir(&self, path: &str, args: OpCreateDir) -> Result<RpCreateDir> {
         { || self.inner.create_dir(path, args.clone()) }
-            .retry(&self.builder)
+            .retry(self.builder)
             .when(|e| e.is_temporary())
             .notify(|err, dur: Duration| self.notify.intercept(err, dur))
             .map(|v| v.map_err(|e| e.set_persistent()))
@@ -302,39 +302,33 @@ impl<A: Access, I: RetryInterceptor> LayeredAccess for RetryAccessor<A, I> {
 
     async fn read(&self, path: &str, args: OpRead) -> Result<(RpRead, Self::Reader)> {
         let (rp, reader) = { || self.inner.read(path, args.clone()) }
-            .retry(&self.builder)
+            .retry(self.builder)
             .when(|e| e.is_temporary())
             .notify(|err, dur| self.notify.intercept(err, dur))
             .await
             .map_err(|e| e.set_persistent())?;
 
         let retry_reader = RetryReader::new(self.inner.clone(), path.to_string(), args, reader);
-        let retry_wrapper =
-            RetryWrapper::new(retry_reader, self.notify.clone(), self.builder.clone());
+        let retry_wrapper = RetryWrapper::new(retry_reader, self.notify.clone(), self.builder);
 
         Ok((rp, retry_wrapper))
     }
 
     async fn write(&self, path: &str, args: OpWrite) -> Result<(RpWrite, Self::Writer)> {
         { || self.inner.write(path, args.clone()) }
-            .retry(&self.builder)
+            .retry(self.builder)
             .when(|e| e.is_temporary())
             .notify(|err, dur| self.notify.intercept(err, dur))
             .map(|v| {
-                v.map(|(rp, r)| {
-                    (
-                        rp,
-                        RetryWrapper::new(r, self.notify.clone(), self.builder.clone()),
-                    )
-                })
-                .map_err(|e| e.set_persistent())
+                v.map(|(rp, r)| (rp, RetryWrapper::new(r, self.notify.clone(), self.builder)))
+                    .map_err(|e| e.set_persistent())
             })
             .await
     }
 
     async fn stat(&self, path: &str, args: OpStat) -> Result<RpStat> {
         { || self.inner.stat(path, args.clone()) }
-            .retry(&self.builder)
+            .retry(self.builder)
             .when(|e| e.is_temporary())
             .notify(|err, dur| self.notify.intercept(err, dur))
             .map(|v| v.map_err(|e| e.set_persistent()))
@@ -343,7 +337,7 @@ impl<A: Access, I: RetryInterceptor> LayeredAccess for RetryAccessor<A, I> {
 
     async fn delete(&self, path: &str, args: OpDelete) -> Result<RpDelete> {
         { || self.inner.delete(path, args.clone()) }
-            .retry(&self.builder)
+            .retry(self.builder)
             .when(|e| e.is_temporary())
             .notify(|err, dur| self.notify.intercept(err, dur))
             .map(|v| v.map_err(|e| e.set_persistent()))
@@ -352,7 +346,7 @@ impl<A: Access, I: RetryInterceptor> LayeredAccess for RetryAccessor<A, I> {
 
     async fn copy(&self, from: &str, to: &str, args: OpCopy) -> Result<RpCopy> {
         { || self.inner.copy(from, to, args.clone()) }
-            .retry(&self.builder)
+            .retry(self.builder)
             .when(|e| e.is_temporary())
             .notify(|err, dur| self.notify.intercept(err, dur))
             .map(|v| v.map_err(|e| e.set_persistent()))
@@ -361,7 +355,7 @@ impl<A: Access, I: RetryInterceptor> LayeredAccess for RetryAccessor<A, I> {
 
     async fn rename(&self, from: &str, to: &str, args: OpRename) -> Result<RpRename> {
         { || self.inner.rename(from, to, args.clone()) }
-            .retry(&self.builder)
+            .retry(self.builder)
             .when(|e| e.is_temporary())
             .notify(|err, dur| self.notify.intercept(err, dur))
             .map(|v| v.map_err(|e| e.set_persistent()))
@@ -370,12 +364,12 @@ impl<A: Access, I: RetryInterceptor> LayeredAccess for RetryAccessor<A, I> {
 
     async fn list(&self, path: &str, args: OpList) -> Result<(RpList, Self::Lister)> {
         { || self.inner.list(path, args.clone()) }
-            .retry(&self.builder)
+            .retry(self.builder)
             .when(|e| e.is_temporary())
             .notify(|err, dur| self.notify.intercept(err, dur))
             .map(|v| {
                 v.map(|(l, p)| {
-                    let lister = RetryWrapper::new(p, self.notify.clone(), self.builder.clone());
+                    let lister = RetryWrapper::new(p, self.notify.clone(), self.builder);
                     (l, lister)
                 })
                 .map_err(|e| e.set_persistent())
@@ -395,7 +389,7 @@ impl<A: Access, I: RetryInterceptor> LayeredAccess for RetryAccessor<A, I> {
                 Ok(RpBatch::new(nrp))
             }
         }
-        .retry(&self.builder)
+        .retry(self.builder)
         .when(|e: &Error| e.is_temporary())
         .notify(|err, dur| self.notify.intercept(err, dur))
         .await
@@ -404,7 +398,7 @@ impl<A: Access, I: RetryInterceptor> LayeredAccess for RetryAccessor<A, I> {
 
     fn blocking_create_dir(&self, path: &str, args: OpCreateDir) -> Result<RpCreateDir> {
         { || self.inner.blocking_create_dir(path, args.clone()) }
-            .retry(&self.builder)
+            .retry(self.builder)
             .when(|e| e.is_temporary())
             .notify(|err, dur| self.notify.intercept(err, dur))
             .call()
@@ -413,37 +407,31 @@ impl<A: Access, I: RetryInterceptor> LayeredAccess for RetryAccessor<A, I> {
 
     fn blocking_read(&self, path: &str, args: OpRead) -> Result<(RpRead, Self::BlockingReader)> {
         let (rp, reader) = { || self.inner.blocking_read(path, args.clone()) }
-            .retry(&self.builder)
+            .retry(self.builder)
             .when(|e| e.is_temporary())
             .notify(|err, dur| self.notify.intercept(err, dur))
             .call()
             .map_err(|e| e.set_persistent())?;
 
         let retry_reader = RetryReader::new(self.inner.clone(), path.to_string(), args, reader);
-        let retry_wrapper =
-            RetryWrapper::new(retry_reader, self.notify.clone(), self.builder.clone());
+        let retry_wrapper = RetryWrapper::new(retry_reader, self.notify.clone(), self.builder);
 
         Ok((rp, retry_wrapper))
     }
 
     fn blocking_write(&self, path: &str, args: OpWrite) -> Result<(RpWrite, Self::BlockingWriter)> {
         { || self.inner.blocking_write(path, args.clone()) }
-            .retry(&self.builder)
+            .retry(self.builder)
             .when(|e| e.is_temporary())
             .notify(|err, dur| self.notify.intercept(err, dur))
             .call()
-            .map(|(rp, r)| {
-                (
-                    rp,
-                    RetryWrapper::new(r, self.notify.clone(), self.builder.clone()),
-                )
-            })
+            .map(|(rp, r)| (rp, RetryWrapper::new(r, self.notify.clone(), self.builder)))
             .map_err(|e| e.set_persistent())
     }
 
     fn blocking_stat(&self, path: &str, args: OpStat) -> Result<RpStat> {
         { || self.inner.blocking_stat(path, args.clone()) }
-            .retry(&self.builder)
+            .retry(self.builder)
             .when(|e| e.is_temporary())
             .notify(|err, dur| self.notify.intercept(err, dur))
             .call()
@@ -452,7 +440,7 @@ impl<A: Access, I: RetryInterceptor> LayeredAccess for RetryAccessor<A, I> {
 
     fn blocking_delete(&self, path: &str, args: OpDelete) -> Result<RpDelete> {
         { || self.inner.blocking_delete(path, args.clone()) }
-            .retry(&self.builder)
+            .retry(self.builder)
             .when(|e| e.is_temporary())
             .notify(|err, dur| self.notify.intercept(err, dur))
             .call()
@@ -461,7 +449,7 @@ impl<A: Access, I: RetryInterceptor> LayeredAccess for RetryAccessor<A, I> {
 
     fn blocking_copy(&self, from: &str, to: &str, args: OpCopy) -> Result<RpCopy> {
         { || self.inner.blocking_copy(from, to, args.clone()) }
-            .retry(&self.builder)
+            .retry(self.builder)
             .when(|e| e.is_temporary())
             .notify(|err, dur| self.notify.intercept(err, dur))
             .call()
@@ -470,7 +458,7 @@ impl<A: Access, I: RetryInterceptor> LayeredAccess for RetryAccessor<A, I> {
 
     fn blocking_rename(&self, from: &str, to: &str, args: OpRename) -> Result<RpRename> {
         { || self.inner.blocking_rename(from, to, args.clone()) }
-            .retry(&self.builder)
+            .retry(self.builder)
             .when(|e| e.is_temporary())
             .notify(|err, dur| self.notify.intercept(err, dur))
             .call()
@@ -479,12 +467,12 @@ impl<A: Access, I: RetryInterceptor> LayeredAccess for RetryAccessor<A, I> {
 
     fn blocking_list(&self, path: &str, args: OpList) -> Result<(RpList, Self::BlockingLister)> {
         { || self.inner.blocking_list(path, args.clone()) }
-            .retry(&self.builder)
+            .retry(self.builder)
             .when(|e| e.is_temporary())
             .notify(|err, dur| self.notify.intercept(err, dur))
             .call()
             .map(|(rp, p)| {
-                let p = RetryWrapper::new(p, self.notify.clone(), self.builder.clone());
+                let p = RetryWrapper::new(p, self.notify.clone(), self.builder);
                 (rp, p)
             })
             .map_err(|e| e.set_persistent())
@@ -590,7 +578,7 @@ impl<R: oio::Read, I: RetryInterceptor> oio::Read for RetryWrapper<R, I> {
                 (r, res)
             }
         }
-        .retry(&self.builder)
+        .retry(self.builder)
         .when(|e| e.is_temporary())
         .context(inner)
         .notify(|err, dur| self.notify.intercept(err, dur))
@@ -614,7 +602,7 @@ impl<R: oio::BlockingRead, I: RetryInterceptor> oio::BlockingRead for RetryWrapp
                 (r, res)
             }
         }
-        .retry(&self.builder)
+        .retry(self.builder)
         .when(|e| e.is_temporary())
         .context(inner)
         .notify(|err, dur| self.notify.intercept(err, dur))
@@ -638,7 +626,7 @@ impl<R: oio::Write, I: RetryInterceptor> oio::Write for RetryWrapper<R, I> {
                 ((r, bs), res)
             }
         }
-        .retry(&self.builder)
+        .retry(self.builder)
         .when(|e| e.is_temporary())
         .context((inner, bs))
         .notify(|err, dur| self.notify.intercept(err, dur))
@@ -660,7 +648,7 @@ impl<R: oio::Write, I: RetryInterceptor> oio::Write for RetryWrapper<R, I> {
                 (r, res)
             }
         }
-        .retry(&self.builder)
+        .retry(self.builder)
         .when(|e| e.is_temporary())
         .context(inner)
         .notify(|err, dur| self.notify.intercept(err, dur))
@@ -682,7 +670,7 @@ impl<R: oio::Write, I: RetryInterceptor> oio::Write for RetryWrapper<R, I> {
                 (r, res)
             }
         }
-        .retry(&self.builder)
+        .retry(self.builder)
         .when(|e| e.is_temporary())
         .context(inner)
         .notify(|err, dur| self.notify.intercept(err, dur))
@@ -696,7 +684,7 @@ impl<R: oio::Write, I: RetryInterceptor> oio::Write for RetryWrapper<R, I> {
 impl<R: oio::BlockingWrite, I: RetryInterceptor> oio::BlockingWrite for RetryWrapper<R, I> {
     fn write(&mut self, bs: Buffer) -> Result<()> {
         { || self.inner.as_mut().unwrap().write(bs.clone()) }
-            .retry(&self.builder)
+            .retry(self.builder)
             .when(|e| e.is_temporary())
             .notify(|err, dur| {
                 self.notify.intercept(err, dur);
@@ -707,7 +695,7 @@ impl<R: oio::BlockingWrite, I: RetryInterceptor> oio::BlockingWrite for RetryWra
 
     fn close(&mut self) -> Result<()> {
         { || self.inner.as_mut().unwrap().close() }
-            .retry(&self.builder)
+            .retry(self.builder)
             .when(|e| e.is_temporary())
             .notify(|err, dur| {
                 self.notify.intercept(err, dur);
@@ -730,7 +718,7 @@ impl<P: oio::List, I: RetryInterceptor> oio::List for RetryWrapper<P, I> {
                 (p, res)
             }
         }
-        .retry(&self.builder)
+        .retry(self.builder)
         .when(|e| e.is_temporary())
         .context(inner)
         .notify(|err, dur| self.notify.intercept(err, dur))
@@ -744,7 +732,7 @@ impl<P: oio::List, I: RetryInterceptor> oio::List for RetryWrapper<P, I> {
 impl<P: oio::BlockingList, I: RetryInterceptor> oio::BlockingList for RetryWrapper<P, I> {
     fn next(&mut self) -> Result<Option<oio::Entry>> {
         { || self.inner.as_mut().unwrap().next() }
-            .retry(&self.builder)
+            .retry(self.builder)
             .when(|e| e.is_temporary())
             .notify(|err, dur| {
                 self.notify.intercept(err, dur);
diff --git a/core/src/services/dropbox/backend.rs b/core/src/services/dropbox/backend.rs
index f62b9e3d47..a6ba1a86f6 100644
--- a/core/src/services/dropbox/backend.rs
+++ b/core/src/services/dropbox/backend.rs
@@ -95,7 +95,7 @@ impl Access for DropboxBackend {
         //
         // Let's try our best to make sure it won't failed for rate limited issues.
         let res = { || self.core.dropbox_create_folder(path) }
-            .retry(&*BACKOFF)
+            .retry(*BACKOFF)
             .when(|e| e.is_temporary())
             .await
             // Set this error to permanent to avoid retrying.
@@ -264,7 +264,7 @@ impl Access for DropboxBackend {
                     .async_job_id
                     .expect("async_job_id should be present");
                 let res = { || self.core.dropbox_delete_batch_check(job_id.clone()) }
-                    .retry(&*BACKOFF)
+                    .retry(*BACKOFF)
                     .when(|e| e.is_temporary())
                     .await?;
 
diff --git a/core/src/services/gcs/core.rs b/core/src/services/gcs/core.rs
index ba11a57715..5a36c672a2 100644
--- a/core/src/services/gcs/core.rs
+++ b/core/src/services/gcs/core.rs
@@ -83,7 +83,7 @@ impl GcsCore {
         }
 
         let cred = { || self.token_loader.load() }
-            .retry(&*BACKOFF)
+            .retry(*BACKOFF)
             .await
             .map_err(new_request_credential_error)?;