Make auditlog log

bffhd/resources/mod.rs

@@ -7,6 +7,7 @@ use rkyv::{Archived, Deserialize};
 use rkyv::option::ArchivedOption;
 use rkyv::ser::Serializer;
 use rkyv::ser::serializers::AllocSerializer;
+use crate::audit::AUDIT;
 use crate::authorization::permissions::PrivilegesBuf;
 use crate::config::MachineDescription;
 use crate::db::ArchivedValue;
@@ -75,6 +76,8 @@ impl Inner {
         self.db.put(&self.id.as_bytes(), &state).unwrap();
         tracing::trace!("Updated DB, sending update signal");
 
+        AUDIT.get().unwrap().log(self.id.as_str(), &format!("{}", state));
+
         self.signal.set(state);
         tracing::trace!("Sent update signal");
     }

bffhd/resources/modules/fabaccess.rs

@@ -1,4 +1,5 @@
-
+use std::fmt;
+use std::fmt::{Write, write};
 use crate::utils::oid::ObjectIdentifier;
 use once_cell::sync::Lazy;
 use rkyv::{Archive, Archived, Deserialize, Infallible};
@@ -57,6 +58,19 @@ pub struct MachineState {
     pub previous: Option<UserRef>,
 }
 
+impl fmt::Display for ArchivedMachineState {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match &self.state {
+            ArchivedStatus::Free => f.write_str("free"),
+            ArchivedStatus::InUse(user) => write!(f, "inuse {}", user),
+            ArchivedStatus::ToCheck(user) => write!(f, "tocheck {}", user),
+            ArchivedStatus::Blocked(user) => write!(f, "blocked {}", user),
+            ArchivedStatus::Disabled => f.write_str("disabled"),
+            ArchivedStatus::Reserved(user) => write!(f, "reserved {}", user),
+        }
+    }
+}
+
 impl MachineState {
     pub fn new() -> Self {
         Self {

bffhd/resources/state/mod.rs

@@ -31,6 +31,7 @@ pub struct State {
     pub inner: MachineState,
 }
 
+
 impl fmt::Debug for State {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut sf = f.debug_struct("State");
@@ -42,6 +43,12 @@ impl fmt::Debug for State {
     }
 }
 
+impl fmt::Display for ArchivedState {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        Display::fmt(&self.inner, f)
+    }
+}
+
 impl serde::Serialize for State {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where S: serde::Serializer