opendal 0.1.12 → 0.1.13

data/core/services/hf/src/docs.md

@@ -32,6 +32,35 @@ Use [`crate::HfConfig`] for serializable configuration and this builder's
 methods for direct construction. The field and method documentation defines
 accepted values, defaults, and environment interaction.
 
+### Caching resolve results
+
+By default, every range resolves through the Hugging Face Hub in both HTTP and
+XET download modes. Enable
+[`enable_resolve_cache`](crate::Hf::enable_resolve_cache) to share resolved HTTP
+download addresses and XET file metadata across readers and batches on the same
+backend:
+
+```rust,no_run
+let builder = opendal_service_hf::Hf::default()
+    .repo_type("dataset")
+    .repo_id("username/my-dataset")
+    .enable_resolve_cache(true);
+```
+
+Enable the cache only when previously written files are not modified. Changed
+files can remain invisible while a resolved address or XET file metadata is
+reused, including changes from other clients or a floating repository revision.
+Issued signed URLs can also remain usable after Hub permissions change.
+
+The shared cache retains bounded in-memory metadata. HTTP addresses refresh
+30 seconds before their signed expiry, on the next read, or once after a cached
+request returns 401 or 403. In HTTP mode, the first resolve returns its body
+directly. Responses without supported redirect metadata or expiry continue to
+resolve normally.
+The reqwest transport supports the optional
+[`HttpRedirect`](opendal_core::HttpRedirect) extension; custom transports may omit it.
+Separate authorization identities require separately constructed backends.
+
 ## Examples
 
 ### Via Builder (Git-based dataset)

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

