opendal 0.1.11 → 0.1.13

data/core/services/gcs/src/core.rs

@@ -58,6 +58,10 @@ pub mod constants {
     pub const X_GOOG_ACL: &str = "x-goog-acl";
     pub const X_GOOG_STORAGE_CLASS: &str = "x-goog-storage-class";
     pub const X_GOOG_META_PREFIX: &str = "x-goog-meta-";
+
+    pub const RESPONSE_CONTENT_DISPOSITION: &str = "response-content-disposition";
+    pub const RESPONSE_CONTENT_TYPE: &str = "response-content-type";
+    pub const RESPONSE_CACHE_CONTROL: &str = "response-cache-control";
 }
 
 pub struct GcsCore {
@@ -211,7 +215,33 @@ impl GcsCore {
     ) -> Result<Request<Buffer>> {
         let p = build_abs_path(&self.root, path);
 
-        let url = format!("{}/{}/{}", self.endpoint, self.bucket, p);
+        let mut url = format!("{}/{}/{}", self.endpoint, self.bucket, p);
+
+        let mut query_args = Vec::new();
+        if let Some(override_content_disposition) = args.override_content_disposition() {
+            query_args.push(format!(
+                "{}={}",
+                constants::RESPONSE_CONTENT_DISPOSITION,
+                percent_encode_path(override_content_disposition)
+            ))
+        }
+        if let Some(override_content_type) = args.override_content_type() {
+            query_args.push(format!(
+                "{}={}",
+                constants::RESPONSE_CONTENT_TYPE,
+                percent_encode_path(override_content_type)
+            ))
+        }
+        if let Some(override_cache_control) = args.override_cache_control() {
+            query_args.push(format!(
+                "{}={}",
+                constants::RESPONSE_CACHE_CONTROL,
+                percent_encode_path(override_cache_control)
+            ))
+        }
+        if !query_args.is_empty() {
+            url.push_str(&format!("?{}", query_args.join("&")));
+        }
 
         let mut req = Request::get(&url);
 
@@ -575,7 +605,33 @@ impl GcsCore {
     ) -> Result<Request<Buffer>> {
         let p = build_abs_path(&self.root, path);
 
-        let url = format!("{}/{}/{}", self.endpoint, self.bucket, p);
+        let mut url = format!("{}/{}/{}", self.endpoint, self.bucket, p);
+
+        let mut query_args = Vec::new();
+        if let Some(override_content_disposition) = args.override_content_disposition() {
+            query_args.push(format!(
+                "{}={}",
+                constants::RESPONSE_CONTENT_DISPOSITION,
+                percent_encode_path(override_content_disposition)
+            ))
+        }
+        if let Some(override_content_type) = args.override_content_type() {
+            query_args.push(format!(
+                "{}={}",
+                constants::RESPONSE_CONTENT_TYPE,
+                percent_encode_path(override_content_type)
+            ))
+        }
+        if let Some(override_cache_control) = args.override_cache_control() {
+            query_args.push(format!(
+                "{}={}",
+                constants::RESPONSE_CACHE_CONTROL,
+                percent_encode_path(override_cache_control)
+            ))
+        }
+        if !query_args.is_empty() {
+            url.push_str(&format!("?{}", query_args.join("&")));
+        }
 
         let mut req = Request::head(&url);
 
@@ -1618,6 +1674,64 @@ mod tests {
         assert_eq!(create.headers()["x-goog-if-generation-match"], "0");
     }
 
+    #[test]
+    fn test_gcs_get_object_xml_request_with_response_overrides() {
+        let core = test_core();
+
+        let read = core
+            .gcs_get_object_xml_request(
+                "object",
+                BytesRange::default(),
+                &read_args(options::ReadOptions {
+                    override_content_disposition: Some(
+                        "attachment; filename=\"other.txt\"".to_string(),
+                    ),
+                    override_content_type: Some("application/pdf".to_string()),
+                    override_cache_control: Some("max-age=3600".to_string()),
+                    ..Default::default()
+                }),
+            )
+            .expect("read request must build");
+
+        let query = read.uri().query().unwrap();
+        assert!(
+            query.contains(
+                "response-content-disposition=attachment%3B%20filename%3D%22other.txt%22"
+            )
+        );
+        assert!(query.contains("response-content-type=application/pdf"));
+        assert!(query.contains("response-cache-control=max-age%3D3600"));
+    }
+
+    #[test]
+    fn test_gcs_head_object_xml_request_with_response_overrides() {
+        let core = test_core();
+
+        let stat = core
+            .gcs_head_object_xml_request(
+                "object",
+                &options::StatOptions {
+                    override_content_disposition: Some(
+                        "attachment; filename=\"other.txt\"".to_string(),
+                    ),
+                    override_content_type: Some("application/pdf".to_string()),
+                    override_cache_control: Some("max-age=3600".to_string()),
+                    ..Default::default()
+                }
+                .into(),
+            )
+            .expect("stat request must build");
+
+        let query = stat.uri().query().unwrap();
+        assert!(
+            query.contains(
+                "response-content-disposition=attachment%3B%20filename%3D%22other.txt%22"
+            )
+        );
+        assert!(query.contains("response-content-type=application/pdf"));
+        assert!(query.contains("response-cache-control=max-age%3D3600"));
+    }
+
     #[test]
     fn test_parse_missing_target_with_version_condition() {
         let parse_missing = |ctx| {

data/core/services/gcs-grpc/Cargo.toml

@@ -36,7 +36,7 @@ bytes = { workspace = true }
 futures = { workspace = true, features = ["async-await", "std"] }
 http = { workspace = true }
 log = { workspace = true }
-opendal-core = { path = "../../core", version = "0.59.0", default-features = false, features = [
+opendal-core = { path = "../../core", version = "0.59.2", default-features = false, features = [
   "reqsign",
 ] }
 percent-encoding = "2"

data/core/services/gcs-grpc/proto/google/storage/v2/storage.proto

@@ -1,21 +1,20 @@
-/*
- * 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.
- */
+// Copyright 2026 Google LLC
+//
+// Licensed 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.
+
+// Modified by the Apache Software Foundation: retain the wire-compatible subset
+// used by OpenDAL, with unused definitions, annotations, and imports removed.
+// Source: https://github.com/googleapis/googleapis/blob/2e9c5681901a2eebf7f547f0b60c895b1732415e/google/storage/v2/storage.proto
 
 syntax = "proto3";
 

data/core/services/gdrive/Cargo.toml

@@ -32,9 +32,9 @@ version = { workspace = true }
 all-features = true
 
 [dependencies]
-opendal-core = { path = "../../core", version = "0.59.0", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.2", default-features = false }
 
-asyncband = { workspace = true }
+asyncband = { workspace = true, features = ["mutex", "singleflight"] }
 bytes = { workspace = true }
 http = { workspace = true }
 log = { workspace = true }
@@ -42,4 +42,5 @@ serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 
 [dev-dependencies]
+asyncband = { workspace = true, features = ["semaphore"] }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }

data/core/services/gdrive/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/gdrive/src/docs.md

@@ -21,6 +21,8 @@ Google Drive allows duplicate file or directory names under the same parent.
 When multiple entries match the same path, OpenDAL resolves the most recently
 modified match, falling back to the newer creation time if needed.
 
+Concurrent directory creation through an operator and its clones reuses work for shared ancestors and allows independent paths to progress concurrently.
+
 ## Configuration
 
 Use [`crate::GdriveConfig`] for serializable configuration and this builder's

data/core/services/gdrive/src/path_index.rs

@@ -19,6 +19,7 @@ use std::collections::HashMap;
 use std::collections::VecDeque;
 
 use asyncband::mutex::Mutex;
+use asyncband::singleflight::Group;
 
 use super::core::normalize_dir_path;
 use opendal_core::raw::*;
@@ -52,7 +53,7 @@ struct GdrivePathIndexState {
 pub struct GdrivePathIndex<Q: GdrivePathQueryer> {
     query: Q,
     state: Mutex<GdrivePathIndexState>,
-    ensure_dir_lock: Mutex<()>,
+    ensure_dirs: Group<(String, String), String>,
 }
 
 impl<Q: GdrivePathQueryer> GdrivePathIndex<Q> {
@@ -60,7 +61,7 @@ impl<Q: GdrivePathQueryer> GdrivePathIndex<Q> {
         Self {
             query,
             state: Mutex::new(GdrivePathIndexState::default()),
-            ensure_dir_lock: Mutex::new(()),
+            ensure_dirs: Group::new(),
         }
     }
 
@@ -253,8 +254,6 @@ impl<Q: GdrivePathQueryer> GdrivePathIndex<Q> {
 
     /// Ensure input dir exists.
     pub async fn ensure_dir(&self, ctx: &OperationContext, path: &str) -> Result<String> {
-        let _guard = self.ensure_dir_lock.lock().await;
-
         let path = Self::canonical_dir_path(path);
         if path.is_empty() {
             return self.root_id(ctx).await;
@@ -285,17 +284,28 @@ impl<Q: GdrivePathQueryer> GdrivePathIndex<Q> {
                 }
 
                 let name = get_basename(parent);
-                let value = match self.query.query(ctx, &parent_id, name).await {
-                    Ok(Some(value)) => value,
-                    Ok(None) => match self.query.create_dir(ctx, &parent_id, name).await {
-                        Ok(value) => value,
-                        Err(err) if !refreshed && err.kind() == ErrorKind::NotFound => {
-                            refreshed = true;
-                            self.refresh_path(parent).await;
-                            continue 'retry;
+                // A refreshed ancestor has a different ID and must not join work for its old ID.
+                let result: Result<String> = self
+                    .ensure_dirs
+                    .try_work((parent_id.clone(), name.to_string()), async || {
+                        if let Some(value) = {
+                            let state = self.state.lock().await;
+                            Self::lookup_cached_id(&state.entries, parent)
+                        } {
+                            return Ok(value);
                         }
-                        Err(err) => return Err(err),
-                    },
+
+                        let value = match self.query.query(ctx, &parent_id, name).await? {
+                            Some(value) => value,
+                            None => self.query.create_dir(ctx, &parent_id, name).await?,
+                        };
+                        // Publish before completing the flight so a later caller uses the cache.
+                        self.upsert_dir(parent, &value).await;
+                        Ok(value)
+                    })
+                    .await;
+                parent_id = match result {
+                    Ok(value) => value,
                     Err(err) if !refreshed && err.kind() == ErrorKind::NotFound => {
                         refreshed = true;
                         self.refresh_path(parent).await;
@@ -303,9 +313,6 @@ impl<Q: GdrivePathQueryer> GdrivePathIndex<Q> {
                     }
                     Err(err) => return Err(err),
                 };
-
-                self.upsert_dir(parent, &value).await;
-                parent_id = value;
             }
 
             return Ok(parent_id);
@@ -317,11 +324,15 @@ impl<Q: GdrivePathQueryer> GdrivePathIndex<Q> {
 mod tests {
     use std::collections::HashMap;
     use std::collections::HashSet;
+    use std::future::Future;
     use std::sync::Arc;
     use std::sync::atomic::AtomicUsize;
     use std::sync::atomic::Ordering;
+    use std::task::Context;
+    use std::task::Waker;
 
     use asyncband::mutex::Mutex;
+    use asyncband::semaphore::Semaphore;
 
     use super::*;
 
@@ -331,6 +342,7 @@ mod tests {
         entries: Arc<Mutex<HashMap<(String, String), String>>>,
         stale_parents: Arc<Mutex<HashSet<String>>>,
         create_count: Arc<AtomicUsize>,
+        create_gate: Option<Arc<Semaphore>>,
     }
 
     impl TestQuery {
@@ -340,6 +352,7 @@ mod tests {
                 entries: Arc::new(Mutex::new(HashMap::new())),
                 stale_parents: Arc::new(Mutex::new(HashSet::new())),
                 create_count: Arc::new(AtomicUsize::new(0)),
+                create_gate: None,
             }
         }
 
@@ -390,6 +403,9 @@ mod tests {
                 return Err(Error::new(ErrorKind::NotFound, "stale parent"));
             }
             self.create_count.fetch_add(1, Ordering::SeqCst);
+            if let Some(gate) = &self.create_gate {
+                drop(gate.acquire(1).await);
+            }
             let id = format!("{parent_id}:{name}");
             self.insert(parent_id, name, &id).await;
             Ok(id)
@@ -453,7 +469,7 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_ensure_dir_is_serialized() {
+    async fn test_ensure_dir_reuses_existing_directory() {
         let query = TestQuery::new();
         query.insert("remote-root", "root/", "svc-root").await;
 
@@ -469,6 +485,81 @@ mod tests {
         assert_eq!(query.create_count.load(Ordering::SeqCst), 1);
     }
 
+    #[tokio::test]
+    async fn test_ensure_dir_coalesces_shared_ancestors() {
+        let gate = Arc::new(Semaphore::new(0));
+        let mut query = TestQuery::new();
+        query.create_gate = Some(gate.clone());
+        query.insert("remote-root", "root/", "svc-root").await;
+        let index = GdrivePathIndex::new(query.clone());
+        let ctx = OperationContext::new();
+        let mut first = Box::pin(index.ensure_dir(&ctx, "root/shared/left"));
+        let mut second = Box::pin(index.ensure_dir(&ctx, "root/shared/right"));
+        let mut cx = Context::from_waker(Waker::noop());
+
+        assert!(first.as_mut().poll(&mut cx).is_pending());
+        assert!(second.as_mut().poll(&mut cx).is_pending());
+        assert_eq!(query.create_count.load(Ordering::SeqCst), 1);
+
+        gate.release(1);
+        let (first, second) = tokio::join!(first, second);
+        assert_eq!(first.unwrap(), "svc-root:shared/:left/");
+        assert_eq!(second.unwrap(), "svc-root:shared/:right/");
+        assert_eq!(query.create_count.load(Ordering::SeqCst), 3);
+    }
+
+    #[tokio::test]
+    async fn test_ensure_dir_unrelated_paths_progress_concurrently() {
+        for (first_path, second_path) in [("root/left", "root/right"), ("left/dir", "right/dir")] {
+            let gate = Arc::new(Semaphore::new(0));
+            let mut query = TestQuery::new();
+            query.create_gate = Some(gate.clone());
+            for name in ["root/", "left/", "right/"] {
+                query.insert("remote-root", name, name).await;
+            }
+            let index = GdrivePathIndex::new(query.clone());
+            let ctx = OperationContext::new();
+            let mut first = Box::pin(index.ensure_dir(&ctx, first_path));
+            let mut second = Box::pin(index.ensure_dir(&ctx, second_path));
+            let mut cx = Context::from_waker(Waker::noop());
+
+            assert!(first.as_mut().poll(&mut cx).is_pending());
+            assert!(second.as_mut().poll(&mut cx).is_pending());
+            assert_eq!(query.create_count.load(Ordering::SeqCst), 2);
+
+            gate.release(1);
+            let (first, second) = tokio::join!(first, second);
+            assert_ne!(first.unwrap(), second.unwrap());
+        }
+    }
+
+    #[tokio::test]
+    async fn test_ensure_dir_retries_after_creator_is_cancelled() {
+        let gate = Arc::new(Semaphore::new(0));
+        let mut query = TestQuery::new();
+        query.create_gate = Some(gate.clone());
+        query.insert("remote-root", "root/", "svc-root").await;
+        let index = GdrivePathIndex::new(query.clone());
+        let ctx = OperationContext::new();
+        let mut first = Box::pin(index.ensure_dir(&ctx, "root/dir"));
+        let mut second = Box::pin(index.ensure_dir(&ctx, "root/dir"));
+        let mut cx = Context::from_waker(Waker::noop());
+
+        assert!(first.as_mut().poll(&mut cx).is_pending());
+        assert!(second.as_mut().poll(&mut cx).is_pending());
+        drop(first);
+        assert!(second.as_mut().poll(&mut cx).is_pending());
+        assert_eq!(query.create_count.load(Ordering::SeqCst), 2);
+
+        gate.release(1);
+        assert_eq!(second.await.unwrap(), "svc-root:dir/");
+        assert_eq!(
+            index.ensure_dir(&ctx, "root/dir").await.unwrap(),
+            "svc-root:dir/"
+        );
+        assert_eq!(query.create_count.load(Ordering::SeqCst), 2);
+    }
+
     #[tokio::test]
     async fn test_ensure_dir_refreshes_stale_ancestor_chain() {
         let query = TestQuery::new();

data/core/services/ghac/Cargo.toml

@@ -36,8 +36,8 @@ bytes = { workspace = true }
 ghac = { version = "0.3.0", default-features = false }
 http = { workspace = true }
 log = { workspace = true }
-opendal-core = { path = "../../core", version = "0.59.0", default-features = false }
-opendal-service-azblob = { path = "../azblob", version = "0.59.0", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.2", default-features = false }
+opendal-service-azblob = { path = "../azblob", version = "0.59.2", default-features = false }
 prost = { version = "0.14.3", default-features = false }
 reqsign-azure-storage = { version = "3.1.1", default-features = false }
 reqsign-core = { version = "3.2.0", default-features = false }

data/core/services/ghac/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/github/Cargo.toml

@@ -36,7 +36,7 @@ base64 = { workspace = true }
 bytes = { workspace = true }
 http = { workspace = true }
 log = { workspace = true }
-opendal-core = { path = "../../core", version = "0.59.0", 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/github/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/goosefs/Cargo.toml

@@ -31,16 +31,25 @@ version = { workspace = true }
 [package.metadata.docs.rs]
 all-features = true
 
+[features]
+# Keep the default GooseFS client graph to gRPC. Cache backends are opt-in so
+# applications that only need the data plane do not pull `lru`, foyer, or
+# io_uring.
+default = []
+metadata-cache = ["goosefs-sdk/metadata-cache"]
+page-cache = ["goosefs-sdk/page-cache"]
+page-cache-io-uring = ["goosefs-sdk/page-cache-io-uring"]
+
 [dependencies]
+asyncband = { workspace = true, features = ["rwlock"] }
 bytes = { workspace = true }
-goosefs-sdk = "0.1.8"
+goosefs-sdk = { version = "0.2.1", default-features = false }
 log = { workspace = true }
-opendal-core = { path = "../../core", version = "0.59.0", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.2", default-features = false }
 serde = { workspace = true, features = ["derive"] }
-tokio = { workspace = true }
 
 [dev-dependencies]
-opendal = { path = "../..", version = "0.59.0", features = [
+opendal = { path = "../..", version = "0.59.2", features = [
   "services-goosefs",
 ] }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }

data/core/services/goosefs/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/goosefs/README.md

@@ -15,12 +15,23 @@ cargo add opendal --features services-goosefs
 The service is available as `opendal::services::GooseFs`. Configure the
 service builder, then pass it to `opendal::Operator::new`.
 
+Optional client caches stay on this crate, not on the `opendal` facade. Add
+this crate as a direct dependency so Cargo unifies the features into the same
+`opendal-service-goosefs` build:
+
+```shell
+cargo add opendal-service-goosefs --features metadata-cache,page-cache
+# Linux io_uring page-cache backend:
+cargo add opendal-service-goosefs --features page-cache-io-uring
+```
+
 ## Use with `opendal-core`
 
 Add the split crates directly:
 
 ```shell
 cargo add opendal-core opendal-service-goosefs
+# Optional caches: cargo add opendal-service-goosefs --features metadata-cache,page-cache
 ```
 
 Pass a configured service builder to `Operator::new`: