opendal 0.1.9 → 0.1.11

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

@@ -222,6 +222,7 @@ impl Service for D1Backend {
     type Lister = ();
     type Deleter = oio::OneShotDeleter<D1Deleter>;
     type Copier = ();
+    type Composer = ();
 
     fn info(&self) -> ServiceInfo {
         self.info.clone()
@@ -247,12 +248,13 @@ impl Service for D1Backend {
         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(ctx, &p).await? {
-                Some(length) => Ok(RpStat::new(
-                    Metadata::new(EntryMode::FILE).with_content_length(length as u64),
-                )),
+                Some(length) => Ok(RpStat::new({
+                    let metadata = MetadataBuilder::file(length as u64);
+                    metadata.build()
+                })),
                 None => Err(Error::new(ErrorKind::NotFound, "kv not found in d1")),
             }
         }
@@ -304,7 +306,6 @@ impl Service for D1Backend {
         _from: &str,
         _to: &str,
         _args: OpCopy,
-        _opts: OpCopier,
     ) -> Result<Self::Copier> {
         Err(Error::new(
             ErrorKind::Unsupported,

data/core/services/d1/src/core.rs

@@ -103,7 +103,10 @@ impl D1Core {
                 let d1_response = D1Response::parse(&bs)?;
                 Ok(d1_response.get_result(&self.value_field))
             }
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("Query")),
+                resp,
+            )),
         }
     }
 
@@ -124,7 +127,10 @@ impl D1Core {
                 let d1_response = D1Response::parse(&bs)?;
                 d1_response.get_usize_result("content_length")
             }
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("Query")),
+                resp,
+            )),
         }
     }
 
@@ -133,9 +139,9 @@ impl D1Core {
         let key_field = &self.key_field;
         let value_field = &self.value_field;
         let query = format!(
-            r#"INSERT INTO "{table}" ("{key_field}", "{value_field}") \
-                VALUES ('?', ?) \
-                ON CONFLICT ("{key_field}") \
+            r#"INSERT INTO "{table}" ("{key_field}", "{value_field}")
+                VALUES (?, ?)
+                ON CONFLICT ("{key_field}")
                     DO UPDATE SET "{value_field}" = EXCLUDED."{value_field}""#,
         );
 
@@ -146,7 +152,10 @@ impl D1Core {
         let status = resp.status();
         match status {
             StatusCode::OK | StatusCode::PARTIAL_CONTENT => Ok(()),
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("Query")),
+                resp,
+            )),
         }
     }
 
@@ -162,73 +171,80 @@ impl D1Core {
         let status = resp.status();
         match status {
             StatusCode::OK | StatusCode::PARTIAL_CONTENT => Ok(()),
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("Query")),
+                resp,
+            )),
         }
     }
 }
 
