opendal 0.1.8 → 0.1.9

data/core/services/goosefs/README.md

@@ -0,0 +1,56 @@
+# Apache OpenDAL™ GooseFS Service
+
+`opendal-service-goosefs` provides access to GooseFS through its native gRPC API for
+applications built with Apache OpenDAL™.
+
+## Use through `opendal`
+
+Applications should normally enable this service through the `opendal` facade with the
+`services-goosefs` feature:
+
+```shell
+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`.
+
+## Use with `opendal-core`
+
+Add the split crates directly:
+
+```shell
+cargo add opendal-core opendal-service-goosefs
+```
+
+Pass a configured service builder to `Operator::new`:
+
+```rust
+use opendal_core::{Operator, OperatorRegistry, Result};
+use opendal_service_goosefs::{register_goosefs_service, GooseFs};
+
+fn build_operator(builder: GooseFs) -> Result<Operator> {
+    Operator::new(builder)
+}
+
+fn register_for_uri() {
+    register_goosefs_service(OperatorRegistry::get());
+}
+```
+
+`register_for_uri` is only needed for scheme-driven construction through
+`Operator::from_uri` or `Operator::via_iter`.
+
+Services that send HTTP requests also require an HTTP transport in
+`OperationContext`. See the
+[`opendal-core` composition example](https://crates.io/crates/opendal-core).
+
+## Documentation
+
+- [Service configuration and examples](https://opendal.apache.org/services/goosefs)
+- [Rust API documentation](https://docs.rs/opendal-service-goosefs)
+- [Apache OpenDAL documentation](https://opendal.apache.org/docs/)
+
+## License
+
+Licensed under the Apache License, Version 2.0.

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

@@ -67,9 +67,10 @@ impl GoosefsBuilder {
     /// When provided here it **overrides** any address discovered from
     /// `goosefs-site.properties` or `GOOSEFS_MASTER_ADDR`. When left unset
     /// the builder falls back to the SDK's auto-discovery chain
-    /// (defaults → properties → env) — see `goosefs-sdk`
-    /// `docs/CLIENT_CONFIGURATION.md` §1. `build()` fails with
-    /// `ConfigInvalid` only if **no** source supplies a master address.
+    /// (defaults → properties → env) — see
+    /// [goosefs-sdk `docs/CLIENT_CONFIGURATION.md`](https://github.com/Tencent/tencent-goosefs-rust-sdk/blob/main/docs/CLIENT_CONFIGURATION.md)
+    /// §1. `build()` fails with `ConfigInvalid` only if **no** source
+    /// supplies a master address.
     pub fn master_addr(mut self, addr: &str) -> Self {
         if !addr.is_empty() {
             self.config.master_addr = Some(addr.to_string());
@@ -128,16 +129,17 @@ impl Builder for GoosefsBuilder {
 
     /// Build the backend and return a GoosefsBackend.
     fn build(self) -> Result<impl Service> {
-        debug!("GoosefsBuilder::build started: {:?}", &self);
+        debug!("GoosefsBuilder::build started: {:?}", self);
 
         let root = normalize_root(&self.config.root.clone().unwrap_or_default());
-        debug!("GoosefsBuilder use root {}", &root);
+        debug!("GoosefsBuilder use root {}", root);
 
         // ── Step 1: establish the base SDK config ─────────────────────────────
         //
         // We follow the same priority chain that `FileSystemContext::connect`
         // (and its `ConfigRefresher`) uses — see
-        // `docs/CLIENT_CONFIGURATION.md` §1 "Configuration Loading Priority":
+        // https://github.com/Tencent/tencent-goosefs-rust-sdk/blob/main/docs/CLIENT_CONFIGURATION.md
+        // §1 "Configuration Loading Priority":
         //
         //   defaults  <  goosefs-site.properties  <  GOOSEFS_* env vars
         //
@@ -210,7 +212,7 @@ impl Builder for GoosefsBuilder {
         }
         debug!(
             "GoosefsBuilder use master_addr {} (addrs={:?})",
-            &goosefs_config.master_addr, &goosefs_config.master_addrs
+            goosefs_config.master_addr, goosefs_config.master_addrs
         );
 
         if let Some(block_size) = self.config.block_size {
@@ -274,14 +276,16 @@ impl Builder for GoosefsBuilder {
                     read: true,
                     write: true,
                     write_can_multi: true,
-                    // GooseFS createFile fails with AlreadyExists if file exists,
-                    // which naturally provides if_not_exists semantics.
-                    // Lance Dataset relies on this for manifest commit safety.
+                    // Authoritative Create: write-via-temp then
+                    // GoosefsCore::rename(..., if_not_exists=true), backed by Master
+                    // no-replace rename. Not CreateFile on the final path
+                    // (writes go to .opendal.tmp.*).
                     write_with_if_not_exists: true,
                     create_dir: true,
                     delete: true,
                     list: true,
                     rename: true,
+                    rename_with_if_not_exists: true,
                     shared: true,
                     ..Default::default()
                 },
@@ -385,9 +389,9 @@ impl Service for GoosefsBackend {
         _ctx: &OperationContext,
         from: &str,
         to: &str,
-        _: OpRename,
+        args: OpRename,
     ) -> Result<RpRename> {
-        self.core.rename(from, to).await?;
+        self.core.rename(from, to, args.if_not_exists()).await?;
         Ok(RpRename::default())
     }
 
@@ -444,4 +448,19 @@ mod tests {
             "unexpected error message: {err}"
         );
     }
+
+    #[test]
+    fn test_capability_rename_with_if_not_exists() {
+        let backend = GoosefsBuilder::default()
+            .root("/data")
+            .master_addr("127.0.0.1:9200")
+            .build()
+            .expect("build");
+        let cap = backend.capability();
+        assert!(cap.write_with_if_not_exists);
+        assert!(
+            cap.rename_with_if_not_exists,
+            "rename_with_if_not_exists must be declared for Create publish"
+        );
+    }
 }

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

@@ -45,7 +45,7 @@ pub struct GoosefsConfig {
     /// `PollingMasterInquireClient` to discover the Primary Master automatically.
     ///
     /// Resolution precedence at `build()` time (highest → lowest), following
-    /// `goosefs-sdk` `docs/CLIENT_CONFIGURATION.md` §1:
+    /// [goosefs-sdk `docs/CLIENT_CONFIGURATION.md`](https://github.com/Tencent/tencent-goosefs-rust-sdk/blob/main/docs/CLIENT_CONFIGURATION.md) §1:
     ///   1. This field (when set on the builder / OpenDAL config map)
     ///   2. `GOOSEFS_MASTER_ADDR` environment variable
     ///   3. `goosefs.master.rpc.addresses` / `goosefs.master.hostname` in

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

@@ -231,7 +231,9 @@ impl GoosefsCore {
 
     pub async fn delete(&self, path: &str) -> Result<()> {
         let full = self.full_path(path);
-        let master = self.master().await?;
+        let ctx = self.ctx().await?;
+        let master = ctx.acquire_master();
+        ctx.invalidate_file_info(&full);
         match master.delete(&full, false).await {
             Ok(()) => Ok(()),
             Err(e) => {
@@ -245,29 +247,37 @@ impl GoosefsCore {
         }
     }
 
-    pub async fn rename(&self, from: &str, to: &str) -> Result<()> {
+    /// Rename `from` → `to`.
+    ///
+    /// When `if_not_exists` is true this is the authoritative publish step for
+    /// `write_with_if_not_exists` (Lance `PutMode::Create`). Conflict detection
+    /// is GooseFS Master no-replace rename
+    /// (`DefaultFileSystemMaster.renameInternal` → `FileAlreadyExistsException`
+    /// → gRPC ALREADY_EXISTS), reached via `MasterClient::rename`. Not a prior
+    /// `get_status`. Destination must never be deleted when `if_not_exists` is
+    /// true.
+    ///
+    /// Mirror HDFS / Alluxio semantics so GooseFS passes OpenDAL's behavior
+    /// contract for rename:
+    ///
+    /// 1. Destination parent directory is created on demand.
+    /// 2. If the destination exists as a file and `if_not_exists` is false,
+    ///    overwrite by deleting it first. Never delete when `if_not_exists`
+    ///    is true (that would destroy Master no-replace and re-introduce
+    ///    TOCTOU overwrite).
+    /// 3. If the destination exists as a directory, surface `IsADirectory`.
+    ///
+    /// Source NotFound is reported by the underlying `rename` RPC, so we
+    /// don't pre-stat the source.
+    pub async fn rename(&self, from: &str, to: &str, if_not_exists: bool) -> Result<()> {
         let src = self.full_path(from);
         let dst = self.full_path(to);
-        let master = self.master().await?;
+        let ctx = self.ctx().await?;
+        let master = ctx.acquire_master();
+
+        ctx.invalidate_file_info(&src);
+        ctx.invalidate_file_info(&dst);
 
-        // Mirror HDFS / Alluxio semantics so GooseFS passes OpenDAL's
-        // behavior contract for rename (see `rename_test.go::testRenameNested`
-        // and `testRenameOverwrite`):
-        //
-        //   1. Destination parent directory is created on demand
-        //      (`testRenameNested` writes to `<uuid>/<uuid>/<uuid>` without
-        //      mkdir'ing intermediate levels first; S3-style backends treat
-        //      this as implicit, fs-style backends must emulate it).
-        //   2. If the destination exists as a file, overwrite by deleting
-        //      it first (`testRenameOverwrite`). GooseFS `rename` itself
-        //      would otherwise return AlreadyExists.
-        //   3. If the destination exists as a directory, surface
-        //      IsADirectory — matches the error code the behavior tests
-        //      assert in `testRenameTargetDir`.
-        //
-        // Source NotFound is reported by the underlying `rename` RPC
-        // (`testRenameNonExistingSource` expects `NotFound`), so we don't
-        // pre-stat the source.
         match master.get_status(&dst).await {
             Ok(info) => {
                 if info.folder.unwrap_or(false) {
@@ -279,9 +289,19 @@ impl GoosefsCore {
                     .with_context("from", from)
                     .with_context("to", to));
                 }
-                // Destination is an existing file — delete it so the
-                // subsequent rename can overwrite atomically at the
-                // master level.
+                if if_not_exists {
+                    // Fast-path only. Authoritative race check is master.rename
+                    // below (AlreadyExists → ConditionNotMatch).
+                    return Err(Error::new(
+                        ErrorKind::ConditionNotMatch,
+                        "target path already exists while if_not_exists is set",
+                    )
+                    .with_context("service", super::GOOSEFS_SCHEME)
+                    .with_context("from", from)
+                    .with_context("to", to));
+                }
+                // Overwrite path ONLY. Master rename rejects existing dst;
+                // delete first so overwrite can proceed.
                 master.delete(&dst, false).await.map_err(parse_error)?;
             }
             Err(goosefs_sdk::error::Error::NotFound { .. }) => {
@@ -299,7 +319,29 @@ impl GoosefsCore {
             Err(e) => return Err(parse_error(e)),
         }
 
-        master.rename(&src, &dst).await.map_err(parse_error)
+        match master.rename(&src, &dst).await {
+            Ok(()) => {
+                // Same inode id moved (Master RenameEntry.setId(srcInode.getId()))
+                // — not a fresh inode. Drop any cached FileInfo so a reader
+                // opening `dst` immediately after sees current metadata.
+                ctx.invalidate_file_info(&src);
+                ctx.invalidate_file_info(&dst);
+                Ok(())
+            }
+            // Authoritative TOCTOU close: concurrent winner published between
+            // get_status and this RPC. Master FileAlreadyExistsException →
+            // gRPC ALREADY_EXISTS → SDK Error::AlreadyExists.
+            Err(goosefs_sdk::error::Error::AlreadyExists { .. }) if if_not_exists => {
+                Err(Error::new(
+                    ErrorKind::ConditionNotMatch,
+                    "target path already exists while if_not_exists is set",
+                )
+                .with_context("service", super::GOOSEFS_SCHEME)
+                .with_context("from", from)
+                .with_context("to", to))
+            }
+            Err(e) => Err(parse_error(e)),
+        }
     }
 
     // ── Data I/O Operations ──────────────────────────────────
@@ -477,6 +519,11 @@ impl GoosefsCore {
         {
             metadata.set_last_modified(ts);
         }
+        // GooseFS Master rename preserves the same inode id; use it as etag
+        // for cache keys / checkout short-circuit (not commit conflict detection).
+        if let Some(fid) = info.file_id {
+            metadata.set_etag(&fid.to_string());
+        }
         metadata
     }
 

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

@@ -1,6 +1,6 @@
 ## Capabilities
 
-This service can be used to:
+Depending on its configuration and the backing system, this service can expose:
 
 - [x] create_dir
 - [x] stat
@@ -10,8 +10,12 @@ This service can be used to:
 - [x] list
 - [ ] copy
 - [x] rename
+- [x] rename (if_not_exists)
 - [ ] presign
 
+Inspect the effective capability set with [`opendal_core::Operator::info`] and
+[`opendal_core::OperatorInfo::capability`] after building an operator.
+
 ## Notes
 
 GooseFS service uses native gRPC protocol (not REST API like Alluxio),
@@ -23,18 +27,14 @@ Features:
 - **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.
 - **All WriteTypes**: Supports MUST_CACHE, CACHE_THROUGH, THROUGH, and ASYNC_THROUGH.
+- **Conditional Create**: `write_with_if_not_exists` publishes via Master no-replace
+  rename (`rename_with_if_not_exists`); destination is never deleted on the Create path.
 
 ## Configuration
 
-- `root`: Set the work directory for backend
-- `master_addr`: GooseFS Master address (`host:port`), supports comma-separated for HA
-- `block_size`: Block size for new files (default: 64 MiB)
-- `chunk_size`: Chunk size for streaming RPCs (default: 1 MiB)
-- `write_type`: Default write type (`must_cache`, `cache_through`, `through`, `async_through`)
-- `auth_type`: Authentication type (`nosasl`, `simple`). Default: `simple`
-- `auth_username`: Authentication username for SIMPLE mode. Default: current OS user
-
-You can refer to [`GoosefsBuilder`]'s docs for more information
+Use [`crate::GoosefsConfig`] for serializable configuration and this builder's
+methods for direct construction. The field and method documentation defines
+accepted values, defaults, and environment interaction.
 
 ## Example
 

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

@@ -15,10 +15,20 @@
 // specific language governing permissions and limitations
 // under the License.
 
-/// Default scheme for GooseFS service.
+#![doc = include_str!("../README.md")]
+#![cfg_attr(docsrs, feature(doc_cfg))]
+#![cfg_attr(docsrs, doc(auto_cfg))]
+#![deny(missing_docs)]
+
+/// URI scheme used for service registration and scheme-driven construction.
 pub const GOOSEFS_SCHEME: &str = "goosefs";
 
-/// Register this service into the given registry.
+/// Register this service's URI scheme or schemes with an operator registry.
+///
+/// Registration enables scheme-driven construction through
+/// [`opendal_core::Operator::from_uri`] and
+/// [`opendal_core::Operator::via_iter`]. Direct construction through
+/// [`opendal_core::Operator::new`] does not require registration.
 pub fn register_goosefs_service(registry: &opendal_core::OperatorRegistry) {
     registry.register::<GooseFs>(GOOSEFS_SCHEME);
 }

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

@@ -150,12 +150,10 @@ impl GoosefsWriter {
     /// path, and cache both.
     async fn ensure_writer(&mut self) -> Result<&mut ClientWriter> {
         if self.writer.is_none() {
-            // Fast-path: reject if-not-exists writes up front so we
-            // don't open a temp that will only be thrown away at
-            // finalize time. The *authoritative* check happens again
-            // at finalize (see `close()` / `finalize_rename()`), which
-            // handles the race where a concurrent writer publishes
-            // the target between here and finalize.
+            // Fast-path only. Authority is GoosefsCore::rename(..., if_not_exists=true)
+            // → Master no-replace rename (DefaultFileSystemMaster →
+            // FileAlreadyExistsException → gRPC ALREADY_EXISTS → ConditionNotMatch).
+            // Not this get_status.
             if self.op.if_not_exists() && self.core.get_status(&self.path).await.is_ok() {
                 return Err(Error::new(
                     ErrorKind::ConditionNotMatch,
@@ -186,8 +184,8 @@ impl GoosefsWriter {
             return Ok(());
         };
 
-        // Second if-not-exists check: a concurrent writer may have
-        // published the target while we were streaming.
+        // Optional fast-path (optimization, not authority). Safe to keep:
+        // a miss here is closed by rename(..., if_not_exists) below.
         if self.op.if_not_exists() && self.core.get_status(&self.path).await.is_ok() {
             // Undo our staged temp before surfacing the error.
             let _ = self.core.delete(&tmp).await;
@@ -197,16 +195,13 @@ impl GoosefsWriter {
             ));
         }
 
-        // Overwrite semantics: GooseFS rename does not silently replace
-        // an existing target, so we pre-delete the final path. NotFound
-        // is the common (fresh-write) case, so we ignore errors here
-        // and let any real failure (e.g. permission denied) surface
-        // through the rename below.
-        if !self.op.if_not_exists() {
-            let _ = self.core.delete(&self.path).await;
-        }
-
-        match self.core.rename(&tmp, &self.path).await {
+        // Authority: pass OpWrite.if_not_exists into core.rename.
+        // Overwrite delete lives only inside core.rename when if_not_exists=false.
+        match self
+            .core
+            .rename(&tmp, &self.path, self.op.if_not_exists())
+            .await
+        {
             Ok(()) => Ok(()),
             Err(e) => {
                 // Rename failed — sweep the temp so we don't leak a
@@ -248,8 +243,13 @@ impl oio::Write for GoosefsWriter {
                 }
                 return Err(e);
             }
+            // Capture file_id before rename; Master rename keeps the same inode id.
+            let mut meta = Metadata::default();
+            if let Some(fid) = writer.file_info().file_id {
+                meta.set_etag(&fid.to_string());
+            }
             self.finalize_rename().await?;
-            return Ok(Metadata::default());
+            return Ok(meta);
         }
 
         // Zero-write path: the caller closed without ever calling
@@ -271,9 +271,13 @@ impl oio::Write for GoosefsWriter {
             let _ = self.core.delete(&tmp).await;
             return Err(e);
         }
+        let mut meta = Metadata::default();
+        if let Some(fid) = w.file_info().file_id {
+            meta.set_etag(&fid.to_string());
+        }
         self.tmp_path = Some(tmp);
         self.finalize_rename().await?;
-        Ok(Metadata::default())
+        Ok(meta)
     }
 
     async fn abort(&mut self) -> Result<()> {

data/core/services/goosefs/tests/safe_conditional_put.rs

@@ -0,0 +1,199 @@
+// 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.
+
+//! Acceptance tests for GooseFS safe Create / conditional rename (doc §8.8).
+//!
+//! Requires a live GooseFS master. Skip unless `OPENDAL_GOOSEFS_MASTER_ADDR`
+//! is set (same env the behavior CI fixture exports).
+
+use std::sync::Arc;
+
+use opendal::ErrorKind;
+use opendal::Operator;
+use opendal::services::GooseFs;
+
+fn maybe_operator() -> Option<Operator> {
+    let master = std::env::var("OPENDAL_GOOSEFS_MASTER_ADDR").ok()?;
+    if master.trim().is_empty() {
+        return None;
+    }
+    let root = std::env::var("OPENDAL_GOOSEFS_ROOT").unwrap_or_else(|_| "/".to_string());
+    let write_type =
+        std::env::var("OPENDAL_GOOSEFS_WRITE_TYPE").unwrap_or_else(|_| "must_cache".to_string());
+
+    let builder = GooseFs::default()
+        .root(&root)
+        .master_addr(&master)
+        .write_type(&write_type);
+    Some(Operator::new(builder).expect("build GooseFS operator"))
+}
+
+fn unique(prefix: &str) -> String {
+    format!(
+        "{prefix}-{}-{}",
+        std::process::id(),
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_nanos()
+    )
+}
+
+#[tokio::test]
+async fn capability_declares_rename_with_if_not_exists() {
+    let Some(op) = maybe_operator() else {
+        eprintln!("skip: OPENDAL_GOOSEFS_MASTER_ADDR unset");
+        return;
+    };
+    let cap = op.info().capability();
+    assert!(cap.write_with_if_not_exists);
+    assert!(cap.rename_with_if_not_exists);
+}
+
+/// T0 / T4: conditional rename against an existing dst → ConditionNotMatch;
+/// destination content is unchanged (Master no-replace).
+#[tokio::test]
+async fn rename_if_not_exists_rejects_existing_dst() {
+    let Some(op) = maybe_operator() else {
+        eprintln!("skip: OPENDAL_GOOSEFS_MASTER_ADDR unset");
+        return;
+    };
+
+    let src = unique("t0-src");
+    let dst = unique("t0-dst");
+    op.write(&src, "from-src").await.expect("write src");
+    op.write(&dst, "dst-original").await.expect("write dst");
+
+    let err = op
+        .rename_with(&src, &dst)
+        .if_not_exists(true)
+        .await
+        .expect_err("rename must fail when dst exists");
+    assert_eq!(err.kind(), ErrorKind::ConditionNotMatch);
+
+    let dst_after = op.read(&dst).await.expect("read dst").to_bytes();
+    assert_eq!(&dst_after[..], b"dst-original");
+
+    let _ = op.delete(&src).await;
+    let _ = op.delete(&dst).await;
+}
+
+/// T3: serial second Create (write_with if_not_exists) must fail.
+#[tokio::test]
+async fn write_if_not_exists_serial_conflict() {
+    let Some(op) = maybe_operator() else {
+        eprintln!("skip: OPENDAL_GOOSEFS_MASTER_ADDR unset");
+        return;
+    };
+
+    let path = unique("t3-create");
+    op.write_with(&path, "winner")
+        .if_not_exists(true)
+        .await
+        .expect("first Create succeeds");
+
+    let err = op
+        .write_with(&path, "loser")
+        .if_not_exists(true)
+        .await
+        .expect_err("second Create must fail");
+    assert_eq!(err.kind(), ErrorKind::ConditionNotMatch);
+
+    let body = op.read(&path).await.expect("read").to_bytes();
+    assert_eq!(&body[..], b"winner");
+
+    let meta = op.stat(&path).await.expect("stat");
+    assert!(
+        meta.etag().is_some(),
+        "P1 etag (file_id) should be present after write"
+    );
+
+    let _ = op.delete(&path).await;
+}
+
+/// T5: overwrite (if_not_exists=false) still replaces an existing file.
+#[tokio::test]
+async fn overwrite_rename_still_works() {
+    let Some(op) = maybe_operator() else {
+        eprintln!("skip: OPENDAL_GOOSEFS_MASTER_ADDR unset");
+        return;
+    };
+
+    let src = unique("t5-src");
+    let dst = unique("t5-dst");
+    op.write(&src, "new-content").await.expect("write src");
+    op.write(&dst, "old-content").await.expect("write dst");
+
+    op.rename(&src, &dst).await.expect("overwrite rename");
+
+    let body = op.read(&dst).await.expect("read dst").to_bytes();
+    assert_eq!(&body[..], b"new-content");
+
+    let _ = op.delete(&dst).await;
+}
+
+/// T1: concurrent Create on the same path — exactly one wins; content is winner's.
+#[tokio::test]
+async fn concurrent_write_if_not_exists_exactly_one_wins() {
+    let Some(op) = maybe_operator() else {
+        eprintln!("skip: OPENDAL_GOOSEFS_MASTER_ADDR unset");
+        return;
+    };
+    let op = Arc::new(op);
+    let path = unique("t1-concurrent");
+
+    let rounds = 8u32;
+    for round in 0..rounds {
+        let p = format!("{path}-r{round}");
+        let op_a = op.clone();
+        let op_b = op.clone();
+        let path_a = p.clone();
+        let path_b = p.clone();
+
+        let (ra, rb) = tokio::join!(
+            async move {
+                op_a.write_with(&path_a, "A")
+                    .if_not_exists(true)
+                    .await
+                    .map(|_| "A")
+            },
+            async move {
+                op_b.write_with(&path_b, "B")
+                    .if_not_exists(true)
+                    .await
+                    .map(|_| "B")
+            },
+        );
+
+        match (&ra, &rb) {
+            (Ok(w), Err(e)) => {
+                assert_eq!(e.kind(), ErrorKind::ConditionNotMatch);
+                let body = op.read(&p).await.expect("read").to_bytes();
+                assert_eq!(&body[..], w.as_bytes());
+            }
+            (Err(e), Ok(w)) => {
+                assert_eq!(e.kind(), ErrorKind::ConditionNotMatch);
+                let body = op.read(&p).await.expect("read").to_bytes();
+                assert_eq!(&body[..], w.as_bytes());
+            }
+            (Ok(_), Ok(_)) => panic!("both concurrent Creates succeeded for {p}"),
+            (Err(ea), Err(eb)) => panic!("both concurrent Creates failed for {p}: {ea:?} / {eb:?}"),
+        }
+
+        let _ = op.delete(&p).await;
+    }
+}

data/core/services/gridfs/Cargo.toml

@@ -18,6 +18,7 @@
 [package]
 description = "Apache OpenDAL GridFS service implementation"
 name = "opendal-service-gridfs"
+readme = "README.md"
 
 authors = { workspace = true }
 edition = { workspace = true }
@@ -34,7 +35,7 @@ all-features = true
 futures = { workspace = true }
 mea = { workspace = true }
 mongodb = "3.3.0"
-opendal-core = { path = "../../core", version = "0.58.0", default-features = false }
+opendal-core = { path = "../../core", version = "0.58.1", default-features = false }
 serde = { workspace = true, features = ["derive"] }
 
 [dev-dependencies]