opendal 0.1.9 → 0.1.11

data/core/services/onedrive/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::*;
@@ -51,6 +51,17 @@ impl oio::StreamRead for OnedriveReader {
         let backend = &self.backend;
         let path = self.path.as_str();
         let args = self.args.clone();
+        let range = match range {
+            BytesRange::Suffix { size } => {
+                let content_length = backend
+                    .core
+                    .onedrive_stat(&self.ctx, path, OpStat::default())
+                    .await?
+                    .content_length();
+                BytesRange::new(content_length.saturating_sub(size), None)
+            }
+            range => range,
+        };
         let response = backend
             .core
             .onedrive_get_content(&self.ctx, path, range, &args)
@@ -63,7 +74,11 @@ impl oio::StreamRead for OnedriveReader {
             _ => {
                 let (part, mut body) = response.into_parts();
                 let buf = body.to_buffer().await?;
-                return Err(parse_error(Response::from_parts(part, buf)));
+                return Err(parse_error(
+                    ErrorContext::new(ServiceOperation("DownloadContent"))
+                        .with_caller_condition(args.is_conditional()),
+                    Response::from_parts(part, buf),
+                ));
             }
         };
 

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

@@ -24,8 +24,8 @@ use http::StatusCode;
 use opendal_core::raw::*;
 use opendal_core::*;
 
-use super::core::OneDriveCore;
 use super::core::parse_error;
+use super::core::{ErrorContext, OneDriveCore};
 use super::graph_model::OneDriveItem;
 use super::graph_model::OneDriveUploadSessionCreationResponseBody;
 
@@ -82,17 +82,20 @@ impl OneDriveWriter {
                 let item: OneDriveItem = serde_json::from_reader(response.into_body().reader())
                     .map_err(new_json_deserialize_error)?;
 
-                let mut meta = Metadata::new(EntryMode::FILE)
-                    .with_etag(item.e_tag)
-                    .with_content_length(item.size.max(0) as u64);
+                let mut meta = MetadataBuilder::file(item.size.max(0) as u64);
+                meta.etag(item.e_tag);
 
                 let last_modified = item.last_modified_date_time;
                 let date_utc_last_modified = last_modified.parse::<Timestamp>()?;
-                meta.set_last_modified(date_utc_last_modified);
+                meta.last_modified(date_utc_last_modified);
 
-                Ok(meta)
+                Ok(meta.build())
             }
-            _ => Err(parse_error(response)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("UploadContent"))
+                    .with_caller_condition(self.op.is_conditional()),
+                response,
+            )),
         }
     }
 
@@ -138,16 +141,20 @@ impl OneDriveWriter {
                     let item: OneDriveItem = serde_json::from_reader(response.into_body().reader())
                         .map_err(new_json_deserialize_error)?;
 
-                    let mut meta = Metadata::new(EntryMode::FILE)
-                        .with_etag(item.e_tag)
-                        .with_content_length(item.size.max(0) as u64);
+                    let mut meta = MetadataBuilder::file(item.size.max(0) as u64);
+                    meta.etag(item.e_tag);
 
                     let last_modified = item.last_modified_date_time;
                     let date_utc_last_modified = last_modified.parse::<Timestamp>()?;
-                    meta.set_last_modified(date_utc_last_modified);
-                    return Ok(meta);
+                    meta.last_modified(date_utc_last_modified);
+                    return Ok(meta.build());
+                }
+                _ => {
+                    return Err(parse_error(
+                        ErrorContext::new(ServiceOperation("UploadFragment")),
+                        response,
+                    ));
                 }
-                _ => return Err(parse_error(response)),
             }
 
             offset += OneDriveWriter::CHUNK_SIZE_FACTOR;
@@ -155,7 +162,7 @@ impl OneDriveWriter {
 
         debug_assert!(false, "should have returned");
 
-        Ok(Metadata::default()) // should not happen, but start with handling this gracefully - do nothing, but return the default metadata
+        Ok(MetadataBuilder::unknown().build()) // should not happen, but start with handling this gracefully - do nothing, but return the default metadata
     }
 
     async fn create_upload_session(&self) -> Result<OneDriveUploadSessionCreationResponseBody> {
@@ -170,7 +177,11 @@ impl OneDriveWriter {
                     serde_json::from_reader(bs.reader()).map_err(new_json_deserialize_error)?;
                 Ok(result)
             }
-            _ => Err(parse_error(response)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("CreateUploadSession"))
+                    .with_caller_condition(self.op.is_conditional()),
+                response,
+            )),
         }
     }
 }

data/core/services/opfs/Cargo.toml

