forgot i could run fmt without clippy

anyway, fmt

ufos/src/consumer.rs

···
 use std::time::Duration;
 use tokio::sync::mpsc::{channel, Receiver, Sender};
 
-use crate::{DeleteAccount, EventBatch, UFOsCommit};
 use crate::error::FirehoseEventError;
+use crate::{DeleteAccount, EventBatch, UFOsCommit};
 
 const MAX_BATCHED_RECORDS: usize = 128; // *non-blocking* limit. drops oldest batched record per collection once reached.
 const MAX_ACCOUNT_REMOVES: usize = 1024; // hard limit, extremely unlikely to reach, but just in case
···
 
         match event.kind {
             EventKind::Commit => {
-                let commit = event.commit.ok_or(FirehoseEventError::CommitEventMissingCommit)?;
+                let commit = event
+                    .commit
+                    .ok_or(FirehoseEventError::CommitEventMissingCommit)?;
                 let (commit, nsid) = UFOsCommit::from_commit_info(commit, event.did, event.cursor)?;
                 self.handle_commit(commit, nsid).await?;
             }
             EventKind::Account => {
-                let account = event.account.ok_or(FirehoseEventError::AccountEventMissingAccount)?;
+                let account = event
+                    .account
+                    .ok_or(FirehoseEventError::AccountEventMissingAccount)?;
                 if !account.active {
                     self.handle_delete_account(event.did, event.cursor).await?;
                 }
···
 
         // if the queue is empty and we have enough, send immediately. otherewise, let the current batch fill up.
         if let Some(earliest) = &self.current_batch.initial_cursor {
-            if event.cursor.duration_since(earliest)?.as_secs_f64() > MIN_BATCH_SPAN_SECS &&
-                self.batch_sender.capacity() == BATCH_QUEUE_SIZE {
+            if event.cursor.duration_since(earliest)?.as_secs_f64() > MIN_BATCH_SPAN_SECS
+                && self.batch_sender.capacity() == BATCH_QUEUE_SIZE
+            {
                 log::info!("queue empty: immediately sending batch.");
                 self.send_current_batch_now().await?;
             }
···
     }
 
     async fn handle_commit(&mut self, commit: UFOsCommit, nsid: Nsid) -> anyhow::Result<()> {
-        if !self
-            .current_batch
-            .batch
-            .commits_by_nsid
-            .contains_key(&nsid)
+        if !self.current_batch.batch.commits_by_nsid.contains_key(&nsid)
             && self.current_batch.batch.commits_by_nsid.len() >= MAX_BATCHED_COLLECTIONS
         {
             self.send_current_batch_now().await?;
         }
 
-        self
-            .current_batch
+        self.current_batch
             .batch
             .commits_by_nsid
             .entry(nsid)

ufos/src/db_types.rs

···
     #[error("expected exclusive bound from lsm_tree (likely bug)")]
     BadRangeBound,
     #[error("expected an hourly-truncated u64, found remainder: {0}")]
-    InvalidHourlyTruncated(u64)
+    InvalidHourlyTruncated(u64),
 }
 
 fn bincode_conf() -> impl Config {

ufos/src/error.rs

···
-use thiserror::Error;
 use crate::db_types::EncodingError;
+use thiserror::Error;
 
 #[derive(Debug, Error)]
 pub enum FirehoseEventError {

ufos/src/lib.rs

···
 pub mod storage_fjall;
 pub mod store_types;
 
-use jetstream::events::{Cursor, CommitEvent, CommitOp};
-use jetstream::exports::{Did, Nsid, RecordKey};
-use std::collections::{HashMap, VecDeque};
-use serde_json::value::RawValue;
 use cardinality_estimator::CardinalityEstimator;
 use error::FirehoseEventError;
+use jetstream::events::{CommitEvent, CommitOp, Cursor};
+use jetstream::exports::{Did, Nsid, RecordKey};
+use serde_json::value::RawValue;
+use std::collections::{HashMap, VecDeque};
 
 #[derive(Debug, Default, Clone)]
 pub struct CollectionCommits {
···
 }
 
 #[derive(Debug, Clone)]
-pub struct PutAction { record: Box<RawValue>, is_update: bool }
+pub struct PutAction {
+    record: Box<RawValue>,
+    is_update: bool,
+}
 
 #[derive(Debug, Clone)]
 pub struct UFOsCommit {
···
     pub fn from_commit_info(
         commit: CommitEvent,
         did: Did,
-        cursor: Cursor
+        cursor: Cursor,
     ) -> Result<(Self, Nsid), FirehoseEventError> {
         let action = match commit.operation {
             CommitOp::Delete => CommitAction::Cut,
             cru @ _ => CommitAction::Put(PutAction {
                 record: commit.record.ok_or(FirehoseEventError::CruMissingRecord)?,
                 is_update: cru == CommitOp::Update,
-            })
+            }),
         };
         let batched = Self {
             cursor,

ufos/src/main.rs

···
 
     let args = Args::parse();
     let jetstream = args.jetstream.clone();
-    let (_read_store, mut write_store, cursor) =
-        FjallStorage::init(args.data, jetstream, args.jetstream_force, Default::default())?;
+    let (_read_store, mut write_store, cursor) = FjallStorage::init(
+        args.data,
+        jetstream,
+        args.jetstream_force,
+        Default::default(),
+    )?;
 
     // println!("starting server with storage...");
     // let serving = server::serve(storage.clone());
···
                         write_store.step_rollup()?;
                     }
                     Ok::<(), StorageError>(())
-                }).await??;
+                })
+                .await??;
 
                 // let r = storage.receive(batches).await;
                 log::warn!("storage.receive ended with");

ufos/src/server.rs

···
 use crate::storage_fjall::{Storage, StorageInfo};
-use crate::{Nsid};
+use crate::Nsid;
 use dropshot::endpoint;
 use dropshot::ApiDescription;
 use dropshot::ConfigDropshot;

ufos/src/storage.rs

···
-use std::path::Path;
+use crate::{error::StorageError, Cursor, EventBatch};
 use jetstream::exports::Nsid;
-use crate::{error::StorageError, Cursor, EventBatch};
+use std::path::Path;
 
-pub trait StorageWhatever<R: StoreReader, W: StoreWriter, C> { // TODO: extract this
+pub trait StorageWhatever<R: StoreReader, W: StoreWriter, C> {
+    // TODO: extract this
     fn init(
         path: impl AsRef<Path>,
         endpoint: String,
         force_endpoint: bool,
         config: C,
-    ) -> Result<(R, W, Option<Cursor>), StorageError> where Self: Sized;
+    ) -> Result<(R, W, Option<Cursor>), StorageError>
+    where
+        Self: Sized;
 }
 
 pub trait StoreWriter {

ufos/src/storage_fjall.rs

···
+use crate::db_types::{db_complete, DbBytes, DbStaticStr, EncodingError, StaticStr};
+use crate::error::StorageError;
 use crate::storage::{StorageWhatever, StoreReader, StoreWriter};
-use crate::db_types::{db_complete, DbBytes, DbStaticStr, EncodingError, StaticStr};
 use crate::store_types::{
     ByCollectionKey, ByCollectionValue, ByCursorSeenKey, ByCursorSeenValue, ByIdKey, ByIdValue,
-    JetstreamCursorKey, JetstreamCursorValue, JetstreamEndpointKey, JetstreamEndpointValue,
-    ModCursorKey, ModCursorValue, ModQueueItemKey, ModQueueItemStringValue, ModQueueItemValue,
-    RollupCursorKey, RollupCursorValue, SeenCounter,
-    NsidRecordFeedKey, NsidRecordFeedVal, RecordLocationKey, RecordLocationVal,
-    LiveRecordsKey, LiveRecordsValue, LiveDidsKey, LiveDidsValue,
-    DeleteAccountQueueKey, DeleteAccountQueueVal,
-    NewRollupCursorKey, NewRollupCursorValue,
-    TakeoffKey, TakeoffValue,
+    DeleteAccountQueueKey, DeleteAccountQueueVal, JetstreamCursorKey, JetstreamCursorValue,
+    JetstreamEndpointKey, JetstreamEndpointValue, LiveDidsKey, LiveDidsValue, LiveRecordsKey,
+    LiveRecordsValue, ModCursorKey, ModCursorValue, ModQueueItemKey, ModQueueItemStringValue,
+    ModQueueItemValue, NewRollupCursorKey, NewRollupCursorValue, NsidRecordFeedKey,
+    NsidRecordFeedVal, RecordLocationKey, RecordLocationVal, RollupCursorKey, RollupCursorValue,
+    SeenCounter, TakeoffKey, TakeoffValue,
 };
-use crate::{
-    DeleteAccount, Did, EventBatch, Nsid, RecordKey, CommitAction,
-};
-use crate::error::StorageError;
+use crate::{CommitAction, DeleteAccount, Did, EventBatch, Nsid, RecordKey};
 use fjall::{
     Batch as FjallBatch, CompressionType, Config, Keyspace, PartitionCreateOptions, PartitionHandle,
 };
···
 struct Db {
     keyspace: Keyspace,
     global: PartitionHandle,
-
 }
 
 /**
···
         let js_cursor = get_static_neu::<JetstreamCursorKey, JetstreamCursorValue>(&global)?;
 
         if js_cursor.is_some() {
-            let stored_endpoint = get_static_neu::<JetstreamEndpointKey, JetstreamEndpointValue>(&global)?;
+            let stored_endpoint =
+                get_static_neu::<JetstreamEndpointKey, JetstreamEndpointValue>(&global)?;
 
-            let JetstreamEndpointValue(stored) = stored_endpoint
-                .ok_or(StorageError::InitError("found cursor but missing js_endpoint, refusing to start.".to_string()))?;
+            let JetstreamEndpointValue(stored) = stored_endpoint.ok_or(StorageError::InitError(
+                "found cursor but missing js_endpoint, refusing to start.".to_string(),
+            ))?;
 
             if stored != endpoint {
                 if force_endpoint {
···
                 &global,
                 JetstreamEndpointValue(endpoint.to_string()),
             )?;
-            insert_static_neu::<TakeoffKey>(
-                &global,
-                Cursor::at(SystemTime::now()),
-            )?;
-            insert_static_neu::<NewRollupCursorKey>(
-                &global,
-                Cursor::from_start(),
-            )?;
+            insert_static_neu::<TakeoffKey>(&global, Cursor::at(SystemTime::now()))?;
+            insert_static_neu::<NewRollupCursorKey>(&global, Cursor::from_start())?;
         }
 
         let reader = FjallReader {
···
             records: records.clone(),
             rollups: rollups.clone(),
         };
-        let writer = FjallWriter { keyspace, global, feeds, records, rollups, queues };
+        let writer = FjallWriter {
+            keyspace,
+            global,
+            feeds,
+            records,
+            rollups,
+            queues,
+        };
         Ok((reader, writer, js_cursor))
     }
 }
···
 }
 
 impl StoreReader for FjallReader {
-    fn get_total_by_collection(&self, collection: &jetstream::exports::Nsid) -> Result<u64, StorageError> {
+    fn get_total_by_collection(
+        &self,
+        collection: &jetstream::exports::Nsid,
+    ) -> Result<u64, StorageError> {
         // TODO: start from rollup
         let full_range = LiveRecordsKey::range_from_cursor(Cursor::from_start())?;
         let mut total = 0;
···
     pub fn step_rollup(&mut self) -> Result<(), StorageError> {
         // let mut batch = self.keyspace.batch();
 
-        let rollup_cursor = get_static_neu::<NewRollupCursorKey, NewRollupCursorValue>(&self.global)?
-            .ok_or(StorageError::BadStateError("Could not find current rollup cursor".to_string()))?;
+        let rollup_cursor =
+            get_static_neu::<NewRollupCursorKey, NewRollupCursorValue>(&self.global)?.ok_or(
+                StorageError::BadStateError("Could not find current rollup cursor".to_string()),
+            )?;
 
         // timelies
         let live_records_range = LiveRecordsKey::range_from_cursor(rollup_cursor)?;
···
         let next_timely = timely_iter
             .next()
             .transpose()?
-            .map(|(key_bytes, val_bytes)|
-                db_complete::<LiveRecordsKey>(&key_bytes)
-                    .map(|k| (k, val_bytes)))
+            .map(|(key_bytes, val_bytes)| {
+                db_complete::<LiveRecordsKey>(&key_bytes).map(|k| (k, val_bytes))
+            })
             .transpose()?;
 
         // delete accounts
-        let delete_accounts_range = DeleteAccountQueueKey::new(rollup_cursor).range_to_prefix_end()?;
+        let delete_accounts_range =
+            DeleteAccountQueueKey::new(rollup_cursor).range_to_prefix_end()?;
 
-        let next_delete = self.queues.range(delete_accounts_range)
+        let next_delete = self
+            .queues
+            .range(delete_accounts_range)
             .next()
             .transpose()?
-            .map(|(key_bytes, val_bytes)|
-                db_complete::<DeleteAccountQueueKey>(&key_bytes)
-                    .map(|k| (k.suffix, val_bytes)))
+            .map(|(key_bytes, val_bytes)| {
+                db_complete::<DeleteAccountQueueKey>(&key_bytes).map(|k| (k.suffix, val_bytes))
+            })
             .transpose()?;
 
         match (next_timely, next_delete) {
···
 impl StoreWriter for FjallWriter {
     fn insert_batch(&mut self, event_batch: EventBatch) -> Result<(), StorageError> {
         if event_batch.is_empty() {
-            return Ok(())
+            return Ok(());
         }
 
         let mut batch = self.keyspace.batch();
···
                     }
                     CommitAction::Put(put_action) => {
                         let feed_key = NsidRecordFeedKey::from_pair(nsid.clone(), commit.cursor);
-                        let feed_val: NsidRecordFeedVal = (&commit.did, &commit.rkey, commit.rev.as_str()).into();
+                        let feed_val: NsidRecordFeedVal =
+                            (&commit.did, &commit.rkey, commit.rev.as_str()).into();
                         batch.insert(
                             &self.feeds,
                             feed_key.to_db_bytes()?,
                             feed_val.to_db_bytes()?,
                         );
 
-                        let location_val: RecordLocationVal = (commit.cursor, commit.rev.as_str(), put_action).into();
+                        let location_val: RecordLocationVal =
+                            (commit.cursor, commit.rev.as_str(), put_action).into();
                         batch.insert(
                             &self.records,
                             &location_key.to_db_bytes()?,
···
     }
 }
 
-
 #[derive(Clone)]
 pub struct Storage {
     /// horrible: gate all db access behind this to force global serialization to avoid deadlock
···
             PartitionCreateOptions::default().compression(CompressionType::None),
         )?;
         Ok(Self {
-            db: Db {
-                keyspace,
-                global,
-            },
+            db: Db { keyspace, global },
         })
     }
 
···
 }
 
 /// Get a value from a fixed key
-fn get_static_neu<K: StaticStr, V: DbBytes>(global: &PartitionHandle) -> Result<Option<V>, StorageError> {
+fn get_static_neu<K: StaticStr, V: DbBytes>(
+    global: &PartitionHandle,
+) -> Result<Option<V>, StorageError> {
     let key_bytes = DbStaticStr::<K>::default().to_db_bytes()?;
     let value = global
         .get(&key_bytes)?
···
 }
 
 /// Get stats that haven't been rolled up yet
-fn get_unrolled_collection_seen(
-    global: &PartitionHandle,
-    collection: Nsid,
-) -> anyhow::Result<u64> {
+fn get_unrolled_collection_seen(global: &PartitionHandle, collection: Nsid) -> anyhow::Result<u64> {
     let range =
         if let Some(cursor_value) = get_static::<RollupCursorKey, RollupCursorValue>(global)? {
             eprintln!("found existing cursor");
···
     Ok(collection_total)
 }
 
-fn get_unrolled_top_collections(
-    global: &PartitionHandle,
-) -> anyhow::Result<HashMap<String, u64>> {
+fn get_unrolled_top_collections(global: &PartitionHandle) -> anyhow::Result<HashMap<String, u64>> {
     let range =
         if let Some(cursor_value) = get_static::<RollupCursorKey, RollupCursorValue>(global)? {
             eprintln!("found existing cursor");
···
 
         log::trace!("delete_record: iterate over up to current cursor...");
 
-        for (i, pair) in self
-            .global
-            .range(key_prefix_bytes..key_limit)
-            .enumerate()
-        {
+        for (i, pair) in self.global.range(key_prefix_bytes..key_limit).enumerate() {
             log::trace!("delete_record iter {i}: found");
             // find all (hopefully 1)
             let (key_bytes, _) = pair?;
···
     )
 }
 
-
-
 #[cfg(test)]
 mod tests {
+    use super::*;
+    use crate::{CollectionCommits, UFOsCommit};
+    use jetstream::events::{CommitEvent, CommitOp};
     use jetstream::exports::Cid;
-    use jetstream::events::{CommitEvent, CommitOp};
     use serde_json::value::RawValue;
-    use crate::{UFOsCommit, CollectionCommits};
-    use super::*;
 
     #[test]
     fn test_hello() -> anyhow::Result<()> {
···
             rev: "asdf".to_string(),
             operation: CommitOp::Create,
             record: Some(*Box::new(RawValue::from_string("{}".to_string()).unwrap())),
-            cid: Some("bafyreidofvwoqvd2cnzbun6dkzgfucxh57tirf3ohhde7lsvh4fu3jehgy".parse().unwrap()),
+            cid: Some(
+                "bafyreidofvwoqvd2cnzbun6dkzgfucxh57tirf3ohhde7lsvh4fu3jehgy"
+                    .parse()
+                    .unwrap(),
+            ),
         };
-        let (commit, collection) = UFOsCommit::from_commit_info(event, did.clone(), Cursor::from_raw_u64(100))?;
+        let (commit, collection) =
+            UFOsCommit::from_commit_info(event, did.clone(), Cursor::from_raw_u64(100))?;
 
         let mut commits = CollectionCommits::default();
         commits.total_seen += 1;

ufos/src/store_types.rs

···
-use cardinality_estimator::CardinalityEstimator;
 use crate::db_types::{
-    DbBytes, DbConcat, DbEmpty, DbStaticStr, EncodingError, StaticStr, UseBincodePlz, SerdeBytes,
+    DbBytes, DbConcat, DbEmpty, DbStaticStr, EncodingError, SerdeBytes, StaticStr, UseBincodePlz,
 };
-use crate::{Cursor, Did, Nsid, RecordKey, UFOsCommit, PutAction};
+use crate::{Cursor, Did, Nsid, PutAction, RecordKey, UFOsCommit};
 use bincode::{Decode, Encode};
+use cardinality_estimator::CardinalityEstimator;
 use std::ops::Range;
 
 /// key format: ["js_cursor"]
···
 /// value format: [rollup_cursor(Cursor)|collection(Nsid)]
 pub type RollupCursorValue = DbConcat<Cursor, Nsid>;
 
-
 /// key format: ["rollup_cursor"]
 #[derive(Debug, PartialEq)]
 pub struct NewRollupCursorKey {}
···
 // pub type NewRollupCursorKey = DbStaticStr<_NewRollupCursorKey>;
 /// value format: [rollup_cursor(Cursor)|collection(Nsid)]
 pub type NewRollupCursorValue = Cursor;
-
 
 /// key format: ["js_endpoint"]
 #[derive(Debug, PartialEq)]
···
 }
 pub type TakeoffValue = Cursor;
 
-
 /// key format: ["js_endpoint"]
 #[derive(Debug, PartialEq)]
 pub struct JetstreamEndpointKey {}
···
     fn from((did, rkey, rev): (&Did, &RecordKey, &str)) -> Self {
         Self::from_pair(
             did.clone(),
-            DbConcat::from_pair(rkey.clone(), rev.to_string()))
+            DbConcat::from_pair(rkey.clone(), rev.to_string()),
+        )
     }
 }
 
 pub type RecordLocationKey = DbConcat<Did, DbConcat<Nsid, RecordKey>>;
 impl From<(&UFOsCommit, &Nsid)> for RecordLocationKey {
     fn from((commit, collection): (&UFOsCommit, &Nsid)) -> Self {
-        Self::from_pair(commit.did.clone(), DbConcat::from_pair(collection.clone(), commit.rkey.clone()))
+        Self::from_pair(
+            commit.did.clone(),
+            DbConcat::from_pair(collection.clone(), commit.rkey.clone()),
+        )
     }
 }
 #[derive(Debug, PartialEq, Encode, Decode)]
···
     }
 }
 #[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
-pub struct LiveDidsValue(pub CardinalityEstimator::<Did>);
+pub struct LiveDidsValue(pub CardinalityEstimator<Did>);
 impl SerdeBytes for LiveDidsValue {}
 impl DbBytes for LiveDidsValue {
     fn to_db_bytes(&self) -> Result<Vec<u8>, EncodingError> {
···
     }
 }
 pub type DeleteAccountQueueVal = Did;
-
 
 #[derive(Debug, Clone, Encode, Decode)]
 pub struct SeenCounter(pub u64);
···
     }
 }
 
-
 const HOUR_IN_MICROS: u64 = 1_000_000 * 3600;
 #[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
 pub struct HourTrucatedCursor(u64);
···
     pub fn try_from_raw_u64(time_us: u64) -> Result<Self, EncodingError> {
         let rem = time_us % HOUR_IN_MICROS;
         if rem != 0 {
-            return Err(EncodingError::InvalidHourlyTruncated(rem))
+            return Err(EncodingError::InvalidHourlyTruncated(rem));
         }
         Ok(Self(time_us))
     }
···
     }
 }
 
-
 #[cfg(test)]
 mod test {
-    use super::{ByCollectionKey, ByCollectionValue, Cursor, Did, EncodingError, Nsid, RecordKey, HourTrucatedCursor, HOUR_IN_MICROS};
+    use super::{
+        ByCollectionKey, ByCollectionValue, Cursor, Did, EncodingError, HourTrucatedCursor, Nsid,
+        RecordKey, HOUR_IN_MICROS,
+    };
     use crate::db_types::DbBytes;
 
     #[test]