1use std::collections::BTreeMap;
2use std::fs;
3use std::io;
4use std::path::{Path, PathBuf};
5use std::sync::{Arc, RwLock};
6
7pub mod wal;
8pub mod sstable;
9pub mod memtable;
10
11use sstable::SSTable;
12use memtable::MemTable;
13
14#[derive(Debug)]
15pub enum StoreError {
16 IO(io::Error),
17 Lock,
18 Other(String),
19}
20
21impl std::fmt::Display for StoreError {
22 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
23 match self {
24 StoreError::IO(err) => write!(f, "IO Error: {}", err),
25 StoreError::Lock => write!(f, "Thread Lock Poisoned"),
26 StoreError::Other(msg) => write!(f, "Store Error: {}", msg),
27 }
28 }
29}
30
31impl std::error::Error for StoreError {}
32
33impl From<io::Error> for StoreError {
34 fn from(err: io::Error) -> Self {
35 StoreError::IO(err)
36 }
37}
38
39const FLUSH_THRESHOLD_BYTES: usize = 4 * 1024 * 1024;
41
42pub struct SynapseStore {
43 db_dir: PathBuf,
44 memtable: Arc<RwLock<MemTable>>,
45 sstables: Arc<RwLock<Vec<(u32, SSTable)>>>, }
47
48impl SynapseStore {
49 pub fn open<P: AsRef<Path>>(dir: P) -> Result<Self, StoreError> {
51 let db_dir = dir.as_ref().to_path_buf();
52 fs::create_dir_all(&db_dir)?;
53
54 let mut sst_files = Vec::new();
56 for entry in fs::read_dir(&db_dir)? {
57 let entry = entry?;
58 let path = entry.path();
59 if path.is_file() {
60 let filename = path.file_name().unwrap().to_string_lossy();
61 if filename.starts_with("sst_") && filename.ends_with(".db") {
62 let idx_str = &filename[4..filename.len() - 3];
64 if let Ok(idx) = idx_str.parse::<u32>() {
65 sst_files.push((idx, path));
66 }
67 }
68 }
69 }
70
71 sst_files.sort_by_key(|(idx, _)| *idx);
73
74 let mut sstables = Vec::new();
75 for (idx, path) in sst_files {
76 let table = SSTable::open(path)?;
77 sstables.push((idx, table));
78 }
79
80 sstables.reverse();
82
83 let wal_path = db_dir.join("wal.log");
85 let memtable = MemTable::open(wal_path)?;
86
87 Ok(Self {
88 db_dir,
89 memtable: Arc::new(RwLock::new(memtable)),
90 sstables: Arc::new(RwLock::new(sstables)),
91 })
92 }
93
94 pub fn put(&self, key: &[u8], val: &[u8]) -> Result<(), StoreError> {
96 let mut mem = self.memtable.write().map_err(|_| StoreError::Lock)?;
97 mem.put(key.to_vec(), val.to_vec())?;
98
99 if mem.size_bytes >= FLUSH_THRESHOLD_BYTES {
101 drop(mem); self.flush()?;
103 }
104 Ok(())
105 }
106
107 pub fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>, StoreError> {
109 {
111 let mem = self.memtable.read().map_err(|_| StoreError::Lock)?;
112 if let Some(val_opt) = mem.get(key) {
113 return Ok(val_opt.clone());
114 }
115 }
116
117 let mut ssts = self.sstables.write().map_err(|_| StoreError::Lock)?;
119 for (_, sst) in ssts.iter_mut() {
120 if let Some(val_opt) = sst.get(key)? {
121 return Ok(val_opt); }
123 }
124
125 Ok(None)
126 }
127
128 pub fn delete(&self, key: &[u8]) -> Result<(), StoreError> {
130 let mut mem = self.memtable.write().map_err(|_| StoreError::Lock)?;
131 mem.delete(key.to_vec())?;
132
133 if mem.size_bytes >= FLUSH_THRESHOLD_BYTES {
134 drop(mem);
135 self.flush()?;
136 }
137 Ok(())
138 }
139
140 pub fn flush(&self) -> Result<(), StoreError> {
142 let mut mem = self.memtable.write().map_err(|_| StoreError::Lock)?;
143 if mem.map.is_empty() {
144 return Ok(());
145 }
146
147 let snapshot = mem.clear_and_reset()?;
149 drop(mem); let mut ssts = self.sstables.write().map_err(|_| StoreError::Lock)?;
152
153 let next_idx = ssts.iter().map(|(idx, _)| *idx).max().unwrap_or(0) + 1;
155 let sst_filename = format!("sst_{:05}.db", next_idx);
156 let sst_path = self.db_dir.join(&sst_filename);
157
158 let sorted_data: Vec<(Vec<u8>, Option<Vec<u8>>)> = snapshot.into_iter().collect();
160 SSTable::write_new(&sst_path, &sorted_data)?;
161
162 let sst_reader = SSTable::open(&sst_path)?;
164 ssts.insert(0, (next_idx, sst_reader));
165
166 Ok(())
167 }
168
169 pub fn compact(&self) -> Result<(), StoreError> {
171 let _mem_lock = self.memtable.write().map_err(|_| StoreError::Lock)?;
173
174 let mut ssts = self.sstables.write().map_err(|_| StoreError::Lock)?;
175 if ssts.len() <= 1 {
176 return Ok(()); }
178
179 let mut consolidated: BTreeMap<Vec<u8>, Option<Vec<u8>>> = BTreeMap::new();
181
182 for (_, sst) in ssts.iter_mut().rev() {
184 let keys: Vec<Vec<u8>> = sst.index.iter().map(|r| r.key.clone()).collect();
186 for key in keys {
187 if let Some(val_opt) = sst.get(&key)? {
188 consolidated.insert(key, val_opt);
189 }
190 }
191 }
192
193 let compacted_data: Vec<(Vec<u8>, Option<Vec<u8>>)> = consolidated
195 .into_iter()
196 .filter(|(_, val_opt)| val_opt.is_some())
197 .collect();
198
199 let temp_filename = "sst_compaction.tmp";
201 let temp_path = self.db_dir.join(temp_filename);
202 SSTable::write_new(&temp_path, &compacted_data)?;
203
204 let old_indices: Vec<u32> = ssts.iter().map(|(idx, _)| *idx).collect();
206 ssts.clear();
207
208 for idx in old_indices {
210 let path = self.db_dir.join(format!("sst_{:05}.db", idx));
211 if path.exists() {
212 fs::remove_file(path)?;
213 }
214 }
215
216 let final_path = self.db_dir.join("sst_00001.db");
218 fs::rename(&temp_path, &final_path)?;
219
220 let sst_reader = SSTable::open(&final_path)?;
222 ssts.push((1, sst_reader));
223
224 Ok(())
225 }
226}