fix(ohh): buffer all OHH content to apend atomicly (#277)

Author: elliottneilclark

src/bin/rsp/ohh/reader.rs

@@ -7,13 +7,32 @@ use rs_poker::open_hand_history::{HandHistory, OpenHandHistoryWrapper};
 pub enum ReaderError {
     #[error("failed to read file: {0}")]
     Io(#[from] std::io::Error),
-    #[error("failed to parse line {line}: {source}")]
+    #[error("failed to parse {path}:{line} ({source})\n  line preview: {preview}")]
     Parse {
+        path: std::path::PathBuf,
         line: usize,
+        preview: String,
         source: serde_json::Error,
     },
 }
 
+/// Maximum number of characters of a malformed line to include in the
+/// error message. Long enough to spot interleaves or truncation, short
+/// enough not to dump a whole hand record into the terminal.
+const PREVIEW_LEN: usize = 160;
+
+fn line_preview(line: &str) -> String {
+    let mut out = String::new();
+    for (i, c) in line.chars().enumerate() {
+        if i >= PREVIEW_LEN {
+            out.push('…');
+            break;
+        }
+        out.push(c);
+    }
+    out
+}
+
 /// Read all `.ohh` files from a directory (sorted by filename).
 ///
 /// Files that do not have an `.ohh` extension are skipped. Without this
@@ -57,7 +76,9 @@ pub fn read_ohh_file(path: &Path) -> Result<Vec<HandHistory>, ReaderError> {
         }
         let wrapper: OpenHandHistoryWrapper =
             serde_json::from_str(trimmed).map_err(|e| ReaderError::Parse {
+                path: path.to_path_buf(),
                 line: line_num + 1,
+                preview: line_preview(trimmed),
                 source: e,
             })?;
         hands.push(wrapper.ohh);

src/open_hand_history/writer.rs

@@ -4,18 +4,21 @@ use std::path::Path;
 
 use super::hand_history::{HandHistory, OpenHandHistoryWrapper};
 
-/// Appends a hand history to a file in JSON Lines format
+/// Appends a hand history to a file in JSON Lines format.
+///
+/// Serializes into an in-memory buffer and then issues a single
+/// `write_all` under `O_APPEND`. On Linux regular files the kernel
+/// locks the inode around seek-to-EOF + write, so a single `write(2)`
+/// is atomic at EOF — concurrent writers cannot interleave their
+/// JSON mid-record as long as each record is emitted in one syscall.
 pub fn append_hand(path: &Path, hand: HandHistory) -> io::Result<()> {
-    // Create file if it doesn't exist, append if it does
-    let mut file = OpenOptions::new().create(true).append(true).open(path)?;
-
-    // Wrap the hand history in the OHH wrapper
     let wrapped = OpenHandHistoryWrapper { ohh: hand };
 
-    // Serialize to JSON and append newline
-    serde_json::to_writer(&mut file, &wrapped)?;
-    writeln!(file)?; // Newline at the end
-    writeln!(file)?; // Extra newline for separation
+    let mut buf = serde_json::to_vec(&wrapped)?;
+    buf.extend_from_slice(b"\n\n");
+
+    let mut file = OpenOptions::new().create(true).append(true).open(path)?;
+    file.write_all(&buf)?;
     Ok(())
 }