run cargo fmt --all

bffhd/resources/mod.rs

@@ -90,7 +90,11 @@ impl Inner {
             .unwrap()
             .log(self.id.as_str(), &format!("{}", state));
         if let Err(e) = res {
-            tracing::error!("Writing to the audit log failed for {} {}: {e}", self.id.as_str(), state);
+            tracing::error!(
+                "Writing to the audit log failed for {} {}: {e}",
+                self.id.as_str(),
+                state
+            );
         }
 
         self.signal.set(state);
@@ -164,7 +168,9 @@ impl Resource {
 
     fn set_state(&self, state: MachineState) {
         let mut serializer = AllocSerializer::<1024>::default();
-        serializer.serialize_value(&state).expect("serializing a MachineState shoud be infallible");
+        serializer
+            .serialize_value(&state)
+            .expect("serializing a MachineState shoud be infallible");
         let archived = ArchivedValue::new(serializer.into_serializer().into_inner());
         self.inner.set_state(archived)
     }
@@ -185,14 +191,16 @@ impl Resource {
         let archived = {
             let old_state_ref = self.inner.get_state_ref();
             let old_state: &ArchivedState = old_state_ref.as_ref();
-            let m_state: MachineState =
-                match Deserialize::<MachineState, _>::deserialize(&old_state.inner, &mut serializer) {
-                    Ok(s) => s,
-                    Err(error) => {
-                        tracing::error!(?error, "failed to deserialize stored state!");
-                        return;
-                    }
-                };
+            let m_state: MachineState = match Deserialize::<MachineState, _>::deserialize(
+                &old_state.inner,
+                &mut serializer,
+            ) {
+                Ok(s) => s,
+                Err(error) => {
+                    tracing::error!(?error, "failed to deserialize stored state!");
+                    return;
+                }
+            };
 
             let _ = serializer.serialize_value(&State::with_raw(m_state, data));
             ArchivedValue::new(serializer.into_serializer().into_inner())

bffhd/resources/state/db.rs

@@ -1,5 +1,5 @@
-use rkyv::ser::Serializer;
 use rkyv::ser::serializers::AllocSerializer;
+use rkyv::ser::Serializer;
 use thiserror::Error;
 
 use crate::db;
@@ -54,8 +54,7 @@ impl StateDB {
     }
 
     pub fn open_with_env(env: Arc<Environment>) -> Result<Self, StateDBError> {
-        let db = RawDB::open(&env, Some("state"))
-            .map_err(|e| StateDBError::Open(e.into()))?;
+        let db = RawDB::open(&env, Some("state")).map_err(|e| StateDBError::Open(e.into()))?;
         Ok(Self::new(env, db))
     }
 
@@ -117,11 +116,14 @@ impl StateDB {
     pub fn dump_map(&self) -> miette::Result<std::collections::HashMap<String, State>> {
         let mut map = std::collections::HashMap::new();
         for (key, val) in self.get_all(&self.begin_ro_txn()?)? {
-            let key_str = core::str::from_utf8(&key).map_err(|_e| miette::Error::msg("state key not UTF8"))?.to_string();
-            let val_state: State = rkyv::Deserialize::deserialize(val.as_ref(), &mut rkyv::Infallible).unwrap();
+            let key_str = core::str::from_utf8(&key)
+                .map_err(|_e| miette::Error::msg("state key not UTF8"))?
+                .to_string();
+            let val_state: State =
+                rkyv::Deserialize::deserialize(val.as_ref(), &mut rkyv::Infallible).unwrap();
             map.insert(key_str, val_state);
         }
-        Ok(map)  
+        Ok(map)
     }
 }
 

bffhd/resources/state/mod.rs

@@ -84,7 +84,10 @@ impl<'de> serde::de::Visitor<'de> for StateVisitor {
             ));
         }
         let val: MachineState = map.next_value()?;
-        Ok(State { inner: val, raw: Vec::new() })
+        Ok(State {
+            inner: val,
+            raw: Vec::new(),
+        })
     }
 }