opendal 0.1.9 → 0.1.11

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

@@ -20,11 +20,11 @@ use std::sync::Arc;
 use bytes::Buf;
 use http::StatusCode;
 
-use super::core::B2Core;
 use super::core::StartLargeFileResponse;
 use super::core::UploadPartResponse;
 use super::core::UploadResponse;
 use super::core::parse_error;
+use super::core::{B2Core, ErrorContext};
 use opendal_core::raw::*;
 use opendal_core::*;
 
@@ -49,19 +49,21 @@ impl B2Writer {
     }
 
     pub fn parse_body_into_meta(path: &str, resp: UploadResponse) -> Metadata {
-        let mut meta = Metadata::new(EntryMode::from_path(path));
+        let mut meta = if path.ends_with('/') {
+            MetadataBuilder::dir()
+        } else {
+            MetadataBuilder::file(resp.content_length)
+        };
 
         if let Some(md5) = resp.content_md5 {
-            meta.set_content_md5(&md5);
+            meta.content_md5(&md5);
         }
 
         if let Some(content_type) = resp.content_type {
-            meta.set_content_type(&content_type);
+            meta.content_type(&content_type);
         }
 
-        meta.set_content_length(resp.content_length);
-
-        meta
+        meta.build()
     }
 }
 
@@ -85,7 +87,10 @@ impl oio::MultipartWrite for B2Writer {
 
                 Ok(meta)
             }
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("UploadFile")),
+                resp,
+            )),
         }
     }
 
@@ -106,7 +111,10 @@ impl oio::MultipartWrite for B2Writer {
 
                 Ok(result.file_id)
             }
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("StartLargeFile")),
+                resp,
+            )),
         }
     }
 
@@ -141,7 +149,10 @@ impl oio::MultipartWrite for B2Writer {
                     size: None,
                 })
             }
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("UploadPart")),
+                resp,
+            )),
         }
     }
 
@@ -180,7 +191,10 @@ impl oio::MultipartWrite for B2Writer {
 
                 Ok(meta)
             }
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("FinishLargeFile")),
+                resp,
+            )),
         }
     }
 
@@ -189,7 +203,10 @@ impl oio::MultipartWrite for B2Writer {
         match resp.status() {
             // b2 returns code 200 if abort succeeds.
             StatusCode::OK => Ok(()),
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("CancelLargeFile")),
+                resp,
+            )),
         }
     }
 }

data/core/services/cacache/Cargo.toml

@@ -37,7 +37,7 @@ cacache = { version = "13.0", default-features = false, features = [
   "tokio-runtime",
   "mmap",
 ] }
-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/cacache/src/backend.rs

