opendal 0.1.9 → 0.1.11

data/core/services/webdav/src/core.rs

@@ -140,7 +140,10 @@ impl WebdavCore {
 
         let resp = ctx.http_transport().send(req).await?;
         if !resp.status().is_success() {
-            return Err(parse_error(resp));
+            return Err(parse_error(
+                ErrorContext::new(ServiceOperation("Propfind")),
+                resp,
+            ));
         }
 
         let bs = resp.into_body();
@@ -155,15 +158,15 @@ impl WebdavCore {
             )
         })?;
 
-        let mut metadata = parse_propstats(&propfind_resp.propstat)?;
+        let mut metadata = parse_propstats(&propfind_resp.propstat)?.into_builder();
 
         // Parse user metadata from the raw XML response using configured namespace
         let user_metadata = parse_user_metadata_from_xml(&xml_str, &self.user_metadata_uri);
         if !user_metadata.is_empty() {
-            metadata = metadata.with_user_metadata(user_metadata);
+            metadata.user_metadata(user_metadata);
         }
 
-        Ok(metadata)
+        Ok(metadata.build())
     }
 
     pub async fn webdav_get(
@@ -324,8 +327,6 @@ impl WebdavCore {
         from: &str,
         to: &str,
     ) -> Result<Response<Buffer>> {
-        // Check if source file exists.
-        let _ = self.webdav_stat(ctx, from).await?;
         // Make sure target's dir is exist.
         self.webdav_mkcol(ctx, get_parent(to)).await?;
 
@@ -495,7 +496,10 @@ impl WebdavCore {
 
                 Ok(())
             }
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("Mkcol")),
+                resp,
+            )),
         }
     }
 }
@@ -823,21 +827,26 @@ pub fn parse_propstat(propstat: &Propstat) -> Result<Metadata> {
     } else {
         EntryMode::FILE
     };
-    let mut m = Metadata::new(mode);
-
-    if let Some(v) = getcontentlength {
-        let content_length = v.parse::<u64>().map_err(|err| {
-            Error::new(ErrorKind::Unexpected, "parse webdav content length").set_source(err)
+    let mut m = if mode == EntryMode::FILE {
+        let content_length = getcontentlength.as_ref().ok_or_else(|| {
+            Error::new(
+                ErrorKind::Unexpected,
+                "webdav response does not contain file content length",
+            )
         })?;
-        m.set_content_length(content_length);
-    }
+        MetadataBuilder::file(content_length.parse::<u64>().map_err(|err| {
+            Error::new(ErrorKind::Unexpected, "parse webdav content length").set_source(err)
+        })?)
+    } else {
+        MetadataBuilder::dir()
+    };
 
     if let Some(v) = getcontenttype {
-        m.set_content_type(v);
+        m.content_type(v);
     }
 
     if let Some(v) = getetag {
-        m.set_etag(v);
+        m.etag(v);
     }
 
     // https://www.rfc-editor.org/rfc/rfc4918#section-14.18
@@ -847,10 +856,10 @@ pub fn parse_propstat(propstat: &Propstat) -> Result<Metadata> {
             "propfind response missing getlastmodified",
         ));
     };
-    m.set_last_modified(Timestamp::parse_rfc2822(getlastmodified)?);
+    m.last_modified(Timestamp::parse_rfc2822(getlastmodified)?);
 
     // the storage services have returned all the properties
-    Ok(m)
+    Ok(m.build())
 }
 
 pub fn parse_propstats(propstats: &[Propstat]) -> Result<Metadata> {
@@ -1100,11 +1109,12 @@ mod tests {
                     resourcetype: ResourceTypeContainer::default(),
                 },
             },
-            new_propstat("HTTP/1.1 200 OK", None),
+            new_propstat("HTTP/1.1 200 OK", Some("0")),
         ];
 
         let meta = parse_propstats(&propstats).unwrap();
         assert!(meta.is_file());
+        assert_eq!(meta.content_length(), 0);
     }
 
     #[test]
@@ -1622,52 +1632,99 @@ mod tests {
 
         assert!(check_proppatch_response(xml).is_ok());
     }
-}
-
-mod error {
-    use http::Response;
-    use http::StatusCode;
-
-    use opendal_core::raw::*;
-    use opendal_core::*;
-
-    /// Parse error response into Error.
-    pub(crate) fn parse_error(resp: Response<Buffer>) -> Error {
-        let (parts, body) = resp.into_parts();
-        let bs = body.to_bytes();
-
-        let (kind, retryable) = match parts.status {
-            StatusCode::NOT_FOUND => (ErrorKind::NotFound, false),
-            // Some services (like owncloud) return 403 while file locked.
-            StatusCode::FORBIDDEN => (ErrorKind::PermissionDenied, true),
-            // RFC 7232: 412 means an If-Match / If-Unmodified-Since
-            // precondition failed; 304 means an If-None-Match /
-            // If-Modified-Since precondition matched. Surface both as
-            // ConditionNotMatch so callers can branch on it.
-            StatusCode::PRECONDITION_FAILED | StatusCode::NOT_MODIFIED => {
-                (ErrorKind::ConditionNotMatch, false)
-            }
-            // Allowing retry for resource locked.
-            StatusCode::LOCKED => (ErrorKind::Unexpected, true),
-            StatusCode::INTERNAL_SERVER_ERROR
-            | StatusCode::BAD_GATEWAY
-            | StatusCode::SERVICE_UNAVAILABLE
-            | StatusCode::GATEWAY_TIMEOUT => (ErrorKind::Unexpected, true),
-            _ => (ErrorKind::Unexpected, false),
-        };
 
-        let message = String::from_utf8_lossy(&bs);
+    #[test]
+    fn test_parse_error_maps_missing_if_match_to_not_found() {
+        let resp = Response::builder()
+            .status(StatusCode::PRECONDITION_FAILED)
+            .body(Buffer::from(
+                "An If-Match header was specified and the resource did not exist",
+            ))
+            .unwrap();
+
+        let err = parse_error(
+            ErrorContext::new(ServiceOperation("Get")).with_if_match(true),
+            resp,
+        );
+        assert_eq!(err.kind(), ErrorKind::NotFound);
+    }
 
-        let mut err = Error::new(kind, message);
+    #[test]
+    fn test_parse_error_preserves_etag_mismatch() {
+        let resp = Response::builder()
+            .status(StatusCode::PRECONDITION_FAILED)
+            .body(Buffer::from("The ETag did not match"))
+            .unwrap();
+
+        let err = parse_error(
+            ErrorContext::new(ServiceOperation("Get")).with_if_match(true),
+            resp,
+        );
+        assert_eq!(err.kind(), ErrorKind::ConditionNotMatch);
+    }
+}
 
-        err = with_error_response_context(err, parts);
+/// Context needed to classify an error from this service.
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct ErrorContext {
+    service_operation: ServiceOperation,
+    if_match: bool,
+}
 
-        if retryable {
-            err = err.set_temporary();
+impl ErrorContext {
+    pub(crate) const fn new(service_operation: ServiceOperation) -> Self {
+        Self {
+            service_operation,
+            if_match: false,
         }
+    }
 
-        err
+    pub(crate) const fn with_if_match(mut self, if_match: bool) -> Self {
+        self.if_match = if_match;
+        self
     }
 }
 
-pub(super) use error::*;
+/// Parse an error response using its service request context.
+pub(crate) fn parse_error(ctx: ErrorContext, resp: Response<Buffer>) -> Error {
+    let (parts, body) = resp.into_parts();
+    let bs = body.to_bytes();
+
+    let message = String::from_utf8_lossy(&bs);
+
+    let (kind, retryable) = match parts.status {
+        StatusCode::NOT_FOUND => (ErrorKind::NotFound, false),
+        // Some services (like owncloud) return 403 while file locked.
+        StatusCode::FORBIDDEN => (ErrorKind::PermissionDenied, true),
+        // RFC 7232: 412 means an If-Match / If-Unmodified-Since
+        // precondition failed; 304 means an If-None-Match /
+        // If-Modified-Since precondition matched. Surface both as
+        // ConditionNotMatch so callers can branch on it.
+        StatusCode::PRECONDITION_FAILED
+            if ctx.if_match && message.contains("resource did not exist") =>
+        {
+            (ErrorKind::NotFound, false)
+        }
+        StatusCode::PRECONDITION_FAILED | StatusCode::NOT_MODIFIED => {
+            (ErrorKind::ConditionNotMatch, false)
+        }
+        // Allowing retry for resource locked.
+        StatusCode::LOCKED => (ErrorKind::Unexpected, true),
+        StatusCode::INTERNAL_SERVER_ERROR
+        | StatusCode::BAD_GATEWAY
+        | StatusCode::SERVICE_UNAVAILABLE
+        | StatusCode::GATEWAY_TIMEOUT => (ErrorKind::Unexpected, true),
+        _ => (ErrorKind::Unexpected, false),
+    };
+
+    let mut err = Error::new(kind, message);
+
+    err = err.with_context("service_operation", ctx.service_operation.0);
+    err = with_error_response_context(err, parts);
+
+    if retryable {
+        err = err.set_temporary();
+    }
+
+    err
+}

data/core/services/webdav/src/deleter.rs

@@ -43,7 +43,10 @@ impl oio::OneShotDelete for WebdavDeleter {
         let status = resp.status();
         match status {
             StatusCode::NO_CONTENT | StatusCode::NOT_FOUND => Ok(()),
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("Delete")),
+                resp,
+            )),
         }
     }
 }

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

@@ -66,7 +66,10 @@ impl oio::PageList for WebdavLister {
             ctx.done = true;
             return Ok(());
         } else {
-            return Err(parse_error(resp));
+            return Err(parse_error(
+                ErrorContext::new(ServiceOperation("Propfind")),
+                resp,
+            ));
         };
 
         let result: Multistatus = deserialize_multistatus(&bs.to_bytes())?;

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

@@ -16,7 +16,7 @@
 // under the License.
 
 use super::backend::*;
-use super::core::parse_error;
+use super::core::{ErrorContext, parse_error};
 use http::Response;
 use http::StatusCode;
 use opendal_core::raw::oio;
@@ -67,7 +67,11 @@ impl oio::StreamRead for WebdavReader {
             _ => {
                 let (part, mut body) = resp.into_parts();
                 let buf = body.to_buffer().await?;
-                return Err(parse_error(Response::from_parts(part, buf)));
+                return Err(parse_error(
+                    ErrorContext::new(ServiceOperation("Get"))
+                        .with_if_match(args.if_match().is_some()),
+                    Response::from_parts(part, buf),
+                ));
             }
         };
 

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

@@ -43,17 +43,17 @@ impl WebdavWriter {
     }
 
     fn parse_metadata(headers: &http::HeaderMap) -> Result<Metadata> {
-        let mut metadata = Metadata::default();
+        let mut metadata = MetadataBuilder::unknown();
 
         if let Some(etag) = parse_etag(headers)? {
-            metadata.set_etag(etag);
+            metadata.etag(etag);
         }
 
         if let Some(last_modified) = parse_last_modified(headers)? {
-            metadata.set_last_modified(last_modified);
+            metadata.last_modified(last_modified);
         }
 
-        Ok(metadata)
+        Ok(metadata.build())
     }
 }
 