@@ -86,7 +86,7 @@ impl HfLister {
         recursive: bool,
         cursor: Option<&str>,
     ) -> Result<FileTree> {
-        let uri = self.core.canonical_uri(&self.ctx, path).await?;
+        let uri = self.core.repo.uri(&self.core.root, path);
         let url = uri.file_tree_url(&self.core.endpoint, recursive, cursor);
 
         let req = self
@@ -94,7 +94,7 @@ impl HfLister {
             .request(http::Method::GET, &url, Operation::List, "FileTree")?
             .body(Buffer::new())
             .map_err(new_request_build_error)?;
-        let resp = self.ctx.http_transport().fetch(req).await?;
+        let resp = self.core.send(&self.ctx, req).await?;
         if !resp.status().is_success() {
             let (parts, _) = resp.into_parts();
             return Err(parse_error(
@@ -210,7 +210,7 @@ mod tests {
 
         assert_eq!(
             mock_client.get_captured_url(),
-            "https://huggingface.co/api/models/test-user/test-repo/tree/main/?expand=True"
+            "https://huggingface.co/api/models/test-user/test-repo/tree/main?expand=True"
         );
         assert!(page_ctx.done);
         let entry = page_ctx.entries.pop_front().expect("entry must exist");

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

@@ -16,9 +16,10 @@
 // under the License.
 
 use super::backend::*;
-use super::core::{HfCore, HfDownloadMode, XetFileResponse};
+#[cfg(test)]
+use super::core::HfDownloadMode;
+use super::core::{HfCore, HfReadResponse};
 use asyncband::once::OnceCell;
-use bytes::Buf;
 use http::Response;
 use opendal_core::raw::*;
 use opendal_core::*;
@@ -45,8 +46,7 @@ fn xet_range(range: BytesRange) -> Option<Range<u64>> {
 
 impl HfReadStream {
     /// Build the stream directly from an already-known XET hash + size,
-    /// whether that came from a resolve response just parsed in [`HfReader::open`]
-    /// or was reused from its cache.
+    /// resolved or reused by [`HfCore`].
     async fn new_xet(
         group: &XetDownloadStreamGroup,
         hash: &str,
@@ -79,22 +79,6 @@ impl HfReadStream {
         let metadata = parse_into_metadata(path, resp.headers())?;
         Ok((RpRead::new(metadata), Self::Http(resp.into_body())))
     }
-
-    /// Retrieve a resolve response's XET metadata, or hand the response
-    /// back untouched if it doesn't carry any -- its body is then the
-    /// actual range content, still there for [`Self::new_http`].
-    async fn maybe_xet(
-        resp: Response<HttpBody>,
-    ) -> Result<std::result::Result<XetFileResponse, Response<HttpBody>>> {
-        if !resp.headers().contains_key("x-xet-hash") {
-            return Ok(Err(resp));
-        }
-        let (_, mut body) = resp.into_parts();
-        let buf = body.to_buffer().await?;
-        let info: XetFileResponse =
-            serde_json::from_reader(buf.reader()).map_err(new_json_deserialize_error)?;
-        Ok(Ok(info))
-    }
 }
 
 fn map_session_error(e: SessionError) -> Error {
@@ -119,17 +103,6 @@ pub struct HfReader {
     backend: HfBackend,
     ctx: OperationContext,
     path: String,
-    // `Some((hash, size))`/`None` once this path is known to be (or not be)
-    // XET-backed; only consulted in `HfDownloadMode::Xet`. Single-flighted via
-    // `get_or_try_init`, so concurrent cold opens share one classifying
-    // resolve and every later range reuses it. If not XET-backed, that first
-    // resolve's body goes unused and every open falls back to its own fresh
-    // resolve -- one wasted request per reader, not per range.
-    //
-    // Never re-validated for this reader's life, so a file changed mid-read
-    // (e.g. a new commit on a floating `main`) can serve stale content --
-    // scoped to one reader, not the `Operator`, to bound that window.
-    resolved: OnceCell<Option<(String, u64)>>,
     // Built once per reader and reused for every later XET range, seeded
     // from `HfCore`'s cached CAS token. Reuse across concurrent ranges
     // relies on the `xet` crate's documented (not type-enforced) support
@@ -143,7 +116,6 @@ impl HfReader {
             backend,
             ctx,
             path: path.to_string(),
-            resolved: OnceCell::new(),
             xet_group: OnceCell::new(),
         }
     }
@@ -163,26 +135,6 @@ impl HfReader {
             .await?;
         HfReadStream::new_xet(group, hash, size, range).await
     }
-
-    /// Classify an already-fetched resolve response and dispatch to the
-    /// matching stream. Used by [`Self::open`]'s Http-mode branch, which
-    /// classifies the same response it fetches bytes from. The Xet-mode
-    /// fallback (re-resolving in `HfDownloadMode::Http` after classification
-    /// came back non-XET) does not call this -- it never re-checks for
-    /// XET metadata on that second resolve, so it goes straight to
-    /// `new_http` instead.
-    async fn dispatch(
-        &self,
-        core: &HfCore,
-        path: &str,
-        range: BytesRange,
-        resp: Response<HttpBody>,
-    ) -> Result<(RpRead, HfReadStream)> {
-        match HfReadStream::maybe_xet(resp).await? {
-            Ok(info) => self.xet_stream(core, &info.hash, info.size, range).await,
-            Err(resp) => HfReadStream::new_http(path, resp),
-        }
-    }
 }
 
 impl oio::StreamRead for HfReader {
@@ -190,40 +142,11 @@ impl oio::StreamRead for HfReader {
         let core = &self.backend.core;
         let path = self.path.as_str();
 
-        if core.download_mode != HfDownloadMode::Xet {
-            // Http mode: resolve() is itself the byte-fetching request, done
-            // fresh per range -- there's no separate metadata step to cache.
-            let resp = core
-                .resolve(&self.ctx, path, range, core.download_mode)
-                .await?;
-            let (rp, stream) = self.dispatch(core, path, range, resp).await?;
-            return Ok((rp, Box::new(stream) as Box<dyn oio::ReadStreamDyn>));
-        }
-
-        // Xet mode: classification is single-flighted, see `resolved`'s
-        // doc comment for why that's free for the XET outcome and cheap
-        // (one extra request, once per reader) for the NotXet one.
-        let classification = self
-            .resolved
-            .get_or_try_init(|| async {
-                let resp = core
-                    .resolve(&self.ctx, path, range, HfDownloadMode::Xet)
-                    .await?;
-                match HfReadStream::maybe_xet(resp).await? {
-                    Ok(info) => Ok(Some((info.hash, info.size))),
-                    Err(_) => Ok(None),
-                }
-            })
-            .await?;
-
-        let (rp, stream) = match classification {
-            Some((hash, size)) => self.xet_stream(core, hash, *size, range).await?,
-            None => {
-                let resp = core
-                    .resolve(&self.ctx, path, range, HfDownloadMode::Http)
-                    .await?;
-                HfReadStream::new_http(path, resp)?
+        let (rp, stream) = match core.read(&self.ctx, path, range).await? {
+            HfReadResponse::Xet(info) => {
+                self.xet_stream(core, &info.hash, info.size, range).await?
             }
+            HfReadResponse::Http(resp) => HfReadStream::new_http(path, resp)?,
         };
 
         Ok((rp, Box::new(stream) as Box<dyn oio::ReadStreamDyn>))
@@ -232,7 +155,9 @@ impl oio::StreamRead for HfReader {
 
 #[cfg(test)]
 mod tests {
-    use super::super::backend::test_utils::{mbpp_operator, testing_dataset_core};
+    use super::super::backend::test_utils::{
+        mbpp_operator, miscased_mbpp_operator, testing_dataset_core,
+    };
     use super::super::core::HfRepoType;
     use super::super::core::test_utils::create_test_core;
     use super::super::core::{CommitFile, DeletedFile, HfCore};
@@ -260,6 +185,29 @@ mod tests {
         assert_eq!(xet_range(BytesRange::new(4, None)), Some(4..u64::MAX));
     }
 
+    #[tokio::test]
+    async fn test_default_reads_resolve_each_range_across_readers() -> Result<()> {
+        for mode in [HfDownloadMode::Http, HfDownloadMode::Xet] {
+            let (mut core, ctx, mock_client) = create_test_core(
+                HfRepoType::Model,
+                "test-user/test-repo",
+                "main",
+                "https://huggingface.co",
+            );
+            core.download_mode = mode;
+            let core = Arc::new(core);
+            let first = hf_reader_from_arc(core.clone(), ctx.clone(), "plain.txt");
+            let second = hf_reader_from_arc(core, ctx, "plain.txt");
+
+            for (index, reader) in [&first, &first, &second].into_iter().enumerate() {
+                let (_, mut stream) = reader.open(BytesRange::new(index as u64, Some(1))).await?;
+                assert!(!stream.read().await?.is_empty());
+                assert_eq!(mock_client.request_count(), index + 1);
+            }
+        }
+        Ok(())
+    }
+
     #[tokio::test]
     async fn test_http_read_uses_resolve_url() -> Result<()> {
         let (core, ctx, mock_client) = create_test_core(
@@ -308,26 +256,26 @@ mod tests {
     /// file has no separate metadata step to skip for its actual bytes: the
     /// classifying resolve's body is discarded and every open, including the
     /// first, fetches its own bytes with its own resolve. So the first open
-    /// costs 3 (canonical repo id + classify + fetch) and every later one
-    /// costs 1 (fetch only, classification and the canonical repo id already
-    /// cached).
+    /// costs 2 (classify + fetch) and every later one costs 1 (fetch only,
+    /// classification already cached).
     #[tokio::test]
     async fn test_non_xet_reads_cache_classification_but_still_fetch_each_range() -> Result<()> {
-        let (core, ctx, mock_client) = create_test_core(
+        let (mut core, ctx, mock_client) = create_test_core(
             HfRepoType::Model,
             "test-user/test-repo",
             "main",
             "https://huggingface.co",
         );
+        core.enable_resolve_cache = true;
         let reader = hf_reader(core, ctx, "plain.txt");
 
         let (_, mut s1) = reader.open(BytesRange::new(0, Some(1))).await?;
         s1.read().await?;
-        assert_eq!(mock_client.request_count(), 3);
+        assert_eq!(mock_client.request_count(), 2);
 
         let (_, mut s2) = reader.open(BytesRange::new(1, Some(1))).await?;
         s2.read().await?;
-        assert_eq!(mock_client.request_count(), 4);
+        assert_eq!(mock_client.request_count(), 3);
 
         Ok(())
     }
@@ -337,17 +285,16 @@ mod tests {
     /// stuck erroring for the reader's whole lifetime.
     #[tokio::test]
     async fn test_classification_retries_after_resolve_failure() -> Result<()> {
-        let (core, ctx, mock_client) = create_test_core(
+        let (mut core, ctx, mock_client) = create_test_core(
             HfRepoType::Model,
             "test-user/test-repo",
             "main",
             "https://huggingface.co",
         );
+        core.enable_resolve_cache = true;
         let reader = hf_reader(core, ctx, "plain.txt");
         mock_client.fail_next_requests(1);
 
-        // The injected failure hits the canonical repo id lookup, the first
-        // request a classifying resolve makes.
         let result = reader.open(BytesRange::new(0, Some(1))).await;
         assert!(
             result.is_err(),
@@ -359,8 +306,8 @@ mod tests {
         stream.read().await?;
         assert_eq!(
             mock_client.request_count(),
-            4,
-            "classification must retry (canonical repo id + resolve) then fetch the range (1 more)"
+            3,
+            "classification must retry (1 resolve) then fetch the range (1 more)"
         );
 
         Ok(())
@@ -373,12 +320,13 @@ mod tests {
     /// racing to build its own group.
     #[tokio::test]
     async fn test_concurrent_cold_opens_on_xet_file_share_one_group() -> Result<()> {
-        let (core, ctx, mock_client) = create_test_core(
+        let (mut core, ctx, mock_client) = create_test_core(
             HfRepoType::Model,
             "test-user/test-repo",
             "main",
             "https://huggingface.co",
         );
+        core.enable_resolve_cache = true;
         mock_client.set_xet_backed(&"00".repeat(32), 4);
         mock_client.set_xet_token_expires_at(u64::MAX);
         let reader = hf_reader(core, ctx, "xet-file.bin");
@@ -392,63 +340,68 @@ mod tests {
         r2?;
         r3?;
 
-        // 1 shared canonical repo id lookup + 1 shared classifying resolve +
-        // 1 shared xet-read-token fetch for the shared group build. Fetching
-        // actual bytes from the group would need a real CAS server, so this
-        // test only covers open().
-        assert_eq!(mock_client.request_count(), 3);
+        // 1 shared classifying resolve + 1 shared xet-read-token fetch for
+        // the shared group build. Fetching actual bytes from the group would
+        // need a real CAS server, so this test only covers open().
+        assert_eq!(mock_client.request_count(), 2);
 
         Ok(())
     }
 
-    /// Documents a known sharp edge in the single-flighted classification:
-    /// the `Range` header on the one shared classifying resolve comes from
-    /// whichever concurrent `open()` call happens to win `get_or_try_init`'s
-    /// race, not from the caller that ends up consuming the result. All
-    /// racing callers get that winner's classification regardless of their
-    /// own requested range. See `resolved`'s field doc and the review notes
-    /// on this PR -- not yet confirmed against the real HF service, so no
-    /// fix has been applied; this test only pins today's behavior so a
-    /// future change here is deliberate.
+    /// The probe asks for a fixed single byte, never the caller's range.
+    /// Verified against the live API: XET metadata is byte-identical for no
+    /// range, a head range, and a range far into the file, so one response
+    /// serves every caller -- and for a path that turns out not to be
+    /// XET-backed the discarded body is one byte instead of the whole file
+    /// (248,987 B measured before this).
     #[tokio::test]
-    async fn test_concurrent_cold_opens_classify_with_one_racing_callers_range() -> Result<()> {
-        let (core, ctx, mock_client) = create_test_core(
+    async fn test_xet_probe_uses_fixed_single_byte_range() -> Result<()> {
+        let (mut core, ctx, mock_client) = create_test_core(
             HfRepoType::Model,
             "test-user/test-repo",
             "main",
             "https://huggingface.co",
         );
-        mock_client.set_xet_backed(&"00".repeat(32), 4);
+        core.enable_resolve_cache = true;
+        mock_client.set_xet_backed(&"00".repeat(32), 64);
         mock_client.set_xet_token_expires_at(u64::MAX);
         let reader = hf_reader(core, ctx, "xet-file.bin");
 
-        let ranges = [
-            BytesRange::new(0, Some(1)),
-            BytesRange::new(10, Some(1)),
-            BytesRange::new(20, Some(1)),
-        ];
-        let (r1, r2, r3) = futures::join!(
-            reader.open(ranges[0]),
-            reader.open(ranges[1]),
-            reader.open(ranges[2]),
+        reader.open(BytesRange::new(8, Some(4))).await?;
+
+        assert_eq!(
+            mock_client.get_captured_classify_range_header().as_deref(),
+            Some("bytes=0-0"),
+            "the probe must not inherit the caller's range"
         );
-        r1?;
-        r2?;
-        r3?;
 
-        // Exactly one classifying resolve fires (see
-        // `test_concurrent_cold_opens_on_xet_file_share_one_group`), and its
-        // `Range` header must be exactly one of the three racing callers'
-        // own ranges -- not absent, and not some range not asked for by any
-        // of them.
-        let captured = mock_client
-            .get_captured_classify_range_header()
-            .expect("the shared classifying resolve must carry a Range header");
+        Ok(())
+    }
+
+    /// Http mode never classifies. HF puts `x-xet-hash` on the 302 it
+    /// answers with, not on the CDN response the transport follows it to, so
+    /// a response that does carry the header is still streamed as bytes
+    /// rather than parsed as metadata -- and no separate probe is issued.
+    #[tokio::test]
+    async fn test_http_mode_streams_bytes_without_probing() -> Result<()> {
+        let (mut core, ctx, mock_client) = create_test_core(
+            HfRepoType::Model,
+            "test-user/test-repo",
+            "main",
+            "https://huggingface.co",
+        );
+        core.download_mode = HfDownloadMode::Http;
+        mock_client.set_xet_backed(&"11".repeat(32), 64);
+        let reader = hf_reader(core, ctx, "file.bin");
+
+        let (_, mut stream) = reader.open(BytesRange::new(0, Some(4))).await?;
+        let chunk = stream.read().await?;
+
         assert!(
-            ranges.iter().any(|r| r.to_header() == captured),
-            "the shared classifying resolve's Range header ({captured:?}) must match \
-             one of the racing callers' own ranges"
+            chunk.to_bytes().starts_with(br#"{"hash""#),
+            "the body must be handed back verbatim, not parsed"
         );
+        assert_eq!(mock_client.request_count(), 1, "one resolve, no probe");
 
         Ok(())
     }
@@ -459,12 +412,13 @@ mod tests {
     /// it isn't XET-backed. Each still fetches its own range afterward.
     #[tokio::test]
     async fn test_concurrent_cold_opens_share_one_classifying_resolve() -> Result<()> {
-        let (core, ctx, mock_client) = create_test_core(
+        let (mut core, ctx, mock_client) = create_test_core(
             HfRepoType::Model,
             "test-user/test-repo",
             "main",
             "https://huggingface.co",
         );
+        core.enable_resolve_cache = true;
         let reader = hf_reader(core, ctx, "plain.txt");
 
         let (r1, r2, r3) = futures::join!(
@@ -476,12 +430,43 @@ mod tests {
         r2?.1.read().await?;
         r3?.1.read().await?;
 
-        // 1 canonical repo id lookup + 1 shared classifying resolve + 3 individual fetches.
-        assert_eq!(mock_client.request_count(), 5);
+        // 1 shared classifying resolve + 3 individual fetches.
+        assert_eq!(mock_client.request_count(), 4);
 
         Ok(())
     }
 
+    /// Regression test for #8107 against the live API: a repo id whose case
+    /// differs from the canonical one.
+    ///
+    /// `stat` is the operation that matters here. It posts to `paths-info`,
+    /// and HF answers a miscased id with a `307` carrying a path-only
+    /// `Location`. A transport will follow that for a `GET` but hands a
+    /// bodied `POST` back unfollowed, which is exactly the failure #8107
+    /// reported, so this only passes if `HfCore::send` re-issues the request.
+    /// The read then covers the `resolve` path through the same repo. Both
+    /// use a public dataset, so no token is needed.
+    #[tokio::test]
+    #[ignore = "requires network access"]
+    async fn test_miscased_repo_id_follows_redirects() {
+        let path = "full/train-00000-of-00001.parquet";
+        let op = miscased_mbpp_operator();
+
+        let meta = op
+            .stat(path)
+            .await
+            .expect("stat must follow the case redirect on its paths-info POST");
+        assert!(meta.content_length() > 0);
+
+        let bytes = op
+            .read_with(path)
+            .range(0..4)
+            .await
+            .expect("read must succeed against a miscased repo id")
+            .to_vec();
+        assert_eq!(bytes, PARQUET_MAGIC);
+    }
+
     /// Exercises the XET download code path against a public dataset known to
     /// have XET-stored files. Behavior tests cannot reliably cover this path
     /// because the test dataset may not contain any XET files.
@@ -576,8 +561,8 @@ mod tests {
 
     /// Exercises the group-reuse path for real: two ranges fetched through
     /// the same `Reader` (mirroring `object_store::get_ranges`) must both
-    /// return correct bytes even though only the first call resolves the
-    /// XET hash and builds the CAS download group.
+    /// return correct bytes while each call resolves the XET hash and the
+    /// reader reuses its CAS download group.
     #[tokio::test]
     #[ignore = "requires network access"]
     async fn test_read_xet_multiple_ranges_on_one_reader() {

data/core/services/http/Cargo.toml

@@ -22,7 +22,7 @@ license = "Apache-2.0"
 name = "opendal-service-http"
 readme = "README.md"
 repository = "https://github.com/apache/opendal"
-version = "0.59.1"
+version = "0.59.2"
 
 [package.metadata.docs.rs]
 all-features = true
@@ -30,9 +30,9 @@ all-features = true
 [dependencies]
 http = "1.4"
 log = "0.4"
-opendal-core = { path = "../../core", version = "0.59.1", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.2", default-features = false }
 serde = { version = "1", features = ["derive"] }
 
 [dev-dependencies]
-opendal-core = { path = "../../core", version = "0.59.1", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.2", default-features = false }
 tokio = { version = "1.52", features = ["macros", "rt-multi-thread"] }

data/core/services/http/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/services/ipfs/Cargo.toml

@@ -35,7 +35,7 @@ all-features = true
 bytes = { workspace = true }
 http = { workspace = true }
 log = { workspace = true }
-opendal-core = { path = "../../core", version = "0.59.1", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.2", default-features = false }
 prost = "0.14.3"
 serde = { workspace = true, features = ["derive"] }
 

data/core/services/ipfs/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/services/ipmfs/Cargo.toml

@@ -32,7 +32,7 @@ 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 }
 
 bytes = { workspace = true }
 http = { workspace = true }

data/core/services/ipmfs/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/services/koofr/Cargo.toml

@@ -32,11 +32,11 @@ version = { workspace = true }
 all-features = true
 
 [dependencies]
-asyncband = { workspace = true }
+asyncband = { workspace = true, features = ["mutex", "once-cell"] }
 bytes = { workspace = true }
 http = { workspace = true }
 log = { workspace = true }
-opendal-core = { path = "../../core", version = "0.59.1", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.2", default-features = false }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 

data/core/services/koofr/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/services/lakefs/Cargo.toml

@@ -35,7 +35,7 @@ all-features = true
 bytes = { workspace = true }
 http = { workspace = true }
 log = { workspace = true }
-opendal-core = { path = "../../core", version = "0.59.1", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.2", default-features = false }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }