From b6b48e091ba71e273aad0d3ee4ec3b430775611f Mon Sep 17 00:00:00 2001
From: Erik Grinaker <erik@grinaker.org>
Date: Fri, 17 Nov 2023 22:57:09 +0100
Subject: [PATCH] Move debug storage engine to debug module.

---
 src/storage/debug.rs        | 60 ++++++++++++++++++++++++++++++++
 src/storage/engine/debug.rs | 69 -------------------------------------
 src/storage/engine/mod.rs   |  6 ++--
 3 files changed, 62 insertions(+), 73 deletions(-)
 delete mode 100644 src/storage/engine/debug.rs

diff --git a/src/storage/debug.rs b/src/storage/debug.rs
index eac49830e..d377487d3 100644
--- a/src/storage/debug.rs
+++ b/src/storage/debug.rs
@@ -4,6 +4,7 @@ use std::collections::HashSet;
 
 use super::bincode;
 use super::mvcc::{self, TransactionState};
+use crate::error::Result;
 
 /// Formats a raw byte string, either as a UTF-8 string (if valid and
 /// printable), otherwise hex-encoded.
@@ -88,3 +89,62 @@ pub fn format_key_value(key: &[u8], value: &Option<Vec<u8>>) -> (String, Option<
 
     (fkey, fvalue)
 }
+
+/// A debug storage engine, which wraps another engine and logs mutations.
+pub struct Engine<E: super::engine::Engine> {
+    /// The wrapped engine.
+    inner: E,
+    /// Write log as key/value tuples. Value is None for deletes.
+    write_log: Vec<(Vec<u8>, Option<Vec<u8>>)>,
+}
+
+impl<E: super::engine::Engine> std::fmt::Display for Engine<E> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "debug:{}", self.inner)
+    }
+}
+
+impl<E: super::engine::Engine> Engine<E> {
+    pub fn new(inner: E) -> Self {
+        Self { inner, write_log: Vec::new() }
+    }
+
+    /// Returns and resets the write log. The next call only returns new writes.
+    pub fn take_write_log(&mut self) -> Vec<(Vec<u8>, Option<Vec<u8>>)> {
+        let mut write_log = Vec::new();
+        std::mem::swap(&mut write_log, &mut self.write_log);
+        write_log
+    }
+}
+
+impl<E: super::engine::Engine> super::engine::Engine for Engine<E> {
+    type ScanIterator<'a> = E::ScanIterator<'a> where E: 'a;
+
+    fn flush(&mut self) -> Result<()> {
+        self.inner.flush()
+    }
+
+    fn delete(&mut self, key: &[u8]) -> Result<()> {
+        self.inner.delete(key)?;
+        self.write_log.push((key.to_vec(), None));
+        Ok(())
+    }
+
+    fn get(&mut self, key: &[u8]) -> Result<Option<Vec<u8>>> {
+        self.inner.get(key)
+    }
+
+    fn scan<R: std::ops::RangeBounds<Vec<u8>>>(&mut self, range: R) -> Self::ScanIterator<'_> {
+        self.inner.scan(range)
+    }
+
+    fn set(&mut self, key: &[u8], value: Vec<u8>) -> Result<()> {
+        self.inner.set(key, value.clone())?;
+        self.write_log.push((key.to_vec(), Some(value)));
+        Ok(())
+    }
+
+    fn status(&mut self) -> Result<super::engine::Status> {
+        self.inner.status()
+    }
+}
diff --git a/src/storage/engine/debug.rs b/src/storage/engine/debug.rs
deleted file mode 100644
index ab1b3c8b5..000000000
--- a/src/storage/engine/debug.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-use super::{Engine, Status};
-use crate::error::Result;
-
-/// A debug engine, which wraps another engine and logs mutations.
-pub struct Debug<E: Engine> {
-    /// The wrapped engine.
-    inner: E,
-    /// Write log as key/value tuples. Value is None for deletes.
-    write_log: Vec<(Vec<u8>, Option<Vec<u8>>)>,
-}
-
-impl<E: Engine> std::fmt::Display for Debug<E> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "debug:{}", self.inner)
-    }
-}
-
-impl<E: Engine> Debug<E> {
-    pub fn new(inner: E) -> Self {
-        Self { inner, write_log: Vec::new() }
-    }
-
-    /// Returns and resets the write log. The next call only returns new writes.
-    pub fn take_write_log(&mut self) -> Vec<(Vec<u8>, Option<Vec<u8>>)> {
-        let mut write_log = Vec::new();
-        std::mem::swap(&mut write_log, &mut self.write_log);
-        write_log
-    }
-}
-
-impl<E: Engine> Engine for Debug<E> {
-    type ScanIterator<'a> = E::ScanIterator<'a> where E: 'a;
-
-    fn flush(&mut self) -> Result<()> {
-        self.inner.flush()
-    }
-
-    fn delete(&mut self, key: &[u8]) -> Result<()> {
-        self.inner.delete(key)?;
-        self.write_log.push((key.to_vec(), None));
-        Ok(())
-    }
-
-    fn get(&mut self, key: &[u8]) -> Result<Option<Vec<u8>>> {
-        self.inner.get(key)
-    }
-
-    fn scan<R: std::ops::RangeBounds<Vec<u8>>>(&mut self, range: R) -> Self::ScanIterator<'_> {
-        self.inner.scan(range)
-    }
-
-    fn set(&mut self, key: &[u8], value: Vec<u8>) -> Result<()> {
-        self.inner.set(key, value.clone())?;
-        self.write_log.push((key.to_vec(), Some(value)));
-        Ok(())
-    }
-
-    fn status(&mut self) -> Result<Status> {
-        self.inner.status()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::super::Memory;
-    use super::*;
-
-    super::super::tests::test_engine!(Debug::new(Memory::new()));
-}
diff --git a/src/storage/engine/mod.rs b/src/storage/engine/mod.rs
index fcd321346..9af2d1f92 100644
--- a/src/storage/engine/mod.rs
+++ b/src/storage/engine/mod.rs
@@ -1,11 +1,9 @@
 mod bitcask;
-#[cfg(test)]
-mod debug;
 mod memory;
 
-pub use bitcask::BitCask;
 #[cfg(test)]
-pub use debug::Debug;
+pub use super::debug::Engine as Debug;
+pub use bitcask::BitCask;
 pub use memory::Memory;
 
 use crate::error::Result;