@@ -79,9 +79,13 @@ impl oio::OneShotWrite for WebdavWriter {
 
                 // Set user metadata using PROPPATCH if provided
                 if let Some(user_metadata) = self.op.user_metadata() {
+                    let user_metadata = user_metadata
+                        .into_iter()
+                        .map(|(key, value)| (key.to_owned(), value.to_owned()))
+                        .collect();
                     let proppatch_resp = self
                         .core
-                        .webdav_proppatch(&self.ctx, &self.path, user_metadata)
+                        .webdav_proppatch(&self.ctx, &self.path, &user_metadata)
                         .await?;
 
                     let proppatch_status = proppatch_resp.status();
@@ -92,13 +96,19 @@ impl oio::OneShotWrite for WebdavWriter {
                         let xml = String::from_utf8_lossy(&body);
                         check_proppatch_response(&xml)?;
                     } else if !proppatch_status.is_success() {
-                        return Err(parse_error(proppatch_resp));
+                        return Err(parse_error(
+                            ErrorContext::new(ServiceOperation("Proppatch")),
+                            proppatch_resp,
+                        ));
                     }
                 }
 
                 Ok(metadata)
             }
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("Put")),
+                resp,
+            )),
         }
     }
 }

data/core/services/webhdfs/Cargo.toml

@@ -33,11 +33,11 @@ all-features = true
 
 [dependencies]
 anyhow = { version = "1.0.100", features = ["std"] }
+asyncband = { workspace = true }
 bytes = { workspace = true }
 http = { workspace = true }
 log = { workspace = true }
-mea = { workspace = true }
-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"] }
 serde_json = { workspace = true }
 uuid = { workspace = true, features = ["serde", "v4"] }

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

@@ -18,15 +18,15 @@
 use std::fmt::Debug;
 use std::sync::Arc;
 
+use asyncband::once::OnceCell;
 use bytes::Buf;
 use http::StatusCode;
 use log::debug;
-use mea::once::OnceCell;
 
 use super::WEBHDFS_SCHEME;
 use super::config::WebhdfsConfig;
-use super::core::WebhdfsCore;
 use super::core::parse_error;
+use super::core::{ErrorContext, WebhdfsCore};
 use super::deleter::WebhdfsDeleter;
 use super::lister::WebhdfsLister;
 use super::message::BooleanResp;
@@ -229,7 +229,12 @@ impl WebhdfsBackend {
             StatusCode::NOT_FOUND => {
                 self.create_dir(ctx, "/", OpCreateDir::new()).await?;
             }
-            _ => return Err(parse_error(resp)),
+            _ => {
+                return Err(parse_error(
+                    ErrorContext::new(ServiceOperation("GetFileStatus")),
+                    resp,
+                ));
+            }
         }
         Ok(())
     }
@@ -241,6 +246,7 @@ impl Service for WebhdfsBackend {
     type Lister = oio::PageLister<WebhdfsLister>;
     type Deleter = oio::OneShotDeleter<WebhdfsDeleter>;
     type Copier = ();
+    type Composer = ();
 
     fn info(&self) -> ServiceInfo {
         self.core.info.clone()
@@ -280,7 +286,10 @@ impl Service for WebhdfsBackend {
                     ))
                 }
             }
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("Mkdirs")),
+                resp,
+            )),
         }
     }
 
@@ -302,18 +311,23 @@ impl Service for WebhdfsBackend {
                     .file_status;
 
                 let meta = match file_status.ty {
-                    FileStatusType::Directory => Metadata::new(EntryMode::DIR),
-                    FileStatusType::File => Metadata::new(EntryMode::FILE)
-                        .with_content_length(file_status.length)
-                        .with_last_modified(Timestamp::from_millisecond(
+                    FileStatusType::Directory => MetadataBuilder::dir().build(),
+                    FileStatusType::File => {
+                        let mut metadata = MetadataBuilder::file(file_status.length);
+                        metadata.last_modified(Timestamp::from_millisecond(
                             file_status.modification_time,
-                        )?),
+                        )?);
+                        metadata.build()
+                    }
                 };
 
                 Ok(RpStat::new(meta))
             }
 
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("GetFileStatus")),
+                resp,
+            )),
         }
     }
     fn read(&self, ctx: &OperationContext, path: &str, args: OpRead) -> Result<Self::Reader> {
@@ -388,7 +402,6 @@ impl Service for WebhdfsBackend {
         _from: &str,
         _to: &str,
         _args: OpCopy,
-        _opts: OpCopier,
     ) -> Result<Self::Copier> {
         Err(Error::new(
             ErrorKind::Unsupported,