opendal 0.1.13 → 0.1.15

data/core/services/gdrive/Cargo.toml

@@ -32,7 +32,7 @@ version = { workspace = true }
 all-features = true
 
 [dependencies]
-opendal-core = { path = "../../core", version = "0.59.2", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.4", default-features = false }
 
 asyncband = { workspace = true, features = ["mutex", "singleflight"] }
 bytes = { workspace = true }

data/core/services/ghac/Cargo.toml

@@ -36,8 +36,8 @@ bytes = { workspace = true }
 ghac = { version = "0.3.0", default-features = false }
 http = { workspace = true }
 log = { workspace = true }
-opendal-core = { path = "../../core", version = "0.59.2", default-features = false }
-opendal-service-azblob = { path = "../azblob", version = "0.59.2", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.4", default-features = false }
+opendal-service-azblob = { path = "../azblob", version = "0.59.4", default-features = false }
 prost = { version = "0.14.3", default-features = false }
 reqsign-azure-storage = { version = "3.1.1", default-features = false }
 reqsign-core = { version = "3.2.0", default-features = false }

data/core/services/github/Cargo.toml

@@ -36,7 +36,7 @@ base64 = { workspace = true }
 bytes = { workspace = true }
 http = { workspace = true }
 log = { workspace = true }
-opendal-core = { path = "../../core", version = "0.59.2", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.4", default-features = false }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 

data/core/services/goosefs/Cargo.toml

@@ -45,11 +45,11 @@ asyncband = { workspace = true, features = ["rwlock"] }
 bytes = { workspace = true }
 goosefs-sdk = { version = "0.2.1", default-features = false }
 log = { workspace = true }
-opendal-core = { path = "../../core", version = "0.59.2", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.4", default-features = false }
 serde = { workspace = true, features = ["derive"] }
 
 [dev-dependencies]
-opendal = { path = "../..", version = "0.59.2", features = [
+opendal = { path = "../..", version = "0.59.4", features = [
   "services-goosefs",
 ] }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }

data/core/services/goosefs/src/backend.rs

@@ -90,7 +90,9 @@ impl GoosefsBuilder {
 
     /// Set default write type.
     ///
-    /// Values: `"must_cache"`, `"cache_through"`, `"through"`, `"async_through"`
+    /// Values: `"must_cache"`, `"try_cache"`, `"cache_through"`, `"through"`,
+    /// `"async_through"`. Matching is case-insensitive. `build()` fails with
+    /// [`ErrorKind::ConfigInvalid`] when the value is not one of these.
     pub fn write_type(mut self, wt: &str) -> Self {
         if !wt.is_empty() {
             self.config.write_type = Some(wt.to_string());
@@ -340,22 +342,18 @@ impl Builder for GoosefsBuilder {
             goosefs_config.chunk_size = chunk_size;
         }
 
-        // Parse write_type string → goosefs_sdk::WritePType i32.
-        //
-        // Normalise case once up front so we don't need to enumerate both
-        // `must_cache` and `MUST_CACHE` branches — this mirrors how the
-        // GooseFS server-side config parser (`WritePType::valueOf`) treats
-        // the value as case-insensitive.
+        // Parse write_type through the SDK so unknown values fail instead of
+        // silently becoming MUST_CACHE. `with_write_type_str` is
+        // case-insensitive, matching GooseFS `WritePType::valueOf`.
         if let Some(ref wt) = self.config.write_type {
-            let wt_i32 = match wt.to_lowercase().as_str() {
-                "must_cache" => 1,
-                "try_cache" => 2,
-                "cache_through" => 3,
-                "through" => 4,
-                "async_through" => 5,
-                _ => 1, // default to MUST_CACHE
-            };
-            goosefs_config.write_type = Some(wt_i32);
+            goosefs_config = goosefs_config.with_write_type_str(wt).map_err(|e| {
+                Error::new(
+                    ErrorKind::ConfigInvalid,
+                    format!("invalid write_type: {}", e),
+                )
+                .with_operation("Builder::build")
+                .with_context("service", GOOSEFS_SCHEME)
+            })?;
         }
 
         // Parse auth_type string → goosefs_sdk::auth::AuthType
@@ -775,6 +773,35 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_builder_unknown_write_type_fails() {
+        let _guard = ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        for wt in ["INVALID_WT", "cache_throughh"] {
+            let err = GoosefsBuilder::default()
+                .root("/data")
+                .master_addr("127.0.0.1:9200")
+                .write_type(wt)
+                .build()
+                .expect_err("build must fail on unknown write_type");
+            assert_eq!(err.kind(), ErrorKind::ConfigInvalid);
+            assert!(
+                err.to_string().contains("write_type"),
+                "unexpected error message for {wt}: {err}"
+            );
+        }
+    }
+
+    #[test]
+    fn test_builder_write_type_is_case_insensitive() {
+        let _guard = ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        let backend = GoosefsBuilder::default()
+            .root("/data")
+            .master_addr("127.0.0.1:9200")
+            .write_type("CACHE_THROUGH")
+            .build();
+        assert!(backend.is_ok());
+    }
+
     #[test]
     fn test_capability_rename_with_if_not_exists() {
         let _guard = ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());

data/core/services/goosefs/src/config.rs

@@ -69,7 +69,10 @@ pub struct GoosefsConfig {
 
     /// Default write type for new files.
     ///
-    /// Supported values: `"must_cache"`, `"cache_through"`, `"through"`, `"async_through"`.
+    /// Supported values: `"must_cache"`, `"try_cache"`, `"cache_through"`,
+    /// `"through"`, `"async_through"`. Matching is case-insensitive.
+    /// `build()` fails with `ConfigInvalid` when the value is not one of
+    /// these.
     /// Default: `"must_cache"`.
     pub write_type: Option<String>,
 

data/core/services/goosefs/src/docs.md

@@ -28,7 +28,7 @@ Features:
 - **HA support**: Comma-separated master addresses for automatic Primary Master discovery.
 - **Block-level I/O**: Data reads/writes go through block-level gRPC bidirectional streaming.
 - **Consistent hash routing**: Worker selection uses consistent hashing on block IDs.
-- **All WriteTypes**: Supports MUST_CACHE, CACHE_THROUGH, THROUGH, and ASYNC_THROUGH.
+- **All WriteTypes**: Supports MUST_CACHE, TRY_CACHE, CACHE_THROUGH, THROUGH, and ASYNC_THROUGH. Unknown `write_type` values fail at `build()` with `ConfigInvalid`.
 - **Conditional Create**: `write_with_if_not_exists` publishes via Master no-replace
   rename (`rename_with_if_not_exists`); destination is never deleted on the Create path.
 - **Rename parent directories**: `rename` creates a missing destination parent only

data/core/services/gridfs/Cargo.toml

@@ -35,7 +35,7 @@ all-features = true
 asyncband = { workspace = true, features = ["once-cell"] }
 futures = { workspace = true }
 mongodb = "3.3.0"
-opendal-core = { path = "../../core", version = "0.59.2", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.4", default-features = false }
 serde = { workspace = true, features = ["derive"] }
 
 [dev-dependencies]

data/core/services/hdfs/Cargo.toml

@@ -32,11 +32,11 @@ version = { workspace = true }
 all-features = true
 
 [dependencies]
-opendal-core = { path = "../../core", version = "0.59.2", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.4", default-features = false }
 
 bytes = { workspace = true }
 futures = { workspace = true }
-hdrs = { version = "0.3.2", features = ["async_file"] }
+hdrs = { version = "0.3.3", features = ["async_file"] }
 log = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 tokio = { workspace = true, features = ["rt"] }

data/core/services/hdfs/src/backend.rs

@@ -169,6 +169,8 @@ impl Builder for HdfsBuilder {
 
                     list: true,
 
+                    copy: true,
+
                     rename: true,
                     rename_with_if_not_exists: true,
 
@@ -195,7 +197,7 @@ impl Service for HdfsBackend {
     type Writer = HdfsLazyWriter;
     type Lister = Option<HdfsLister>;
     type Deleter = oio::OneShotDeleter<HdfsDeleter>;
-    type Copier = ();
+    type Copier = oio::OneShotCopier;
     type Composer = ();
 
     fn info(&self) -> ServiceInfo {
@@ -258,14 +260,20 @@ impl Service for HdfsBackend {
     fn copy(
         &self,
         _ctx: &OperationContext,
-        _from: &str,
-        _to: &str,
+        from: &str,
+        to: &str,
         _args: OpCopy,
     ) -> Result<Self::Copier> {
-        Err(Error::new(
-            ErrorKind::Unsupported,
-            "operation is not supported",
-        ))
+        let core = self.core.clone();
+        let from = from.to_string();
+        let to = to.to_string();
+        // Recreate the future so retry layers can rerun the copy after a temporary error.
+        Ok(oio::OneShotCopier::new_with(move || {
+            let core = core.clone();
+            let from = from.clone();
+            let to = to.clone();
+            async move { core.hdfs_copy(&from, &to).await }
+        }))
     }
 
     async fn rename(

data/core/services/hdfs/src/core.rs

@@ -124,8 +124,7 @@ impl HdfsCore {
         });
 
         if !target_exists {
-            let parent = get_parent(&target_path);
-            self.client.create_dir(parent).map_err(new_std_io_error)?;
+            self.ensure_parent_dir(&target_path)?;
         }
         if !should_append {
             initial_size = 0;
@@ -175,20 +174,7 @@ impl HdfsCore {
                     return Err(new_std_io_error(err));
                 }
 
-                let parent = std::path::PathBuf::from(&to_path)
-                    .parent()
-                    .ok_or_else(|| {
-                        Error::new(
-                            ErrorKind::Unexpected,
-                            "path should have parent but not, it must be malformed",
-                        )
-                        .with_context("to", &to_path)
-                    })?
-                    .to_path_buf();
-
-                self.client
-                    .create_dir(&parent.to_string_lossy())
-                    .map_err(new_std_io_error)?;
+                self.ensure_parent_dir(&to_path)?;
             }
             Ok(metadata) => {
                 if metadata.is_file() {
@@ -215,6 +201,59 @@ impl HdfsCore {
 
         Ok(())
     }
+
+    pub async fn hdfs_copy(&self, from: &str, to: &str) -> Result<Metadata> {
+        let from_path = build_rooted_abs_path(&self.root, from);
+        // OpenDAL copy is file-to-file only. Reject directory sources before
+        // the HDFS API can recursively copy their contents.
+        let from_meta = self.client.metadata(&from_path).map_err(new_std_io_error)?;
+        if !from_meta.is_file() {
+            return Err(
+                Error::new(ErrorKind::IsADirectory, "from path should be a file")
+                    .with_context("from", &from_path),
+            );
+        }
+
+        let to_path = build_rooted_abs_path(&self.root, to);
+        match self.client.metadata(&to_path) {
+            Ok(meta) => {
+                // OpenDAL treats `to` as the exact destination file path. Reject
+                // an existing directory instead of copying the source into it.
+                if meta.is_dir() {
+                    return Err(
+                        Error::new(ErrorKind::IsADirectory, "to path should be a file")
+                            .with_context("to", &to_path),
+                    );
+                }
+                // The HDFS copy API does not replace an existing destination,
+                // so remove it first to preserve OpenDAL's overwrite semantics.
+                self.client
+                    .remove_file(&to_path)
+                    .map_err(new_std_io_error)?;
+            }
+            Err(err) if err.kind() == io::ErrorKind::NotFound => {
+                // hdrs copy_file requires the destination parent to already exist.
+                self.ensure_parent_dir(&to_path)?;
+            }
+            Err(err) => return Err(new_std_io_error(err)),
+        }
+
+        let client = self.client.clone();
+        let copy_from = from_path.clone();
+        let copy_to = to_path.clone();
+        tokio::task::spawn_blocking(move || client.copy_file(&copy_from, &copy_to))
+            .await
+            .map_err(|e| Error::new(ErrorKind::Unexpected, "tokio task join failed").set_source(e))?
+            .map_err(new_std_io_error)?;
+
+        Ok(MetadataBuilder::file(from_meta.len()).build())
+    }
+
+    fn ensure_parent_dir(&self, path: &str) -> Result<()> {
+        self.client
+            .create_dir(get_parent(path))
+            .map_err(new_std_io_error)
+    }
 }
 
 #[cfg(test)]

data/core/services/hdfs/src/docs.md

@@ -10,13 +10,21 @@ Depending on its configuration and the backing system, this service can expose:
 - [x] write
 - [x] delete
 - [x] list
-- [ ] copy
+- [x] copy
 - [x] rename
 - [ ] ~~presign~~
 
 Inspect the effective capability set with [`opendal_core::Operator::info`] and
 [`opendal_core::OperatorInfo::capability`] after building an operator.
 
+## Copy behavior
+
+The HDFS service copies files to exact destination file paths and rejects
+directory sources and destinations. Copy overwrites an existing destination by
+removing it before copying the source. This replacement is not atomic: if the
+copy fails after removing the destination, the destination can be missing or
+incomplete.
+
 ## Differences with webhdfs
 
 The [WebHDFS service](https://docs.rs/opendal-service-webhdfs) uses HDFS's

data/core/services/hdfs-native/Cargo.toml

@@ -36,5 +36,5 @@ bytes = { workspace = true }
 futures = { workspace = true }
 hdfs-native = { version = "0.14" }
 log = { workspace = true }
-opendal-core = { path = "../../core", version = "0.59.2", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.4", default-features = false }
 serde = { workspace = true, features = ["derive"] }

data/core/services/hf/Cargo.toml

@@ -37,7 +37,7 @@ bytes = { workspace = true }
 hf-xet = "1.6.0"
 http = { workspace = true }
 log = { workspace = true }
-opendal-core = { path = "../../core", version = "0.59.2", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.4", default-features = false }
 percent-encoding = "2"
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
@@ -45,6 +45,9 @@ serde_json = { workspace = true }
 [dev-dependencies]
 base64 = { workspace = true }
 futures = { workspace = true }
-opendal-http-transport-reqwest = { path = "../../http-transports/reqwest", version = "0.59.2" }
+opendal-core = { path = "../../core", version = "0.59.4", features = [
+  "executors-tokio",
+] }
+opendal-http-transport-reqwest = { path = "../../http-transports/reqwest", version = "0.59.4" }
 serde_json = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }

data/core/services/hf/src/backend.rs

@@ -135,9 +135,14 @@ impl HfBuilder {
 
     /// Enable caching of resolved HTTP download addresses and XET file metadata.
     ///
-    /// Defaults to `false`: every range resolves through the Hub in either
-    /// download mode. Set to `true` to share resolve results across readers on
-    /// the same backend. HTTP addresses refresh near expiry.
+    /// Defaults to `false`: each new reader resolves through the Hub. An XET-mode
+    /// reader retains the XET metadata returned by its first read for its lifetime,
+    /// even when this option is disabled. Its subsequent ranges use that file
+    /// version. Create a new reader to resolve the path again. HTTP reads resolve
+    /// each range.
+    ///
+    /// Set to `true` to share resolve results across readers on the same backend.
+    /// HTTP addresses refresh near expiry.
     ///
     /// Enable this only when previously written files are not modified. Changed
     /// files can remain invisible while cached results are reused, including

data/core/services/hf/src/config.rs

@@ -64,8 +64,10 @@ pub struct HfConfig {
     ///
     /// Defaults to `false`. Set to `true` to share resolve results across readers
     /// on the same backend. Changed files may remain invisible while cached
-    /// results are reused. See [`HfBuilder::enable_resolve_cache`] for freshness
-    /// semantics.
+    /// results are reused. A reader retains XET metadata from its first read for
+    /// its lifetime. Create a new reader to resolve the path again when this
+    /// option is disabled.
+    /// See [`HfBuilder::enable_resolve_cache`] for freshness semantics.
     pub enable_resolve_cache: bool,
 }
 

data/core/services/hf/src/docs.md

@@ -34,8 +34,12 @@ accepted values, defaults, and environment interaction.
 
 ### Caching resolve results
 
-By default, every range resolves through the Hugging Face Hub in both HTTP and
-XET download modes. Enable
+By default, each new reader resolves through the Hugging Face Hub. An XET-mode
+reader retains the XET metadata returned by its first read for its lifetime.
+Subsequent ranges, including concurrent reads, use that file version. Create a
+new reader to resolve an updated path. HTTP reads resolve each range.
+
+Enable
 [`enable_resolve_cache`](crate::Hf::enable_resolve_cache) to share resolved HTTP
 download addresses and XET file metadata across readers and batches on the same
 backend: