chore(hf): remove redundant retry logic

Author: kszucs

core/Cargo.lock

@@ -32,15 +32,16 @@ all-features = true
 
 [dependencies]
 async-trait = "0.1"
-backon = "1.6"
 base64 = { workspace = true }
 bytes = { workspace = true }
 futures = { workspace = true }
 http = { workspace = true }
 log = { workspace = true }
 opendal-core = { path = "../../core", version = "0.55.0", default-features = false }
 percent-encoding = "2"
-reqwest = { version = "0.12", default-features = false, features = ["rustls-tls"] }
+reqwest = { version = "0.12", default-features = false, features = [
+  "rustls-tls",
+] }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 subxet = { git = "https://github.com/kszucs/subxet" }

core/services/hf/Cargo.toml

@@ -120,15 +120,6 @@ impl HfBuilder {
         }
         self
     }
-
-    /// Set the maximum number of retries for commit operations.
-    ///
-    /// Retries on commit conflicts (HTTP 412) and transient server
-    /// errors (HTTP 5xx). Default is 3.
-    pub fn max_retries(mut self, max_retries: usize) -> Self {
-        self.config.max_retries = Some(max_retries);
-        self
-    }
 }
 
 impl Builder for HfBuilder {
@@ -192,18 +183,8 @@ impl Builder for HfBuilder {
         let repo = HfRepo::new(repo_type, repo_id, Some(revision.clone()));
         debug!("backend repo uri: {:?}", repo.uri(&root, ""));
 
-        let max_retries = self.config.max_retries.unwrap_or(3);
-        debug!("backend max_retries: {}", max_retries);
-
         Ok(HfBackend {
-            core: Arc::new(HfCore::build(
-                info,
-                repo,
-                root,
-                token,
-                endpoint,
-                max_retries,
-            )?),
+            core: Arc::new(HfCore::build(info, repo, root, token, endpoint)?),
         })
     }
 }
@@ -287,15 +268,13 @@ pub(super) mod test_utils {
     }
 
     /// Operator for a private dataset requiring HF_OPENDAL_DATASET and HF_OPENDAL_TOKEN.
