Method write_entry

graphlite/src/txn/wal.rs:473–518

Write a WAL entry to persistent storage

(&self, entry: WALEntry)

    /// Write a WAL entry to persistent storage
    pub fn write_entry(&self, entry: WALEntry) -> Result<(), WALError> {
        let serialized = entry.serialize();

        // Check if we need to rotate to a new file
        {
            let current_size = *self.current_file_size.lock().unwrap();
            if current_size + serialized.len() as u64 > MAX_WAL_FILE_SIZE {
                self.rotate_wal_file()?;
            }
        }

        // Write to current file
        {
            let mut writer_guard = self.current_writer.lock().unwrap();
            if let Some(writer) = writer_guard.as_mut() {
                writer
                    .write_all(&serialized)
                    .map_err(|e| WALError::IOError(format!("Failed to write WAL entry: {}", e)))?;

                // Force write to disk for durability
                writer
                    .flush()
                    .map_err(|e| WALError::IOError(format!("Failed to flush WAL: {}", e)))?;

                // Ensure data is written to disk
                writer
                    .get_mut()
                    .sync_data()
                    .map_err(|e| WALError::IOError(format!("Failed to sync WAL: {}", e)))?;

                // Update file size
                *self.current_file_size.lock().unwrap() += serialized.len() as u64;
            } else {
                return Err(WALError::IOError("No active WAL file".to_string()));
            }
        }

        // Also write to catalog WAL if it affects catalog
        if entry.affects_catalog() {
            if let Some(catalog_wal) = &self.catalog_wal {
                catalog_wal.write_entry(&serialized)?;
            }
        }

        Ok(())
    }

    /// Mark a transaction as committed
    #[allow(dead_code)] // ROADMAP v0.3.0 - WAL commit marker for transaction durability