opendal 0.1.9 → 0.1.11

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

@@ -245,6 +245,7 @@ impl Service for FoyerBackend {
     type Lister = ();
     type Deleter = oio::OneShotDeleter<FoyerDeleter>;
     type Copier = ();
+    type Composer = ();
 
     fn info(&self) -> ServiceInfo {
         self.info.clone()
@@ -270,12 +271,13 @@ impl Service for FoyerBackend {
         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(&p).await? {
-                Some(bs) => Ok(RpStat::new(
-                    Metadata::new(EntryMode::FILE).with_content_length(bs.len() as u64),
-                )),
+                Some(bs) => Ok(RpStat::new({
+                    let metadata = MetadataBuilder::file(bs.len() as u64);
+                    metadata.build()
+                })),
                 None => Err(Error::new(ErrorKind::NotFound, "key not found in foyer")),
             }
         }
@@ -325,7 +327,6 @@ impl Service for FoyerBackend {
         _from: &str,
         _to: &str,
         _args: OpCopy,
-        _opts: OpCopier,
     ) -> Result<Self::Copier> {
         Err(Error::new(
             ErrorKind::Unsupported,

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

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

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

@@ -49,8 +49,12 @@ impl oio::Write for FoyerWriter {
         let length = buf.len() as u64;
         self.core.insert(&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/fs/Cargo.toml

@@ -34,7 +34,7 @@ all-features = true
 [dependencies]
 bytes = { 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 = [
   "internal-tokio-rt",
 ] }
 serde = { workspace = true, features = ["derive"] }

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

@@ -180,6 +180,7 @@ impl Service for FsBackend {
     type Lister = FsLazyLister;
     type Deleter = oio::OneShotDeleter<FsDeleter>;
     type Copier = oio::OneShotCopier;
+    type Composer = ();
 
     fn info(&self) -> ServiceInfo {
         self.core.info.clone()
@@ -234,14 +235,14 @@ impl Service for FsBackend {
         from: &str,
         to: &str,
         _args: OpCopy,
-        _opts: OpCopier,
     ) -> Result<Self::Copier> {
         let core = self.core.clone();
         let from = from.to_string();
         let to = to.to_string();
         Ok(oio::OneShotCopier::new(async move {
-            core.fs_copy(&from, &to).await?;
-            Ok(Metadata::default())
+            let size = core.fs_copy(&from, &to).await?;
+            let metadata = MetadataBuilder::file(size);
+            Ok(metadata.build())
         }))
     }
 

data/core/services/fs/src/core.rs

@@ -110,22 +110,25 @@ impl FsCore {
         } else {
             EntryMode::Unknown
         };
-        let mut m = Metadata::new(mode)
-            .with_content_length(meta.len())
-            .with_last_modified(Timestamp::try_from(
-                meta.modified().map_err(new_std_io_error)?,
-            )?);
+        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)?,
+        )?);
 
         // Read user metadata from xattr on Unix systems
         #[cfg(unix)]
         {
             let user_metadata = Self::get_user_metadata(&p)?;
             if !user_metadata.is_empty() {
-                m = m.with_user_metadata(user_metadata);
+                m.user_metadata(user_metadata);
             }
         }
 
-        Ok(m)
+        Ok(m.build())
     }
 
     pub async fn fs_open(&self, path: &str) -> Result<File> {
@@ -158,7 +161,10 @@ impl FsCore {
             open_options.truncate(true);
         }
 
-        let f = open_options.open(path).await.map_err(parse_error)?;
+        let f = open_options
+            .open(path)
+            .await
+            .map_err(|err| parse_error(ErrorContext::new(ServiceOperation("OpenForWrite")), err))?;
 
         Ok(f)
     }
@@ -188,7 +194,12 @@ impl FsCore {
         open_options.write(true);
         open_options.truncate(true);
 
-        let f = open_options.open(&tmp_path).await.map_err(parse_error)?;
+        let f = open_options.open(&tmp_path).await.map_err(|err| {
+            parse_error(
+                ErrorContext::new(ServiceOperation("OpenTemporaryFile")),
+                err,
+            )
+        })?;
 
         Ok((f, Some(tmp_path)))
     }
@@ -215,7 +226,7 @@ impl FsCore {
         }
     }
 
-    pub async fn fs_copy(&self, from: &str, to: &str) -> Result<()> {
+    pub async fn fs_copy(&self, from: &str, to: &str) -> Result<u64> {
         let from = self.root_join(from)?;
         // try to get the metadata of the source file to ensure it exists
         tokio::fs::metadata(&from).await.map_err(new_std_io_error)?;
@@ -224,7 +235,7 @@ impl FsCore {
             .ensure_write_abs_path(&self.root, to.trim_end_matches('/'))
             .await?;
 
-        tokio::fs::copy(&from, &to)
+        let size = tokio::fs::copy(&from, &to)
             .await
             .map_err(new_std_io_error)?;
 
@@ -238,7 +249,7 @@ impl FsCore {
             }
         }
 
-        Ok(())
+        Ok(size)
     }
 
     pub async fn fs_rename(&self, from: &str, to: &str) -> Result<()> {
@@ -315,24 +326,31 @@ impl FsCore {
 #[cfg(unix)]
 const XATTR_USER_PREFIX: &str = "user.";
 
-mod error {
-    use opendal_core::raw::*;
-    use opendal_core::*;
+/// Context needed to classify an error from this service.
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct ErrorContext {
+    service_operation: ServiceOperation,
+}
 
-    /// Parse error response into Error.
-    pub(crate) fn parse_error(e: std::io::Error) -> Error {
-        match e.kind() {
-            std::io::ErrorKind::AlreadyExists => Error::new(
-                ErrorKind::ConditionNotMatch,
-                "The file already exists in the filesystem",
-            )
-            .set_source(e),
-            _ => new_std_io_error(e),
-        }
+impl ErrorContext {
+    pub(crate) const fn new(service_operation: ServiceOperation) -> Self {
+        Self { service_operation }
     }
 }
 
-pub(super) use error::*;
+/// Parse an error using its service operation context.
+pub(crate) fn parse_error(ctx: ErrorContext, err: std::io::Error) -> Error {
+    let err = match err.kind() {
+        std::io::ErrorKind::AlreadyExists => Error::new(
+            ErrorKind::ConditionNotMatch,
+            "The file already exists in the filesystem",
+        )
+        .set_source(err),
+        _ => new_std_io_error(err),
+    };
+
+    err.with_context("service_operation", ctx.service_operation.0)
+}
 
 #[cfg(test)]
 mod tests {

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

@@ -19,7 +19,7 @@ use std::path::Path;
 use std::path::PathBuf;
 
 use opendal_core::EntryMode;
-use opendal_core::Metadata;
+use opendal_core::MetadataBuilder;
 use opendal_core::Result;
 use opendal_core::raw::*;
 
@@ -51,7 +51,7 @@ impl oio::List for FsLister<tokio::fs::ReadDir> {
         loop {
             // since list should return path itself, we return it first
             if let Some(path) = self.current_path.take() {
-                let e = oio::Entry::new(path.as_str(), Metadata::new(EntryMode::DIR));
+                let e = oio::Entry::new(path.as_str(), MetadataBuilder::dir().build());
                 return Ok(Some(e));
             }
 
@@ -106,11 +106,14 @@ impl oio::List for FsLister<tokio::fs::ReadDir> {
                 }
                 Err(e) => return Err(new_std_io_error(e)),
             };
-            let metadata = Metadata::new(mode)
-                .with_content_length(de_metadata.len())
-                .with_last_modified(Timestamp::try_from(last_modified)?);
+            let mut metadata = match mode {
+                EntryMode::FILE => MetadataBuilder::file(de_metadata.len()),
+                EntryMode::DIR => MetadataBuilder::dir(),
+                EntryMode::Unknown => MetadataBuilder::unknown(),
+            };
+            metadata.last_modified(Timestamp::try_from(last_modified)?);
 
-            return Ok(Some(oio::Entry::new(path, metadata)));
+            return Ok(Some(oio::Entry::new(path, metadata.build())));
         }
     }
 }

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

@@ -46,7 +46,12 @@ impl FsWriter {
 
         // Store user metadata for later use on Unix systems.
         #[cfg(unix)]
-        let user_metadata = op.user_metadata().cloned();
+        let user_metadata = op.user_metadata().map(|metadata| {
+            metadata
+                .into_iter()
+                .map(|(key, value)| (key.to_owned(), value.to_owned()))
+                .collect()
+        });
 
         // Quick path while atomic_write_dir is not set.
         if core.atomic_write_dir.is_none() {
@@ -123,12 +128,11 @@ impl oio::Write for FsWriter {
         }
 
         let file_meta = self.f.metadata().await.map_err(new_std_io_error)?;
-        let meta = Metadata::new(EntryMode::FILE)
-            .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 = MetadataBuilder::file(file_meta.len());
+        meta.last_modified(Timestamp::try_from(
+            file_meta.modified().map_err(new_std_io_error)?,
+        )?);
+        Ok(meta.build())
     }
 
     async fn abort(&mut self) -> Result<()> {
@@ -205,12 +209,15 @@ impl oio::PositionWrite for FsWriter {
         } 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(&self) -> Result<()> {

data/core/services/ftp/Cargo.toml

@@ -34,17 +34,15 @@ all-features = true
 [dependencies]
 bytes = { workspace = true }
 fastpool = "1.0.2"
-futures = { workspace = true, features = ["std", "async-await"] }
-futures-rustls = "0.26.0"
 http = { workspace = true }
 log = { workspace = true }
-opendal-core = { path = "../../core", version = "0.58.1", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.0", default-features = false }
 rustls-native-certs = "0.8"
 serde = { workspace = true, features = ["derive"] }
-suppaftp = { version = "8.0.3", default-features = false, features = [
-  "async-std-rustls-ring",
+suppaftp = { version = "10.0.2", default-features = false, features = [
+  "tokio-rustls-ring",
 ] }
-tokio = { workspace = true, features = ["macros", "time"] }
+tokio = { workspace = true, features = ["io-util", "macros", "time"] }
 
 [dev-dependencies]
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }

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

@@ -162,6 +162,7 @@ impl Builder for FtpBuilder {
 
         let manager = Manager {
             endpoint: endpoint.clone(),
+            host: host.to_string(),
             root: root.clone(),
             user: user.clone(),
             password: password.clone(),
@@ -190,6 +191,7 @@ impl Service for FtpBackend {
     type Lister = FtpLazyLister;
     type Deleter = oio::OneShotDeleter<FtpDeleter>;
     type Copier = ();
+    type Composer = ();
 
     fn info(&self) -> ServiceInfo {
         self.core.info()
@@ -240,11 +242,14 @@ impl Service for FtpBackend {
             EntryMode::Unknown
         };
 
-        let mut meta = Metadata::new(mode);
-        meta.set_content_length(file.size() as u64);
-        meta.set_last_modified(Timestamp::try_from(file.modified())?);
+        let mut meta = match mode {
+            EntryMode::FILE => MetadataBuilder::file(file.size() as u64),
+            EntryMode::DIR => MetadataBuilder::dir(),
+            EntryMode::Unknown => MetadataBuilder::unknown(),
+        };
+        meta.last_modified(Timestamp::try_from(file.modified())?);
 
-        Ok(RpStat::new(meta))
+        Ok(RpStat::new(meta.build()))
     }
     fn read(&self, _ctx: &OperationContext, path: &str, args: OpRead) -> Result<Self::Reader> {
         let output: oio::StreamReader<FtpReader> = {
@@ -279,7 +284,6 @@ impl Service for FtpBackend {
         _from: &str,
         _to: &str,
         _args: OpCopy,
-        _opts: OpCopier,
     ) -> Result<Self::Copier> {
         Err(Error::new(
             ErrorKind::Unsupported,

data/core/services/ftp/src/core.rs

@@ -16,16 +16,17 @@
 // under the License.
 
 use std::sync::Arc;
+use std::time::Duration;
 
 use fastpool::{ManageObject, ObjectStatus, bounded};
-use futures_rustls::TlsConnector;
-use futures_rustls::rustls::ClientConfig;
-use futures_rustls::rustls::RootCertStore;
 use suppaftp::FtpError;
 use suppaftp::Status;
-use suppaftp::async_std::AsyncRustlsConnector;
-use suppaftp::async_std::AsyncRustlsFtpStream;
-use suppaftp::async_std::ImplAsyncFtpStream;
+use suppaftp::tokio::AsyncRustlsConnector;
+use suppaftp::tokio::AsyncRustlsFtpStream;
+use suppaftp::tokio::ImplAsyncFtpStream;
+use suppaftp::tokio_rustls::TlsConnector;
+use suppaftp::tokio_rustls::rustls::ClientConfig;
+use suppaftp::tokio_rustls::rustls::RootCertStore;
 use suppaftp::types::FileType;
 
 use opendal_core::raw::*;
@@ -73,6 +74,7 @@ impl FtpCore {
 #[derive(Clone)]
 pub struct Manager {
     pub endpoint: String,
+    pub host: String,
     pub root: String,
     pub user: String,
     pub password: String,
@@ -100,7 +102,7 @@ impl ManageObject for Manager {
             stream
                 .into_secure(
                     AsyncRustlsConnector::from(TlsConnector::from(Arc::new(cfg))),
-                    &self.endpoint,
+                    &self.host,
                 )
                 .await?
         } else {

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

@@ -50,21 +50,20 @@ impl oio::List for FtpLister {
         let path = self.path.to_string() + de.name();
 
         let mut meta = if de.is_file() {
-            Metadata::new(EntryMode::FILE)
+            MetadataBuilder::file(de.size() as u64)
         } else if de.is_directory() {
-            Metadata::new(EntryMode::DIR)
+            MetadataBuilder::dir()
         } else {
-            Metadata::new(EntryMode::Unknown)
+            MetadataBuilder::unknown()
         };
-        meta.set_content_length(de.size() as u64);
-        meta.set_last_modified(Timestamp::try_from(de.modified())?);
+        meta.last_modified(Timestamp::try_from(de.modified())?);
 
         let entry = if de.is_file() {
-            oio::Entry::new(&path, meta)
+            oio::Entry::new(&path, meta.build())
         } else if de.is_directory() {
-            oio::Entry::new(&format!("{}/", path), meta)
+            oio::Entry::new(&format!("{}/", path), meta.build())
         } else {
-            oio::Entry::new(&path, meta)
+            oio::Entry::new(&path, meta.build())
         };
 
         Ok(Some(entry))

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

@@ -23,14 +23,14 @@ use super::lister::FtpLister;
 use super::writer::FtpWriter;
 use bytes::BytesMut;
 use fastpool::bounded;
-use futures::AsyncRead;
-use futures::AsyncReadExt;
 use opendal_core::raw::*;
 use opendal_core::*;
 use std::sync::Arc;
 use suppaftp::FtpError;
 use suppaftp::Status;
 use suppaftp::types::Response;
+use tokio::io::AsyncRead;
+use tokio::io::AsyncReadExt;
 
 pub struct FtpReadStream {
     /// Keep the connection alive while data stream is alive.
@@ -164,7 +164,7 @@ impl oio::Write for FtpLazyWriter {
     async fn close(&mut self) -> Result<Metadata> {
         match &mut self.inner {
             Some(w) => w.close().await,
-            None => Ok(Metadata::default()),
+            None => Ok(MetadataBuilder::unknown().build()),
         }
     }
 

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

@@ -17,8 +17,8 @@
 
 use bytes::Buf;
 use fastpool::bounded;
-use futures::AsyncWrite;
-use futures::AsyncWriteExt;
+use tokio::io::AsyncWrite;
+use tokio::io::AsyncWriteExt;
 
 use super::core::Manager;
 use super::core::format_ftp_error;
@@ -110,7 +110,7 @@ impl oio::Write for FtpWriter {
             }
         }
 
-        Ok(Metadata::default())
+        Ok(MetadataBuilder::unknown().build())
     }
 
     async fn abort(&mut self) -> Result<()> {

data/core/services/gcs/Cargo.toml

@@ -36,7 +36,7 @@ async-trait = "0.1"
 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",
 ] }
 percent-encoding = "2.3"
@@ -47,7 +47,9 @@ reqsign-google = { version = "3.0.3", default-features = false }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 tokio = { workspace = true, features = ["rt"] }
+uuid = { workspace = true, features = ["v4"] }
 
 [dev-dependencies]
+futures = { workspace = true }
 serde_json = { workspace = true }
-tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
+tokio = { workspace = true, features = ["macros", "rt-multi-thread", "sync"] }