Refactor: Deprecate changemap

Author: lbirkert

qb-core/src/change.rs

@@ -3,9 +3,10 @@
 //! This module provides primitives for working with changes applied
 //! to a filesystem.
 
-use std::collections::HashMap;
+use std::{collections::HashMap, fmt};
 
 use bitcode::{Decode, Encode};
+use itertools::Itertools;
 use serde::{Deserialize, Serialize};
 
 use crate::{diff::QBDiff, path::QBResource, time::QBTimeStampUnique};
@@ -19,6 +20,19 @@ pub struct QBChange {
     pub kind: QBChangeKind,
 }
 
+impl fmt::Display for QBChange {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{} {:?}", self.timestamp, self.kind)
+    }
+}
+
+impl QBChange {
+    /// Construct a new change.
+    pub fn new(timestamp: QBTimeStampUnique, kind: QBChangeKind) -> Self {
+        Self { timestamp, kind }
+    }
+}
+
 /// The kind of change.
 #[derive(Encode, Decode, Serialize, Deserialize, Debug, Clone)]
 pub enum QBChangeKind {
@@ -61,14 +75,15 @@ impl QBChangeKind {
 }
 
 /// This struct is a map which stores a collection of changes for each resource.
-#[derive(Encode, Decode, Serialize, Deserialize, Debug, Default)]
+#[derive(Encode, Decode, Serialize, Deserialize, Debug, Default, Clone)]
 pub struct QBChangeMap {
     changes: HashMap<QBResource, Vec<QBChange>>,
+    head: QBTimeStampUnique,
 }
 
 impl QBChangeMap {
     /// Gets the changes since the timestamp.
-    pub fn since_cloned(&self, since: QBTimeStampUnique) -> QBChangeMap {
+    pub fn since_cloned(&self, since: &QBTimeStampUnique) -> QBChangeMap {
         // iterator magic
         let changes = self
             .changes
@@ -78,19 +93,64 @@ impl QBChangeMap {
                     resource.clone(),
                     entries
                         .into_iter()
-                        .filter(|e| e.timestamp > since)
+                        .filter(|e| &e.timestamp > since)
                         .cloned()
                         .collect::<Vec<_>>(),
                 )
             })
             .filter(|(_, entries)| !entries.is_empty())
             .collect::<HashMap<_, _>>();
 
-        QBChangeMap { changes }
+        QBChangeMap {
+            changes,
+            head: self.head.clone(),
+        }
+    }
+
+    /// Gets the changes since the timestamp.
+    pub fn since(&mut self, since: &QBTimeStampUnique) -> QBChangeMap {
+        // iterator magic
+        let changes = self
+            .changes
+            .iter_mut()
+            .filter_map(|(resource, entries)| {
+                Some((
+                    resource.clone(),
+                    entries
+                        .drain(entries.iter().position(|e| &e.timestamp > since)?..)
+                        .collect(),
+                ))
+            })
+            .collect::<HashMap<_, _>>();
+
+        QBChangeMap {
+            changes,
+            head: self.head.clone(),
+        }
+    }
+
+    /// Returns whether this changemap is empty.
+    #[inline(always)]
+    pub fn is_empty(&self) -> bool {
+        self.changes.is_empty()
+    }
+
+    /// Iterate over the changes.
+    pub fn iter(&self) -> impl Iterator<Item = (&QBResource, &QBChange)> {
+        self.changes
+            .iter()
+            .map(|(resource, entries)| entries.into_iter().map(move |change| (resource, change)))
+            .flatten()
+            .sorted_by(|a, b| a.1.timestamp.cmp(&b.1.timestamp))
+    }
+
+    /// Return the head of this changemap (the last change).
+    pub fn head(&self) -> &QBTimeStampUnique {
+        &self.head
     }
 
     /// Gets the changes for a given resource from this changemap.
-    #[inline]
+    #[inline(always)]
     pub fn entries(&mut self, resource: QBResource) -> &mut Vec<QBChange> {
         self.changes.entry(resource).or_default()
     }
@@ -102,12 +162,12 @@ impl QBChangeMap {
         }
     }
 
-    #[inline]
+    #[inline(always)]
     fn _sort(entries: &mut [QBChange]) {
         entries.sort_by(|a, b| a.timestamp.cmp(&b.timestamp));
     }
 
-    #[inline]
+    #[inline(always)]
     fn _sort_borrowed(entries: &mut [&QBChange]) {
         entries.sort_by(|a, b| a.timestamp.cmp(&b.timestamp));
     }
@@ -120,7 +180,7 @@ impl QBChangeMap {
         }
     }
 
-    #[inline]
+    #[inline(always)]
     fn _minify(entries: &mut Vec<QBChange>) {
         let mut remove_until = 0;
 

qb-core/src/fs.rs

@@ -22,7 +22,7 @@ use crate::{
     hash::QBHash,
     ignore::{QBIgnoreMap, QBIgnoreMapBuilder},
     path::qbpaths::{
-        INTERNAL_CHANGELOG, INTERNAL_DEVICES, INTERNAL_FILETABLE, INTERNAL_FILETREE,
+        INTERNAL_CHANGEMAP, INTERNAL_DEVICES, INTERNAL_FILETABLE, INTERNAL_FILETREE,
         INTERNAL_IGNORE,
     },
     path::{qbpaths, QBPath, QBPathError},
@@ -87,7 +87,7 @@ impl QBFS {
         let ignore_builder: QBIgnoreMapBuilder = wrapper.dload(INTERNAL_IGNORE.as_ref()).await;
         let ignore = ignore_builder.build(&table);
         let devices = wrapper.dload(INTERNAL_DEVICES.as_ref()).await;
-        let changelog = wrapper.dload(INTERNAL_CHANGELOG.as_ref()).await;
+        let changelog = wrapper.dload(INTERNAL_CHANGEMAP.as_ref()).await;
 
         println!("loaded {}", ignore);
 
@@ -205,7 +205,7 @@ impl QBFS {
     /// Save changelog to file system.
     pub async fn save_changelog(&self) -> QBFSResult<()> {
         self.wrapper
-            .save(qbpaths::INTERNAL_CHANGELOG.as_ref(), &self.changelog)
+            .save(qbpaths::INTERNAL_CHANGEMAP.as_ref(), &self.changelog)
             .await
     }
 

qb-core/src/path.rs

@@ -24,7 +24,7 @@ pub mod qbpaths {
         /// the directory where quixbyte stores internal files
         pub static ref INTERNAL: QBPath = unsafe { QBPath::new("/.qb") };
         /// the internal changelog path
-        pub static ref INTERNAL_CHANGELOG: QBPath = unsafe { QBPath::new("/.qb/changelog") };
+        pub static ref INTERNAL_CHANGEMAP: QBPath = unsafe { QBPath::new("/.qb/changemap") };
         /// the internal filetree path
         pub static ref INTERNAL_FILETREE: QBPath = unsafe { QBPath::new("/.qb/filetree") };
         /// the internal filetable path

qb-core/src/time.rs

@@ -8,7 +8,7 @@ use std::{
     fmt,
     time::{SystemTime, UNIX_EPOCH},
 };
-use time::OffsetDateTime;
+use time::{macros::format_description, OffsetDateTime};
 
 use crate::device::QBDeviceId;
 
@@ -21,7 +21,8 @@ pub struct QBTimeStamp(u64);
 impl fmt::Display for QBTimeStamp {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let datetime = OffsetDateTime::from_unix_timestamp(self.0 as i64).unwrap();
-        write!(f, "{}", datetime)
+        let ft = format_description!("[day]-[month repr:short]-[year] [hour]:[minute]:[second]");
+        write!(f, "{}", datetime.format(ft).unwrap())
     }
 }
 

qb-daemon/src/daemon.rs

@@ -4,7 +4,7 @@
 //! which handles controlling tasks and processes the control
 //! requests sent by those. It manages the [master].
 
-use qb_core::{common::qbpaths::INTERNAL_CONFIG, fs::wrapper::QBFSWrapper};
+use qb_core::{fs::wrapper::QBFSWrapper, path::qbpaths::INTERNAL_CONFIG};
 use std::{
     collections::{HashMap, HashSet},
     future::Future,

qb-daemon/src/master.rs

@@ -7,12 +7,10 @@
 use std::{collections::HashMap, future::Future, pin::Pin, rc::Rc};
 
 use qb_core::{
-    change::log::QBChangelog,
-    common::{
-        device::{QBDeviceId, QBDeviceTable},
-        qbpaths::{INTERNAL_CHANGELOG, INTERNAL_DEVICES},
-    },
+    change::QBChangeMap,
+    device::{QBDeviceId, QBDeviceTable},
     fs::wrapper::QBFSWrapper,
+    path::qbpaths::{INTERNAL_CHANGEMAP, INTERNAL_DEVICES},
 };
 use qb_ext::{
     hook::{QBHChannel, QBHContext, QBHHostMessage, QBHId, QBHSlaveMessage},
@@ -95,7 +93,7 @@ pub struct QBMaster {
     pub hook_rx: mpsc::Receiver<(QBHId, QBHSlaveMessage)>,
     hook_tx: mpsc::Sender<(QBHId, QBHSlaveMessage)>,
     devices: QBDeviceTable,
-    changelog: QBChangelog,
+    changemap: QBChangeMap,
     wrapper: QBFSWrapper,
 }
 
@@ -110,7 +108,7 @@ impl QBMaster {
 
         wrapper.init().await.unwrap();
         let devices = wrapper.dload(INTERNAL_DEVICES.as_ref()).await;
-        let changelog = wrapper.dload(INTERNAL_CHANGELOG.as_ref()).await;
+        let changemap = wrapper.dload(INTERNAL_CHANGEMAP.as_ref()).await;
 
         QBMaster {
             interfaces: HashMap::new(),
@@ -120,7 +118,7 @@ impl QBMaster {
             hook_rx,
             hook_tx,
             devices,
-            changelog,
+            changemap,
             wrapper,
         }
     }
@@ -132,7 +130,7 @@ impl QBMaster {
             .await
             .unwrap();
         self.wrapper
-            .save(INTERNAL_CHANGELOG.as_ref(), &self.changelog)
+            .save(INTERNAL_CHANGEMAP.as_ref(), &self.changemap)
             .await
             .unwrap();
     }
@@ -221,18 +219,19 @@ impl QBMaster {
         let handle_common = self.devices.get_common(&device_id);
 
         match msg {
-            QBIMessage::Sync { common, changes } => {
+            QBIMessage::Sync { common, .. } => {
                 assert!(handle_common == &common);
 
                 // Find local changes
-                let local_entries = self.changelog.after(&common).unwrap();
+                let local_entries = self.changemap.since(&common);
 
                 // Apply changes to changelog
-                let (mut entries, _) = QBChangelog::merge(local_entries.clone(), changes).unwrap();
-                self.changelog.append(&mut entries);
+                // TODO: merging
+                //let (mut entries, _) = QBChangelog::merge(local_entries.clone(), changes).unwrap();
+                //self.changemap.append(&mut entries);
 
-                // Negotiate a new common hash
-                let new_common = self.changelog.head();
+                // find the new common hash
+                let new_common = self.changemap.head().clone();
                 self.devices.set_common(&device_id, new_common);
 
                 // Send sync to remote
@@ -389,7 +388,7 @@ impl QBMaster {
                 }
 
                 let handle_common = self.devices.get_common(&device_id);
-                let changes = self.changelog.after_cloned(handle_common).unwrap();
+                let changes = self.changemap.since_cloned(handle_common);
 
                 // skip if no changes to sync
                 if changes.is_empty() {

qb-ext/src/interface.rs

@@ -22,10 +22,7 @@ use serde::{Deserialize, Serialize};
 use std::fmt;
 use std::future::Future;
 
-use qb_core::{
-    change::QBChange,
-    common::{device::QBDeviceId, hash::QBHash},
-};
+use qb_core::{change::QBChangeMap, device::QBDeviceId, time::QBTimeStampUnique};
 
 use crate::QBChannel;
 
@@ -89,14 +86,14 @@ pub enum QBIMessage {
     /// change gets updated (synchronization)
     Common {
         /// hash that points to the common change
-        common: QBHash,
+        common: QBTimeStampUnique,
     },
     /// synchronize
     Sync {
         /// the common hash that was used for creating the changes vector
-        common: QBHash,
+        common: QBTimeStampUnique,
         /// a vector describing the changes
-        changes: Vec<QBChange>,
+        changes: QBChangeMap,
     },
     /// An interface might not be properly initialized
     /// at attachment and we might not even know the Id
@@ -111,13 +108,11 @@ pub enum QBIMessage {
 impl fmt::Display for QBIMessage {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match &self {
-            QBIMessage::Sync {
-                common,
-                changes: entries,
-            } => {
+            QBIMessage::Sync { common, changes } => {
                 writeln!(f, "QBI_MSG_SYNC common: {}", common)?;
-                for entry in entries {
+                for (resource, entry) in changes.iter() {
                     fmt::Display::fmt(entry, f)?;
+                    fmt::Display::fmt(resource, f)?;
                     writeln!(f)?;
                 }
                 Ok(())