opendal 0.1.9 → 0.1.11

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

@@ -19,8 +19,8 @@ use std::sync::Arc;
 
 use http::StatusCode;
 
-use super::core::DbfsCore;
 use super::core::parse_error;
+use super::core::{DbfsCore, ErrorContext};
 use opendal_core::raw::*;
 use opendal_core::*;
 
@@ -58,8 +58,11 @@ impl oio::OneShotWrite for DbfsWriter {
 
         let status = resp.status();
         match status {
-            StatusCode::CREATED | StatusCode::OK => Ok(Metadata::default()),
-            _ => Err(parse_error(resp)),
+            StatusCode::CREATED | StatusCode::OK => Ok(MetadataBuilder::unknown().build()),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("Put")),
+                resp,
+            )),
         }
     }
 }

data/core/services/dropbox/Cargo.toml

@@ -32,10 +32,10 @@ version = { workspace = true }
 all-features = true
 
 [dependencies]
+asyncband = { workspace = true }
 bytes = { workspace = true }
 http = { workspace = true }
-mea = { 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/dropbox/src/backend.rs

@@ -30,7 +30,7 @@ use opendal_core::*;
 
 use std::fmt::Debug;
 
-use mea::mutex::Mutex;
+use asyncband::mutex::Mutex;
 
 use super::DROPBOX_SCHEME;
 use super::config::DropboxConfig;
@@ -200,6 +200,7 @@ impl Service for DropboxBackend {
     type Lister = oio::PageLister<DropboxLister>;
     type Deleter = oio::OneShotDeleter<DropboxDeleter>;
     type Copier = oio::OneShotCopier;
+    type Composer = ();
 
     fn info(&self) -> ServiceInfo {
         self.core.info.clone()
@@ -250,27 +251,32 @@ impl Service for DropboxBackend {
                     _ => EntryMode::Unknown,
                 };
 
-                let mut metadata = Metadata::new(entry_mode);
+                let mut metadata = match entry_mode {
+                    EntryMode::FILE => {
+                        MetadataBuilder::file(decoded_response.size.ok_or_else(|| {
+                            Error::new(
+                                ErrorKind::Unexpected,
+                                format!("no size found for file {path}"),
+                            )
+                        })?)
+                    }
+                    EntryMode::DIR => MetadataBuilder::dir(),
+                    EntryMode::Unknown => MetadataBuilder::unknown(),
+                };
                 // Only set last_modified and size if entry_mode is FILE, because Dropbox API
                 // returns last_modified and size only for files.
                 // FYI: https://www.dropbox.com/developers/documentation/http/documentation#files-get_metadata
                 if entry_mode == EntryMode::FILE {
                     let date_utc_last_modified =
                         decoded_response.client_modified.parse::<Timestamp>()?;
-                    metadata.set_last_modified(date_utc_last_modified);
-
-                    if let Some(size) = decoded_response.size {
-                        metadata.set_content_length(size);
-                    } else {
-                        return Err(Error::new(
-                            ErrorKind::Unexpected,
-                            format!("no size found for file {path}"),
-                        ));
-                    }
+                    metadata.last_modified(date_utc_last_modified);
                 }
-                Ok(RpStat::new(metadata))
+                Ok(RpStat::new(metadata.build()))
             }
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("GetMetadata")),
+                resp,
+            )),
         }
     }
     fn read(&self, ctx: &OperationContext, path: &str, args: OpRead) -> Result<Self::Reader> {
@@ -330,7 +336,6 @@ impl Service for DropboxBackend {
         from: &str,
         to: &str,
         _: OpCopy,
-        _opts: OpCopier,
     ) -> Result<Self::Copier> {
         let core = self.core.clone();
         let ctx = ctx.clone();
@@ -342,14 +347,16 @@ impl Service for DropboxBackend {
             let status = resp.status();
 
             match status {
-                StatusCode::OK => Ok(Metadata::default()),
-                _ => {
-                    let err = parse_error(resp);
-                    match err.kind() {
-                        ErrorKind::NotFound => Ok(Metadata::default()),
-                        _ => Err(err),
-                    }
+                StatusCode::OK => {
+                    let decoded_response: DropboxMetadataResponse =
+                        serde_json::from_reader(resp.into_body().reader())
+                            .map_err(new_json_deserialize_error)?;
+                    DropboxWriter::parse_metadata(decoded_response)
                 }
+                _ => Err(parse_error(
+                    ErrorContext::new(ServiceOperation("CopyFile")),
+                    resp,
+                )),
             }
         }))
     }
