Make read() only allowed in tests

Author: mkeeter

downstairs/src/extent.rs

@@ -5,7 +5,6 @@ use std::fmt::Debug;
 use std::fs::{File, OpenOptions};
 
 use anyhow::{anyhow, bail, Context, Result};
-use bytes::BufMut;
 use nix::unistd::{sysconf, SysconfVar};
 
 use serde::{Deserialize, Serialize};
@@ -54,24 +53,28 @@ pub(crate) trait ExtentInner: Send + Sync + Debug {
         requests: &[crucible_protocol::ReadRequest],
         iov_max: usize,
         out: &mut BytesMut,
-    ) -> Result<(), CrucibleError> {
-        // Call the existing read implementation, then do serialization by hand
-        // here.  Note that we serialize the individual ReadResponse values, but
-        // not the leading size, because that's already placed into the buffer.
-        let data = self.read(job_id, requests, iov_max)?;
-        let mut w = out.writer();
-        for d in data {
-            bincode::serialize_into(&mut w, &d).unwrap();
-        }
-        Ok(())
-    }
+    ) -> Result<(), CrucibleError>;
 
+    /// Read the given requests into a `Vec<ReadResponse>`
+    ///
+    /// The default implementation defers to `read_raw`, then deserializes the
+    /// resulting buffer.
+    ///
+    /// This function is only built during unit tests, because it's less
+    /// efficient than `read_raw`.
+    #[cfg(test)]
     fn read(
         &mut self,
         job_id: JobId,
         requests: &[crucible_protocol::ReadRequest],
         iov_max: usize,
-    ) -> Result<Vec<crucible_protocol::ReadResponse>, CrucibleError>;
+    ) -> Result<Vec<crucible_protocol::ReadResponse>, CrucibleError> {
+        use bytes::BufMut;
+        let mut b = BytesMut::new();
+        b.put_u64_le(requests.len() as u64);
+        self.read_raw(job_id, requests, iov_max, &mut b)?;
+        Ok(bincode::deserialize(&b).unwrap())
+    }
 
     fn write(
         &mut self,

downstairs/src/extent_inner_raw.rs

@@ -430,18 +430,6 @@ impl ExtentInner for RawInner {
         let out = RawInner::get_block_contexts(self, block, count)?;
         Ok(out.into_iter().map(|v| v.into_iter().collect()).collect())
     }
-
-    fn read(
-        &mut self,
-        job_id: JobId,
-        requests: &[crucible_protocol::ReadRequest],
-        iov_max: usize,
-    ) -> Result<Vec<crucible_protocol::ReadResponse>, CrucibleError> {
-        let mut b = BytesMut::new();
-        b.put_u64_le(requests.len() as u64);
-        self.read_raw(job_id, requests, iov_max, &mut b)?;
-        Ok(bincode::deserialize(&b).unwrap())
-    }
 }
 
 impl RawInner {

downstairs/src/extent_inner_sqlite.rs

@@ -9,6 +9,7 @@ use crate::{
 use crucible_protocol::EncryptionContext;
 
 use anyhow::{bail, Result};
+use bytes::{BufMut, BytesMut};
 use rusqlite::{params, Connection, Transaction};
 use slog::{error, Logger};
 
@@ -41,13 +42,22 @@ impl ExtentInner for SqliteInner {
         self.0.lock().unwrap().flush(new_flush, new_gen, job_id)
     }
 
-    fn read(
+    fn read_raw(
         &mut self,
         job_id: JobId,
         requests: &[crucible_protocol::ReadRequest],
         iov_max: usize,
-    ) -> Result<Vec<crucible_protocol::ReadResponse>, CrucibleError> {
-        self.0.lock().unwrap().read(job_id, requests, iov_max)
+        out: &mut BytesMut,
+    ) -> Result<(), CrucibleError> {
+        // Call the existing read implementation, then do serialization by hand
+        // here.  Note that we serialize the individual ReadResponse values, but
+        // not the leading size, because that's already placed into the buffer.
+        let data = self.0.lock().unwrap().read(job_id, requests, iov_max)?;
+        let mut w = out.writer();
+        for d in data {
+            bincode::serialize_into(&mut w, &d).unwrap();
+        }
+        Ok(())
     }
 
     fn write(