opendal 0.1.12 → 0.1.13

data/core/core/LICENSE

@@ -199,3 +199,19 @@
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
+
+
+------------------------------------------------------------------------------------
+This product bundles third-party components under other open source licenses.
+This section summarizes those components and their licenses. See the referenced
+license files for text of these licenses.
+
+
+Creative Commons Zero v1.0 Universal
+------------------------------------
+
+bindings/dotnet/.gitignore
+
+The above file is derived from VisualStudio.gitignore in
+https://github.com/github/gitignore. Its license text is in
+bindings/dotnet/LICENSE-CC0-1.0.txt.

data/core/core/src/docs/upgrade.md

@@ -1,3 +1,11 @@
+# Unreleased
+
+## Raw API
+
+### Submit tasks through `ConcurrentTasks::execute`
+
+`raw::ConcurrentTasks::create_task` has been removed. Submit inputs with `execute()` and collect outputs in submission order with `next()`. These methods keep task ownership, completion accounting, and retry handling inside the queue. If code needs input data after successful completion, include that data in the factory's output type.
+
 # Upgrade to v0.59
 
 ## Public API

data/core/core/src/lib.rs

@@ -15,9 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#![doc(
-    html_logo_url = "https://raw.githubusercontent.com/apache/opendal/main/website/static/img/logo.svg"
-)]
+#![doc(html_logo_url = "https://opendal.apache.org/img/logo.svg")]
 #![doc = include_str!("../README.md")]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 #![cfg_attr(docsrs, doc(auto_cfg))]

data/core/core/src/raw/futures_util.rs

@@ -63,7 +63,10 @@ impl<T: Send> MaybeSend for T {}
 #[cfg(target_arch = "wasm32")]
 impl<T> MaybeSend for T {}
 
-/// ConcurrentTasks is used to execute tasks concurrently.
+/// ConcurrentTasks executes tasks concurrently and collects outputs in submission order.
+///
+/// Submit inputs with [`Self::execute`] and collect outputs with [`Self::next`].
+/// The queue owns the task handles and tracks their completion for concurrency control.
 ///
 /// ConcurrentTasks has two generic types:
 ///
@@ -75,20 +78,20 @@ impl<T> MaybeSend for T {}
 /// The code patterns below are intentional; please do not modify them unless you fully understand these notes.
 ///
 /// ```skip
-///  let (i, o) = self
+///  let result = self
 ///     .tasks
 ///     .front_mut()                                        // Use `front_mut` instead of `pop_front`
 ///     .expect("tasks must be available")
 ///     .await;
 /// ...
-/// match o {
+/// match result {
 ///     Ok(o) => {
 ///         let _ = self.tasks.pop_front();                 // `pop_front` after got `Ok(o)`
 ///         self.results.push_back(o)
 ///     }
-///     Err(err) => {
+///     Err((i, err)) => {
 ///         if err.is_temporary() {
-///             let task = self.create_task(i);
+///             let task = self.spawn_task(i);
 ///             self.tasks
 ///                 .front_mut()
 ///                 .expect("tasks must be available")
