fmt

Author: MarinPostma

libsql-server/src/namespace/configurator/libsql_primary.rs

@@ -279,16 +279,24 @@ impl ConfigureNamespace for LibsqlPrimaryConfigurator {
                     match timestamp {
                         Some(ts) => {
                             let ns: libsql_sys::name::NamespaceName = from_ns.name().clone().into();
-                            let _key = s.backend().find_segment(&s.backend().default_config(), &ns, libsql_wal::storage::backend::FindSegmentReq::Timestamp(ts)).await.unwrap();
+                            let _key = s
+                                .backend()
+                                .find_segment(
+                                    &s.backend().default_config(),
+                                    &ns,
+                                    libsql_wal::storage::backend::FindSegmentReq::Timestamp(ts),
+                                )
+                                .await
+                                .unwrap();
                             todo!()
-                        },
+                        }
                         // find the most recent frame_no
                         None => todo!("fork from most recent"),
                     };
-                },
+                }
                 Either::B(_) => {
                     todo!("cannot fork without storage");
-                },
+                }
             }
         })
     }

libsql-server/src/wal_toolkit.rs

@@ -81,11 +81,15 @@ impl WalToolkit {
                 if let Some((first, last)) = compactor.get_segment_range(&namespace)? {
                     println!(
                         "- oldest segment: {}-{} ({})",
-                        first.key.start_frame_no, first.key.end_frame_no, DateTime::from_timestamp_millis(first.key.timestamp as _).unwrap()
+                        first.key.start_frame_no,
+                        first.key.end_frame_no,
+                        DateTime::from_timestamp_millis(first.key.timestamp as _).unwrap()
                     );
                     println!(
                         "- most recent segment: {}-{} ({})",
-                        last.key.start_frame_no, last.key.end_frame_no, DateTime::from_timestamp_millis(last.key.timestamp as _).unwrap()
+                        last.key.start_frame_no,
+                        last.key.end_frame_no,
+                        DateTime::from_timestamp_millis(last.key.timestamp as _).unwrap()
                     );
                 }
 
@@ -94,7 +98,9 @@ impl WalToolkit {
                     compactor.list_all(&namespace, |info| {
                         println!(
                             "- {}-{} ({})",
-                            info.key.start_frame_no, info.key.end_frame_no, DateTime::from_timestamp_millis(info.key.timestamp as _).unwrap()
+                            info.key.start_frame_no,
+                            info.key.end_frame_no,
+                            DateTime::from_timestamp_millis(info.key.timestamp as _).unwrap()
                         );
                     })?;
                 }

libsql-wal/src/segment/sealed.rs

@@ -212,8 +212,13 @@ where
     }
 
     fn timestamp(&self) -> DateTime<Utc> {
-        assert_ne!(self.header().sealed_at_timestamp.get(), 0, "segment was not sealed properly");
-        DateTime::from_timestamp_millis(self.header().sealed_at_timestamp.get() as _).expect("this should be a guaranteed roundtrip with DateTime::timestamp_millis")
+        assert_ne!(
+            self.header().sealed_at_timestamp.get(),
+            0,
+            "segment was not sealed properly"
+        );
+        DateTime::from_timestamp_millis(self.header().sealed_at_timestamp.get() as _)
+            .expect("this should be a guaranteed roundtrip with DateTime::timestamp_millis")
     }
 }
 

libsql-wal/src/storage/async_storage.rs

@@ -234,7 +234,11 @@ where
         let config = config_override.unwrap_or_else(|| self.backend.default_config());
         let key = self
             .backend
-            .find_segment(&config, namespace, super::backend::FindSegmentReq::Frame(frame_no))
+            .find_segment(
+                &config,
+                namespace,
+                super::backend::FindSegmentReq::Frame(frame_no),
+            )
             .await?;
         Ok(key)
     }

libsql-wal/src/storage/backend/mod.rs

@@ -170,9 +170,7 @@ impl<T: Backend> Backend for Arc<T> {
         namespace: &NamespaceName,
         req: FindSegmentReq,
     ) -> Result<SegmentKey> {
-        self.as_ref()
-            .find_segment(config, namespace, req)
-            .await
+        self.as_ref().find_segment(config, namespace, req).await
     }
 
     async fn fetch_segment_index(

libsql-wal/src/storage/compaction/mod.rs

@@ -302,7 +302,11 @@ impl<B> Compactor<B> {
                     segment_id: Uuid::new_v4(),
                     start_frame_no: start,
                     end_frame_no: end,
-                    segment_timestamp: DateTime::from_timestamp_millis(set.last().unwrap().timestamp as _).unwrap().to_utc(),
+                    segment_timestamp: DateTime::from_timestamp_millis(
+                        set.last().unwrap().timestamp as _,
+                    )
+                    .unwrap()
+                    .to_utc(),
                 },
                 out_file,
                 out_index.into_inner().unwrap(),
@@ -378,7 +382,11 @@ impl AnalyzedSegments {
                 for chunk in nodes.chunks(2) {
                     let start_frame_no = chunk[0];
                     let end_frame_no = chunk[1];
-                    let timestamp = *self.graph.edges(start_frame_no).find_map(|(_, to, ts)| (to == end_frame_no).then_some(ts)).unwrap();
+                    let timestamp = *self
+                        .graph
+                        .edges(start_frame_no)
+                        .find_map(|(_, to, ts)| (to == end_frame_no).then_some(ts))
+                        .unwrap();
                     let key = SegmentKey {
                         start_frame_no,
                         end_frame_no,

libsql-wal/src/storage/job.rs

@@ -111,6 +111,7 @@ mod test {
     use crate::io::file::FileExt;
     use crate::io::StdIO;
     use crate::segment::compacted::CompactedSegmentDataHeader;
+    use crate::storage::backend::FindSegmentReq;
     use crate::storage::{RestoreOptions, SegmentKey};
     use libsql_sys::name::NamespaceName;
 
@@ -232,7 +233,7 @@ mod test {
                 &self,
                 _config: &Self::Config,
                 _namespace: &NamespaceName,
-                _frame_no: u64,
+                _frame_no: FindSegmentReq,
             ) -> Result<SegmentKey> {
                 todo!()
             }

libsql-wal/tests/flaky_fs.rs

@@ -5,6 +5,7 @@ use std::path::Path;
 use std::sync::atomic::{AtomicBool, Ordering::Relaxed};
 use std::sync::Arc;
 
+use chrono::prelude::{DateTime, Utc};
 use libsql_wal::io::{file::FileExt, Io};
 use libsql_wal::registry::WalRegistry;
 use libsql_wal::storage::TestStorage;
@@ -140,8 +141,8 @@ impl Io for FlakyIo {
         todo!()
     }
 
-    fn now(&self) -> chrono::prelude::DateTime<chrono::prelude::Utc> {
-        todo!()
+    fn now(&self) -> DateTime<Utc> {
+        Utc::now()
     }
 
     fn hard_link(&self, _src: &Path, _dst: &Path) -> std::io::Result<()> {