@@ -87,6 +87,7 @@ impl Service for CacacheBackend {
     type Lister = ();
     type Deleter = oio::OneShotDeleter<CacacheDeleter>;
     type Copier = ();
+    type Composer = ();
 
     fn info(&self) -> ServiceInfo {
         self.info.clone()
@@ -113,14 +114,13 @@ impl Service for CacacheBackend {
 
         match metadata {
             Some(meta) => {
-                let mut md = Metadata::new(EntryMode::FILE);
-                md.set_content_length(meta.size as u64);
+                let mut md = MetadataBuilder::file(meta.size as u64);
                 // Convert u128 milliseconds to Timestamp
                 let millis = meta.time as i64;
                 if let Ok(dt) = Timestamp::from_millisecond(millis) {
-                    md.set_last_modified(dt);
+                    md.last_modified(dt);
                 }
-                Ok(RpStat::new(md))
+                Ok(RpStat::new(md.build()))
             }
             None => Err(Error::new(ErrorKind::NotFound, "entry not found")),
         }
@@ -167,7 +167,6 @@ impl Service for CacacheBackend {
         _from: &str,
         _to: &str,
         _args: OpCopy,
-        _opts: OpCopier,
     ) -> Result<Self::Copier> {
         Err(Error::new(
             ErrorKind::Unsupported,

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

@@ -44,7 +44,10 @@ impl oio::StreamRead for CacacheReader {
             Some(bytes) => {
                 let content_length = bytes.len() as u64;
                 let buffer = Buffer::from(bytes.slice(range.to_content_range(bytes.len())?));
-                let metadata = Metadata::new(EntryMode::FILE).with_content_length(content_length);
+                let metadata = {
+                    let metadata = MetadataBuilder::file(content_length);
+                    metadata.build()
+                };
                 Ok((
                     RpRead::new(metadata),
                     Box::new(buffer) as Box<dyn oio::ReadStreamDyn>,

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

@@ -50,8 +50,12 @@ impl oio::Write for CacacheWriter {
 
         self.core.set(&self.path, buf.to_bytes()).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/cloudflare-kv/Cargo.toml

@@ -34,6 +34,6 @@ all-features = true
 [dependencies]
 bytes = { workspace = true }
 http = { 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/cloudflare-kv/src/backend.rs

@@ -25,8 +25,8 @@ use opendal_core::*;
 
 use super::CLOUDFLARE_KV_SCHEME;
 use super::config::CloudflareKvConfig;
-use super::core::CloudflareKvCore;
 use super::core::parse_error;
+use super::core::{CloudflareKvCore, ErrorContext};
 use super::deleter::CloudflareKvDeleter;
 use super::lister::CloudflareKvLister;
 use super::model::*;
@@ -37,6 +37,7 @@ use super::writer::CloudflareWriter;
 #[derive(Default)]
 pub struct CloudflareKvBuilder {
     pub(super) config: CloudflareKvConfig,
+    pub(super) default_ttl: Option<Duration>,
 }
 
 impl Debug for CloudflareKvBuilder {
@@ -76,7 +77,7 @@ impl CloudflareKvBuilder {
     ///
     /// If set, we will specify `EX` for write operations.
     pub fn default_ttl(mut self, ttl: Duration) -> Self {
-        self.config.default_ttl = Some(ttl);
+        self.default_ttl = Some(ttl);
         self
     }
 
@@ -96,6 +97,14 @@ impl Builder for CloudflareKvBuilder {
     type Config = CloudflareKvConfig;
 
     fn build(self) -> Result<impl Service> {
+        let default_ttl = match self.default_ttl {
+            Some(ttl) => Some(ttl),
+            None => self
+                .config
+                .default_ttl
+                .map(signed_duration_to_duration)
+                .transpose()?,
+        };
         let api_token = match &self.config.api_token {
             Some(api_token) => format_authorization_by_bearer(api_token)?,
             None => {
@@ -121,7 +130,7 @@ impl Builder for CloudflareKvBuilder {
         };
 
         // Validate default TTL is at least 60 seconds if specified
-        if let Some(ttl) = self.config.default_ttl
+        if let Some(ttl) = default_ttl
             && ttl < Duration::from_secs(60)
         {
             return Err(Error::new(
@@ -143,7 +152,7 @@ impl Builder for CloudflareKvBuilder {
                 api_token,
                 account_id,
                 namespace_id,
-                expiration_ttl: self.config.default_ttl,
+                expiration_ttl: default_ttl,
                 info: ServiceInfo::new(CLOUDFLARE_KV_SCHEME, &root, ""),
                 capability: Capability {
                     create_dir: true,
@@ -189,6 +198,7 @@ impl Service for CloudflareKvBackend {
     type Lister = oio::PageLister<CloudflareKvLister>;
     type Deleter = oio::BatchDeleter<CloudflareKvDeleter>;
     type Copier = ();
+    type Composer = ();
 
     fn info(&self) -> ServiceInfo {
         self.core.info.clone()
@@ -266,7 +276,7 @@ impl Service for CloudflareKvBackend {
                     if let Some(entries) = list_result.result
                         && !entries.is_empty()
                     {
-                        return Ok(RpStat::new(Metadata::new(EntryMode::DIR)));
+                        return Ok(RpStat::new(MetadataBuilder::dir().build()));
                     }
 
                     // Empty or no results means not found
@@ -278,7 +288,10 @@ impl Service for CloudflareKvBackend {
             }
 
             // For all other error cases, parse the error response
-            return Err(parse_error(resp));
+            return Err(parse_error(
+                ErrorContext::new(ServiceOperation("GetMetadata")),
+                resp,
+            ));
         }
 
         let resp_body = resp.into_body();
@@ -354,16 +367,15 @@ impl Service for CloudflareKvBackend {
             ));
         }
 
-        let meta = Metadata::new(if metadata.is_dir {
-            EntryMode::DIR
+        let mut meta = if metadata.is_dir {
+            MetadataBuilder::dir()
         } else {
-            EntryMode::FILE
-        })
-        .with_etag(metadata.etag)
-        .with_content_length(metadata.content_length as u64)
-        .with_last_modified(metadata.last_modified.parse::<Timestamp>()?);
+            MetadataBuilder::file(metadata.content_length as u64)
+        };
+        meta.etag(metadata.etag)
+            .last_modified(metadata.last_modified.parse::<Timestamp>()?);
 
-        Ok(RpStat::new(meta))
+        Ok(RpStat::new(meta.build()))
     }
     fn read(&self, ctx: &OperationContext, path: &str, args: OpRead) -> Result<Self::Reader> {
         let output: oio::StreamReader<CloudflareKvReader> = {
@@ -438,7 +450,6 @@ impl Service for CloudflareKvBackend {
         _from: &str,
         _to: &str,
         _args: OpCopy,
-        _opts: OpCopier,
     ) -> Result<Self::Copier> {
         Err(Error::new(
             ErrorKind::Unsupported,

data/core/services/cloudflare-kv/src/config.rs

@@ -34,7 +34,7 @@ pub struct CloudflareKvConfig {
     /// The namespace ID. Used as URI path parameter.
     pub namespace_id: Option<String>,
     /// The default ttl for write operations.
-    pub default_ttl: Option<Duration>,
+    pub default_ttl: Option<SignedDuration>,
 
     /// Root within this backend.
     pub root: Option<String>,
@@ -94,7 +94,10 @@ impl opendal_core::Configurator for CloudflareKvConfig {
     }
 
     fn into_builder(self) -> Self::Builder {
-        CloudflareKvBuilder { config: self }
+        CloudflareKvBuilder {
+            config: self,
+            default_ttl: None,
+        }
     }
 }
 
@@ -125,4 +128,12 @@ mod tests {
 
         assert!(CloudflareKvConfig::from_uri(&uri).is_err());
     }
+
+    #[test]
+    fn from_iter_parses_default_ttl() {
+        let cfg = CloudflareKvConfig::from_iter([("default_ttl".to_string(), "PT1M".to_string())])
+            .unwrap();
+
+        assert_eq!(cfg.default_ttl, Some(SignedDuration::from_mins(1)));
+    }
 }

data/core/services/cloudflare-kv/src/core.rs

@@ -174,69 +174,75 @@ impl CloudflareKvCore {
     }
 }
 
-mod error {
-    use bytes::Buf;
-    use http::Response;
-    use http::StatusCode;
-    use opendal_core::raw::*;
-    use opendal_core::*;
-    use serde_json::de;
-
-    use crate::model::CfKvError;
-    use crate::model::CfKvResponse;
-
-    /// 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, err) = de::from_reader::<_, CfKvResponse>(bs.clone().reader())
-            .map(|err| (format!("{err:?}"), Some(err)))
-            .unwrap_or_else(|_| (String::from_utf8_lossy(&bs).into_owned(), None));
-
-        if let Some(err) = err {
-            (kind, retryable) = parse_cfkv_error_code(err.errors).unwrap_or((kind, retryable));
-        }
+use bytes::Buf;
+use http::StatusCode;
+use serde_json::de;
 
-        let mut err = Error::new(kind, message);
+use crate::model::CfKvError;
+use crate::model::CfKvResponse;
 
-        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, err) = de::from_reader::<_, CfKvResponse>(bs.clone().reader())
+        .map(|err| (format!("{err:?}"), Some(err)))
+        .unwrap_or_else(|_| (String::from_utf8_lossy(&bs).into_owned(), None));
+
+    if let Some(err) = err {
+        (kind, retryable) = parse_cfkv_error_code(err.errors).unwrap_or((kind, retryable));
     }
 
-    pub(crate) fn parse_cfkv_error_code(errors: Vec<CfKvError>) -> 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(crate) fn parse_cfkv_error_code(errors: Vec<CfKvError>) -> 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/cloudflare-kv/src/deleter.rs

@@ -49,7 +49,10 @@ impl oio::BatchDelete for CloudflareKvDeleter {
         let status = resp.status();
 
         if status != StatusCode::OK {
-            return Err(parse_error(resp.clone()));
+            return Err(parse_error(
+                ErrorContext::new(ServiceOperation("BulkDelete")),
+                resp.clone(),
+            ));
         }
 
         let bs = resp.clone().into_body();
@@ -57,7 +60,10 @@ impl oio::BatchDelete for CloudflareKvDeleter {
             serde_json::from_reader(bs.reader()).map_err(new_json_deserialize_error)?;
 
         if !res.success {
-            return Err(parse_error(resp.clone()));
+            return Err(parse_error(
+                ErrorContext::new(ServiceOperation("BulkDelete")),
+                resp.clone(),
+            ));
         }
 
         Ok(())
@@ -77,7 +83,10 @@ impl oio::BatchDelete for CloudflareKvDeleter {
         let status = resp.status();
 
         if status != StatusCode::OK {
-            return Err(parse_error(resp));
+            return Err(parse_error(
+                ErrorContext::new(ServiceOperation("BulkDelete")),
+                resp,
+            ));
         }
 
         let bs = resp.into_body();

data/core/services/cloudflare-kv/src/lister.rs

@@ -21,8 +21,8 @@ use bytes::Buf;
 use opendal_core::raw::*;
 use opendal_core::*;
 
-use super::core::CloudflareKvCore;
 use super::core::parse_error;
+use super::core::{CloudflareKvCore, ErrorContext};
 use super::model::{CfKvListKey, CfKvListResponse};
 
 pub struct CloudflareKvLister {
@@ -34,6 +34,22 @@ pub struct CloudflareKvLister {
     recursive: bool,
 }
 
+/// Strip the service root from a root-prefixed key.
+///
+/// The keys returned by the KV API carry the service root as a prefix, so only that prefix may be
+/// removed. `str::replace` removes *every* occurrence anywhere in the key, which silently mangles
+/// any key that repeats the root as an inner path segment.
+///
+/// The sibling object-store listers reach for `build_rel_path` here, but that helper
+/// `debug_assert!`s that the path really does start with the root -- a guarantee this service does
+/// not enforce on the values the API hands back -- so this stays total and leaves a
+/// non-root-prefixed key untouched.
+fn relative_to_root(root: &str, name: &str) -> String {
+    name.strip_prefix(root.trim_start_matches('/'))
+        .unwrap_or(name)
+        .to_string()
+}
+
 impl CloudflareKvLister {
     pub fn new(
         core: Arc<CloudflareKvCore>,
@@ -60,7 +76,7 @@ impl CloudflareKvLister {
             name += "/";
         }
 
-        let mut name = name.replace(root.trim_start_matches('/'), "");
+        let mut name = relative_to_root(root, &name);
 
         // If it is the root directory, it needs to be processed as /
         if name.is_empty() {
@@ -68,14 +84,15 @@ impl CloudflareKvLister {
         }
 
         let entry_metadata = if name.ends_with('/') {
-            Metadata::new(EntryMode::DIR)
-                .with_etag(build_tmp_path_of(&name))
-                .with_content_length(0)
+            let mut metadata = MetadataBuilder::dir();
+            metadata.etag(build_tmp_path_of(&name));
+            metadata.build()
         } else {
-            Metadata::new(EntryMode::FILE)
-                .with_etag(metadata.etag)
-                .with_content_length(metadata.content_length as u64)
-                .with_last_modified(metadata.last_modified.parse::<Timestamp>()?)
+            let mut result = MetadataBuilder::file(metadata.content_length as u64);
+            result
+                .etag(&metadata.etag)
+                .last_modified(metadata.last_modified.parse::<Timestamp>()?);
+            result.build()
         };
 
         Ok(oio::Entry::new(&name, entry_metadata))
@@ -91,13 +108,12 @@ impl CloudflareKvLister {
             let entry = self.build_entry_for_item(item, root)?;
             ctx.entries.push_back(entry);
         } else if !result.is_empty() {
-            let path_name = self.path.replace(root.trim_start_matches('/'), "");
-            let entry = oio::Entry::new(
-                &format!("{path_name}/"),
-                Metadata::new(EntryMode::DIR)
-                    .with_etag(build_tmp_path_of(&path_name))
-                    .with_content_length(0),
-            );
+            let path_name = relative_to_root(root, &self.path);
+            let entry = oio::Entry::new(&format!("{path_name}/"), {
+                let mut metadata = MetadataBuilder::dir();
+                metadata.etag(build_tmp_path_of(&path_name));
+                metadata.build()
+            });
             ctx.entries.push_back(entry);
         }
         ctx.done = true;
@@ -114,7 +130,10 @@ impl oio::PageList for CloudflareKvLister {
             .await?;
 
         if resp.status() != http::StatusCode::OK {
-            return Err(parse_error(resp));
+            return Err(parse_error(
+                ErrorContext::new(ServiceOperation("ListKeys")),
+                resp,
+            ));
         }
 
         let bs = resp.into_body();
@@ -171,3 +190,33 @@ impl oio::PageList for CloudflareKvLister {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn relative_to_root_strips_only_the_prefix() {
+        // The root repeated as an inner segment must survive; only the leading copy goes.
+        assert_eq!(
+            relative_to_root("/data/", "data/backup/data/file.txt"),
+            "backup/data/file.txt"
+        );
+        assert_eq!(relative_to_root("/data/", "data/file.txt"), "file.txt");
+    }
+
+    #[test]
+    fn relative_to_root_does_not_match_mid_key() {
+        // "replace" would turn this into "xfile.txt" by deleting a substring that is not a prefix.
+        assert_eq!(
+            relative_to_root("/data/", "xdata/file.txt"),
+            "xdata/file.txt"
+        );
+    }
+
+    #[test]
+    fn relative_to_root_handles_the_root_itself_and_a_bare_root() {
+        assert_eq!(relative_to_root("/data/", "data/"), "");
+        assert_eq!(relative_to_root("/", "file.txt"), "file.txt");
+    }
+}

data/core/services/cloudflare-kv/src/reader.rs

@@ -16,7 +16,7 @@
 // under the License.
 
 use super::backend::*;
-use super::core::parse_error;
+use super::core::{ErrorContext, parse_error};
 use super::model::*;
 use bytes::Buf;
 use http::StatusCode;
@@ -58,20 +58,22 @@ impl oio::StreamRead for CloudflareKvReader {
         let status = resp.status();
 
         if status != StatusCode::OK {
-            return Err(parse_error(resp));
+            return Err(parse_error(
+                ErrorContext::new(ServiceOperation("GetValue")),
+                resp,
+            ));
         }
 
         let resp_body = resp.into_body();
 
-        if args.if_match().is_some()
-            || args.if_none_match().is_some()
-            || args.if_modified_since().is_some()
-            || args.if_unmodified_since().is_some()
-        {
+        if args.is_conditional() {
             let meta_resp = backend.core.metadata(&self.ctx, &path).await?;
 
             if meta_resp.status() != StatusCode::OK {
-                return Err(parse_error(meta_resp));
+                return Err(parse_error(
+                    ErrorContext::new(ServiceOperation("GetMetadata")),
+                    meta_resp,
+                ));
             }
 
             let cf_response: CfKvStatResponse =
@@ -133,7 +135,10 @@ impl oio::StreamRead for CloudflareKvReader {
 
         let total_size = resp_body.len() as u64;
         let buffer = resp_body.slice(range.to_content_range(resp_body.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>,