@@ -368,7 +375,7 @@ impl Service for DropboxBackend {
         match status {
             StatusCode::OK => Ok(RpRename::default()),
             _ => {
-                let err = parse_error(resp);
+                let err = parse_error(ErrorContext::new(ServiceOperation("MoveFile")), resp);
                 match err.kind() {
                     ErrorKind::NotFound => Ok(RpRename::default()),
                     _ => Err(err),

data/core/services/dropbox/src/core.rs

@@ -18,6 +18,7 @@
 use std::fmt::Debug;
 use std::sync::Arc;
 
+use asyncband::mutex::Mutex;
 use bytes::Buf;
 use bytes::Bytes;
 use http::Request;
@@ -26,7 +27,6 @@ use http::StatusCode;
 use http::header;
 use http::header::CONTENT_LENGTH;
 use http::header::CONTENT_TYPE;
-use mea::mutex::Mutex;
 use serde::Deserialize;
 use serde::Serialize;
 
@@ -224,7 +224,7 @@ impl DropboxCore {
         match status {
             StatusCode::OK => Ok(RpCreateDir::default()),
             _ => {
-                let err = parse_error(resp);
+                let err = parse_error(ErrorContext::new(ServiceOperation("CreateFolder")), resp);
                 match err.kind() {
                     ErrorKind::AlreadyExists => Ok(RpCreateDir::default()),
                     _ => Err(err),
@@ -529,75 +529,77 @@ pub struct DropboxListResponse {
     pub has_more: bool,
 }
 
-mod error {
-    use http::Response;
-    use http::StatusCode;
-    use serde::Deserialize;
+#[derive(Default, Debug, Deserialize)]
+#[serde(default)]
+pub struct DropboxErrorResponse {
+    pub error_summary: String,
+}
 
-    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,
+}
 
-    #[derive(Default, Debug, Deserialize)]
-    #[serde(default)]
-    pub struct DropboxErrorResponse {
-        pub error_summary: String,
+impl ErrorContext {
+    pub(crate) const fn new(service_operation: ServiceOperation) -> Self {
+        Self { service_operation }
     }
+}
 
-    /// 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),
-            StatusCode::FORBIDDEN => (ErrorKind::PermissionDenied, false),
-            StatusCode::TOO_MANY_REQUESTS => (ErrorKind::RateLimited, true),
-            StatusCode::INTERNAL_SERVER_ERROR
-            | StatusCode::BAD_GATEWAY
-            | StatusCode::SERVICE_UNAVAILABLE
-            | StatusCode::GATEWAY_TIMEOUT => (ErrorKind::Unexpected, true),
-            _ => (ErrorKind::Unexpected, false),
-        };
-
-        let (message, dropbox_err) = serde_json::from_slice::<DropboxErrorResponse>(&bs)
-            .map(|dropbox_err| (format!("{dropbox_err:?}"), Some(dropbox_err)))
-            .unwrap_or_else(|_| (String::from_utf8_lossy(&bs).into_owned(), None));
-
-        if let Some(dropbox_err) = dropbox_err {
-            (kind, retryable) = parse_dropbox_error_summary(&dropbox_err.error_summary)
-                .unwrap_or((kind, retryable));
-        }
-
-        let mut err = Error::new(kind, message);
+/// 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),
+        StatusCode::FORBIDDEN => (ErrorKind::PermissionDenied, false),
+        StatusCode::TOO_MANY_REQUESTS => (ErrorKind::RateLimited, true),
+        StatusCode::INTERNAL_SERVER_ERROR
+        | StatusCode::BAD_GATEWAY
+        | StatusCode::SERVICE_UNAVAILABLE
+        | StatusCode::GATEWAY_TIMEOUT => (ErrorKind::Unexpected, true),
+        _ => (ErrorKind::Unexpected, false),
+    };
+
+    let (message, dropbox_err) = serde_json::from_slice::<DropboxErrorResponse>(&bs)
+        .map(|dropbox_err| (format!("{dropbox_err:?}"), Some(dropbox_err)))
+        .unwrap_or_else(|_| (String::from_utf8_lossy(&bs).into_owned(), None));
+
+    if let Some(dropbox_err) = dropbox_err {
+        (kind, retryable) =
+            parse_dropbox_error_summary(&dropbox_err.error_summary).unwrap_or((kind, retryable));
+    }
 
-        err = with_error_response_context(err, parts);
+    let mut err = Error::new(kind, message);
 
-        if retryable {
-            err = err.set_temporary();
-        }
+    err = err.with_context("service_operation", ctx.service_operation.0);
+    err = with_error_response_context(err, parts);
 
-        err
+    if retryable {
+        err = err.set_temporary();
     }
 
-    /// We cannot get the error type from the response header when the status code is 409.
-    /// Because Dropbox API v2 will put error summary in the response body,
-    /// we need to parse it to get the correct error type and then error kind.
-    ///
-    /// See <https://www.dropbox.com/developers/documentation/http/documentation#error-handling>
-    pub fn parse_dropbox_error_summary(summary: &str) -> Option<(ErrorKind, bool)> {
-        if summary.starts_with("path/not_found")
-            || summary.starts_with("path_lookup/not_found")
-            || summary.starts_with("from_lookup/not_found")
-        {
-            Some((ErrorKind::NotFound, false))
-        } else if summary.starts_with("path/conflict") {
-            Some((ErrorKind::AlreadyExists, false))
-        } else if summary.starts_with("too_many_write_operations") {
-            Some((ErrorKind::RateLimited, true))
-        } else {
-            None
-        }
-    }
+    err
 }
 
-pub(super) use error::*;
+/// We cannot get the error type from the response header when the status code is 409.
+/// Because Dropbox API v2 will put error summary in the response body,
+/// we need to parse it to get the correct error type and then error kind.
+///
+/// See <https://www.dropbox.com/developers/documentation/http/documentation#error-handling>
+pub fn parse_dropbox_error_summary(summary: &str) -> Option<(ErrorKind, bool)> {
+    if summary.starts_with("path/not_found")
+        || summary.starts_with("path_lookup/not_found")
+        || summary.starts_with("from_lookup/not_found")
+    {
+        Some((ErrorKind::NotFound, false))
+    } else if summary.starts_with("path/conflict") {
+        Some((ErrorKind::AlreadyExists, false))
+    } else if summary.starts_with("too_many_write_operations") {
+        Some((ErrorKind::RateLimited, true))
+    } else {
+        None
+    }
+}

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

@@ -44,7 +44,7 @@ impl oio::OneShotDelete for DropboxDeleter {
         match status {
             StatusCode::OK => Ok(()),
             _ => {
-                let err = parse_error(resp);
+                let err = parse_error(ErrorContext::new(ServiceOperation("DeleteFile")), resp);
                 match err.kind() {
                     ErrorKind::NotFound => Ok(()),
                     _ => Err(err),

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

@@ -68,7 +68,14 @@ impl oio::PageList for DropboxLister {
         let status_code = response.status();
 
         if !status_code.is_success() {
-            let error = parse_error(response);
+            let error = parse_error(
+                ErrorContext::new(if ctx.token.is_empty() {
+                    ServiceOperation("ListFolder")
+                } else {
+                    ServiceOperation("ListFolderContinue")
+                }),
+                response,
+            );
 
             let result = match error.kind() {
                 ErrorKind::NotFound => Ok(()),
@@ -91,7 +98,13 @@ impl oio::PageList for DropboxLister {
             };
 
             let mut name = entry.name;
-            let mut meta = Metadata::new(entry_mode);
+            let mut meta = match entry_mode {
+                EntryMode::FILE => entry
+                    .size
+                    .map_or_else(MetadataBuilder::unknown, MetadataBuilder::file),
+                EntryMode::DIR => MetadataBuilder::dir(),
+                EntryMode::Unknown => MetadataBuilder::unknown(),
+            };
 
             // Dropbox will return folder names that do not end with '/'.
             if entry_mode == EntryMode::DIR && !name.ends_with('/') {
@@ -101,14 +114,10 @@ impl oio::PageList for DropboxLister {
             // The behavior here aligns with Dropbox's stat function.
             if entry_mode == EntryMode::FILE {
                 let date_utc_last_modified = entry.client_modified.parse::<Timestamp>()?;
-                meta.set_last_modified(date_utc_last_modified);
-
-                if let Some(size) = entry.size {
-                    meta.set_content_length(size);
-                }
+                meta.last_modified(date_utc_last_modified);
             }
 
-            ctx.entries.push_back(oio::Entry::with(name, meta));
+            ctx.entries.push_back(oio::Entry::with(name, meta.build()));
         }
 
         if decoded_response.has_more {

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

@@ -65,7 +65,10 @@ impl oio::StreamRead for DropboxReader {
             _ => {
                 let (part, mut body) = resp.into_parts();
                 let buf = body.to_buffer().await?;
-                return Err(parse_error(Response::from_parts(part, buf)));
+                return Err(parse_error(
+                    ErrorContext::new(ServiceOperation("DownloadFile")),
+                    Response::from_parts(part, buf),
+                ));
             }
         };
 

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

@@ -21,7 +21,7 @@ use bytes::Buf;
 use http::StatusCode;
 
 use super::core::parse_error;
-use super::core::{DropboxCore, DropboxMetadataResponse};
+use super::core::{DropboxCore, DropboxMetadataResponse, ErrorContext};
 use opendal_core::raw::*;
 use opendal_core::*;
 
@@ -42,30 +42,30 @@ impl DropboxWriter {
         }
     }
 
-    fn parse_metadata(decoded_response: DropboxMetadataResponse) -> Result<Metadata> {
-        let mut metadata = Metadata::default();
+    pub(crate) fn parse_metadata(decoded_response: DropboxMetadataResponse) -> Result<Metadata> {
+        let mut metadata = MetadataBuilder::unknown();
 
         if let Some(size) = decoded_response.size {
-            metadata.set_content_length(size);
+            metadata.set_file(size);
         }
 
         if let Some(content_hash) = decoded_response.content_hash {
-            metadata.set_etag(&content_hash);
+            metadata.etag(&content_hash);
         }
 
         if let Some(rev) = decoded_response.rev {
-            metadata.set_version(&rev);
+            metadata.version(&rev);
         }
 
         if let Some(server_modified) = decoded_response.server_modified {
             let date_utc = server_modified.parse::<Timestamp>()?;
-            metadata.set_last_modified(date_utc);
+            metadata.last_modified(date_utc);
         } else {
             let date_utc = decoded_response.client_modified.parse::<Timestamp>()?;
-            metadata.set_last_modified(date_utc);
+            metadata.last_modified(date_utc);
         }
 
-        Ok(metadata)
+        Ok(metadata.build())
     }
 }
 
@@ -84,7 +84,10 @@ impl oio::OneShotWrite for DropboxWriter {
                 let metadata = DropboxWriter::parse_metadata(decoded_response)?;
                 Ok(metadata)
             }
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("UploadFile")),
+                resp,
+            )),
         }
     }
 }

data/core/services/etcd/Cargo.toml

@@ -34,7 +34,7 @@ all-features = true
 [dependencies]
 etcd-client = { version = "0.19.0", features = ["tls"] }
 fastpool = "1.0.2"
-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"] }
 tokio = { workspace = true, features = ["time"] }
 

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

@@ -209,6 +209,7 @@ impl Service for EtcdBackend {
     type Lister = oio::HierarchyLister<EtcdLazyLister>;
     type Deleter = oio::OneShotDeleter<EtcdDeleter>;
     type Copier = ();
+    type Composer = ();
 
     fn info(&self) -> ServiceInfo {
         self.info.clone()
@@ -246,9 +247,12 @@ impl Service for EtcdBackend {
         // First check if it's a direct key
         match self.core.get(&abs_path).await? {
             Some(buffer) => {
-                let mut metadata = Metadata::new(EntryMode::from_path(&abs_path));
-                metadata.set_content_length(buffer.len() as u64);
-                Ok(RpStat::new(metadata))
+                let metadata = if abs_path.ends_with('/') {
+                    MetadataBuilder::dir()
+                } else {
+                    MetadataBuilder::file(buffer.len() as u64)
+                };
+                Ok(RpStat::new(metadata.build()))
             }
             None => {
                 // Check if it's a directory by looking for keys with this prefix
@@ -262,7 +266,7 @@ impl Service for EtcdBackend {
                 let has_children = self.core.has_prefix(&prefix).await?;
                 if has_children {
                     // Has children, it's a directory
-                    let metadata = Metadata::new(EntryMode::DIR);
+                    let metadata = MetadataBuilder::dir().build();
                     Ok(RpStat::new(metadata))
                 } else {
                     Err(Error::new(ErrorKind::NotFound, "path not found"))
@@ -324,7 +328,6 @@ impl Service for EtcdBackend {
         _from: &str,
         _to: &str,
         _args: OpCopy,
-        _opts: OpCopier,
     ) -> Result<Self::Copier> {
         Err(Error::new(
             ErrorKind::Unsupported,

data/core/services/etcd/src/core.rs

@@ -148,16 +148,10 @@ impl EtcdCore {
     }
 }
 
-mod error {
-    use etcd_client::Error as EtcdError;
+use etcd_client::Error as EtcdError;
 
-    use opendal_core::{Error, ErrorKind};
-
-    pub fn format_etcd_error(e: EtcdError) -> Error {
-        Error::new(ErrorKind::Unexpected, e.to_string().as_str())
-            .set_source(e)
-            .set_temporary()
-    }
+pub fn format_etcd_error(e: EtcdError) -> Error {
+    Error::new(ErrorKind::Unexpected, e.to_string().as_str())
+        .set_source(e)
+        .set_temporary()
 }
-
-pub(super) use error::*;

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

@@ -69,7 +69,12 @@ impl oio::List for EtcdLister {
             if key.starts_with(&self.path) {
                 let path = build_rel_path(&self.root, &key);
 
-                let entry = Entry::new(&path, Metadata::new(EntryMode::from_path(&key)));
+                let metadata = if key.ends_with('/') {
+                    MetadataBuilder::dir()
+                } else {
+                    MetadataBuilder::unknown()
+                };
+                let entry = Entry::new(&path, metadata.build());
                 return Ok(Some(entry));
             }
         }

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

@@ -44,7 +44,10 @@ impl oio::StreamRead for EtcdReader {
             Some(buffer) => {
                 let total_size = buffer.len() as u64;
                 let sliced_buffer = buffer.slice(range.to_content_range(buffer.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),

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

@@ -48,10 +48,13 @@ impl oio::Write for EtcdWriter {
 
         self.core.set(&self.path, buf.clone()).await?;
 
-        let mut metadata = Metadata::new(EntryMode::from_path(&self.path));
-        metadata.set_content_length(buf.len() as u64);
+        let metadata = if self.path.ends_with('/') {
+            MetadataBuilder::dir()
+        } else {
+            MetadataBuilder::file(buf.len() as u64)
+        };
 
-        Ok(metadata)
+        Ok(metadata.build())
     }
 
     async fn abort(&mut self) -> Result<()> {

data/core/services/foundationdb/Cargo.toml

@@ -36,7 +36,7 @@ foundationdb = { version = "0.11.0", features = [
   "embedded-fdb-include",
   "fdb-7_3",
 ] }
-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/foundationdb/src/backend.rs

@@ -126,6 +126,7 @@ impl Service for FoundationdbBackend {
     type Lister = ();
     type Deleter = oio::OneShotDeleter<FoundationdbDeleter>;
     type Copier = ();
+    type Composer = ();
 
     fn info(&self) -> ServiceInfo {
         self.info.clone()
@@ -151,13 +152,14 @@ impl Service for FoundationdbBackend {
         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 {
             let bs = self.core.get(&p).await?;
             match bs {
-                Some(bs) => Ok(RpStat::new(
-                    Metadata::new(EntryMode::FILE).with_content_length(bs.len() as u64),
-                )),
+                Some(bs) => Ok(RpStat::new({
+                    let metadata = MetadataBuilder::file(bs.len() as u64);
+                    metadata.build()
+                })),
                 None => Err(Error::new(
                     ErrorKind::NotFound,
                     "kv not found in foundationdb",
@@ -210,7 +212,6 @@ impl Service for FoundationdbBackend {
         _from: &str,
         _to: &str,
         _args: OpCopy,
-        _opts: OpCopier,
     ) -> Result<Self::Copier> {
         Err(Error::new(
             ErrorKind::Unsupported,

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

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

@@ -48,8 +48,12 @@ impl oio::Write for FoundationdbWriter {
         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/foyer/Cargo.toml

@@ -34,12 +34,12 @@ all-features = true
 [dependencies]
 foyer = { version = "0.22.3" }
 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]
-opendal = { path = "../..", version = "0.58.1", features = ["services-memory"] }
-opendal-core = { path = "../../core", version = "0.58.1", features = [
+opendal = { path = "../..", version = "0.59.0", features = ["services-memory"] }
+opendal-core = { path = "../../core", version = "0.59.0", features = [
   "services-memory",
 ] }
 size = "0.5"