fmt

Author: MarinPostma

bottomless/src/replicator.rs

@@ -1455,7 +1455,8 @@ impl Replicator {
             4096,
             libsql_sys::connection::NO_AUTOCHECKPOINT,
             encryption_config,
-        ).await?;
+        )
+        .await?;
         let prefix = format!("{}-{}/", self.db_name, generation);
         let mut page_buf = {
             let mut v = Vec::with_capacity(page_size);

libsql-replication/src/injector/error.rs

@@ -1,4 +1,4 @@
-pub type Result<T, E=Error> = std::result::Result<T, E>;
+pub type Result<T, E = Error> = std::result::Result<T, E>;
 pub type BoxError = Box<dyn std::error::Error + Send + Sync + 'static>;
 
 #[derive(Debug, thiserror::Error)]

libsql-replication/src/injector/mod.rs

@@ -1,16 +1,16 @@
 use std::future::Future;
 
-pub use sqlite_injector::SqliteInjector;
 pub use libsql_injector::LibsqlInjector;
+pub use sqlite_injector::SqliteInjector;
 
 use crate::frame::{Frame, FrameNo};
 
-use error::Result;
 pub use error::Error;
+use error::Result;
 
 mod error;
-mod sqlite_injector;
 mod libsql_injector;
+mod sqlite_injector;
 
 pub trait Injector {
     /// Inject a singular frame.

libsql-replication/src/injector/sqlite_injector/mod.rs

@@ -25,28 +25,23 @@ pub struct SqliteInjector {
 }
 
 impl Injector for SqliteInjector {
-    async fn inject_frame(
-        &mut self,
-        frame: Frame,
-    ) -> Result<Option<FrameNo>> {
+    async fn inject_frame(&mut self, frame: Frame) -> Result<Option<FrameNo>> {
         let inner = self.inner.clone();
-        spawn_blocking(move || {
-            inner.lock().inject_frame(frame)
-        }).await.unwrap()
+        spawn_blocking(move || inner.lock().inject_frame(frame))
+            .await
+            .unwrap()
     }
 
     async fn rollback(&mut self) {
         let inner = self.inner.clone();
-        spawn_blocking(move || {
-            inner.lock().rollback()
-        }).await.unwrap();
+        spawn_blocking(move || inner.lock().rollback())
+            .await
+            .unwrap();
     }
 
     async fn flush(&mut self) -> Result<Option<FrameNo>> {
         let inner = self.inner.clone();
-        spawn_blocking(move || {
-            inner.lock().flush()
-        }).await.unwrap()
+        spawn_blocking(move || inner.lock().flush()).await.unwrap()
     }
 }
 
@@ -56,13 +51,15 @@ impl SqliteInjector {
         capacity: usize,
         auto_checkpoint: u32,
         encryption_config: Option<libsql_sys::EncryptionConfig>,
-    ) ->super::Result<Self> {
+    ) -> super::Result<Self> {
         let inner = spawn_blocking(move || {
             SqliteInjectorInner::new(path, capacity, auto_checkpoint, encryption_config)
-        }).await.unwrap()?;
+        })
+        .await
+        .unwrap()?;
 
         Ok(Self {
-            inner: Arc::new(Mutex::new(inner))
+            inner: Arc::new(Mutex::new(inner)),
         })
     }
 }
@@ -278,7 +275,8 @@ mod test {
     fn test_simple_inject_frames() {
         let temp = tempfile::tempdir().unwrap();
 
-        let mut injector = SqliteInjectorInner::new(temp.path().join("data"), 10, 10000, None).unwrap();
+        let mut injector =
+            SqliteInjectorInner::new(temp.path().join("data"), 10, 10000, None).unwrap();
         let log = wal_log();
         for frame in log {
             injector.inject_frame(frame).unwrap();
@@ -298,7 +296,8 @@ mod test {
         let temp = tempfile::tempdir().unwrap();
 
         // inject one frame at a time
-        let mut injector = SqliteInjectorInner::new(temp.path().join("data"), 1, 10000, None).unwrap();
+        let mut injector =
+            SqliteInjectorInner::new(temp.path().join("data"), 1, 10000, None).unwrap();
         let log = wal_log();
         for frame in log {
             injector.inject_frame(frame).unwrap();
@@ -318,7 +317,8 @@ mod test {
         let temp = tempfile::tempdir().unwrap();
 
         // inject one frame at a time
-        let mut injector = SqliteInjectorInner::new(temp.path().join("data"), 10, 1000, None).unwrap();
+        let mut injector =
+            SqliteInjectorInner::new(temp.path().join("data"), 10, 1000, None).unwrap();
         let mut frames = wal_log();
 
         assert!(injector

libsql-replication/src/replicator.rs

@@ -168,7 +168,7 @@ where
             auto_checkpoint,
             encryption_config,
         )
-            .await?;
+        .await?;
 
         Ok(Self::new(client, injector))
     }
@@ -179,7 +179,6 @@ where
     C: ReplicatorClient,
     I: Injector,
 {
-
     pub fn new(client: C, injector: I) -> Self {
         Self {
             client,

libsql-replication/src/rpc.rs

@@ -51,7 +51,7 @@ pub mod replication {
         pub fn new(wal_flavor: WalFlavor) -> Self {
             Self {
                 handshake_version: Some(1),
-                wal_flavor: Some(wal_flavor.into())
+                wal_flavor: Some(wal_flavor.into()),
             }
         }
     }

libsql-server/src/rpc/replication_log.rs

@@ -7,8 +7,8 @@ use bytes::Bytes;
 use chrono::{DateTime, Utc};
 use futures::stream::BoxStream;
 use futures_core::Future;
-use libsql_replication::rpc::replication::hello_request::WalFlavor;
 pub use libsql_replication::rpc::replication as rpc;
+use libsql_replication::rpc::replication::hello_request::WalFlavor;
 use libsql_replication::rpc::replication::replication_log_server::ReplicationLog;
 use libsql_replication::rpc::replication::{
     Frame, Frames, HelloRequest, HelloResponse, LogOffset, NAMESPACE_DOESNT_EXIST,
@@ -357,7 +357,7 @@ impl ReplicationLog for ReplicationLogService {
         }
 
         if let WalFlavor::Libsql = req.get_ref().wal_flavor() {
-            return Err(Status::invalid_argument("libsql wal not supported"))
+            return Err(Status::invalid_argument("libsql wal not supported"));
         }
 
         let (logger, config, version, _, _) =

libsql-wal/src/replication/injector.rs

@@ -94,7 +94,10 @@ mod test {
 
         let mut tx = crate::transaction::Transaction::Read(replica_shared.begin_read(42));
         replica_shared.upgrade(&mut tx).unwrap();
-        let guard = tx.into_write().unwrap_or_else(|_| panic!()).into_lock_owned();
+        let guard = tx
+            .into_write()
+            .unwrap_or_else(|_| panic!())
+            .into_lock_owned();
         let mut injector = Injector::new(replica_shared.clone(), guard, 10).unwrap();
 
         primary_conn.execute("create table test (x)", ()).unwrap();