Small touchups

Author: kim

crates/commitlog/src/commitlog.rs

@@ -8,7 +8,7 @@ use std::{
 };
 
 use itertools::Itertools;
-use log::{debug, info, trace, warn};
+use log::{debug, error, info, trace, warn};
 
 use crate::{
     commit::StoredCommit,
@@ -320,7 +320,7 @@ impl<R: Repo, T: Encode> Generic<R, T> {
         let writer = &mut self.head;
         let committed = writer.commit(transactions)?;
         if writer.len() >= self.opts.max_segment_size {
-            self.flush().expect("failed to flush segment");
+            self.flush().expect("failed to flush segment upon rotation");
             self.sync();
             self.start_new_segment()?;
         }
@@ -371,7 +371,7 @@ impl<R: Repo, T> Drop for Generic<R, T> {
     fn drop(&mut self) {
         if !self.panicked {
             if let Err(e) = self.flush_and_sync() {
-                warn!("failed to flush on drop: {e:#}");
+                error!("failed to flush on drop: {e:#}");
             }
         }
     }

crates/durability/src/lib.rs

@@ -95,12 +95,8 @@ pub type Close = BoxFuture<'static, Option<TxOffset>>;
 ///
 /// NOTE: This is a preliminary definition, still under consideration.
 ///
-/// A durability implementation accepts one or more [Transaction]s to be made
-/// durable via [Durability::commit] in a non-blocking fashion.
-///
-/// A batch of transactions is eventually made durable atomically.
-/// Note that this means that a torn write can render the whole batch
-/// inaccessible, so small batches are usually preferable.
+/// A durability implementation accepts a [Transaction] to be made durable via
+/// the [Durability::append_tx] method in a non-blocking fashion.
 ///
 /// Once a transaction becomes durable, the [DurableOffset] is updated.
 /// What durable means depends on the implementation, informally it can be
@@ -115,6 +111,16 @@ pub trait Durability: Send + Sync {
     /// cannot be made durable immediately.
     ///
     /// Errors may be signalled by panicking.
+    //
+    // TODO: Support batches of txs, i.e. commits.
+    //
+    // The commitlog supports this, but allocation overhead in the durability
+    // API is too high given we don't make any use of it.
+    //
+    // We don't make any use of it because a commit is an atomic unit of storage
+    // (i.e. a torn write will corrupt all transactions contained in it), and it
+    // is very unclear when it is both correct and beneficial to bundle more
+    // than a single transaction into a commit.
     fn append_tx(&self, tx: Transaction<Self::TxData>);
 
     /// Obtain a handle to the [DurableOffset].

crates/durability/tests/io/fallocate.rs

@@ -99,15 +99,15 @@ async fn local_durability_crashes_on_new_segment_if_not_enough_space() {
             new_segment_rx.borrow_and_update();
             // Write past available space.
             for offset in 0..256 {
-                durability.commit([(offset, txdata.clone()).into()].into());
+                durability.append_tx((offset, txdata.clone()).into());
             }
             // Ensure new segment is created.
             new_segment_rx.changed().await?;
             // Yield to give fallocate a chance to run (and fail).
             sleep(Duration::from_millis(5)).await;
             // Durability actor should have crashed, so this should panic.
             info!("trying append on crashed durability");
-            durability.commit([(256, txdata.clone()).into()].into());
+            durability.append_tx((256, txdata.clone()).into());
         }
 
         Ok(())