opendal 0.1.12 → 0.1.13

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.1", default-features = false }
-opendal-service-azblob = { path = "../azblob", version = "0.59.1", 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.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/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.9"
+goosefs-sdk = { version = "0.2.1", default-features = false }
 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"] }
-tokio = { workspace = true }
 
 [dev-dependencies]
-opendal = { path = "../..", version = "0.59.1", 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`:

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

@@ -228,11 +228,9 @@ fn detect_master_addr_source() -> MasterAddrSource {
         return MasterAddrSource::Env;
     }
 
-    // The SDK searches `$GOOSEFS_CONFIG_FILE`, `$GOOSEFS_HOME/conf`,
-    // `~/.goosefs`, and `/etc/goosefs` for `goosefs-site.properties`. It
-    // documents `$GOOSEFS_CONF_DIR` as well, but 0.1.9 looks up the Java
-    // property name `goosefs.conf.dir` as the environment variable, so that
-    // path never matches. An unreadable file is left to
+    // The SDK searches `$GOOSEFS_CONFIG_FILE`, `$GOOSEFS_CONF_DIR`,
+    // `$GOOSEFS_HOME/conf`, `~/.goosefs`, and `/etc/goosefs` for
+    // `goosefs-site.properties`. An unreadable file is left to
     // `from_properties_auto()`, which already failed the build above.
     if let Some(path) = goosefs_sdk::config::discover_config_file()
         && let Ok(content) = std::fs::read_to_string(&path)

data/core/services/goosefs/src/core.rs

@@ -19,12 +19,12 @@ use std::fmt::Debug;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicU32, Ordering};
 
+use asyncband::rwlock::RwLock;
 use goosefs_sdk::client::MasterClient;
 use goosefs_sdk::config::GoosefsConfig as ClientConfig;
 use goosefs_sdk::context::FileSystemContext;
 use goosefs_sdk::io::{GoosefsFileReader, GoosefsFileWriter};
 use goosefs_sdk::proto::grpc::file::FileInfo;
-use tokio::sync::RwLock;
 
 use opendal_core::raw::*;
 use opendal_core::*;

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

@@ -23,6 +23,8 @@ which means it connects directly to GooseFS Master (port 9200) and
 Worker (port 9203) without requiring a Proxy component.
 
 Features:
+- **Read metadata**: Streams expose full-file metadata from the SDK reader before
+  consuming the body. Bounded reads do not issue a separate stat to obtain it.
 - **HA support**: Comma-separated master addresses for automatic Primary Master discovery.
 - **Block-level I/O**: Data reads/writes go through block-level gRPC bidirectional streaming.
 - **Consistent hash routing**: Worker selection uses consistent hashing on block IDs.
@@ -32,6 +34,9 @@ Features:
 - **Rename parent directories**: `rename` creates a missing destination parent only
   when Master reports it missing. Write-via-temp publish does not call
   `CreateDirectory` for a parent that `CreateFile(recursive)` already created.
+- **Optional client caches**: `goosefs-sdk` 0.2.1 keeps metadata and page caches
+  behind Cargo features so the default build stays a gRPC client. Enable them
+  on this crate; see [Optional client caches](#optional-client-caches).
 
 ## Configuration
 
@@ -48,9 +53,8 @@ first:
    list or the SDK's `gfs://h1:9200,h2:9200/root` URI form;
 2. `goosefs.master.rpc.addresses` or `goosefs.master.hostname` in
    `goosefs-site.properties`, discovered through `$GOOSEFS_CONFIG_FILE`,
-   `$GOOSEFS_HOME/conf`, `~/.goosefs`, and `/etc/goosefs`. `goosefs-sdk` 0.1.9
-   documents `$GOOSEFS_CONF_DIR` as a search path but does not read it, so use
-   `$GOOSEFS_CONFIG_FILE` to point at a file outside those directories;
+   `$GOOSEFS_CONF_DIR`, `$GOOSEFS_HOME/conf`, `~/.goosefs`, and `/etc/goosefs`.
+   Use `$GOOSEFS_CONFIG_FILE` to point at a file outside those directories;
 3. the `master_addr` config key, which also receives the URI authority of
    `goosefs://host:port/path`.
 
@@ -68,6 +72,43 @@ address; it never falls back to `127.0.0.1:9200`.
 | absent, or no master keys | unset | set | `master_addr` |
 | absent, or no master keys | unset | absent | none — `ConfigInvalid` |
 
+### Optional client caches
+
+`goosefs-sdk` 0.2.1 compiles the client metadata cache and the disk-backed page
+cache only when their Cargo features are enabled. The default
+`services-goosefs` / `opendal-service-goosefs` build stays a gRPC client.
+
+Enable a cache on this crate. Applications that use the `opendal` facade still
+add `opendal-service-goosefs` as a direct dependency so Cargo unifies the
+features into the same build:
+
+| Feature | Compiles |
+| --- | --- |
+| `metadata-cache` | Process-local status / listing LRU |
+| `page-cache` | Disk-backed page cache via `tokio::fs` |
+| `page-cache-io-uring` | Page cache plus the Linux io_uring backend |
+
+```shell
+cargo add opendal --features services-goosefs
+cargo add opendal-service-goosefs --features metadata-cache,page-cache-io-uring
+```
+
+`page-cache-io-uring` already enables `page-cache`. On non-Linux targets the
+SDK still builds the portable `tokio::fs` store; io_uring is Linux-only.
+
+Compiling a cache does not replace runtime configuration. `build()` loads
+`goosefs-site.properties` and `GOOSEFS_*` environment variables through
+`GoosefsConfig::from_properties_auto()`:
+
+- **Metadata cache**: on by default once `metadata-cache` is compiled. Set
+  `GOOSEFS_METADATA_CACHE_ENABLED=false` to disable it.
+- **Page cache**: off by default. Set `GOOSEFS_USER_CLIENT_CACHE_ENABLED=true`
+  and configure cache directories through
+  `goosefs.user.client.cache.dirs` / `GOOSEFS_USER_CLIENT_CACHE_DIRS`.
+
+See [goosefs-sdk client configuration](https://github.com/Tencent/tencent-goosefs-rust-sdk/blob/main/docs/CLIENT_CONFIGURATION.md)
+for the full cache knob list.
+
 ## Example
 
 ### Via Builder

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

@@ -16,94 +16,25 @@
 // under the License.
 
 use super::backend::*;
-use super::core::GoosefsCore;
 use super::core::{ErrorContext, parse_error};
 use goosefs_sdk::io::GoosefsFileReader as SdkReader;
 use opendal_core::raw::*;
 use opendal_core::*;
-use std::sync::Arc;
 
 pub struct GoosefsReadStream {
-    core: Arc<GoosefsCore>,
-    path: String,
-    range: BytesRange,
-    content_length: Option<u64>,
-    /// Lazily-opened SDK reader. `None` until the first `read()` call.
-    inner: Option<SdkReader>,
-    /// Terminal flag: once the underlying stream has returned `None`,
-    /// subsequent `read()` calls must keep returning an empty `Buffer`
-    /// without re-entering the SDK (which would try to open a fresh
-    /// stream and re-read the file).
+    inner: SdkReader,
+    // The SDK may reopen its stream after EOF; keep OpenDAL's EOF terminal.
     done: bool,
 }
 
-impl GoosefsReadStream {
-    pub fn new(
-        core: Arc<GoosefsCore>,
-        path: String,
-        range: BytesRange,
-        content_length: Option<u64>,
-    ) -> Self {
-        GoosefsReadStream {
-            core,
-            path,
-            range,
-            content_length,
-            inner: None,
-            done: false,
-        }
-    }
-
-    /// Open the underlying SDK reader, picking between the full-file
-    /// and ranged variants based on `self.range`.
-    async fn open(&self) -> Result<SdkReader> {
-        let offset = self.range.offset();
-        let size = self.range.size();
-
-        // Three cases:
-        //   1. No offset and no size      → full-file stream.
-        //   2. Offset+size both set       → ranged stream.
-        //   3. Offset set, size unbounded → resolve tail length via
-        //      get_status and fall through to the ranged opener, so we
-        //      still get per-block streaming (rather than buffering the
-        //      whole tail in one call).
-        match (offset, size) {
-            (0, None) => self.core.open_reader(&self.path).await,
-            (off, Some(len)) => self.core.open_range_reader(&self.path, off, len).await,
-            (off, None) => {
-                let content_length = self.content_length.ok_or_else(|| {
-                    Error::new(
-                        ErrorKind::Unexpected,
-                        "content length must be known for offset reads",
-                    )
-                })?;
-                let len = content_length.saturating_sub(off);
-                if len == 0 {
-                    // Empty tail — short-circuit with a zero-length
-                    // ranged open so the very next `read_next_block`
-                    // call returns `None` and we EOF cleanly.
-                    self.core.open_range_reader(&self.path, off, 0).await
-                } else {
-                    self.core.open_range_reader(&self.path, off, len).await
-                }
-            }
-        }
-    }
-}
-
 impl oio::ReadStream for GoosefsReadStream {
     async fn read(&mut self) -> Result<Buffer> {
         if self.done {
             return Ok(Buffer::new());
         }
 
-        // Lazy open on first call.
-        if self.inner.is_none() {
-            self.inner = Some(self.open().await?);
-        }
-        let reader = self.inner.as_mut().expect("inner was just set");
-
-        match reader
+        match self
+            .inner
             .read_next_block()
             .await
             .map_err(|err| parse_error(ErrorContext::new(ServiceOperation("ReadNextBlock")), err))?
@@ -137,25 +68,27 @@ impl oio::StreamRead for GoosefsReader {
         let backend = &self.backend;
         let path = self.path.as_str();
 
-        let content_length = if range.offset() != 0 && range.size().is_none() {
-            let file_info = backend.core.get_status(path).await?;
-            Some(
-                backend
+        let inner = match (range.offset(), range.size()) {
+            (0, None) => backend.core.open_reader(path).await?,
+            (offset, Some(length)) => backend.core.open_range_reader(path, offset, length).await?,
+            (offset, None) => {
+                let file_info = backend.core.get_status(path).await?;
+                let content_length = backend
                     .core
                     .file_info_to_metadata(&file_info)?
-                    .content_length(),
-            )
-        } else {
-            None
+                    .content_length();
+                backend
+                    .core
+                    .open_range_reader(path, offset, content_length.saturating_sub(offset))
+                    .await?
+            }
         };
-        let rp = RpRead::default();
-        let stream = GoosefsReadStream::new(
-            backend.core.clone(),
-            path.to_string(),
-            range,
-            content_length,
-        );
+        let metadata = backend.core.file_info_to_metadata(inner.file_info())?;
+        let stream = GoosefsReadStream { inner, done: false };
 
-        Ok((rp, Box::new(stream) as Box<dyn oio::ReadStreamDyn>))
+        Ok((
+            RpRead::new(metadata),
+            Box::new(stream) as Box<dyn oio::ReadStreamDyn>,
+        ))
     }
 }

data/core/services/gridfs/Cargo.toml

@@ -32,10 +32,10 @@ version = { workspace = true }
 all-features = true
 
 [dependencies]
-asyncband = { workspace = true }
+asyncband = { workspace = true, features = ["once-cell"] }
 futures = { workspace = true }
 mongodb = "3.3.0"
-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"] }
 
 [dev-dependencies]

data/core/services/gridfs/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.