@@ -35,7 +35,7 @@ targets = ["wasm32-unknown-unknown"]
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 js-sys = "0.3.77"
-opendal-core = { path = "../../core", version = "0.58.1", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.0", default-features = false }
 send_wrapper = "0.6"
 serde = { workspace = true, features = ["derive"] }
 wasm-bindgen = "0.2.100"

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

@@ -73,6 +73,7 @@ impl Service for OpfsBackend {
     type Lister = OpfsLister;
     type Deleter = oio::OneShotDeleter<OpfsDeleter>;
     type Copier = ();
+    type Composer = ();
 
     fn info(&self) -> ServiceInfo {
         self.core.info.clone()
@@ -87,7 +88,7 @@ impl Service for OpfsBackend {
 
         if p.ends_with('/') {
             get_directory_handle(&p, false).await?;
-            return Ok(RpStat::new(Metadata::new(EntryMode::DIR)));
+            return Ok(RpStat::new(MetadataBuilder::dir().build()));
         }
 
         // File: get metadata via getFile().
@@ -97,13 +98,12 @@ impl Service for OpfsBackend {
             .and_then(JsCast::dyn_into)
             .map_err(parse_js_error)?;
 
-        let mut meta = Metadata::new(EntryMode::FILE);
-        meta.set_content_length(file.size() as u64);
+        let mut meta = MetadataBuilder::file(file.size() as u64);
         if let Ok(t) = Timestamp::from_millisecond(file.last_modified() as i64) {
-            meta.set_last_modified(t);
+            meta.last_modified(t);
         }
 
-        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<OpfsReader> = {
@@ -152,14 +152,7 @@ impl Service for OpfsBackend {
         Ok(output)
     }
 
-    fn copy(
-        &self,
-        _: &OperationContext,
-        _: &str,
-        _: &str,
-        _: OpCopy,
-        _: OpCopier,
-    ) -> Result<Self::Copier> {
+    fn copy(&self, _: &OperationContext, _: &str, _: &str, _: OpCopy) -> Result<Self::Copier> {
         Err(Error::new(
             ErrorKind::Unsupported,
             "operation is not supported",

data/core/services/opfs/src/core.rs

@@ -57,46 +57,42 @@ impl OpfsCore {
     }
 }
 
-mod error {
-    use wasm_bindgen::JsCast;
-    use wasm_bindgen::JsValue;
-    use web_sys::DomException;
-
-    use opendal_core::Error;
-    use opendal_core::ErrorKind;
-
-    pub(crate) fn parse_js_error(value: JsValue) -> Error {
-        if let Some(exc) = value.dyn_ref::<DomException>() {
-            let kind = match exc.name().as_str() {
-                "NotFoundError" => ErrorKind::NotFound,
-                "TypeMismatchError" => ErrorKind::NotFound,
-                "NotAllowedError" => ErrorKind::PermissionDenied,
-                "QuotaExceededError" => ErrorKind::Unexpected,
-                e => {
-                    console_debug!("Got unhandled DOM exception {e:?}");
-                    ErrorKind::Unexpected
-                }
-            };
-            return Error::new(kind, exc.message());
-        }
-
-        // FIXME: how to map `TypeError`` from `getDirectoryHandle`:
-        // "name specified is not a valid string or contains characters that
-        // would interfere with the native file system"
-        if let Some(err) = value.dyn_ref::<js_sys::Error>() {
-            return Error::new(ErrorKind::Unexpected, String::from(err.message()));
-        }
+use wasm_bindgen::JsCast;
+use wasm_bindgen::JsValue;
+use web_sys::DomException;
+
+use opendal_core::Error;
+use opendal_core::ErrorKind;
+
+pub(crate) fn parse_js_error(value: JsValue) -> Error {
+    if let Some(exc) = value.dyn_ref::<DomException>() {
+        let kind = match exc.name().as_str() {
+            "NotFoundError" => ErrorKind::NotFound,
+            "TypeMismatchError" => ErrorKind::NotFound,
+            "NotAllowedError" => ErrorKind::PermissionDenied,
+            "QuotaExceededError" => ErrorKind::Unexpected,
+            e => {
+                console_debug!("Got unhandled DOM exception {e:?}");
+                ErrorKind::Unexpected
+            }
+        };
+        return Error::new(kind, exc.message());
+    }
 
-        Error::new(
-            ErrorKind::Unexpected,
-            value
-                .as_string()
-                .unwrap_or_else(|| "unknown JS error".to_string()),
-        )
+    // FIXME: how to map `TypeError`` from `getDirectoryHandle`:
+    // "name specified is not a valid string or contains characters that
+    // would interfere with the native file system"
+    if let Some(err) = value.dyn_ref::<js_sys::Error>() {
+        return Error::new(ErrorKind::Unexpected, String::from(err.message()));
     }
-}
 
-pub(super) use error::*;
+    Error::new(
+        ErrorKind::Unexpected,
+        value
+            .as_string()
+            .unwrap_or_else(|| "unknown JS error".to_string()),
+    )
+}
 
 mod utils {
     use opendal_core::Result;

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

@@ -88,12 +88,12 @@ impl oio::List for OpfsLister {
             .and_then(|v| v.as_string())
             .unwrap_or_default();
 
-        let (entry_path, mode) = if kind == "directory" {
-            (format!("{}{}/", self.path, name), EntryMode::DIR)
+        let (entry_path, metadata) = if kind == "directory" {
+            (format!("{}{}/", self.path, name), MetadataBuilder::dir())
         } else {
-            (format!("{}{}", self.path, name), EntryMode::FILE)
+            (format!("{}{}", self.path, name), MetadataBuilder::unknown())
         };
 
-        Ok(Some(oio::Entry::new(&entry_path, Metadata::new(mode))))
+        Ok(Some(oio::Entry::new(&entry_path, metadata.build())))
     }
 }

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

@@ -101,9 +101,7 @@ impl oio::Write for OpfsWriter {
         }
 
         // We cannot set LastModified here - stream does not have such metadata
-        let mut meta = Metadata::new(EntryMode::FILE);
-        meta.set_content_length(self.bytes_written);
-        Ok(meta)
+        Ok(MetadataBuilder::file(self.bytes_written).build())
     }
 
     async fn abort(&mut self) -> Result<()> {

data/core/services/oss/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"] }

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

@@ -643,6 +643,7 @@ impl Service for OssBackend {
     type Lister = OssListers;
     type Deleter = oio::BatchDeleter<OssDeleter>;
     type Copier = oio::OneShotCopier;
+    type Composer = ();
 
     fn info(&self) -> ServiceInfo {
         self.core.info.clone()
@@ -672,15 +673,22 @@ impl Service for OssBackend {
         match status {
             StatusCode::OK => {
                 let headers = resp.headers();
-                let mut meta = self.core.parse_metadata(path, resp.headers())?;
+                let mut meta = self
+                    .core
+                    .parse_metadata(path, resp.headers())?
+                    .into_builder();
 
                 if let Some(v) = parse_header_to_str(headers, constants::X_OSS_VERSION_ID)? {
-                    meta.set_version(v);
+                    meta.version(v);
                 }
 
-                Ok(RpStat::new(meta))
+                Ok(RpStat::new(meta.build()))
             }
-            _ => Err(parse_error(resp)),
+            _ => Err(parse_error(
+                ErrorContext::new(ServiceOperation("HeadObject"))
+                    .with_caller_condition(args.is_conditional()),
+                resp,
+            )),
         }
     }
     fn read(&self, ctx: &OperationContext, path: &str, args: OpRead) -> Result<Self::Reader> {
@@ -758,20 +766,44 @@ impl Service for OssBackend {
         ctx: &OperationContext,
         from: &str,
         to: &str,
-        _args: OpCopy,
-        _opts: OpCopier,
+        args: OpCopy,
     ) -> Result<Self::Copier> {
         let core = self.core.clone();
         let ctx = ctx.clone();
         let from = from.to_string();
         let to = to.to_string();
         Ok(oio::OneShotCopier::new(async move {
+            let source_size = match args.source_content_length_hint() {
+                Some(size) => size,
+                None => {
+                    let stat_args: OpStat = options::StatOptions {
+                        version: args.source_version().map(str::to_owned),
+                        ..Default::default()
+                    }
+                    .into();
+                    let resp = core.oss_head_object(&ctx, &from, &stat_args).await?;
+                    match resp.status() {
+                        StatusCode::OK => {
+                            parse_into_metadata(&from, resp.headers())?.content_length()
+                        }
+                        _ => {
+                            return Err(parse_error(
+                                ErrorContext::new(ServiceOperation("HeadObject")),
+                                resp,
+                            ));
+                        }
+                    }
+                }
+            };
             let resp = core.oss_copy_object(&ctx, &from, &to).await?;
             let status = resp.status();
 
             match status {
-                StatusCode::OK => Ok(Metadata::default()),
-                _ => Err(parse_error(resp)),
+                StatusCode::OK => Ok(MetadataBuilder::file(source_size).build()),
+                _ => Err(parse_error(
+                    ErrorContext::new(ServiceOperation("CopyObject")),
+                    resp,
+                )),
             }
         }))
     }