opendal 0.1.9 → 0.1.11

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

@@ -18,9 +18,8 @@
 use std::sync::Arc;
 
 use super::core::GoosefsCore;
-use opendal_core::EntryMode;
 use opendal_core::ErrorKind;
-use opendal_core::Metadata;
+use opendal_core::MetadataBuilder;
 use opendal_core::Result;
 use opendal_core::raw::oio::Entry;
 use opendal_core::raw::*;
@@ -65,7 +64,7 @@ impl oio::PageList for GoosefsLister {
                 // synthesis for it.
                 if !self.path.is_empty() && self.path.ends_with('/') {
                     ctx.entries
-                        .push_back(Entry::new(&self.path, Metadata::new(EntryMode::DIR)));
+                        .push_back(Entry::new(&self.path, MetadataBuilder::dir().build()));
                 }
 
                 for file_info in file_infos {

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

@@ -17,7 +17,7 @@
 
 use super::backend::*;
 use super::core::GoosefsCore;
-use super::core::parse_error;
+use super::core::{ErrorContext, parse_error};
 use goosefs_sdk::io::GoosefsFileReader as SdkReader;
 use opendal_core::raw::*;
 use opendal_core::*;
@@ -103,7 +103,11 @@ impl oio::ReadStream for GoosefsReadStream {
         }
         let reader = self.inner.as_mut().expect("inner was just set");
 
-        match reader.read_next_block().await.map_err(parse_error)? {
+        match reader
+            .read_next_block()
+            .await
+            .map_err(|err| parse_error(ErrorContext::new(ServiceOperation("ReadNextBlock")), err))?
+        {
             Some(block) => Ok(Buffer::from(block)),
             None => {
                 self.done = true;
@@ -138,7 +142,7 @@ impl oio::StreamRead for GoosefsReader {
             Some(
                 backend
                     .core
-                    .file_info_to_metadata(&file_info)
+                    .file_info_to_metadata(&file_info)?
                     .content_length(),
             )
         } else {

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

@@ -24,7 +24,7 @@ use std::time::UNIX_EPOCH;
 use goosefs_sdk::io::GoosefsFileWriter as ClientWriter;
 
 use super::core::GoosefsCore;
-use super::core::parse_error;
+use super::core::{ErrorContext, parse_error};
 use opendal_core::raw::*;
 use opendal_core::*;
 
@@ -226,7 +226,10 @@ impl oio::Write for GoosefsWriter {
         // Iterator yields one `Bytes` per segment; the SDK writer
         // takes `&[u8]`, so each chunk flows through without a copy.
         for chunk in bs {
-            writer.write(&chunk).await.map_err(parse_error)?;
+            writer
+                .write(&chunk)
+                .await
+                .map_err(|err| parse_error(ErrorContext::new(ServiceOperation("Write")), err))?;
         }
         Ok(())
     }
@@ -235,7 +238,11 @@ impl oio::Write for GoosefsWriter {
         if let Some(mut writer) = self.writer.take() {
             // Commit the temp inode on the master, then publish it
             // onto the caller's final path via `finalize_rename`.
-            if let Err(e) = writer.close().await.map_err(parse_error) {
+            if let Err(e) = writer
+                .close()
+                .await
+                .map_err(|err| parse_error(ErrorContext::new(ServiceOperation("Close")), err))
+            {
                 // Close failed — the temp is in an indeterminate state
                 // on the master; best-effort sweep to avoid leaks.
                 if let Some(tmp) = self.tmp_path.take() {
@@ -244,12 +251,12 @@ impl oio::Write for GoosefsWriter {
                 return Err(e);
             }
             // Capture file_id before rename; Master rename keeps the same inode id.
-            let mut meta = Metadata::default();
+            let mut meta = MetadataBuilder::unknown();
             if let Some(fid) = writer.file_info().file_id {
-                meta.set_etag(&fid.to_string());
+                meta.etag(fid.to_string());
             }
             self.finalize_rename().await?;
-            return Ok(meta);
+            return Ok(meta.build());
         }
 
         // Zero-write path: the caller closed without ever calling
@@ -267,17 +274,21 @@ impl oio::Write for GoosefsWriter {
 
         let tmp = Self::make_tmp_path(&self.path);
         let mut w = self.core.create_writer(&tmp).await?;
-        if let Err(e) = w.close().await.map_err(parse_error) {
+        if let Err(e) = w
+            .close()
+            .await
+            .map_err(|err| parse_error(ErrorContext::new(ServiceOperation("Close")), err))
+        {
             let _ = self.core.delete(&tmp).await;
             return Err(e);
         }
-        let mut meta = Metadata::default();
+        let mut meta = MetadataBuilder::unknown();
         if let Some(fid) = w.file_info().file_id {
-            meta.set_etag(&fid.to_string());
+            meta.etag(fid.to_string());
         }
         self.tmp_path = Some(tmp);
         self.finalize_rename().await?;
-        Ok(meta)
+        Ok(meta.build())
     }
 
     async fn abort(&mut self) -> Result<()> {

data/core/services/goosefs/tests/safe_conditional_put.rs

@@ -197,3 +197,40 @@ async fn concurrent_write_if_not_exists_exactly_one_wins() {
         let _ = op.delete(&p).await;
     }
 }
+
+/// Nested write: CreateFile(recursive) on the temp sibling creates the parent,
+/// so publish rename must succeed without an eager CreateDirectory.
+#[tokio::test]
+async fn write_nested_path_creates_parents() {
+    let Some(op) = maybe_operator() else {
+        eprintln!("skip: OPENDAL_GOOSEFS_MASTER_ADDR unset");
+        return;
+    };
+
+    let path = format!("{}/nested/file", unique("nested-write"));
+    op.write(&path, "nested-body")
+        .await
+        .expect("write into missing parents");
+    let body = op.read(&path).await.expect("read").to_bytes();
+    assert_eq!(&body[..], b"nested-body");
+    let _ = op.delete(&path).await;
+}
+
+/// Public rename still creates a destination parent that does not exist yet.
+#[tokio::test]
+async fn rename_creates_missing_destination_parent() {
+    let Some(op) = maybe_operator() else {
+        eprintln!("skip: OPENDAL_GOOSEFS_MASTER_ADDR unset");
+        return;
+    };
+
+    let src = unique("mkdir-src");
+    op.write(&src, "payload").await.expect("write src");
+    let dst = format!("{}/nested/file", unique("mkdir-dst"));
+    op.rename(&src, &dst)
+        .await
+        .expect("rename should create missing parent");
+    let body = op.read(&dst).await.expect("read dst").to_bytes();
+    assert_eq!(&body[..], b"payload");
+    let _ = op.delete(&dst).await;
+}

data/core/services/gridfs/Cargo.toml

@@ -32,10 +32,10 @@ version = { workspace = true }
 all-features = true
 
 [dependencies]
+asyncband = { workspace = true }
 futures = { workspace = true }
-mea = { workspace = true }
 mongodb = "3.3.0"
-opendal-core = { path = "../../core", version = "0.58.1", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.0", default-features = false }
 serde = { workspace = true, features = ["derive"] }
 
 [dev-dependencies]

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

@@ -17,7 +17,7 @@
 
 use std::sync::Arc;
 
-use mea::once::OnceCell;
+use asyncband::once::OnceCell;
 use opendal_core::raw::*;
 use opendal_core::*;
 
@@ -93,7 +93,7 @@ impl GridfsBuilder {
         self
     }
 
-    /// Set the chunk size of the MongoDB GridFs service used to break the user file into chunks.
+    /// Set the chunk size in bytes for MongoDB GridFs service. We break the user file into chunks by size.
     ///
     /// Default to `255 KiB` if not specified.
     pub fn chunk_size(mut self, chunk_size: u32) -> Self {
@@ -104,6 +104,9 @@ impl GridfsBuilder {
     }
 }
 
+/// Default GridFS chunk size in bytes.
+const DEFAULT_CHUNK_SIZE_BYTES: u32 = 255 * 1024; // 255 KiB
+
 impl Builder for GridfsBuilder {
     type Config = GridfsConfig;
 
@@ -128,7 +131,7 @@ impl Builder for GridfsBuilder {
             Some(v) => v.clone(),
             None => "fs".to_string(),
         };
-        let chunk_size = self.config.chunk_size.unwrap_or(255);
+        let chunk_size = self.config.chunk_size.unwrap_or(DEFAULT_CHUNK_SIZE_BYTES);
 
         let root = normalize_root(
             self.config
@@ -196,6 +199,7 @@ impl Service for GridfsBackend {
     type Lister = ();
     type Deleter = oio::OneShotDeleter<GridfsDeleter>;
     type Copier = ();
+    type Composer = ();
 
     fn info(&self) -> ServiceInfo {
         self.info.clone()
@@ -221,12 +225,13 @@ impl Service for GridfsBackend {
         let p = build_abs_path(&self.root, path);
 
         if p == build_abs_path(&self.root, "") {
-            Ok(RpStat::new(Metadata::new(EntryMode::DIR)))
+            Ok(RpStat::new(MetadataBuilder::dir().build()))
         } else {
             match self.core.get_length(&p).await? {
-                Some(len) => Ok(RpStat::new(
-                    Metadata::new(EntryMode::FILE).with_content_length(len as u64),
-                )),
+                Some(len) => Ok(RpStat::new({
+                    let metadata = MetadataBuilder::file(len as u64);
+                    metadata.build()
+                })),
                 None => Err(Error::new(ErrorKind::NotFound, "kv not found in gridfs")),
             }
         }
@@ -276,7 +281,6 @@ impl Service for GridfsBackend {
         _from: &str,
         _to: &str,
         _args: OpCopy,
-        _opts: OpCopier,
     ) -> Result<Self::Copier> {
         Err(Error::new(
             ErrorKind::Unsupported,

data/core/services/gridfs/src/core.rs

@@ -17,9 +17,9 @@
 
 use std::fmt::Debug;
 
+use asyncband::once::OnceCell;
 use futures::AsyncReadExt;
 use futures::AsyncWriteExt;
-use mea::once::OnceCell;
 use mongodb::bson::doc;
 use mongodb::gridfs::{FilesCollectionDocument, GridFsBucket};
 use mongodb::options::ClientOptions;

data/core/services/gridfs/src/reader.rs

@@ -46,7 +46,10 @@ impl oio::StreamRead for GridfsReader {
             }
         };
         let content = bs.slice(range.to_content_range(bs.len())?);
-        let metadata = Metadata::new(EntryMode::FILE).with_content_length(bs.len() as u64);
+        let metadata = {
+            let metadata = MetadataBuilder::file(bs.len() as u64);
+            metadata.build()
+        };
         Ok((
             RpRead::new(metadata),
             Box::new(content) as Box<dyn oio::ReadStreamDyn>,

data/core/services/gridfs/src/writer.rs

@@ -49,8 +49,12 @@ impl oio::Write for GridfsWriter {
         let length = buf.len() as u64;
         self.core.set(&self.path, buf).await?;
 
-        let meta = Metadata::new(EntryMode::from_path(&self.path)).with_content_length(length);
-        Ok(meta)
+        let metadata = if self.path.ends_with('/') {
+            MetadataBuilder::dir()
+        } else {
+            MetadataBuilder::file(length)
+        };
+        Ok(metadata.build())
     }
 
     async fn abort(&mut self) -> Result<()> {

data/core/services/hdfs/Cargo.toml

@@ -32,7 +32,7 @@ version = { workspace = true }
 all-features = true
 
 [dependencies]
-opendal-core = { path = "../../core", version = "0.58.1", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.0", default-features = false }
 
 bytes = { workspace = true }
 futures = { workspace = true }

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

@@ -196,6 +196,7 @@ impl Service for HdfsBackend {
     type Lister = Option<HdfsLister>;
     type Deleter = oio::OneShotDeleter<HdfsDeleter>;
     type Copier = ();
+    type Composer = ();
 
     fn info(&self) -> ServiceInfo {
         self.core.info.clone()
@@ -260,7 +261,6 @@ impl Service for HdfsBackend {
         _from: &str,
         _to: &str,
         _args: OpCopy,
-        _opts: OpCopier,
     ) -> Result<Self::Copier> {
         Err(Error::new(
             ErrorKind::Unsupported,

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

@@ -72,11 +72,14 @@ impl HdfsCore {
         } else {
             EntryMode::Unknown
         };
-        let mut m = Metadata::new(mode);
-        m.set_content_length(meta.len());
-        m.set_last_modified(Timestamp::try_from(meta.modified())?);
+        let mut m = match mode {
+            EntryMode::FILE => MetadataBuilder::file(meta.len()),
+            EntryMode::DIR => MetadataBuilder::dir(),
+            EntryMode::Unknown => MetadataBuilder::unknown(),
+        };
+        m.last_modified(Timestamp::try_from(meta.modified())?);
 
-        Ok(m)
+        Ok(m.build())
     }
 
     pub async fn hdfs_open(&self, path: &str) -> Result<hdrs::File> {

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

@@ -15,8 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use opendal_core::EntryMode;
-use opendal_core::Metadata;
+use opendal_core::MetadataBuilder;
 use opendal_core::Result;
 use opendal_core::raw::*;
 
@@ -43,7 +42,7 @@ impl HdfsLister {
 impl oio::List for HdfsLister {
     async fn next(&mut self) -> Result<Option<oio::Entry>> {
         if let Some(path) = self.current_path.take() {
-            return Ok(Some(oio::Entry::new(&path, Metadata::new(EntryMode::DIR))));
+            return Ok(Some(oio::Entry::new(&path, MetadataBuilder::dir().build())));
         }
 
         let de = match self.rd.next() {
@@ -54,15 +53,14 @@ impl oio::List for HdfsLister {
         let path = build_rel_path(&self.root, de.path());
 
         let entry = if de.is_file() {
-            let meta = Metadata::new(EntryMode::FILE)
-                .with_content_length(de.len())
-                .with_last_modified(Timestamp::try_from(de.modified())?);
-            oio::Entry::new(&path, meta)
+            let mut meta = MetadataBuilder::file(de.len());
+            meta.last_modified(Timestamp::try_from(de.modified())?);
+            oio::Entry::new(&path, meta.build())
         } else if de.is_dir() {
             // Make sure we are returning the correct path.
-            oio::Entry::new(&format!("{path}/"), Metadata::new(EntryMode::DIR))
+            oio::Entry::new(&format!("{path}/"), MetadataBuilder::dir().build())
         } else {
-            oio::Entry::new(&path, Metadata::new(EntryMode::Unknown))
+            oio::Entry::new(&path, MetadataBuilder::unknown().build())
         };
 
         Ok(Some(entry))

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

@@ -92,7 +92,11 @@ impl oio::Write for HdfsWriter<hdrs::AsyncFile> {
                 .map_err(new_std_io_error)?
         }
 
-        Ok(Metadata::default().with_content_length(self.size))
+        Ok({
+            let mut metadata = MetadataBuilder::unknown();
+            metadata.set_file(self.size);
+            metadata.build()
+        })
     }
 
     async fn abort(&mut self) -> Result<()> {

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.58.1", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.0", default-features = false }
 serde = { workspace = true, features = ["derive"] }

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

@@ -167,6 +167,7 @@ impl Service for HdfsNativeBackend {
     type Lister = HdfsNativeLazyLister;
     type Deleter = oio::OneShotDeleter<HdfsNativeDeleter>;
     type Copier = ();
+    type Composer = ();
 
     fn info(&self) -> ServiceInfo {
         self.core.info.clone()
@@ -221,7 +222,6 @@ impl Service for HdfsNativeBackend {
         _from: &str,
         _to: &str,
         _args: OpCopy,
-        _opts: OpCopier,
     ) -> Result<Self::Copier> {
         Err(Error::new(
             ErrorKind::Unsupported,

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

@@ -68,14 +68,16 @@ impl HdfsNativeCore {
             EntryMode::FILE
         };
 
-        let mut metadata = Metadata::new(mode);
-        metadata
-            .set_last_modified(Timestamp::from_millisecond(
-                status.modification_time as i64,
-            )?)
-            .set_content_length(status.length as u64);
-
-        Ok(metadata)
+        let mut metadata = if mode == EntryMode::FILE {
+            MetadataBuilder::file(status.length as u64)
+        } else {
+            MetadataBuilder::dir()
+        };
+        metadata.last_modified(Timestamp::from_millisecond(
+            status.modification_time as i64,
+        )?);
+
+        Ok(metadata.build())
     }
 
     pub async fn hdfs_open(&self, path: &str) -> Result<hdfs_native::file::FileReader> {
@@ -200,49 +202,41 @@ impl HdfsNativeCore {
     }
 }
 
-mod error {
-    use hdfs_native::HdfsError;
-
-    use opendal_core::*;
-
-    /// Parse hdfs-native error into opendal::Error.
-    pub fn parse_hdfs_error(hdfs_error: HdfsError) -> Error {
-        let (kind, retryable, msg) = match &hdfs_error {
-            HdfsError::IOError(err) => (ErrorKind::Unexpected, false, err.to_string()),
-            HdfsError::DataTransferError(msg) => (ErrorKind::Unexpected, false, msg.clone()),
-            HdfsError::ChecksumError => (
-                ErrorKind::Unexpected,
-                false,
-                "checksums didn't match".to_string(),
-            ),
-            HdfsError::UrlParseError(err) => (ErrorKind::Unexpected, false, err.to_string()),
-            HdfsError::AlreadyExists(msg) => (ErrorKind::AlreadyExists, false, msg.clone()),
-            HdfsError::OperationFailed(msg) => (ErrorKind::Unexpected, false, msg.clone()),
-            HdfsError::RPCError(msg0, msg1) => {
-                if msg0.contains("java.io.FileNotFoundException") {
-                    (ErrorKind::NotFound, false, msg1.clone())
-                } else {
-                    (ErrorKind::Unexpected, false, msg1.clone())
-                }
+/// Parse hdfs-native error into opendal::Error.
+pub fn parse_hdfs_error(hdfs_error: HdfsError) -> Error {
+    let (kind, retryable, msg) = match &hdfs_error {
+        HdfsError::IOError(err) => (ErrorKind::Unexpected, false, err.to_string()),
+        HdfsError::DataTransferError(msg) => (ErrorKind::Unexpected, false, msg.clone()),
+        HdfsError::ChecksumError => (
+            ErrorKind::Unexpected,
+            false,
+            "checksums didn't match".to_string(),
+        ),
+        HdfsError::UrlParseError(err) => (ErrorKind::Unexpected, false, err.to_string()),
+        HdfsError::AlreadyExists(msg) => (ErrorKind::AlreadyExists, false, msg.clone()),
+        HdfsError::OperationFailed(msg) => (ErrorKind::Unexpected, false, msg.clone()),
+        HdfsError::RPCError(msg0, msg1) => {
+            if msg0.contains("java.io.FileNotFoundException") {
+                (ErrorKind::NotFound, false, msg1.clone())
+            } else {
+                (ErrorKind::Unexpected, false, msg1.clone())
             }
-            HdfsError::FileNotFound(msg) => (ErrorKind::NotFound, false, msg.clone()),
-            HdfsError::BlocksNotFound(msg) => (ErrorKind::NotFound, false, msg.clone()),
-            HdfsError::IsADirectoryError(msg) => (ErrorKind::IsADirectory, false, msg.clone()),
-            _ => (
-                ErrorKind::Unexpected,
-                false,
-                "unexpected error from hdfs".to_string(),
-            ),
-        };
-
-        let mut err = Error::new(kind, msg).set_source(hdfs_error);
-
-        if retryable {
-            err = err.set_temporary();
         }
-
-        err
+        HdfsError::FileNotFound(msg) => (ErrorKind::NotFound, false, msg.clone()),
+        HdfsError::BlocksNotFound(msg) => (ErrorKind::NotFound, false, msg.clone()),
+        HdfsError::IsADirectoryError(msg) => (ErrorKind::IsADirectory, false, msg.clone()),
+        _ => (
+            ErrorKind::Unexpected,
+            false,
+            "unexpected error from hdfs".to_string(),
+        ),
+    };
+
+    let mut err = Error::new(kind, msg).set_source(hdfs_error);
+
+    if retryable {
+        err = err.set_temporary();
     }
-}
 
-pub(super) use error::*;
+    err
+}

data/core/services/hdfs-native/src/lister.rs

@@ -17,8 +17,7 @@
 
 use hdfs_native::client::ListStatusIterator;
 
-use opendal_core::EntryMode;
-use opendal_core::Metadata;
+use opendal_core::MetadataBuilder;
 use opendal_core::Result;
 use opendal_core::raw::*;
 
@@ -54,7 +53,7 @@ impl oio::List for HdfsNativeLister {
         }
 
         if let Some(path) = self.current_path.take() {
-            return Ok(Some(oio::Entry::new(&path, Metadata::new(EntryMode::DIR))));
+            return Ok(Some(oio::Entry::new(&path, MetadataBuilder::dir().build())));
         }
 
         match self.iter.next().await {
@@ -62,14 +61,13 @@ impl oio::List for HdfsNativeLister {
                 let path = build_rel_path(&self.root, &status.path);
 
                 let entry = if status.isdir {
-                    oio::Entry::new(&format!("{path}/"), Metadata::new(EntryMode::DIR))
+                    oio::Entry::new(&format!("{path}/"), MetadataBuilder::dir().build())
                 } else {
-                    let meta = Metadata::new(EntryMode::FILE)
-                        .with_content_length(status.length as u64)
-                        .with_last_modified(Timestamp::from_millisecond(
-                            status.modification_time as i64,
-                        )?);
-                    oio::Entry::new(&path, meta)
+                    let mut meta = MetadataBuilder::file(status.length as u64);
+                    meta.last_modified(Timestamp::from_millisecond(
+                        status.modification_time as i64,
+                    )?);
+                    oio::Entry::new(&path, meta.build())
                 };
 
                 Ok(Some(entry))

data/core/services/hdfs-native/src/writer.rs

@@ -49,7 +49,11 @@ impl oio::Write for HdfsNativeWriter {
     async fn close(&mut self) -> Result<Metadata> {
         self.f.close().await.map_err(parse_hdfs_error)?;
 
-        Ok(Metadata::default().with_content_length(self.size))
+        Ok({
+            let mut metadata = MetadataBuilder::unknown();
+            metadata.set_file(self.size);
+            metadata.build()
+        })
     }
 
     async fn abort(&mut self) -> Result<()> {

data/core/services/hf/Cargo.toml

@@ -32,11 +32,12 @@ version = { workspace = true }
 all-features = true
 
 [dependencies]
+asyncband = { workspace = true }
 bytes = { workspace = true }
-hf-xet = "1.5.0"
+hf-xet = "1.6.0"
 http = { workspace = true }
 log = { workspace = true }
-opendal-core = { path = "../../core", version = "0.58.1", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.0", default-features = false }
 percent-encoding = "2"
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
@@ -44,6 +45,6 @@ serde_json = { workspace = true }
 [dev-dependencies]
 base64 = { workspace = true }
 futures = { workspace = true }
-opendal-http-transport-reqwest = { path = "../../http-transports/reqwest", version = "0.58.1" }
+opendal-http-transport-reqwest = { path = "../../http-transports/reqwest", version = "0.59.0" }
 serde_json = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }

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

@@ -248,6 +248,7 @@ impl Builder for HfBuilder {
             stat: true,
             read: true,
             write: token.is_some(),
+            write_can_multi: token.is_some(),
             delete: token.is_some(),
             delete_max_size: Some(100),
             list: true,
@@ -285,6 +286,7 @@ impl Service for HfBackend {
     type Lister = oio::PageLister<HfLister>;
     type Deleter = oio::BatchDeleter<HfDeleter>;
     type Copier = ();
+    type Composer = ();
 
     fn info(&self) -> ServiceInfo {
         self.core.info.clone()
@@ -309,12 +311,12 @@ impl Service for HfBackend {
     async fn stat(&self, ctx: &OperationContext, path: &str, _: OpStat) -> Result<RpStat> {
         // Stat root always returns a DIR.
         if path == "/" {
-            return Ok(RpStat::new(Metadata::new(EntryMode::DIR)));
+            return Ok(RpStat::new(MetadataBuilder::dir().build()));
         }
 
         // Buckets have no git directory entries; treat any trailing-slash path as a virtual dir.
         if self.core.repo.is_bucket() && path.ends_with('/') {
-            return Ok(RpStat::new(Metadata::new(EntryMode::DIR)));
+            return Ok(RpStat::new(MetadataBuilder::dir().build()));
         }
 
         let info = self.core.path_info(ctx, path).await?;
@@ -371,7 +373,6 @@ impl Service for HfBackend {
         _from: &str,
         _to: &str,
         _args: OpCopy,
-        _opts: OpCopier,
     ) -> Result<Self::Copier> {
         Err(Error::new(
             ErrorKind::Unsupported,