@feltdb/core 0.6.9 → 0.6.10

package/dist/create/server-source/crates/feltdb/src/lib.rs

@@ -40,6 +40,9 @@ pub mod in_process_transport;
 pub mod tcp_transport;
 pub mod operation_algebra;
 pub mod crash_atomic_boundary;
+pub mod multi_operation_transaction;
+pub mod p1_atomicity_acceptance;
+pub mod p1_application_atomicity;
 pub mod causal_dependency_barrier;
 pub mod partition_reconciliation;
 pub mod consistency_contract;
@@ -63,7 +66,6 @@ mod phase1c_atomicity_proof;
 #[cfg(test)]
 mod phase1c3_acceptance;
 #[cfg(test)]
-mod phase_1c_three_node;
 #[cfg(test)]
 mod phase_1c_real_tcp;
 #[cfg(test)]
@@ -2140,13 +2142,55 @@ where
     }
 }
 
+/// Read the log, separating a torn tail from real corruption.
+///
+/// A process that dies while appending leaves a final record that was never
+/// terminated. That record was never committed, so recovery discards it and
+/// truncates it away: leaving the bytes in place would make the next append
+/// splice onto them and turn a normal crash into permanent corruption.
+///
+/// Damage anywhere earlier is not an interrupted write. Recovery refuses it
+/// rather than silently dropping committed history.
+fn read_log_lines(path: &Path) -> Result<Vec<String>> {
+    let mut file = BufReader::new(OpenOptions::new().read(true).open(path)?);
+    let mut lines: Vec<(String, bool)> = Vec::new();
+    let mut buffer = Vec::new();
+    loop {
+        buffer.clear();
+        if file.read_until(b'\n', &mut buffer)? == 0 {
+            break;
+        }
+        let terminated = buffer.ends_with(b"\n");
+        let text = String::from_utf8_lossy(&buffer)
+            .trim_end_matches('\n')
+            .to_string();
+        lines.push((text, terminated));
+    }
+
+    let mut torn_bytes = 0usize;
+    if let Some((text, terminated)) = lines.last() {
+        let unusable = !*terminated || serde_json::from_str::<Value>(text).is_err();
+        if unusable && !text.trim().is_empty() {
+            torn_bytes = text.len() + usize::from(*terminated);
+            lines.pop();
+        }
+    }
+
+    if torn_bytes > 0 {
+        let file = OpenOptions::new().write(true).open(path)?;
+        let length = file.metadata()?.len();
+        file.set_len(length.saturating_sub(torn_bytes as u64))?;
+        file.sync_all()?;
+    }
+
+    Ok(lines.into_iter().map(|(text, _)| text).collect())
+}
+
 fn replay_log(inner: &mut Inner) -> Result<()> {
-    let file = OpenOptions::new().read(true).open(&inner.path)?;
-    let reader = BufReader::new(file);
+    let lines = read_log_lines(&inner.path)?;
 
     let mut snapshot_log = false;
-    for line in reader.lines() {
-        let line = line?;
+    for line in lines {
         if line.trim().is_empty() {
             continue;
         }