opendal 0.1.9 → 0.1.11

data/core/layers/retry/src/lib.rs

@@ -298,6 +298,7 @@ impl<I: RetryInterceptor> Service for RetryService<I> {
     type Lister = RetryWrapper<oio::Lister, I>;
     type Deleter = RetryWrapper<oio::Deleter, I>;
     type Copier = RetryWrapper<oio::Copier, I>;
+    type Composer = oio::Composer;
 
     fn info(&self) -> ServiceInfo {
         self.inner.info()
@@ -307,6 +308,10 @@ impl<I: RetryInterceptor> Service for RetryService<I> {
         self.inner.capability()
     }
 
+    fn compose(&self, ctx: &OperationContext, to: &str, args: OpCompose) -> Result<Self::Composer> {
+        self.inner.compose(ctx, to, args)
+    }
+
     async fn create_dir(
         &self,
         ctx: &OperationContext,
@@ -418,10 +423,9 @@ impl<I: RetryInterceptor> Service for RetryService<I> {
         from: &str,
         to: &str,
         args: OpCopy,
-        opts: OpCopier,
     ) -> Result<Self::Copier> {
         let mut attempt: u32 = 0;
-        let copier = { || self.inner.copy(ctx, from, to, args.clone(), opts.clone()) }
+        let copier = { || self.inner.copy(ctx, from, to, args.clone()) }
             .retry(self.builder)
             .when(|e| e.is_temporary())
             .notify(|err, dur| {
@@ -463,6 +467,29 @@ impl<I: RetryInterceptor> Service for RetryService<I> {
             .map_err(|err| err.set_persistent())
     }
 
+    async fn restore(
+        &self,
+        ctx: &OperationContext,
+        path: &str,
+        args: OpRestore,
+    ) -> Result<RpRestore> {
+        let mut attempt: u32 = 0;
+        { || self.inner.restore(ctx, path, args.clone()) }
+            .retry(self.builder)
+            .when(|e| e.is_temporary())
+            .notify(|err, dur| {
+                attempt += 1;
+                self.notify.intercept(RetryEvent {
+                    op: Operation::Restore,
+                    err,
+                    retry_after: dur,
+                    attempt,
+                })
+            })
+            .await
+            .map_err(|err| err.set_persistent())
+    }
+
     fn list(&self, ctx: &OperationContext, path: &str, args: OpList) -> Result<Self::Lister> {
         let mut attempt: u32 = 0;
         let lister = { || self.inner.list(ctx, path, args.clone()) }
@@ -765,6 +792,38 @@ impl<R: oio::Write, I: RetryInterceptor> oio::Write for RetryWrapper<R, I> {
         res.map_err(|err| err.set_persistent())
     }
 
+    async fn copy_from(&mut self, path: &str, args: OpRead, range: BytesRange) -> Result<()> {
+        use backon::RetryableWithContext;
+
+        let inner = self.take_inner()?;
+        let path = path.to_string();
+        let mut attempt: u32 = 0;
+
+        let ((inner, _, _, _), res) = {
+            |(mut r, path, args, range): (R, String, OpRead, BytesRange)| async move {
+                let res = r.copy_from(&path, args.clone(), range).await;
+
+                ((r, path, args, range), res)
+            }
+        }
+        .retry(self.builder)
+        .when(|e| e.is_temporary())
+        .context((inner, path, args, range))
+        .notify(|err, dur| {
+            attempt += 1;
+            self.notify.intercept(RetryEvent {
+                op: Operation::Write,
+                err,
+                retry_after: dur,
+                attempt,
+            })
+        })
+        .await;
+
+        self.inner = Some(inner);
+        res.map_err(|err| err.set_persistent())
+    }
+
     async fn abort(&mut self) -> Result<()> {
         use backon::RetryableWithContext;
 
@@ -1073,7 +1132,10 @@ mod tests {
     impl oio::StreamRead for MockReader {
         async fn open(&self, range: BytesRange) -> Result<(RpRead, Box<dyn oio::ReadStreamDyn>)> {
             let backend = &self.backend;
-            let rp = RpRead::new(Metadata::new(EntryMode::FILE).with_content_length(0));
+            let rp = RpRead::new({
+                let metadata = MetadataBuilder::file(13);
+                metadata.build()
+            });
             let stream = MockReadStream {
                 buf: Bytes::from("Hello, World!").into(),
                 range,
@@ -1090,6 +1152,7 @@ mod tests {
         type Lister = MockLister;
         type Deleter = MockDeleter;
         type Copier = MockCopier;
+        type Composer = ();
 
         fn info(&self) -> ServiceInfo {
             ServiceInfo::with_scheme("mock")
@@ -1123,9 +1186,10 @@ mod tests {
         }
 
         async fn stat(&self, _: &OperationContext, _: &str, _: OpStat) -> Result<RpStat> {
-            Ok(RpStat::new(
-                Metadata::new(EntryMode::FILE).with_content_length(13),
-            ))
+            Ok(RpStat::new({
+                let metadata = MetadataBuilder::file(13);
+                metadata.build()
+            }))
         }
 
         fn read(&self, _: &OperationContext, path: &str, args: OpRead) -> Result<Self::Reader> {
@@ -1152,14 +1216,7 @@ mod tests {
             Ok(lister)
         }
 
-        fn copy(
-            &self,
-            _: &OperationContext,
-            _: &str,
-            _: &str,
-            _: OpCopy,
-            _: OpCopier,
-        ) -> Result<Self::Copier> {
+        fn copy(&self, _: &OperationContext, _: &str, _: &str, _: OpCopy) -> Result<Self::Copier> {
             Ok(MockCopier {
                 attempt: self.attempt.clone(),
             })
@@ -1253,11 +1310,11 @@ mod tests {
                 .set_temporary()),
                 2 => Ok(Some(oio::Entry::new(
                     "hello",
-                    Metadata::new(EntryMode::FILE),
+                    MetadataBuilder::file(0).build(),
                 ))),
                 3 => Ok(Some(oio::Entry::new(
                     "world",
-                    Metadata::new(EntryMode::FILE),
+                    MetadataBuilder::file(0).build(),
                 ))),
                 4 => Err(
                     Error::new(ErrorKind::Unexpected, "retryable internal server error")
@@ -1265,11 +1322,11 @@ mod tests {
                 ),
                 5 => Ok(Some(oio::Entry::new(
                     "2023/",
-                    Metadata::new(EntryMode::DIR),
+                    MetadataBuilder::dir().build(),
                 ))),
                 6 => Ok(Some(oio::Entry::new(
                     "0208/",
-                    Metadata::new(EntryMode::DIR),
+                    MetadataBuilder::dir().build(),
                 ))),
                 7 => Ok(None),
                 _ => {
@@ -1354,7 +1411,7 @@ mod tests {
         }
 
         async fn close(&mut self) -> Result<Metadata> {
-            Ok(Metadata::default())
+            Ok(MetadataBuilder::unknown().build())
         }
 
         async fn abort(&mut self) -> Result<()> {

data/core/layers/route/Cargo.toml

@@ -33,10 +33,10 @@ all-features = true
 
 [dependencies]
 globset = "0.4.15"
-opendal-core = { path = "../../core", version = "0.58.1", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.0", default-features = false }
 
 [dev-dependencies]
 futures = { workspace = true }
-opendal-core = { path = "../../core", version = "0.58.1" }
-opendal-service-fs = { path = "../../services/fs", version = "0.58.1" }
+opendal-core = { path = "../../core", version = "0.59.0" }
+opendal-service-fs = { path = "../../services/fs", version = "0.59.0" }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }

data/core/layers/route/src/lib.rs

@@ -196,13 +196,29 @@ impl Service for RouteAccessor {
     type Lister = oio::Lister;
     type Deleter = oio::Deleter;
     type Copier = oio::Copier;
+    type Composer = ();
 
     fn info(&self) -> ServiceInfo {
         self.inner.info()
     }
 
     fn capability(&self) -> Capability {
-        self.inner.capability()
+        let mut capability = self.inner.capability();
+        capability.write_can_copy_from = false;
+        capability.compose = false;
+        capability.compose_with_content_type = false;
+        capability.compose_with_content_disposition = false;
+        capability.compose_with_content_encoding = false;
+        capability.compose_with_cache_control = false;
+        capability.compose_with_user_metadata = false;
+        capability.compose_with_if_match = false;
+        capability.compose_with_if_none_match = false;
+        capability.compose_with_if_version_match = false;
+        capability.compose_with_if_version_not_match = false;
+        capability.compose_with_if_not_exists = false;
+        capability.compose_with_source_version = false;
+        capability.compose_with_source_if_match = false;
+        capability
     }
 
     async fn create_dir(
@@ -237,11 +253,10 @@ impl Service for RouteAccessor {
         from: &str,
         to: &str,
         args: OpCopy,
-        opts: OpCopier,
     ) -> Result<oio::Copier> {
         match self.select(from) {
-            RouteSelected::Default(srv) => srv.copy(ctx, from, to, args, opts),
-            RouteSelected::Target(target) => target.srv.copy(&target.ctx, from, to, args, opts),
+            RouteSelected::Default(srv) => srv.copy(ctx, from, to, args),
+            RouteSelected::Target(target) => target.srv.copy(&target.ctx, from, to, args),
         }
     }
 
@@ -258,6 +273,18 @@ impl Service for RouteAccessor {
         }
     }
 
+    async fn restore(
+        &self,
+        ctx: &OperationContext,
+        path: &str,
+        args: OpRestore,
+    ) -> Result<RpRestore> {
+        match self.select(path) {
+            RouteSelected::Default(srv) => srv.restore(ctx, path, args).await,
+            RouteSelected::Target(target) => target.srv.restore(&target.ctx, path, args).await,
+        }
+    }
+
     async fn stat(&self, ctx: &OperationContext, path: &str, args: OpStat) -> Result<RpStat> {
         match self.select(path) {
             RouteSelected::Default(srv) => srv.stat(ctx, path, args).await,
@@ -467,6 +494,7 @@ mod tests {
         type Lister = ();
         type Deleter = ();
         type Copier = ();
+        type Composer = ();
 
         fn info(&self) -> ServiceInfo {
             self.info.clone()
@@ -496,7 +524,7 @@ mod tests {
 
         async fn stat(&self, _: &OperationContext, path: &str, _: OpStat) -> Result<RpStat> {
             if self.paths.lock().unwrap().contains(path) {
-                Ok(RpStat::new(Metadata::new(EntryMode::FILE)))
+                Ok(RpStat::new(MetadataBuilder::file(0).build()))
             } else {
                 Err(Error::new(ErrorKind::NotFound, "path not found"))
             }
@@ -536,7 +564,6 @@ mod tests {
             from: &str,
             to: &str,
             _: OpCopy,
-            _: OpCopier,
         ) -> Result<Self::Copier> {
             if !self.paths.lock().unwrap().contains(from) {
                 return Err(Error::new(ErrorKind::NotFound, "source not found"));
@@ -580,7 +607,7 @@ mod tests {
 
         async fn close(&mut self) -> Result<Metadata> {
             self.paths.lock().unwrap().insert(self.path.clone());
-            Ok(Metadata::new(EntryMode::FILE))
+            Ok(MetadataBuilder::unknown().build())
         }
 
         async fn abort(&mut self) -> Result<()> {

data/core/layers/tail-cut/Cargo.toml

@@ -32,9 +32,9 @@ version = { workspace = true }
 all-features = true
 
 [dependencies]
-opendal-core = { path = "../../core", version = "0.58.1", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.0", default-features = false }
 tokio = { workspace = true, features = ["time"] }
 
 [dev-dependencies]
-opendal-core = { path = "../../core", version = "0.58.1" }
+opendal-core = { path = "../../core", version = "0.59.0" }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }

data/core/layers/tail-cut/src/lib.rs

@@ -371,6 +371,7 @@ impl Service for TailCutService {
     type Lister = TailCutWrapper<oio::Lister>;
     type Deleter = TailCutWrapper<oio::Deleter>;
     type Copier = TailCutWrapper<oio::Copier>;
+    type Composer = oio::Composer;
 
     fn info(&self) -> ServiceInfo {
         self.inner.info()
@@ -380,6 +381,10 @@ impl Service for TailCutService {
         self.inner.capability()
     }
 
+    fn compose(&self, ctx: &OperationContext, to: &str, args: OpCompose) -> Result<Self::Composer> {
+        self.inner.compose(ctx, to, args)
+    }
+
     async fn create_dir(
         &self,
         ctx: &OperationContext,
@@ -412,10 +417,9 @@ impl Service for TailCutService {
         from: &str,
         to: &str,
         args: OpCopy,
-        opts: OpCopier,
     ) -> Result<Self::Copier> {
         self.inner
-            .copy(ctx, from, to, args, opts)
+            .copy(ctx, from, to, args)
             .map(|c| TailCutWrapper::new(c, None, self.config.clone(), self.stats.clone()))
     }
 
@@ -434,6 +438,15 @@ impl Service for TailCutService {
         .await
     }
 
+    async fn restore(
+        &self,
+        ctx: &OperationContext,
+        path: &str,
+        args: OpRestore,
+    ) -> Result<RpRestore> {
+        self.inner.restore(ctx, path, args).await
+    }
+
     async fn stat(&self, ctx: &OperationContext, path: &str, args: OpStat) -> Result<RpStat> {
         self.with_deadline(Operation::Stat, None, self.inner.stat(ctx, path, args))
             .await
@@ -615,6 +628,19 @@ impl<R: oio::Write> oio::Write for TailCutWrapper<R> {
         .await
     }
 
+    async fn copy_from(&mut self, path: &str, args: OpRead, range: BytesRange) -> Result<()> {
+        let deadline = self.calculate_deadline(Operation::Write);
+        Self::with_io_deadline(
+            deadline,
+            self.config.percentile,
+            &self.stats,
+            self.size,
+            Operation::Write,
+            self.inner.copy_from(path, args, range),
+        )
+        .await
+    }
+
     async fn close(&mut self) -> Result<Metadata> {
         let deadline = self.calculate_deadline(Operation::Write);
         Self::with_io_deadline(

data/core/layers/throttle/Cargo.toml

@@ -33,7 +33,7 @@ all-features = true
 
 [dependencies]
 governor = "0.10.4"
-opendal-core = { path = "../../core", version = "0.58.1", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.0", default-features = false }
 
 [dev-dependencies]
-opendal-core = { path = "../../core", version = "0.58.1" }
+opendal-core = { path = "../../core", version = "0.59.0" }

data/core/layers/throttle/src/lib.rs

@@ -118,6 +118,7 @@ impl Service for ThrottleAccessor {
     type Lister = oio::Lister;
     type Deleter = oio::Deleter;
     type Copier = oio::Copier;
+    type Composer = oio::Composer;
 
     fn info(&self) -> ServiceInfo {
         self.inner.info()
@@ -127,6 +128,10 @@ impl Service for ThrottleAccessor {
         self.inner.capability()
     }
 
+    fn compose(&self, ctx: &OperationContext, to: &str, args: OpCompose) -> Result<Self::Composer> {
+        self.inner.compose(ctx, to, args)
+    }
+
     async fn create_dir(
         &self,
         ctx: &OperationContext,
@@ -162,9 +167,8 @@ impl Service for ThrottleAccessor {
         from: &str,
         to: &str,
         args: OpCopy,
-        opts: OpCopier,
     ) -> Result<Self::Copier> {
-        self.inner.copy(ctx, from, to, args, opts)
+        self.inner.copy(ctx, from, to, args)
     }
 
     fn delete(&self, ctx: &OperationContext) -> Result<Self::Deleter> {
@@ -181,6 +185,15 @@ impl Service for ThrottleAccessor {
         self.inner.rename(ctx, from, to, args).await
     }
 
+    async fn restore(
+        &self,
+        ctx: &OperationContext,
+        path: &str,
+        args: OpRestore,
+    ) -> Result<RpRestore> {
+        self.inner.restore(ctx, path, args).await
+    }
+
     fn list(&self, ctx: &OperationContext, path: &str, args: OpList) -> Result<Self::Lister> {
         self.inner.list(ctx, path, args)
     }
@@ -258,6 +271,10 @@ impl<R: oio::Write> oio::Write for ThrottleWrapper<R> {
         self.inner.write(bs).await
     }
 
+    async fn copy_from(&mut self, path: &str, args: OpRead, range: BytesRange) -> Result<()> {
+        self.inner.copy_from(path, args, range).await
+    }
+
     async fn close(&mut self) -> Result<Metadata> {
         self.inner.close().await
     }

data/core/layers/timeout/Cargo.toml

@@ -32,11 +32,11 @@ version = { workspace = true }
 all-features = true
 
 [dependencies]
-opendal-core = { path = "../../core", version = "0.58.1", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.0", default-features = false }
 tokio = { workspace = true, features = ["time"] }
 
 [dev-dependencies]
 futures = { workspace = true }
-opendal-core = { path = "../../core", version = "0.58.1" }
-opendal-layer-retry = { path = "../retry", version = "0.58.1" }
+opendal-core = { path = "../../core", version = "0.59.0" }
+opendal-layer-retry = { path = "../retry", version = "0.59.0" }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }

data/core/layers/timeout/src/lib.rs

@@ -206,6 +206,7 @@ impl Service for TimeoutService {
     type Lister = TimeoutWrapper<oio::Lister>;
     type Deleter = TimeoutWrapper<oio::Deleter>;
     type Copier = TimeoutWrapper<oio::Copier>;
+    type Composer = TimeoutWrapper<oio::Composer>;
 
     fn info(&self) -> ServiceInfo {
         self.inner.info()
@@ -243,10 +244,15 @@ impl Service for TimeoutService {
         from: &str,
         to: &str,
         args: OpCopy,
-        opts: OpCopier,
     ) -> Result<Self::Copier> {
         self.inner
-            .copy(ctx, from, to, args, opts)
+            .copy(ctx, from, to, args)
+            .map(|c| TimeoutWrapper::new(c, self.io_timeout))
+    }
+
+    fn compose(&self, ctx: &OperationContext, to: &str, args: OpCompose) -> Result<Self::Composer> {
+        self.inner
+            .compose(ctx, to, args)
             .map(|c| TimeoutWrapper::new(c, self.io_timeout))
     }
 
@@ -261,6 +267,16 @@ impl Service for TimeoutService {
             .await
     }
 
+    async fn restore(
+        &self,
+        ctx: &OperationContext,
+        path: &str,
+        args: OpRestore,
+    ) -> Result<RpRestore> {
+        self.timeout(Operation::Restore, self.inner.restore(ctx, path, args))
+            .await
+    }
+
     async fn stat(&self, ctx: &OperationContext, path: &str, args: OpStat) -> Result<RpStat> {
         self.timeout(Operation::Stat, self.inner.stat(ctx, path, args))
             .await
@@ -374,6 +390,11 @@ impl<R: oio::Write> oio::Write for TimeoutWrapper<R> {
         Self::io_timeout(self.timeout, Operation::Write.into_static(), fut).await
     }
 
+    async fn copy_from(&mut self, path: &str, args: OpRead, range: BytesRange) -> Result<()> {
+        let fut = self.inner.copy_from(path, args, range);
+        Self::io_timeout(self.timeout, Operation::Write.into_static(), fut).await
+    }
+
     async fn close(&mut self) -> Result<Metadata> {
         let fut = self.inner.close();
         Self::io_timeout(self.timeout, Operation::Write.into_static(), fut).await
@@ -421,6 +442,18 @@ impl<C: oio::Copy> oio::Copy for TimeoutWrapper<C> {
     }
 }
 
+impl<C: oio::Compose> oio::Compose for TimeoutWrapper<C> {
+    async fn compose(&mut self, path: &str, args: OpRead) -> Result<()> {
+        let fut = self.inner.compose(path, args);
+        Self::io_timeout(self.timeout, Operation::Compose.into_static(), fut).await
+    }
+
+    async fn close(&mut self) -> Result<Metadata> {
+        let fut = self.inner.close();
+        Self::io_timeout(self.timeout, Operation::Compose.into_static(), fut).await
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::future::pending;
@@ -439,6 +472,7 @@ mod tests {
         type Lister = MockLister;
         type Deleter = MockDeleter;
         type Copier = MockCopier;
+        type Composer = ();
 
         fn info(&self) -> ServiceInfo {
             ServiceInfo::with_scheme("mock")
@@ -494,14 +528,7 @@ mod tests {
             Ok(MockLister)
         }
 
-        fn copy(
-            &self,
-            _: &OperationContext,
-            _: &str,
-            _: &str,
-            _: OpCopy,
-            _: OpCopier,
-        ) -> Result<Self::Copier> {
+        fn copy(&self, _: &OperationContext, _: &str, _: &str, _: OpCopy) -> Result<Self::Copier> {
             Ok(MockCopier)
         }
 
@@ -651,9 +678,7 @@ mod tests {
             .with_io_timeout(Duration::from_millis(100))
             .apply_service(Arc::new(MockService));
         let ctx = OperationContext::new();
-        let mut copier = service
-            .copy(&ctx, "f", "t", OpCopy::default(), OpCopier::default())
-            .unwrap();
+        let mut copier = service.copy(&ctx, "f", "t", OpCopy::default()).unwrap();
 
         let err = copier.next().await.unwrap_err();
         assert!(err.to_string().contains("timeout"));

data/core/layers/tracing/Cargo.toml

@@ -34,13 +34,13 @@ all-features = true
 [dependencies]
 futures = { workspace = true }
 http = { workspace = true }
-opendal-core = { path = "../../core", version = "0.58.1", default-features = false }
+opendal-core = { path = "../../core", version = "0.59.0", default-features = false }
 tracing = "0.1"
 
 [dev-dependencies]
 anyhow = "1.0"
 dotenvy = "0.15"
-opendal-core = { path = "../../core", version = "0.58.1" }
+opendal-core = { path = "../../core", version = "0.59.0" }
 opentelemetry = { version = "0.32.0", default-features = false, features = [
   "trace",
 ] }

data/core/layers/tracing/src/lib.rs

@@ -224,6 +224,7 @@ impl Service for TracingService {
     type Lister = TracingWrapper<oio::Lister>;
     type Deleter = TracingWrapper<oio::Deleter>;
     type Copier = oio::Copier;
+    type Composer = oio::Composer;
 
     fn info(&self) -> ServiceInfo {
         self.inner.info()
@@ -233,6 +234,10 @@ impl Service for TracingService {
         self.inner.capability()
     }
 
+    fn compose(&self, ctx: &OperationContext, to: &str, args: OpCompose) -> Result<Self::Composer> {
+        self.inner.compose(ctx, to, args)
+    }
+
     async fn create_dir(
         &self,
         ctx: &OperationContext,
@@ -266,11 +271,10 @@ impl Service for TracingService {
         from: &str,
         to: &str,
         args: OpCopy,
-        opts: OpCopier,
     ) -> Result<Self::Copier> {
-        let span = span!(Level::DEBUG, "copy", from, to, ?args, ?opts);
+        let span = span!(Level::DEBUG, "copy", from, to, ?args);
         let _guard = span.enter();
-        self.inner.copy(ctx, from, to, args, opts)
+        self.inner.copy(ctx, from, to, args)
     }
 
     async fn rename(
@@ -287,6 +291,16 @@ impl Service for TracingService {
             .await
     }
 
+    async fn restore(
+        &self,
+        ctx: &OperationContext,
+        path: &str,
+        args: OpRestore,
+    ) -> Result<RpRestore> {
+        let span = span!(Level::DEBUG, "restore", path, ?args);
+        self.inner.restore(ctx, path, args).instrument(span).await
+    }
+
     async fn stat(&self, ctx: &OperationContext, path: &str, args: OpStat) -> Result<RpStat> {
         let span = span!(Level::DEBUG, "stat", path, ?args);
         self.inner.stat(ctx, path, args).instrument(span).await
@@ -354,6 +368,13 @@ impl<R: oio::Write> oio::Write for TracingWrapper<R> {
         self.inner.write(bs).instrument(self.span.clone()).await
     }
 
+    async fn copy_from(&mut self, path: &str, args: OpRead, range: BytesRange) -> Result<()> {
+        self.inner
+            .copy_from(path, args, range)
+            .instrument(self.span.clone())
+            .await
+    }
+
     async fn abort(&mut self) -> Result<()> {
         self.inner.abort().instrument(self.span.clone()).await
     }

data/core/services/aliyun-drive/Cargo.toml

@@ -32,11 +32,11 @@ version = { workspace = true }
 all-features = true
 
 [dependencies]
+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 }