@@ -128,7 +131,7 @@ pub struct ConcurrentTasks<I, O> {
     /// to poll the tasks to see if they are ready.
     ///
     /// Dropping task without `await` it will cancel the task.
-    tasks: VecDeque<Task<(I, Result<O>)>>,
+    tasks: VecDeque<Task<Result<O, (I, Error)>>>,
     /// `results` stores the successful results.
     results: VecDeque<O>,
 
@@ -202,13 +205,15 @@ impl<I: Send + 'static, O: Send + 'static> ConcurrentTasks<I, O> {
         !self.results.is_empty()
     }
 
-    /// Create a task with given input.
-    pub fn create_task(&self, input: I) -> Task<(I, Result<O>)> {
+    fn spawn_task(&self, input: I) -> Task<Result<O, (I, Error)>> {
         let completed = self.completed_but_unretrieved.clone();
-
-        let fut = (self.factory)(input).inspect(move |_| {
-            completed.fetch_add(1, Ordering::Relaxed);
-        });
+        let fut = (self.factory)(input)
+            // Completed tasks can remain queued while the caller produces more work.
+            // Only failures need to retain their input for a retry.
+            .map(|(input, result)| result.map_err(|err| (input, err)))
+            .inspect(move |_| {
+                completed.fetch_add(1, Ordering::Relaxed);
+            });
 
         self.executor.execute(fut)
     }
@@ -240,22 +245,22 @@ impl<I: Send + 'static, O: Send + 'static> ConcurrentTasks<I, O> {
         }
 
         if !self.has_remaining() {
-            let (i, o) = self
+            let result = self
                 .tasks
                 .front_mut()
                 .expect("tasks must be available")
                 .await;
             self.completed_but_unretrieved
                 .fetch_sub(1, Ordering::Relaxed);
-            match o {
+            match result {
                 Ok(o) => {
                     let _ = self.tasks.pop_front();
                     self.results.push_back(o)
                 }
-                Err(err) => {
+                Err((i, err)) => {
                     // Retry this task if the error is temporary
                     if err.is_temporary() {
-                        let task = self.create_task(i);
+                        let task = self.spawn_task(i);
                         self.tasks
                             .front_mut()
                             .expect("tasks must be available")
@@ -269,7 +274,7 @@ impl<I: Send + 'static, O: Send + 'static> ConcurrentTasks<I, O> {
             }
         }
 
-        self.tasks.push_back(self.create_task(input));
+        self.tasks.push_back(self.spawn_task(input));
         Ok(())
     }
 
@@ -287,18 +292,18 @@ impl<I: Send + 'static, O: Send + 'static> ConcurrentTasks<I, O> {
         }
 
         if let Some(task) = self.tasks.front_mut() {
-            let (i, o) = task.await;
+            let result = task.await;
             self.completed_but_unretrieved
                 .fetch_sub(1, Ordering::Relaxed);
-            return match o {
+            return match result {
                 Ok(o) => {
                     let _ = self.tasks.pop_front();
                     Some(Ok(o))
                 }
-                Err(err) => {
+                Err((i, err)) => {
                     // Retry this task if the error is temporary
                     if err.is_temporary() {
-                        let task = self.create_task(i);
+                        let task = self.spawn_task(i);
                         self.tasks
                             .front_mut()
                             .expect("tasks must be available")

data/core/core/src/raw/http_util/error.rs

@@ -62,6 +62,15 @@ pub fn with_error_response_context(mut err: Error, mut parts: Parts) -> Error {
     parts.headers.remove("WWW-Authenticate");
     parts.headers.remove("Proxy-Authenticate");
 
+    if parts.headers.contains_key(http::header::LOCATION) {
+        let location = crate::HttpUri::from_response_location(&mut parts)
+            .map(|uri| uri.redacted_uri())
+            .unwrap_or("<invalid URL>")
+            .parse()
+            .unwrap_or_else(|_| http::HeaderValue::from_static("<invalid URL>"));
+        parts.headers.insert(http::header::LOCATION, location);
+    }
+
     err = err.with_context("response", format!("{parts:?}"));
 
     err

data/core/core/src/raw/ops.rs

@@ -1520,6 +1520,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(target_pointer_width = "64")]
     fn compact_operation_layouts() {
         assert_eq!(size_of::<OpRead>(), 16);
         assert_eq!(size_of::<OpStat>(), 16);

data/core/core/src/types/http_transport/mod.rs

@@ -36,12 +36,16 @@ use crate::types::Result;
 mod body;
 pub use body::HttpBody;
 
+mod uri;
+pub use uri::{HttpRedirect, HttpUri};
+
 static DEFAULT_HTTP_TRANSPORTER: OnceLock<HttpTransporter> = OnceLock::new();
 
 /// HTTP transport used by OpenDAL services.
 ///
 /// Implement this trait to provide a custom HTTP backend. A transport must
 /// support 3xx redirection.
+/// It can support [`HttpRedirect`] to let services reuse redirect destinations.
 pub trait HttpTransport: Send + Sync + Unpin + 'static {
     /// Fetch a request and return a streamable [`HttpBody`].
     #[cfg(not(target_arch = "wasm32"))]
@@ -114,8 +118,32 @@ impl HttpTransporter {
     }
 
     /// Fetch a request and return a streamable [`HttpBody`].
-    pub async fn fetch(&self, req: Request<Buffer>) -> Result<Response<HttpBody>> {
-        self.inner.fetch_dyn(req).await
+    ///
+    /// Mark credential headers as sensitive for diagnostics without changing
+    /// their values.
+    pub async fn fetch(&self, mut req: Request<Buffer>) -> Result<Response<HttpBody>> {
+        // Mark credentials at the shared boundary before any transport wrapper
+        // formats the request. Values on the wire remain unchanged.
+        for (name, value) in req.headers_mut() {
+            if matches!(
+                name.as_str(),
+                "authorization" | "proxy-authorization" | "cookie" | "cookie2"
+            ) {
+                value.set_sensitive(true);
+            }
+        }
+        let mut resp = self.inner.fetch_dyn(req).await?;
+        for (name, value) in resp.headers_mut() {
+            if matches!(
+                name.as_str(),
+                "set-cookie" | "www-authenticate" | "proxy-authenticate"
+            ) {
+                value.set_sensitive(true);
+            }
+        }
+        let (mut parts, body) = resp.into_parts();
+        HttpUri::from_response_location(&mut parts);
+        Ok(Response::from_parts(parts, body))
     }
 }
 

data/core/core/src/types/http_transport/uri.rs

@@ -0,0 +1,166 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::fmt::{Debug, Formatter};
+use std::sync::Arc;
+
+use percent_encoding::percent_decode_str;
+
+/// An HTTP URI or relative location with a precomputed diagnostic representation.
+///
+/// Construction preserves the original spelling and masks user information and
+/// recognized credential query values in a separate representation. It does not
+/// validate, resolve, or normalize the URI. Ordinary query values remain intact.
+/// Clones share both representations; formatting does not repeat redaction.
+///
+/// Recognized query names are `Signature`, `Policy`, `token`, `access_token`,
+/// `X-Amz-Signature`, and `X-Amz-Security-Token`, matched case-insensitively after
+/// decoding the name. Arbitrary application parameters are not classified.
+#[derive(Clone)]
+pub struct HttpUri {
+    original: Arc<str>,
+    redacted: Arc<str>,
+}
+
+impl HttpUri {
+    /// Retain the original URI and compute its diagnostic representation once.
+    pub fn new(uri: impl Into<Arc<str>>) -> Self {
+        let original = uri.into();
+        let redacted = redact_uri(&original).into();
+        Self { original, redacted }
+    }
+
+    /// Return the original URI, including any credentials it contains.
+    pub fn original_uri(&self) -> &str {
+        &self.original
+    }
+
+    /// Return the URI with recognized credentials masked for diagnostics.
+    pub fn redacted_uri(&self) -> &str {
+        &self.redacted
+    }
+
+    /// Get or create the diagnostic value for a response's `Location` header.
+    ///
+    /// Store it in response extensions so service errors and shared response
+    /// diagnostics reuse the same value. If a wrapper changes the header,
+    /// replace the cached value. Return `None` for missing or non-text headers.
+    /// The original header is not changed.
+    pub fn from_response_location(parts: &mut http::response::Parts) -> Option<&Self> {
+        let location = parts.headers.get(http::header::LOCATION)?.to_str().ok()?;
+        if parts
+            .extensions
+            .get::<Self>()
+            .is_none_or(|uri| uri.original_uri() != location)
+        {
+            let uri = Self::new(location);
+            parts.extensions.insert(uri);
+        }
+        parts.extensions.get::<Self>()
+    }
+}
+
+impl Debug for HttpUri {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("HttpUri")
+            .field(&self.redacted_uri())
+            .finish()
+    }
+}
+
+/// A reusable HTTP redirect handled by the transport.
+///
+/// A transport that supports this extension may return it with a response after
+/// following redirects. Services can copy it into later request extensions to
+/// reuse that destination while keeping the original request URI for diagnostics.
+/// The transport must send to the destination and apply its redirect credential
+/// policy, including credentials supplied by client defaults.
+///
+/// The destination retains its original and redacted representations in
+/// [`HttpUri`]. Only the transport should use the original as a request URI.
+/// Services may inspect it to determine whether reuse is valid, but must use
+/// the redacted representation for diagnostics. This extension alone does not
+/// establish that the original path still selects the same object. Transports
+/// that do not support reusable redirects must not return it.
+#[derive(Clone)]
+pub struct HttpRedirect(HttpUri);
+
+impl HttpRedirect {
+    /// Record a destination that this transport can reuse.
+    pub fn new(uri: http::Uri) -> Self {
+        Self(HttpUri::new(uri.to_string()))
+    }
+
+    /// Return the destination's original and diagnostic representations.
+    pub fn uri(&self) -> &HttpUri {
+        &self.0
+    }
+}
+
+impl Debug for HttpRedirect {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("HttpRedirect")
+            .field(&self.0.redacted_uri())
+            .finish()
+    }
+}
+
+fn redact_uri(value: &str) -> String {
+    let mut value = value.to_string();
+    let authority_start = value
+        .split_once("://")
+        .filter(|(scheme, _)| {
+            scheme.eq_ignore_ascii_case("http") || scheme.eq_ignore_ascii_case("https")
+        })
+        .map(|(scheme, _)| scheme.len() + 3)
+        .or_else(|| value.starts_with("//").then_some(2));
+    if let Some(start) = authority_start {
+        let end = value[start..]
+            .find(['/', '?', '#'])
+            .map_or(value.len(), |offset| start + offset);
+        if let Some(offset) = value[start..end].rfind('@') {
+            value.replace_range(start..start + offset, "[REDACTED]");
+        }
+    }
+
+    let end = value.find('#').unwrap_or(value.len());
+    if let Some(start) = value[..end].find('?') {
+        let query = value[start + 1..end]
+            .split('&')
+            .map(|pair| {
+                let Some((key, _)) = pair.split_once('=') else {
+                    return pair.to_string();
+                };
+                let name = percent_decode_str(key).decode_utf8_lossy();
+                match name.to_ascii_lowercase().as_str() {
+                    "signature"
+                    | "policy"
+                    | "token"
+                    | "access_token"
+                    | "x-amz-signature"
+                    | "x-amz-security-token" => {
+                        format!("{key}=[REDACTED]")
+                    }
+                    _ => pair.to_string(),
+                }
+            })
+            .collect::<Vec<_>>()
+            .join("&");
+        value.replace_range(start + 1..end, &query);
+    }
+    value
+}

data/core/core/src/types/metadata.rs

@@ -743,6 +743,7 @@ mod tests {
     use super::*;
 
     #[test]
+    #[cfg(target_pointer_width = "64")]
     fn metadata_layout_is_40_bytes() {
         assert_eq!(size_of::<MetadataHeader>(), 24);
         assert_eq!(size_of::<CompactValues>(), 16);

data/core/core/src/types/mod.rs

@@ -25,8 +25,10 @@ pub(crate) mod compact;
 
 mod http_transport;
 pub use http_transport::HttpBody;
+pub use http_transport::HttpRedirect;
 pub use http_transport::HttpTransport;
 pub use http_transport::HttpTransporter;
+pub use http_transport::HttpUri;
 
 mod entry;
 pub use entry::Entry;

data/core/http-transports/reqwest/Cargo.toml

@@ -53,7 +53,7 @@ bytes = { workspace = true }
 futures = { workspace = true, features = ["std"] }
 http = { workspace = true }
 http-body = "1"
-opendal-core = { path = "../../core", version = "0.59.1", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.2", default-features = false }
 reqwest = { version = "0.13.4", features = [
   "stream",
 ], default-features = false }

data/core/http-transports/reqwest/LICENSE

@@ -199,3 +199,19 @@
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
+
+
+------------------------------------------------------------------------------------
+This product bundles third-party components under other open source licenses.
+This section summarizes those components and their licenses. See the referenced
+license files for text of these licenses.
+
+
+Creative Commons Zero v1.0 Universal
+------------------------------------
+
+bindings/dotnet/.gitignore
+
+The above file is derived from VisualStudio.gitignore in
+https://github.com/github/gitignore. Its license text is in
+bindings/dotnet/LICENSE-CC0-1.0.txt.

data/core/http-transports/reqwest/src/lib.rs

@@ -32,6 +32,7 @@ use opendal_core::Buffer;
 use opendal_core::Error;
 use opendal_core::ErrorKind;
 use opendal_core::HttpBody;
+use opendal_core::HttpRedirect;
 use opendal_core::HttpTransport;
 use opendal_core::HttpTransporter;
 use opendal_core::Result;
@@ -79,15 +80,43 @@ impl HttpTransport for ReqwestTransport {
         let uri = req.uri().clone();
         let is_head = req.method() == http::Method::HEAD;
 
-        let (parts, body) = req.into_parts();
+        let (mut parts, body) = req.into_parts();
+        let original = uri.to_string();
+        let target = parts
+            .extensions
+            .get::<HttpRedirect>()
+            .map(|redirect| redirect.uri().original_uri())
+            .unwrap_or(&original);
 
-        let url = reqwest::Url::parse(&uri.to_string()).map_err(|err| {
+        let url = reqwest::Url::parse(target).map_err(|err| {
             Error::new(ErrorKind::Unexpected, "request url is invalid")
                 .with_operation("reqwest::fetch")
                 .with_context("url", uri.to_string())
                 .set_source(err)
         })?;
 
+        if parts.extensions.get::<HttpRedirect>().is_some() {
+            let original = reqwest::Url::parse(&uri.to_string()).map_err(|err| {
+                Error::new(ErrorKind::Unexpected, "original request url is invalid").set_source(err)
+            })?;
+            if original.origin() != url.origin() {
+                // A reused redirect must not gain credentials from client
+                // defaults or cookie storage that a normal redirect strips.
+                for name in [
+                    "authorization",
+                    "proxy-authorization",
+                    "cookie",
+                    "cookie2",
+                    "www-authenticate",
+                ] {
+                    parts.headers.insert(
+                        http::header::HeaderName::from_static(name),
+                        http::HeaderValue::from_static(""),
+                    );
+                }
+            }
+        }
+
         let mut req_builder = self
             .client
             .request(parts.method, url)
@@ -116,7 +145,7 @@ impl HttpTransport for ReqwestTransport {
                 .with_operation("reqwest::send")
                 .with_context("url", uri.to_string())
                 .with_temporary(is_temporary_error(&err))
-                .set_source(err)
+                .set_source(err.without_url())
         })?;
 
         // Get content length from header so that we can check it.
@@ -135,6 +164,19 @@ impl HttpTransport for ReqwestTransport {
             // it later.
             .extension(uri.clone());
 
+        // Optional metadata must not turn a successful fetch into an error.
+        if let Ok(target) = resp.url().as_str().parse::<http::Uri>()
+            && target != uri
+        {
+            let redirect = parts
+                .extensions
+                .get::<HttpRedirect>()
+                .filter(|redirect| redirect.uri().original_uri() == resp.url().as_str())
+                .cloned()
+                .unwrap_or_else(|| HttpRedirect::new(target));
+            hr = hr.extension(redirect);
+        }
+
         // Response builder under wasm doesn't support set version.
         #[cfg(not(target_arch = "wasm32"))]
         {
@@ -153,7 +195,7 @@ impl HttpTransport for ReqwestTransport {
                         .with_operation("reqwest::fetch")
                         .with_context("url", uri.to_string())
                         .with_temporary(is_temporary_error(&err))
-                        .set_source(err)
+                        .set_source(err.without_url())
                 }),
             content_length,
         );

data/core/layers/async-backtrace/Cargo.toml

@@ -33,7 +33,7 @@ all-features = true
 
 [dependencies]
 async-backtrace = "0.2.6"
-opendal-core = { path = "../../core", version = "0.59.1", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.2", default-features = false }
 
 [dev-dependencies]
-opendal-core = { path = "../../core", version = "0.59.1" }
+opendal-core = { path = "../../core", version = "0.59.2" }

data/core/layers/async-backtrace/LICENSE

@@ -199,3 +199,19 @@
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
+
+
+------------------------------------------------------------------------------------
+This product bundles third-party components under other open source licenses.
+This section summarizes those components and their licenses. See the referenced
+license files for text of these licenses.
+
+
+Creative Commons Zero v1.0 Universal
+------------------------------------
+
+bindings/dotnet/.gitignore
+
+The above file is derived from VisualStudio.gitignore in
+https://github.com/github/gitignore. Its license text is in
+bindings/dotnet/LICENSE-CC0-1.0.txt.

data/core/layers/await-tree/Cargo.toml

@@ -34,7 +34,7 @@ all-features = true
 [dependencies]
 await-tree = "0.3"
 futures = { workspace = true }
-opendal-core = { path = "../../core", version = "0.59.1", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.2", default-features = false }
 
 [dev-dependencies]
-opendal-core = { path = "../../core", version = "0.59.1" }
+opendal-core = { path = "../../core", version = "0.59.2" }

data/core/layers/await-tree/LICENSE

@@ -199,3 +199,19 @@
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
+
+
+------------------------------------------------------------------------------------
+This product bundles third-party components under other open source licenses.
+This section summarizes those components and their licenses. See the referenced
+license files for text of these licenses.
+
+
+Creative Commons Zero v1.0 Universal
+------------------------------------
+
+bindings/dotnet/.gitignore
+
+The above file is derived from VisualStudio.gitignore in
+https://github.com/github/gitignore. Its license text is in
+bindings/dotnet/LICENSE-CC0-1.0.txt.

data/core/layers/capability-check/Cargo.toml

@@ -32,8 +32,8 @@ version = { workspace = true }
 all-features = true
 
 [dependencies]
-opendal-core = { path = "../../core", version = "0.59.1", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.2", default-features = false }
 
 [dev-dependencies]
-opendal-core = { path = "../../core", version = "0.59.1" }
+opendal-core = { path = "../../core", version = "0.59.2" }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }

data/core/layers/capability-check/LICENSE

@@ -199,3 +199,19 @@
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
+
+
+------------------------------------------------------------------------------------
+This product bundles third-party components under other open source licenses.
+This section summarizes those components and their licenses. See the referenced
+license files for text of these licenses.
+
+
+Creative Commons Zero v1.0 Universal
+------------------------------------
+
+bindings/dotnet/.gitignore
+
+The above file is derived from VisualStudio.gitignore in
+https://github.com/github/gitignore. Its license text is in
+bindings/dotnet/LICENSE-CC0-1.0.txt.

data/core/layers/chaos/Cargo.toml

@@ -32,8 +32,8 @@ version = { workspace = true }
 all-features = true
 
 [dependencies]
-opendal-core = { path = "../../core", version = "0.59.1", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.2", default-features = false }
 rand = { workspace = true }
 
 [dev-dependencies]
-opendal-core = { path = "../../core", version = "0.59.1" }
+opendal-core = { path = "../../core", version = "0.59.2" }