run cargo fmt --all

bffhd/actors/process.rs

@@ -1,7 +1,7 @@
+use base64::Engine;
 use futures_util::future::BoxFuture;
 use std::collections::HashMap;
 use std::process::{Command, Stdio};
-use base64::Engine;
 
 use crate::actors::Actor;
 use crate::db::ArchivedValue;

bffhd/capnp/machine.rs

@@ -3,15 +3,16 @@ use crate::resources::modules::fabaccess::{ArchivedStatus, Status};
 use crate::resources::Resource;
 use crate::session::SessionHandle;
 use api::general_capnp::optional;
+use api::machine_capnp::machine::prodable::{ProdWithDataParams, ProdWithDataResults};
 use api::machine_capnp::machine::{
     self, admin, admin::Server as AdminServer, check, check::Server as CheckServer,
     in_use as inuse, in_use::Server as InUseServer, info, info::Server as InfoServer, manage,
-    manage::Server as ManageServer, use_, use_::Server as UseServer, MachineState, prodable::Server as ProdableServer,
+    manage::Server as ManageServer, prodable::Server as ProdableServer, use_,
+    use_::Server as UseServer, MachineState,
 };
 use capnp::capability::Promise;
 use capnp::Error;
 use capnp_rpc::pry;
-use api::machine_capnp::machine::prodable::{ProdWithDataParams, ProdWithDataResults};
 
 #[derive(Clone)]
 pub struct Machine {
@@ -188,7 +189,11 @@ impl InUseServer for Machine {
 }
 
 impl ProdableServer for Machine {
-    fn prod_with_data(&mut self, params: ProdWithDataParams, _: ProdWithDataResults) -> Promise<(), Error> {
+    fn prod_with_data(
+        &mut self,
+        params: ProdWithDataParams,
+        _: ProdWithDataResults,
+    ) -> Promise<(), Error> {
         let data: Vec<u8> = pry!(pry!(params.get()).get_data()).to_vec();
         self.resource.send_raw(data);
         Promise::ok(())

bffhd/capnp/user.rs

@@ -143,7 +143,8 @@ impl admin::Server for User {
             // Only update if needed
             if !target.userdata.roles.iter().any(|r| r.as_str() == rolename) {
                 target.userdata.roles.push(rolename.to_string());
-                pry!(self.session
+                pry!(self
+                    .session
                     .users
                     .put_user(self.user.get_username(), &target));
             }
@@ -168,7 +169,8 @@ impl admin::Server for User {
             // Only update if needed
             if target.userdata.roles.iter().any(|r| r.as_str() == rolename) {
                 target.userdata.roles.retain(|r| r.as_str() != rolename);
-                pry!(self.session
+                pry!(self
+                    .session
                     .users
                     .put_user(self.user.get_username(), &target));
             }
@@ -210,10 +212,7 @@ impl card_d_e_s_fire_e_v2::Server for User {
                 "User API object with nonexisting user \"{}\"",
                 self.user.get_username()
             ))));
-        if let Some(tk) = user
+        if let Some(tk) = user.userdata.kv.get("cardtoken") {
-            .userdata
-            .kv
-            .get("cardtoken") {
             let b = results.get();
             let mut lb = b.init_token_list(1);
             lb.set(0, tk.as_ref());

bffhd/config/dhall.rs

@@ -57,7 +57,11 @@ pub struct MachineDescription {
     #[serde(flatten)]
     pub privs: PrivilegesBuf,
 
-    #[serde(default = "default_prodable", skip_serializing_if = "bool_is_false", deserialize_with = "deser_bool")]
+    #[serde(
+        default = "default_prodable",
+        skip_serializing_if = "bool_is_false",
+        deserialize_with = "deser_bool"
+    )]
     pub prodable: bool,
 }
 
@@ -128,7 +132,6 @@ where
     Ok(bool::deserialize(d).unwrap_or(false))
 }
 
-
 pub(crate) fn deser_option<'de, D, T>(d: D) -> std::result::Result<Option<T>, D::Error>
 where
     D: serde::Deserializer<'de>,

bffhd/initiators/mod.rs

@@ -2,9 +2,7 @@ use crate::initiators::dummy::Dummy;
 use crate::initiators::process::Process;
 use crate::resources::modules::fabaccess::Status;
 use crate::session::SessionHandle;
-use crate::{
+use crate::{AuthenticationHandle, Config, Resource, ResourcesHandle, SessionManager};
-    AuthenticationHandle, Config, Resource, ResourcesHandle, SessionManager,
-};
 use executor::prelude::Executor;
 use futures_util::ready;
 use std::collections::HashMap;

bffhd/lib.rs

@@ -208,9 +208,11 @@ impl Difluoroborane {
     pub fn dump_db(&mut self, file: &str) -> Result<(), miette::Error> {
         let users = self.users.dump_map()?;
         let state = self.statedb.dump_map()?;
-        let dump = DatabaseDump{users, state};
+        let dump = DatabaseDump { users, state };
-        let data = toml::ser::to_vec(&dump).map_err(|e| miette::Error::msg(format!("Serializing database dump failed: {}", e)))?;
+        let data = toml::ser::to_vec(&dump)
-        std::fs::write(file, &data).map_err(|e| miette::Error::msg(format!("writing database dump failed: {}", e)))?;
+            .map_err(|e| miette::Error::msg(format!("Serializing database dump failed: {}", e)))?;
+        std::fs::write(file, &data)
+            .map_err(|e| miette::Error::msg(format!("writing database dump failed: {}", e)))?;
         Ok(())
     }
 
@@ -236,7 +238,8 @@ impl Difluoroborane {
             self.resources.clone(),
             sessionmanager.clone(),
             authentication.clone(),
-        ).expect("initializing initiators failed");
+        )
+        .expect("initializing initiators failed");
         // TODO 0.5: error handling. Add variant to BFFHError
 
         actors::load(self.executor.clone(), &self.config, self.resources.clone())?;

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 =
+            let m_state: MachineState = match Deserialize::<MachineState, _>::deserialize(
-                match Deserialize::<MachineState, _>::deserialize(&old_state.inner, &mut serializer) {
+                &old_state.inner,
-                    Ok(s) => s,
+                &mut serializer,
-                    Err(error) => {
+            ) {
-                        tracing::error!(?error, "failed to deserialize stored state!");
+                Ok(s) => s,
-                        return;
+                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"))
+        let db = RawDB::open(&env, Some("state")).map_err(|e| StateDBError::Open(e.into()))?;
-            .map_err(|e| StateDBError::Open(e.into()))?;
         Ok(Self::new(env, db))
     }
 
@@ -117,8 +116,11 @@ 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 key_str = core::str::from_utf8(&key)
-            let val_state: State = rkyv::Deserialize::deserialize(val.as_ref(), &mut rkyv::Infallible).unwrap();
+                .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)

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(),
+        })
     }
 }
 

bffhd/users/mod.rs

@@ -178,7 +178,7 @@ impl Users {
         Ok(())
     }
 
-    pub fn load_map(&mut self, dump: &HashMap<String,UserData>) -> miette::Result<()> {
+    pub fn load_map(&mut self, dump: &HashMap<String, UserData>) -> miette::Result<()> {
         let mut txn = unsafe { self.userdb.get_rw_txn() }?;
 
         self.userdb.clear_txn(&mut txn)?;
@@ -199,7 +199,7 @@ impl Users {
     }
 
     pub fn dump_map(&self) -> miette::Result<HashMap<String, UserData>> {
-        return Ok(self.userdb.get_all()?)
+        return Ok(self.userdb.get_all()?);
     }
     pub fn dump_file(&self, path_str: &str, force: bool) -> miette::Result<usize> {
         let path = Path::new(path_str);

bin/bffhd/main.rs

@@ -184,9 +184,13 @@ fn main() -> miette::Result<()> {
     } else if matches.is_present("load-users") {
         let bffh = Difluoroborane::new(config)?;
 
-        bffh.users.load_file(matches.value_of("load-users").unwrap())?;
+        bffh.users
+            .load_file(matches.value_of("load-users").unwrap())?;
 
-        tracing::info!("loaded users from {}", matches.value_of("load-users").unwrap());
+        tracing::info!(
+            "loaded users from {}",
+            matches.value_of("load-users").unwrap()
+        );
 
         return Ok(());
     } else {