-mod error {
-    use bytes::Buf;
-    use http::Response;
-    use http::StatusCode;
-    use serde_json::de;
-
-    use crate::model::*;
-    use opendal_core::raw::*;
-    use opendal_core::*;
-
-    /// Parse error response into Error.
-    pub(crate) fn parse_error(resp: Response<Buffer>) -> Error {
-        let (parts, body) = resp.into_parts();
-        let bs = body.to_bytes();
-
-        let (mut kind, mut retryable) = match parts.status {
-            StatusCode::NOT_FOUND => (ErrorKind::NotFound, false),
-            // Some services (like owncloud) return 403 while file locked.
-            StatusCode::FORBIDDEN => (ErrorKind::PermissionDenied, true),
-            // Allowing retry for resource locked.
-            StatusCode::LOCKED => (ErrorKind::Unexpected, true),
-            StatusCode::INTERNAL_SERVER_ERROR
-            | StatusCode::BAD_GATEWAY
-            | StatusCode::SERVICE_UNAVAILABLE
-            | StatusCode::GATEWAY_TIMEOUT => (ErrorKind::Unexpected, true),
-            _ => (ErrorKind::Unexpected, false),
-        };
-
-        let (message, d1_err) = de::from_reader::<_, D1Response>(bs.clone().reader())
-            .map(|d1_err| (format!("{d1_err:?}"), Some(d1_err)))
-            .unwrap_or_else(|_| (String::from_utf8_lossy(&bs).into_owned(), None));
-
-        if let Some(d1_err) = d1_err {
-            (kind, retryable) = parse_d1_error_code(d1_err.errors).unwrap_or((kind, retryable));
-        }
-
-        let mut err = Error::new(kind, message);
+use bytes::Buf;
+use http::Response;
+use serde_json::de;
 
-        err = with_error_response_context(err, parts);
+/// Context needed to classify an error from this service.
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct ErrorContext {
+    service_operation: ServiceOperation,
+}
 
-        if retryable {
-            err = err.set_temporary();
-        }
+impl ErrorContext {
+    pub(crate) const fn new(service_operation: ServiceOperation) -> Self {
+        Self { service_operation }
+    }
+}
 
-        err
+/// Parse an error response using its service request context.
+pub(crate) fn parse_error(ctx: ErrorContext, resp: Response<Buffer>) -> Error {
+    let (parts, body) = resp.into_parts();
+    let bs = body.to_bytes();
+
+    let (mut kind, mut retryable) = match parts.status {
+        StatusCode::NOT_FOUND => (ErrorKind::NotFound, false),
+        // Some services (like owncloud) return 403 while file locked.
+        StatusCode::FORBIDDEN => (ErrorKind::PermissionDenied, true),
+        // Allowing retry for resource locked.
+        StatusCode::LOCKED => (ErrorKind::Unexpected, true),
+        StatusCode::INTERNAL_SERVER_ERROR
+        | StatusCode::BAD_GATEWAY
+        | StatusCode::SERVICE_UNAVAILABLE
+        | StatusCode::GATEWAY_TIMEOUT => (ErrorKind::Unexpected, true),
+        _ => (ErrorKind::Unexpected, false),
+    };
+
+    let (message, d1_err) = de::from_reader::<_, D1Response>(bs.clone().reader())
+        .map(|d1_err| (format!("{d1_err:?}"), Some(d1_err)))
+        .unwrap_or_else(|_| (String::from_utf8_lossy(&bs).into_owned(), None));
+
+    if let Some(d1_err) = d1_err {
+        (kind, retryable) = parse_d1_error_code(d1_err.errors).unwrap_or((kind, retryable));
     }
 
-    pub fn parse_d1_error_code(errors: Vec<D1Error>) -> Option<(ErrorKind, bool)> {
-        if errors.is_empty() {
-            return None;
-        }
+    let mut err = Error::new(kind, message);
 
-        match errors[0].code {
-            // The request is malformed: failed to decode id.
-            7400 => Some((ErrorKind::Unexpected, false)),
-            // no such column: Xxxx.
-            7500 => Some((ErrorKind::NotFound, false)),
-            // Authentication error.
-            10000 => Some((ErrorKind::PermissionDenied, false)),
-            _ => None,
-        }
+    err = err.with_context("service_operation", ctx.service_operation.0);
+    err = with_error_response_context(err, parts);
+
+    if retryable {
+        err = err.set_temporary();
     }
+
+    err
 }
 
-pub(super) use error::*;
+pub fn parse_d1_error_code(errors: Vec<D1Error>) -> Option<(ErrorKind, bool)> {
+    if errors.is_empty() {
+        return None;
+    }
+
+    match errors[0].code {
+        // The request is malformed: failed to decode id.
+        7400 => Some((ErrorKind::Unexpected, false)),
+        // no such column: Xxxx.
+        7500 => Some((ErrorKind::NotFound, false)),
+        // Authentication error.
+        10000 => Some((ErrorKind::PermissionDenied, false)),
+        _ => None,
+    }
+}

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

@@ -48,7 +48,10 @@ impl oio::StreamRead for D1Reader {
             }
         };
         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/d1/src/writer.rs

@@ -50,8 +50,12 @@ impl oio::Write for D1Writer {
         let length = buf.len() as u64;
         self.core.set(&self.ctx, &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/dashmap/Cargo.toml

@@ -34,7 +34,7 @@ all-features = true
 [dependencies]
 dashmap = "6"
 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"] }
 
 [dev-dependencies]

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

@@ -116,6 +116,7 @@ impl Service for DashmapBackend {
     type Lister = oio::HierarchyLister<DashmapLister>;
     type Deleter = oio::OneShotDeleter<DashmapDeleter>;
     type Copier = ();
+    type Composer = ();
 
     fn info(&self) -> ServiceInfo {
         self.info.clone()
@@ -149,7 +150,7 @@ impl Service for DashmapBackend {
                 if p.ends_with('/') {
                     let has_children = self.core.cache.iter().any(|kv| kv.key().starts_with(&p));
                     if has_children {
-                        return Ok(RpStat::new(Metadata::new(EntryMode::DIR)));
+                        return Ok(RpStat::new(MetadataBuilder::dir().build()));
                     }
                 }
                 Err(Error::new(ErrorKind::NotFound, "key not found in dashmap"))
@@ -204,7 +205,6 @@ impl Service for DashmapBackend {
         _from: &str,
         _to: &str,
         _args: OpCopy,
-        _opts: OpCopier,
     ) -> Result<Self::Copier> {
         Err(Error::new(
             ErrorKind::Unsupported,

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

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

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

@@ -50,24 +50,27 @@ impl oio::Write for DashmapWriter {
     async fn close(&mut self) -> Result<Metadata> {
         let content = self.buf.clone().collect();
 
-        let entry_mode = EntryMode::from_path(&self.path);
-        let mut meta = Metadata::new(entry_mode);
-        meta.set_content_length(content.len() as u64);
-        meta.set_last_modified(Timestamp::now());
+        let mut meta = if self.path.ends_with('/') {
+            MetadataBuilder::dir()
+        } else {
+            MetadataBuilder::file(content.len() as u64)
+        };
+        meta.last_modified(Timestamp::now());
 
         if let Some(v) = self.op.content_type() {
-            meta.set_content_type(v);
+            meta.content_type(v);
         }
         if let Some(v) = self.op.content_disposition() {
-            meta.set_content_disposition(v);
+            meta.content_disposition(v);
         }
         if let Some(v) = self.op.cache_control() {
-            meta.set_cache_control(v);
+            meta.cache_control(v);
         }
         if let Some(v) = self.op.content_encoding() {
-            meta.set_content_encoding(v);
+            meta.content_encoding(v);
         }
 
+        let meta = meta.build();
         self.core.set(
             &self.path,
             DashmapValue {

data/core/services/dbfs/Cargo.toml

@@ -36,7 +36,7 @@ base64 = { workspace = true }
 bytes = { workspace = true }
 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 }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 

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

@@ -24,8 +24,8 @@ use serde::Deserialize;
 
 use super::DBFS_SCHEME;
 use super::config::DbfsConfig;
-use super::core::DbfsCore;
 use super::core::parse_error;
+use super::core::{DbfsCore, ErrorContext};
 use super::deleter::DbfsDeleter;
 use super::lister::DbfsLister;
 use super::writer::DbfsWriter;
@@ -144,6 +144,7 @@ impl Service for DbfsBackend {
     type Lister = oio::PageLister<DbfsLister>;
     type Deleter = oio::OneShotDeleter<DbfsDeleter>;
     type Copier = ();
+    type Composer = ();
 
     fn info(&self) -> ServiceInfo {
         ServiceInfo::new(DBFS_SCHEME, &self.core.root, "")
@@ -165,14 +166,17 @@ impl Service for DbfsBackend {
 
         match status {
             StatusCode::CREATED | StatusCode::OK => Ok(RpCreateDir::default()),
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("Mkdirs")),
+                resp,
+            )),
         }
     }
 
     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()));
         }
 
         let resp = self.core.dbfs_get_status(ctx, path).await?;
@@ -181,26 +185,26 @@ impl Service for DbfsBackend {
 
         match status {
             StatusCode::OK => {
-                let mut meta = parse_into_metadata(path, resp.headers())?;
+                let mut meta = MetadataBuilder::unknown();
                 let bs = resp.into_body();
                 let decoded_response: DbfsStatus =
                     serde_json::from_reader(bs.reader()).map_err(new_json_deserialize_error)?;
-                meta.set_last_modified(Timestamp::from_millisecond(
+                meta.last_modified(Timestamp::from_millisecond(
                     decoded_response.modification_time,
                 )?);
                 match decoded_response.is_dir {
-                    true => meta.set_mode(EntryMode::DIR),
-                    false => {
-                        meta.set_mode(EntryMode::FILE);
-                        meta.set_content_length(decoded_response.file_size as u64)
-                    }
+                    true => meta.set_dir(),
+                    false => meta.set_file(decoded_response.file_size as u64),
                 };
-                Ok(RpStat::new(meta))
+                Ok(RpStat::new(meta.build()))
             }
             StatusCode::NOT_FOUND if path.ends_with('/') => {
-                Ok(RpStat::new(Metadata::new(EntryMode::DIR)))
+                Ok(RpStat::new(MetadataBuilder::dir().build()))
             }
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("GetStatus")),
+                resp,
+            )),
         }
     }
 
@@ -260,7 +264,10 @@ impl Service for DbfsBackend {
 
         match status {
             StatusCode::OK => Ok(RpRename::default()),
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("Move")),
+                resp,
+            )),
         }
     }
 
@@ -270,7 +277,6 @@ impl Service for DbfsBackend {
         _from: &str,
         _to: &str,
         _args: OpCopy,
-        _opts: OpCopier,
     ) -> Result<Self::Copier> {
         Err(Error::new(
             ErrorKind::Unsupported,

data/core/services/dbfs/src/core.rs

@@ -24,6 +24,7 @@ use http::Request;
 use http::Response;
 use http::StatusCode;
 use http::header;
+use serde::Deserialize;
 use serde_json::json;
 
 use opendal_core::raw::*;
@@ -62,7 +63,7 @@ impl DbfsCore {
             .to_string();
 
         let req_body = &json!({
-            "path": percent_encode_path(&p),
+            "path": p,
         });
         let body = Buffer::from(Bytes::from(req_body.to_string()));
 
@@ -91,7 +92,7 @@ impl DbfsCore {
             .to_string();
 
         let request_body = &json!({
-            "path": percent_encode_path(&p),
+            "path": p,
             // TODO: support recursive toggle, should we add a new field in OpDelete?
             "recursive": true,
         });
@@ -123,8 +124,8 @@ impl DbfsCore {
         req = req.header(header::AUTHORIZATION, auth_header_content);
 
         let req_body = &json!({
-            "source_path": percent_encode_path(&source),
-            "destination_path": percent_encode_path(&target),
+            "source_path": source,
+            "destination_path": target,
         });
 
         let body = Buffer::from(Bytes::from(req_body.to_string()));
@@ -172,7 +173,7 @@ impl DbfsCore {
         req = req.header(header::AUTHORIZATION, auth_header_content);
 
         let req_body = &json!({
-            "path": path,
+            "path": build_rooted_abs_path(&self.root, path),
             "contents": contents,
             "overwrite": true,
         });
@@ -222,71 +223,75 @@ impl DbfsCore {
             StatusCode::NOT_FOUND => {
                 self.dbfs_create_dir(ctx, path).await?;
             }
-            _ => return Err(parse_error(resp)),
+            _ => {
+                return Err(parse_error(
+                    ErrorContext::new(ServiceOperation("GetStatus")),
+                    resp,
+                ));
+            }
         }
         Ok(())
     }
 }
 
-mod error {
-    use std::fmt::Debug;
+/// DbfsError is the error returned by DBFS service.
+#[derive(Default, Deserialize)]
+struct DbfsError {
+    error_code: String,
+    message: String,
+}
 
-    use http::Response;
-    use http::StatusCode;
-    use serde::Deserialize;
+impl Debug for DbfsError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("DbfsError")
+            .field("error_code", &self.error_code)
+            // replace `\n` to ` ` for better reading.
+            .field("message", &self.message.replace('\n', " "))
+            .finish()
+    }
+}
 
-    use opendal_core::raw::*;
-    use opendal_core::*;
+/// Context needed to classify an error from this service.
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct ErrorContext {
+    service_operation: ServiceOperation,
+}
 
-    /// DbfsError is the error returned by DBFS service.
-    #[derive(Default, Deserialize)]
-    struct DbfsError {
-        error_code: String,
-        message: String,
+impl ErrorContext {
+    pub(crate) const fn new(service_operation: ServiceOperation) -> Self {
+        Self { service_operation }
     }
+}
 
-    impl Debug for DbfsError {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            f.debug_struct("DbfsError")
-                .field("error_code", &self.error_code)
-                // replace `\n` to ` ` for better reading.
-                .field("message", &self.message.replace('\n', " "))
-                .finish()
-        }
+/// Parse an error response using its service request context.
+pub(crate) fn parse_error(ctx: ErrorContext, resp: Response<Buffer>) -> Error {
+    let (parts, body) = resp.into_parts();
+    let bs = body.to_bytes();
+
+    let (kind, retryable) = match parts.status {
+        StatusCode::NOT_FOUND => (ErrorKind::NotFound, false),
+        StatusCode::UNAUTHORIZED | StatusCode::FORBIDDEN => (ErrorKind::PermissionDenied, false),
+        StatusCode::PRECONDITION_FAILED => (ErrorKind::ConditionNotMatch, false),
+        StatusCode::INTERNAL_SERVER_ERROR
+        | StatusCode::BAD_GATEWAY
+        | StatusCode::SERVICE_UNAVAILABLE
+        | StatusCode::GATEWAY_TIMEOUT => (ErrorKind::Unexpected, true),
+        _ => (ErrorKind::Unexpected, false),
+    };
+
+    let message = match serde_json::from_slice::<DbfsError>(&bs) {
+        Ok(dbfs_error) => format!("{:?}", dbfs_error.message),
+        Err(_) => String::from_utf8_lossy(&bs).into_owned(),
+    };
+
+    let mut err = Error::new(kind, message);
+
+    err = err.with_context("service_operation", ctx.service_operation.0);
+    err = with_error_response_context(err, parts);
+
+    if retryable {
+        err = err.set_temporary();
     }
 
-    pub(crate) fn parse_error(resp: Response<Buffer>) -> Error {
-        let (parts, body) = resp.into_parts();
-        let bs = body.to_bytes();
-
-        let (kind, retryable) = match parts.status {
-            StatusCode::NOT_FOUND => (ErrorKind::NotFound, false),
-            StatusCode::UNAUTHORIZED | StatusCode::FORBIDDEN => {
-                (ErrorKind::PermissionDenied, false)
-            }
-            StatusCode::PRECONDITION_FAILED => (ErrorKind::ConditionNotMatch, false),
-            StatusCode::INTERNAL_SERVER_ERROR
-            | StatusCode::BAD_GATEWAY
-            | StatusCode::SERVICE_UNAVAILABLE
-            | StatusCode::GATEWAY_TIMEOUT => (ErrorKind::Unexpected, true),
-            _ => (ErrorKind::Unexpected, false),
-        };
-
-        let message = match serde_json::from_slice::<DbfsError>(&bs) {
-            Ok(dbfs_error) => format!("{:?}", dbfs_error.message),
-            Err(_) => String::from_utf8_lossy(&bs).into_owned(),
-        };
-
-        let mut err = Error::new(kind, message);
-
-        err = with_error_response_context(err, parts);
-
-        if retryable {
-            err = err.set_temporary();
-        }
-
-        err
-    }
+    err
 }
-
-pub(super) use error::*;

data/core/services/dbfs/src/deleter.rs

@@ -44,7 +44,10 @@ impl oio::OneShotDelete for DbfsDeleter {
         match status {
             // NOTE: Server will return 200 even if the path doesn't exist.
             StatusCode::OK => Ok(()),
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("Delete")),
+                resp,
+            )),
         }
     }
 }

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

@@ -21,8 +21,8 @@ use bytes::Buf;
 use http::StatusCode;
 use serde::Deserialize;
 
-use super::core::DbfsCore;
 use super::core::parse_error;
+use super::core::{DbfsCore, ErrorContext};
 use opendal_core::raw::*;
 use opendal_core::*;
 
@@ -48,7 +48,7 @@ impl oio::PageList for DbfsLister {
                 ctx.done = true;
                 return Ok(());
             }
-            let error = parse_error(response);
+            let error = parse_error(ErrorContext::new(ServiceOperation("List")), response);
             return Err(error);
         }
 
@@ -59,18 +59,18 @@ impl oio::PageList for DbfsLister {
         ctx.done = true;
 
         for status in decoded_response.files {
+            let path = build_rel_path(&self.core.root, &status.path);
             let entry: oio::Entry = match status.is_dir {
                 true => {
-                    let normalized_path = format!("{}/", status.path);
-                    let mut meta = Metadata::new(EntryMode::DIR);
-                    meta.set_last_modified(Timestamp::from_millisecond(status.modification_time)?);
-                    oio::Entry::new(&normalized_path, meta)
+                    let normalized_path = format!("{path}/");
+                    let mut meta = MetadataBuilder::dir();
+                    meta.last_modified(Timestamp::from_millisecond(status.modification_time)?);
+                    oio::Entry::new(&normalized_path, meta.build())
                 }
                 false => {
-                    let mut meta = Metadata::new(EntryMode::FILE);
-                    meta.set_last_modified(Timestamp::from_millisecond(status.modification_time)?);
-                    meta.set_content_length(status.file_size as u64);
-                    oio::Entry::new(&status.path, meta)
+                    let mut meta = MetadataBuilder::file(status.file_size as u64);
+                    meta.last_modified(Timestamp::from_millisecond(status.modification_time)?);
+                    oio::Entry::new(&path, meta.build())
                 }
             };
             ctx.entries.push_back(entry);