-    /// Uses higher max_retries to tolerate concurrent commit conflicts (412).
     pub fn testing_operator() -> Operator {
         let (repo_id, token) = testing_credentials();
         let op = Operator::new(
             HfBuilder::default()
                 .repo_type("dataset")
                 .repo_id(&repo_id)
-                .token(&token)
-                .max_retries(10),
+                .token(&token),
         )
         .unwrap()
         .finish();
@@ -309,8 +288,7 @@ pub(super) mod test_utils {
             HfBuilder::default()
                 .repo_type("bucket")
                 .repo_id(&repo_id)
-                .token(&token)
-                .max_retries(10),
+                .token(&token),
         )
         .unwrap()
         .finish();

core/services/hf/src/backend.rs

@@ -52,11 +52,6 @@ pub struct HfConfig {
     ///
     /// Default is "https://huggingface.co".
     pub endpoint: Option<String>,
-    /// Maximum number of retries for commit operations.
-    ///
-    /// Retries on commit conflicts (HTTP 412) and transient server
-    /// errors (HTTP 5xx). Default is 3.
-    pub max_retries: Option<usize>,
 }
 
 impl Debug for HfConfig {

core/services/hf/src/config.rs

@@ -18,8 +18,6 @@
 use std::fmt::Debug;
 use std::sync::Arc;
 
-use backon::ExponentialBuilder;
-use backon::Retryable;
 use bytes::Buf;
 use bytes::Bytes;
 use http::Request;
@@ -219,7 +217,6 @@ pub struct HfCore {
     pub root: String,
     pub token: Option<String>,
     pub endpoint: String,
-    pub max_retries: usize,
 
     /// HTTP client with redirects disabled, used by XET probes to
     /// inspect headers on 302 responses.
@@ -243,7 +240,6 @@ impl HfCore {
         root: String,
         token: Option<String>,
         endpoint: String,
-        max_retries: usize,
         no_redirect_client: HttpClient,
     ) -> Self {
         Self {
@@ -252,7 +248,6 @@ impl HfCore {
             root,
             token,
             endpoint,
-            max_retries,
             no_redirect_client,
         }
     }
@@ -267,21 +262,12 @@ impl HfCore {
         root: String,
         token: Option<String>,
         endpoint: String,
-        max_retries: usize,
     ) -> Result<Self> {
         let standard = HttpClient::with(build_reqwest(reqwest::redirect::Policy::default())?);
         let no_redirect = HttpClient::with(build_reqwest(reqwest::redirect::Policy::none())?);
         info.update_http_client(|_| standard);
 
-        Ok(Self::new(
-            info,
-            repo,
-            root,
-            token,
-            endpoint,
-            max_retries,
-            no_redirect,
-        ))
+        Ok(Self::new(info, repo, root, token, endpoint, no_redirect))
     }
 
     /// Build an authenticated HTTP request.
@@ -304,30 +290,14 @@ impl HfCore {
         self.repo.uri(&self.root, path)
     }
 
-    /// Send a request with retries, returning the successful response.
-    ///
-    /// Retries on commit conflicts (HTTP 412) and transient server errors
-    /// (HTTP 5xx) up to `self.max_retries` attempts with exponential backoff.
+    /// Send a request and return the successful response or a parsed error.
     pub(super) async fn send(&self, req: Request<Buffer>) -> Result<Response<Buffer>> {
-        let backoff = ExponentialBuilder::default()
-            .with_min_delay(std::time::Duration::from_millis(200))
-            .with_max_delay(std::time::Duration::from_millis(6400))
-            .with_max_times(self.max_retries.saturating_sub(1));
-        let client = self.info.http_client();
-
-        let send_once = || async {
-            let resp = client.send(req.clone()).await?;
-            if resp.status().is_success() {
-                Ok(resp)
-            } else {
-                Err(parse_error(resp))
-            }
-        };
-
-        send_once
-            .retry(backoff)
-            .when(|e: &Error| e.kind() == ErrorKind::ConditionNotMatch || e.is_temporary())
-            .await
+        let resp = self.info.http_client().send(req).await?;
+        if resp.status().is_success() {
+            Ok(resp)
+        } else {
+            Err(parse_error(resp))
+        }
     }
 
     /// Send a request, check for success, and deserialize the JSON response.
@@ -402,16 +372,11 @@ impl HfCore {
             .body(Buffer::new())
             .map_err(new_request_build_error)?;
 
-        let mut attempt = 0;
-        let resp = loop {
-            let resp = self.no_redirect_client.send(req.clone()).await?;
+        let resp = self.no_redirect_client.send(req).await?;
 
-            attempt += 1;
-            let retryable = resp.status().is_server_error();
-            if attempt >= self.max_retries || !retryable {
-                break resp;
-            }
-        };
+        if resp.status().is_client_error() || resp.status().is_server_error() {
+            return Err(parse_error(resp));
+        }
 
         let hash = resp
             .headers()
@@ -434,11 +399,6 @@ impl HfCore {
         Ok(Some(XetFileInfo::new(hash.to_string(), size)))
     }
 
-    /// Commit file changes (uploads and/or deletions) to the repository.
-    ///
-    /// Retries on commit conflicts (HTTP 412) and transient server errors
-    /// (HTTP 5xx), matching the behavior of the official HuggingFace Hub
-    /// client.
     /// Determine upload mode by calling the preupload API.
     ///
     /// Returns the upload mode string from the API (e.g., "regular" or "lfs").
@@ -626,7 +586,6 @@ pub(crate) mod test_utils {
             "/".to_string(),
             None,
             endpoint.to_string(),
-            3,
             HttpClient::with(mock_client.clone()),
         );