opendal 0.1.9 → 0.1.11

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

@@ -49,24 +49,28 @@ impl oio::Write for MiniMokaWriter {
     async fn close(&mut self) -> Result<Metadata> {
         let buf = self.buffer.clone().collect();
 
-        let mut md = Metadata::new(EntryMode::from_path(&self.path));
-        md.set_content_length(buf.len() as u64);
-        md.set_last_modified(Timestamp::now());
+        let mut md = if self.path.ends_with('/') {
+            MetadataBuilder::dir()
+        } else {
+            MetadataBuilder::file(buf.len() as u64)
+        };
+        md.last_modified(Timestamp::now());
 
         // Set metadata from OpWrite
         if let Some(content_type) = self.op.content_type() {
-            md.set_content_type(content_type);
+            md.content_type(content_type);
         }
         if let Some(content_disposition) = self.op.content_disposition() {
-            md.set_content_disposition(content_disposition);
+            md.content_disposition(content_disposition);
         }
         if let Some(content_encoding) = self.op.content_encoding() {
-            md.set_content_encoding(content_encoding);
+            md.content_encoding(content_encoding);
         }
         if let Some(cache_control) = self.op.cache_control() {
-            md.set_cache_control(cache_control);
+            md.cache_control(cache_control);
         }
 
+        let md = md.build();
         let value = MiniMokaValue {
             metadata: md.clone(),
             content: buf,

data/core/services/moka/Cargo.toml

@@ -34,7 +34,7 @@ all-features = true
 [dependencies]
 log = { workspace = true }
 moka = { version = "0.12", features = ["future", "sync"] }
-opendal-core = { path = "../../core", version = "0.58.1", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.0", default-features = false }
 serde = { workspace = true, features = ["derive"] }
 
 [dev-dependencies]

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

@@ -226,6 +226,7 @@ impl Service for MokaBackend {
     type Lister = oio::HierarchyLister<MokaLister>;
     type Deleter = oio::OneShotDeleter<MokaDeleter>;
     type Copier = ();
+    type Composer = ();
 
     fn info(&self) -> ServiceInfo {
         self.info.clone()
@@ -251,19 +252,19 @@ impl Service for MokaBackend {
         let p = build_abs_path(&self.root, path);
 
         if p == build_abs_path(&self.root, "") {
-            Ok(RpStat::new(Metadata::new(EntryMode::DIR)))
+            Ok(RpStat::new(MetadataBuilder::dir().build()))
         } else {
             // Check the exact path first
             match self.core.get(&p).await? {
                 Some(value) => {
                     // Use the stored metadata but override mode if necessary
-                    let mut metadata = value.metadata.clone();
+                    let mut metadata = value.metadata.clone().into_builder();
                     // If path ends with '/' but we found a file, return DIR
                     // This is because CompleteLayer's create_dir creates empty files with '/' suffix
-                    if p.ends_with('/') && metadata.mode() != EntryMode::DIR {
-                        metadata.set_mode(EntryMode::DIR);
+                    if p.ends_with('/') && value.metadata.mode() != EntryMode::DIR {
+                        metadata.set_dir();
                     }
-                    Ok(RpStat::new(metadata))
+                    Ok(RpStat::new(metadata.build()))
                 }
                 None => {
                     // If path ends with '/', check if there are any children
@@ -275,7 +276,7 @@ impl Service for MokaBackend {
                             .any(|kv| kv.0.starts_with(&p) && kv.0.len() > p.len());
 
                         if has_children {
-                            Ok(RpStat::new(Metadata::new(EntryMode::DIR)))
+                            Ok(RpStat::new(MetadataBuilder::dir().build()))
                         } else {
                             Err(Error::new(ErrorKind::NotFound, "key not found in moka"))
                         }
@@ -336,7 +337,6 @@ impl Service for MokaBackend {
         _from: &str,
         _to: &str,
         _args: OpCopy,
-        _opts: OpCopier,
     ) -> Result<Self::Copier> {
         Err(Error::new(
             ErrorKind::Unsupported,

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

@@ -46,7 +46,10 @@ impl oio::StreamRead for MokaReader {
                 let buffer = value
                     .content
                     .slice(range.to_content_range(value.content.len())?);
-                let metadata = Metadata::new(EntryMode::FILE).with_content_length(total_size);
+                let metadata = {
+                    let metadata = MetadataBuilder::file(total_size);
+                    metadata.build()
+                };
                 Ok((
                     RpRead::new(metadata),
                     Box::new(buffer) as Box<dyn oio::ReadStreamDyn>,

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

@@ -51,22 +51,26 @@ impl oio::Write for MokaWriter {
         let length = buf.len() as u64;
 
         // Build metadata with write options
-        let mut metadata =
-            Metadata::new(EntryMode::from_path(&self.path)).with_content_length(length);
+        let mut metadata = if self.path.ends_with('/') {
+            MetadataBuilder::dir()
+        } else {
+            MetadataBuilder::file(length)
+        };
 
         if let Some(content_type) = self.op.content_type() {
-            metadata.set_content_type(content_type);
+            metadata.content_type(content_type);
         }
         if let Some(content_disposition) = self.op.content_disposition() {
-            metadata.set_content_disposition(content_disposition);
+            metadata.content_disposition(content_disposition);
         }
         if let Some(cache_control) = self.op.cache_control() {
-            metadata.set_cache_control(cache_control);
+            metadata.cache_control(cache_control);
         }
         if let Some(content_encoding) = self.op.content_encoding() {
-            metadata.set_content_encoding(content_encoding);
+            metadata.content_encoding(content_encoding);
         }
 
+        let metadata = metadata.build();
         let value = MokaValue {
             metadata: metadata.clone(),
             content: buf,

data/core/services/mongodb/Cargo.toml

@@ -32,9 +32,9 @@ version = { workspace = true }
 all-features = true
 
 [dependencies]
-mea = { workspace = true }
+asyncband = { workspace = true }
 mongodb = { version = "3.3.0" }
-opendal-core = { path = "../../core", version = "0.58.1", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.0", default-features = false }
 serde = { workspace = true, features = ["derive"] }
 
 [dev-dependencies]

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

@@ -17,7 +17,7 @@
 
 use std::sync::Arc;
 
-use mea::once::OnceCell;
+use asyncband::once::OnceCell;
 
 use super::MONGODB_SCHEME;
 use super::config::MongodbConfig;
@@ -214,6 +214,7 @@ impl Service for MongodbBackend {
     type Lister = ();
     type Deleter = oio::OneShotDeleter<MongodbDeleter>;
     type Copier = ();
+    type Composer = ();
 
     fn info(&self) -> ServiceInfo {
         self.info.clone()
@@ -239,12 +240,13 @@ impl Service for MongodbBackend {
         let p = build_abs_path(&self.root, path);
 
         if p == build_abs_path(&self.root, "") {
-            Ok(RpStat::new(Metadata::new(EntryMode::DIR)))
+            Ok(RpStat::new(MetadataBuilder::dir().build()))
         } else {
             match self.core.get_length(&p).await? {
-                Some(length) => Ok(RpStat::new(
-                    Metadata::new(EntryMode::FILE).with_content_length(length as u64),
-                )),
+                Some(length) => Ok(RpStat::new({
+                    let metadata = MetadataBuilder::file(length as u64);
+                    metadata.build()
+                })),
                 None => Err(Error::new(ErrorKind::NotFound, "kv not found in mongodb")),
             }
         }
@@ -294,7 +296,6 @@ impl Service for MongodbBackend {
         _from: &str,
         _to: &str,
         _args: OpCopy,
-        _opts: OpCopier,
     ) -> Result<Self::Copier> {
         Err(Error::new(
             ErrorKind::Unsupported,

data/core/services/mongodb/src/core.rs

@@ -17,7 +17,7 @@
 
 use std::fmt::Debug;
 
-use mea::once::OnceCell;
+use asyncband::once::OnceCell;
 use mongodb::bson::Binary;
 use mongodb::bson::Bson;
 use mongodb::bson::Document;

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

@@ -46,7 +46,10 @@ impl oio::StreamRead for MongodbReader {
             }
         };
         let content = bs.slice(range.to_content_range(bs.len())?);
-        let metadata = Metadata::new(EntryMode::FILE).with_content_length(bs.len() as u64);
+        let metadata = {
+            let metadata = MetadataBuilder::file(bs.len() as u64);
+            metadata.build()
+        };
         Ok((
             RpRead::new(metadata),
             Box::new(content) as Box<dyn oio::ReadStreamDyn>,

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

@@ -48,8 +48,12 @@ impl oio::Write for MongodbWriter {
         let length = buf.len() as u64;
         self.core.set(&self.path, buf).await?;
 
-        let meta = Metadata::new(EntryMode::from_path(&self.path)).with_content_length(length);
-        Ok(meta)
+        let metadata = if self.path.ends_with('/') {
+            MetadataBuilder::dir()
+        } else {
+            MetadataBuilder::file(length)
+        };
+        Ok(metadata.build())
     }
 
     async fn abort(&mut self) -> Result<()> {

data/core/services/monoiofs/Cargo.toml

@@ -32,16 +32,16 @@ version = { workspace = true }
 all-features = true
 
 [dependencies]
+asyncband = { workspace = true }
 bytes = { workspace = true }
 flume = "0.12"
-futures = { workspace = true, features = ["std", "async-await"] }
 monoio = { version = "0.2.4", features = [
   "sync",
   "mkdirat",
   "unlinkat",
   "renameat",
 ] }
-opendal-core = { path = "../../core", version = "0.58.1", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.0", default-features = false }
 serde = { workspace = true, features = ["derive"] }
 
 [dev-dependencies]

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

@@ -97,6 +97,7 @@ impl Service for MonoiofsBackend {
     type Lister = ();
     type Deleter = oio::OneShotDeleter<MonoiofsDeleter>;
     type Copier = oio::OneShotCopier;
+    type Composer = ();
 
     fn info(&self) -> ServiceInfo {
         self.core.info.clone()
@@ -120,12 +121,15 @@ impl Service for MonoiofsBackend {
         } else {
             EntryMode::Unknown
         };
-        let m = Metadata::new(mode)
-            .with_content_length(meta.len())
-            .with_last_modified(Timestamp::try_from(
-                meta.modified().map_err(new_std_io_error)?,
-            )?);
-        Ok(RpStat::new(m))
+        let mut m = match mode {
+            EntryMode::FILE => MetadataBuilder::file(meta.len()),
+            EntryMode::DIR => MetadataBuilder::dir(),
+            EntryMode::Unknown => MetadataBuilder::unknown(),
+        };
+        m.last_modified(Timestamp::try_from(
+            meta.modified().map_err(new_std_io_error)?,
+        )?);
+        Ok(RpStat::new(m.build()))
     }
     fn read(&self, _ctx: &OperationContext, path: &str, _args: OpRead) -> Result<Self::Reader> {
         let path = self.core.prepare_path(path)?;
@@ -200,7 +204,6 @@ impl Service for MonoiofsBackend {
         from: &str,
         to: &str,
         _args: OpCopy,
-        _opts: OpCopier,
     ) -> Result<Self::Copier> {
         let core = self.core.clone();
         let from = self.core.prepare_path(from)?;
@@ -251,12 +254,15 @@ impl Service for MonoiofsBackend {
                         buf.clear();
                     }
                     core.buf_pool.put(buf);
-                    Ok(())
+                    Ok(pos)
                 }
             })
             .await
-            .map_err(new_std_io_error)?;
-            Ok(Metadata::default())
+            .map_err(new_std_io_error)
+            .map(|size| {
+                let metadata = MetadataBuilder::file(size);
+                metadata.build()
+            })
         });
 
         Ok(copier)

data/core/services/monoiofs/src/core.rs

@@ -15,15 +15,15 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::future::Future;
 use std::mem;
 use std::path::Path;
 use std::path::PathBuf;
 use std::sync::Mutex;
 
+use asyncband::oneshot;
 use flume::Receiver;
 use flume::Sender;
-use futures::Future;
-use futures::channel::oneshot;
 use monoio::FusionDriver;
 use monoio::RuntimeBuilder;
 use opendal_core::raw::*;
@@ -230,9 +230,8 @@ impl MonoiofsCore {
 mod tests {
     use std::sync::Arc;
 
-    use futures::StreamExt;
-    use futures::channel::mpsc::UnboundedSender;
-    use futures::channel::mpsc::{self};
+    use asyncband::mpsc;
+    use asyncband::mpsc::UnboundedSender;
 
     use super::*;
 
@@ -261,16 +260,16 @@ mod tests {
                     })
                     .await;
                 assert_eq!(result, sleep_millis);
-                tx.unbounded_send(result).unwrap();
+                tx.send(result).unwrap();
             });
         }
 
         spawn_task(core.clone(), tx.clone(), 200);
         spawn_task(core.clone(), tx.clone(), 20);
         drop(tx);
-        let first = rx.next().await;
-        let second = rx.next().await;
-        let third = rx.next().await;
+        let first = rx.recv().await.ok();
+        let second = rx.recv().await.ok();
+        let third = rx.recv().await.ok();
         assert_eq!(first, Some(20));
         assert_eq!(second, Some(200));
         assert_eq!(third, None);

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

@@ -17,9 +17,8 @@
 
 use super::core::MonoiofsCore;
 use super::writer::MonoiofsWriter;
-use futures::StreamExt;
-use futures::channel::mpsc;
-use futures::channel::oneshot;
+use asyncband::mpsc;
+use asyncband::oneshot;
 use monoio::fs::OpenOptions;
 use opendal_core::raw::*;
 use opendal_core::*;
@@ -76,7 +75,7 @@ impl MonoiofsReader {
         };
         // wait for read request and send back result to main thread
         loop {
-            let Some(req) = rx.next().await else {
+            let Ok(req) = rx.recv().await else {
                 // MonoiofsReader is dropped, exit worker task
                 break;
             };
@@ -104,12 +103,11 @@ impl MonoiofsReader {
 
         // send read request to worker thread and wait for result
         let (tx, rx) = oneshot::channel();
-        self.core
-            .unwrap(self.tx.unbounded_send(ReaderRequest::Read {
-                offset,
-                buf: vec![0; size].into_boxed_slice(),
-                tx,
-            }));
+        self.core.unwrap(self.tx.send(ReaderRequest::Read {
+            offset,
+            buf: vec![0; size].into_boxed_slice(),
+            tx,
+        }));
         let (n, buf) = self.core.unwrap(rx.await)?;
 
         let mut buf = Vec::from(buf);

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

@@ -18,12 +18,10 @@
 use std::path::PathBuf;
 use std::sync::Arc;
 
+use asyncband::mpsc;
+use asyncband::oneshot;
 use bytes::Buf;
 use bytes::Bytes;
-use futures::SinkExt;
-use futures::StreamExt;
-use futures::channel::mpsc;
-use futures::channel::oneshot;
 use monoio::fs::OpenOptions;
 use opendal_core::raw::*;
 use opendal_core::*;
@@ -93,7 +91,7 @@ impl MonoiofsWriter {
         };
         // wait for write or close request and send back result to main thread
         loop {
-            let Some(req) = rx.next().await else {
+            let Ok(req) = rx.recv().await else {
                 // MonoiofsWriter is dropped, exit worker task
                 break;
             };
@@ -131,15 +129,11 @@ impl oio::Write for MonoiofsWriter {
             let buf = bs.current();
             let n = buf.len();
             let (tx, rx) = oneshot::channel();
-            self.core.unwrap(
-                self.tx
-                    .send(WriterRequest::Write {
-                        pos: self.pos,
-                        buf,
-                        tx,
-                    })
-                    .await,
-            );
+            self.core.unwrap(self.tx.send(WriterRequest::Write {
+                pos: self.pos,
+                buf,
+                tx,
+            }));
             self.core.unwrap(rx.await)?;
             self.pos += n as u64;
             bs.advance(n);
@@ -152,13 +146,11 @@ impl oio::Write for MonoiofsWriter {
     /// on worker thread.
     async fn close(&mut self) -> Result<Metadata> {
         let (tx, rx) = oneshot::channel();
-        self.core
-            .unwrap(self.tx.send(WriterRequest::Stat { tx }).await);
+        self.core.unwrap(self.tx.send(WriterRequest::Stat { tx }));
         let file_meta = self.core.unwrap(rx.await)?;
 
         let (tx, rx) = oneshot::channel();
-        self.core
-            .unwrap(self.tx.send(WriterRequest::Close { tx }).await);
+        self.core.unwrap(self.tx.send(WriterRequest::Close { tx }));
         self.core.unwrap(rx.await)?;
 
         let mode = if file_meta.is_dir() {
@@ -168,12 +160,15 @@ impl oio::Write for MonoiofsWriter {
         } else {
             EntryMode::Unknown
         };
-        let meta = Metadata::new(mode)
-            .with_content_length(file_meta.len())
-            .with_last_modified(Timestamp::try_from(
-                file_meta.modified().map_err(new_std_io_error)?,
-            )?);
-        Ok(meta)
+        let mut meta = match mode {
+            EntryMode::FILE => MetadataBuilder::file(file_meta.len()),
+            EntryMode::DIR => MetadataBuilder::dir(),
+            EntryMode::Unknown => MetadataBuilder::unknown(),
+        };
+        meta.last_modified(Timestamp::try_from(
+            file_meta.modified().map_err(new_std_io_error)?,
+        )?);
+        Ok(meta.build())
     }
 
     async fn abort(&mut self) -> Result<()> {

data/core/services/mysql/Cargo.toml

@@ -32,8 +32,8 @@ version = { workspace = true }
 all-features = true
 
 [dependencies]
-mea = { workspace = true }
-opendal-core = { path = "../../core", version = "0.58.1", default-features = false }
+asyncband = { workspace = true }
+opendal-core = { path = "../../core", version = "0.59.0", default-features = false }
 serde = { workspace = true, features = ["derive"] }
 sqlx = { version = "0.8.0", features = ["runtime-tokio-rustls", "mysql"] }
 

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

@@ -18,7 +18,7 @@
 use std::fmt::Debug;
 use std::sync::Arc;
 
-use mea::once::OnceCell;
+use asyncband::once::OnceCell;
 use sqlx::mysql::MySqlConnectOptions;
 
 use super::MYSQL_SCHEME;
@@ -195,6 +195,7 @@ impl Service for MysqlBackend {
     type Lister = oio::HierarchyLister<MysqlLazyLister>;
     type Deleter = oio::OneShotDeleter<MysqlDeleter>;
     type Copier = ();
+    type Composer = ();
 
     fn info(&self) -> ServiceInfo {
         self.info.clone()
@@ -220,12 +221,13 @@ impl Service for MysqlBackend {
         let p = build_abs_path(&self.root, path);
 
         if p == build_abs_path(&self.root, "") {
-            Ok(RpStat::new(Metadata::new(EntryMode::DIR)))
+            Ok(RpStat::new(MetadataBuilder::dir().build()))
         } else {
             match self.core.get_length(&p).await? {
-                Some(length) => Ok(RpStat::new(
-                    Metadata::new(EntryMode::FILE).with_content_length(length as u64),
-                )),
+                Some(length) => Ok(RpStat::new({
+                    let metadata = MetadataBuilder::file(length as u64);
+                    metadata.build()
+                })),
                 None => Err(Error::new(ErrorKind::NotFound, "kv not found in mysql")),
             }
         }
@@ -279,7 +281,6 @@ impl Service for MysqlBackend {
         _from: &str,
         _to: &str,
         _args: OpCopy,
-        _opts: OpCopier,
     ) -> Result<Self::Copier> {
         Err(Error::new(
             ErrorKind::Unsupported,

data/core/services/mysql/src/core.rs

@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use mea::once::OnceCell;
+use asyncband::once::OnceCell;
 use sqlx::MySqlPool;
 use sqlx::mysql::MySqlConnectOptions;
 

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

@@ -18,10 +18,10 @@
 use std::sync::Arc;
 use std::vec::IntoIter;
 
+use opendal_core::MetadataBuilder;
 use opendal_core::Result;
 use opendal_core::raw::oio::{Entry, List};
 use opendal_core::raw::{build_abs_path, build_rel_path};
-use opendal_core::{EntryMode, Metadata};
 
 use super::core::MysqlCore;
 
@@ -47,8 +47,12 @@ impl List for MysqlLister {
         if path.is_empty() {
             path = "/".to_string();
         }
-        let meta = Metadata::new(EntryMode::from_path(&path));
-        Ok(Some(Entry::new(&path, meta)))
+        let meta = if path.ends_with('/') {
+            MetadataBuilder::dir()
+        } else {
+            MetadataBuilder::unknown()
+        };
+        Ok(Some(Entry::new(&path, meta.build())))
     }
 }
 

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

@@ -45,7 +45,10 @@ impl oio::StreamRead for MysqlReader {
             None => return Err(Error::new(ErrorKind::NotFound, "kv not found in mysql")),
         };
         let content = bs.slice(range.to_content_range(bs.len())?);
-        let metadata = Metadata::new(EntryMode::FILE).with_content_length(bs.len() as u64);
+        let metadata = {
+            let metadata = MetadataBuilder::file(bs.len() as u64);
+            metadata.build()
+        };
         Ok((
             RpRead::new(metadata),
             Box::new(content) as Box<dyn oio::ReadStreamDyn>,

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

@@ -48,8 +48,12 @@ impl oio::Write for MysqlWriter {
         let length = buf.len() as u64;
         self.core.set(&self.path, buf).await?;
 
-        let meta = Metadata::new(EntryMode::from_path(&self.path)).with_content_length(length);
-        Ok(meta)
+        let metadata = if self.path.ends_with('/') {
+            MetadataBuilder::dir()
+        } else {
+            MetadataBuilder::file(length)
+        };
+        Ok(metadata.build())
     }
 
     async fn abort(&mut self) -> Result<()> {

data/core/services/obs/Cargo.toml

@@ -35,7 +35,7 @@ all-features = true
 bytes = { workspace = true }
 http = { workspace = true }
 log = { workspace = true }
-opendal-core = { path = "../../core", version = "0.58.1", default-features = false, features = [
+opendal-core = { path = "../../core", version = "0.59.0", default-features = false, features = [
   "reqsign",
 ] }
 quick-xml = { workspace = true, features = ["serialize", "overlapped-lists"] }