Merge memory_persister.rs into persister.rs of test_configs.

MemoryStorage is inlined into config.rs.

kvraft/src/testing_utils/config.rs

@@ -5,12 +5,10 @@ use parking_lot::Mutex;
 use rand::seq::SliceRandom;
 use rand::thread_rng;
 
-use ruaft::Persister;
-use test_configs::register_server;
+use test_configs::{register_server, Persister};
 
 use crate::client::Clerk;
 use crate::server::KVServer;
-use crate::testing_utils::memory_persister::{MemoryPersister, MemoryStorage};
 use crate::testing_utils::rpcs::register_kv_server;
 
 struct ConfigState {
@@ -22,7 +20,7 @@ pub struct Config {
     network: Arc<Mutex<labrpc::Network>>,
     server_count: usize,
     state: Mutex<ConfigState>,
-    storage: Mutex<MemoryStorage>,
+    storage: Mutex<Vec<Arc<Persister>>>,
     maxraftstate: usize,
 }
 
@@ -55,7 +53,7 @@ impl Config {
             }
         }
 
-        let persister = self.storage.lock().at(index);
+        let persister = self.storage.lock()[index].clone();
 
         let kv =
             KVServer::new(clients, index, persister, Some(self.maxraftstate));
@@ -153,9 +151,10 @@ impl Config {
             network.remove_server(Self::kv_server_name(index));
         }
 
-        let data = self.storage.lock().at(index).read();
+        let data = self.storage.lock()[index].read();
 
-        let persister = self.storage.lock().replace(index);
+        let persister = Arc::new(Persister::new());
+        self.storage.lock()[index] = persister.clone();
         persister.restore(data);
 
         if let Some(kv_server) = self.state.lock().kv_servers[index].take() {
@@ -253,10 +252,10 @@ impl Config {
     fn check_size(
         &self,
         upper: usize,
-        size_fn: impl Fn(&MemoryPersister) -> usize,
+        size_fn: impl Fn(&Persister) -> usize,
     ) -> Result<(), String> {
         let mut over_limits = String::new();
-        for (index, p) in self.storage.lock().all().iter().enumerate() {
+        for (index, p) in self.storage.lock().iter().enumerate() {
             let size = size_fn(p);
             if size > upper {
                 let str = format!(" (index {}, size {})", index, size);
@@ -273,11 +272,11 @@ impl Config {
     }
 
     pub fn check_log_size(&self, upper: usize) -> Result<(), String> {
-        self.check_size(upper, MemoryPersister::state_size)
+        self.check_size(upper, ruaft::Persister::state_size)
     }
 
     pub fn check_snapshot_size(&self, upper: usize) -> Result<(), String> {
-        self.check_size(upper, MemoryPersister::snapshot_size)
+        self.check_size(upper, Persister::snapshot_size)
     }
 }
 
@@ -298,11 +297,10 @@ pub fn make_config(
         next_clerk: 0,
     });
 
-    let mut storage = MemoryStorage::default();
-    for _ in 0..server_count {
-        storage.make();
-    }
-    let storage = Mutex::new(storage);
+    let storage = Mutex::new(vec![]);
+    storage
+        .lock()
+        .resize_with(server_count, || Arc::new(Persister::new()));
 
     let cfg = Config {
         network,

kvraft/src/testing_utils/memory_persister.rs

@@ -1,85 +0,0 @@
-use std::sync::Arc;
-
-use parking_lot::Mutex;
-
-#[derive(Clone)]
-pub struct State {
-    bytes: bytes::Bytes,
-    snapshot: Vec<u8>,
-}
-
-pub struct MemoryPersister {
-    state: Mutex<State>,
-}
-
-impl MemoryPersister {
-    pub fn new() -> Self {
-        Self {
-            state: Mutex::new(State {
-                bytes: bytes::Bytes::new(),
-                snapshot: vec![],
-            }),
-        }
-    }
-}
-
-impl ruaft::Persister for MemoryPersister {
-    fn read_state(&self) -> bytes::Bytes {
-        self.state.lock().bytes.clone()
-    }
-
-    fn save_state(&self, data: bytes::Bytes) {
-        self.state.lock().bytes = data;
-    }
-
-    fn state_size(&self) -> usize {
-        self.state.lock().bytes.len()
-    }
-
-    fn save_snapshot_and_state(&self, state: bytes::Bytes, snapshot: &[u8]) {
-        let mut this = self.state.lock();
-        this.bytes = state;
-        this.snapshot = snapshot.to_vec();
-    }
-}
-
-impl MemoryPersister {
-    pub fn read(&self) -> State {
-        self.state.lock().clone()
-    }
-
-    pub fn restore(&self, state: State) {
-        *self.state.lock() = state;
-    }
-
-    pub fn snapshot_size(&self) -> usize {
-        self.state.lock().snapshot.len()
-    }
-}
-
-#[derive(Default)]
-pub struct MemoryStorage {
-    state_vec: Vec<Arc<MemoryPersister>>,
-}
-
-impl MemoryStorage {
-    pub fn make(&mut self) -> Arc<MemoryPersister> {
-        let persister = Arc::new(MemoryPersister::new());
-        self.state_vec.push(persister.clone());
-        persister
-    }
-
-    pub fn at(&self, index: usize) -> Arc<MemoryPersister> {
-        self.state_vec[index].clone()
-    }
-
-    pub fn replace(&mut self, index: usize) -> Arc<MemoryPersister> {
-        let persister = Arc::new(MemoryPersister::new());
-        self.state_vec[index] = persister.clone();
-        persister
-    }
-
-    pub fn all(&self) -> &Vec<Arc<MemoryPersister>> {
-        &self.state_vec
-    }
-}

kvraft/src/testing_utils/mod.rs

@@ -1,4 +1,3 @@
 pub mod config;
 pub mod generic_test;
-mod memory_persister;
 mod rpcs;

test_configs/src/persister.rs

@@ -1,8 +1,9 @@
 use parking_lot::Mutex;
 
-struct State {
-    bytes: bytes::Bytes,
-    snapshot: Vec<u8>,
+#[derive(Clone)]
+pub struct State {
+    pub bytes: bytes::Bytes,
+    pub snapshot: Vec<u8>,
 }
 
 pub struct Persister {
@@ -45,3 +46,17 @@ impl ruaft::Persister for Persister {
         this.snapshot = snapshot.to_vec();
     }
 }
+
+impl Persister {
+    pub fn read(&self) -> State {
+        self.state.lock().clone()
+    }
+
+    pub fn restore(&self, state: State) {
+        *self.state.lock() = state;
+    }
+
+    pub fn snapshot_size(&self) -> usize {
+        self.state.lock().snapshot.len()
+    }
+}