adapt to new oio::Read

core/src/services/compfs/backend.rs

@@ -97,15 +97,15 @@ impl Access for CompfsBackend {
         am
     }
 
-    async fn read(&self, path: &str, _: OpRead) -> Result<(RpRead, Self::Reader)> {
+    async fn read(&self, path: &str, op: OpRead) -> Result<(RpRead, Self::Reader)> {
         let path = self.core.root.join(path.trim_end_matches('/'));
 
         let file = self
             .core
             .exec(|| async move { compio::fs::OpenOptions::new().read(true).open(&path).await })
             .await?;
 
-        let r = CompfsReader::new(self.core.clone(), file);
+        let r = CompfsReader::new(self.core.clone(), file, op.range());
         Ok((RpRead::new(), r))
     }
 

core/src/services/compfs/reader.rs

@@ -26,25 +26,27 @@ use crate::*;
 #[derive(Debug)]
 pub struct CompfsReader {
     core: Arc<CompfsCore>,
-    f: compio::fs::File,
+    file: compio::fs::File,
+    range: BytesRange,
 }
 
 impl CompfsReader {
-    pub fn new(core: Arc<CompfsCore>, f: compio::fs::File) -> Self {
-        Self { core, f }
+    pub fn new(core: Arc<CompfsCore>, file: compio::fs::File, range: BytesRange) -> Self {
+        Self { core, file, range }
     }
 }
 
 impl oio::Read for CompfsReader {
-    async fn read_at(&self, offset: u64, limit: usize) -> Result<Buffer> {
+    async fn read(&mut self) -> Result<Buffer> {
         let mut bs = self.core.buf_pool.get();
-        bs.reserve(limit);
-        let f = self.f.clone();
+
+        let len = self.range.size().expect("range size is always Some");
+        bs.reserve(len as _);
+        let f = self.file.clone();
         let mut bs = self
             .core
             .exec(move || async move {
-                let (_, bs) = buf_try!(@try f.read_at(bs, offset).await);
-
+                let (_, bs) = buf_try!(@try f.read_at(bs, len).await);
                 Ok(bs)
             })
             .await?;