Created proof-of-concept for saving cache to disk

Author: IsaacShelton

Cargo.lock

@@ -49,6 +49,11 @@ pub fn server_main(max_idle_time: Duration) -> io::Result<()> {
             }
         }
 
+        // Try to save the cache to disk before we exit if possible
+        if rt.lock().await.cache_to_disk {
+            let _ = rt.lock().await.cache().save("adept.cache");
+        }
+
         Ok(())
     })
 }

src/components/daemon/src/server.rs

@@ -52,74 +52,80 @@ pub async fn watch<'e, P: Pf, REQ: Into<P::Req<'e>> + Clone + Send + UnwrapAft<'
         // NOTE: We keep the lock acquired for the entire lifetime of the query
         let mut rt = rt.lock().await;
 
-        let run = async {
-            // Read the new project while we're at it. This will likely have already been computed.
-            let new_project = watch_query(
-                rt.deref_mut(),
-                GetProject {
-                    working_directory: working_directory.clone(),
-                },
-                QueryMode::Continue,
-                TimeoutAt(Instant::now() + Duration::from_millis(50)),
-            )
-            .await;
-
-            // Determine if the watch config was changed as part of the project config.
-            let new_watch_config = match new_project {
-                Ok(BlockOn::Complete(Ok(project))) => {
-                    let config = WatchConfig {
-                        interval_ms: project.interval_ms.unwrap_or(DEFAULTS.interval_ms),
-                        cache_to_disk: project.cache_to_disk.unwrap_or(DEFAULTS.cache_to_disk),
-                        max_idle_time_ms: project.max_idle_time_ms,
-                    };
-
-                    (config != watch_config).then_some(config)
-                }
-                Ok(BlockOn::Complete(Err(errors)))
-                    if !errors
-                        .iter_unordered()
-                        .any(|error| error.is_invalid_project_config_syntax()) =>
-                {
-                    // Failed to parse project file, don't change the configuration
-                    None
-                }
-                _ => {
-                    // Failed to read project file
-                    (watch_config != DEFAULTS).then_some(DEFAULTS)
-                }
-            };
+        // Read the new project while we're at it.
+        let new_project = watch_query(
+            rt.deref_mut(),
+            GetProject {
+                working_directory: working_directory.clone(),
+            },
+            QueryMode::New,
+            TimeoutAt(Instant::now() + Duration::from_millis(50)),
+        )
+        .await;
+
+        // Determine if the watch config was changed as part of the project config.
+        let new_watch_config = match new_project {
+            Ok(BlockOn::Complete(Ok(project))) => {
+                let config = WatchConfig {
+                    interval_ms: project.interval_ms.unwrap_or(DEFAULTS.interval_ms),
+                    cache_to_disk: project.cache_to_disk.unwrap_or(DEFAULTS.cache_to_disk),
+                    max_idle_time_ms: project.max_idle_time_ms,
+                };
+
+                (config != watch_config).then_some(config)
+            }
+            Ok(BlockOn::Complete(Err(errors)))
+                if !errors
+                    .iter_unordered()
+                    .any(|error| error.is_invalid_project_config_syntax()) =>
+            {
+                // Failed to parse project file, don't change the configuration
+                None
+            }
+            _ => {
+                // Failed to read project file
+                (watch_config != DEFAULTS).then_some(DEFAULTS)
+            }
+        };
 
-            // If we have a new watch config, update it as well as the idle tracker.
-            if let Some(new_watch_config) = new_watch_config {
-                watch_config = new_watch_config;
+        // If we have a new watch config, update it as well as the idle tracker.
+        if let Some(new_watch_config) = new_watch_config {
+            watch_config = new_watch_config;
 
-                let mut idle_tracker = server.idle_tracker.lock().await;
-                idle_tracker.last_active = Instant::now();
-                idle_tracker
-                    .set_max_idle_time(watch_config.max_idle_time_ms.map(Duration::from_millis));
-            }
+            let mut idle_tracker = server.idle_tracker.lock().await;
+            idle_tracker.last_active = Instant::now();
+            idle_tracker
+                .set_max_idle_time(watch_config.max_idle_time_ms.map(Duration::from_millis));
+            rt.cache_to_disk = watch_config.cache_to_disk;
+        }
 
+        let run = async {
             let timeout = TimeoutAt(Instant::now() + Duration::from_secs(2));
-            Ok(watch_query(rt.deref_mut(), watchee.clone(), QueryMode::New, timeout).await)
+            Ok(watch_query(
+                rt.deref_mut(),
+                watchee.clone(),
+                QueryMode::Continue,
+                timeout,
+            )
+            .await)
         };
 
         let timeout = async {
             Timer::after(Duration::from_millis(500)).await;
             Err(())
         };
 
+        if server.idle_tracker.lock().await.shutdown_if_idle() {
+            break;
+        }
+
         log!("Watch Result is {:?}", run.or(timeout).await);
         Timer::after(Duration::from_millis(watch_config.interval_ms)).await;
 
         if server.idle_tracker.lock().await.shutdown_if_idle() {
             break;
         }
     }
-
-    // Try to save the cache to disk before we exit if possible
-    if watch_config.cache_to_disk {
-        let _ = rt.lock().await.cache().save("adept.cache");
-    }
 }
 
 async fn watch_query<

src/components/daemon/src/watch.rs

@@ -15,7 +15,7 @@ infinite_iterator = { version = "0.1.0", path = "../../support/infinite_iterator
 line_column = { version = "0.1.0", path = "../../support/line_column" }
 serde = { version = "1.0.228", features = ["derive", "rc"] }
 serde_json = "1.0.145"
-smallvec = "1.15.1"
+smallvec = { version = "1.15.1", features = ["serde"] }
 text = { version = "0.1.0", path = "../../support/text" }
 thiserror = "2.0.17"
 token = { version = "0.1.0", path = "../../representations/token" }

src/components/req/Cargo.toml

@@ -1,8 +1,11 @@
 use derive_more::IsVariant;
+use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 use thiserror::Error;
 
-#[derive(Clone, Debug, Error, Hash, PartialEq, Eq, PartialOrd, Ord, IsVariant)]
+#[derive(
+    Clone, Debug, Error, Hash, PartialEq, Eq, PartialOrd, Ord, IsVariant, Serialize, Deserialize,
+)]
 pub enum Error {
     #[error("Missing project file `adept.build`")]
     MissingProjectFile,

src/components/req/src/errors.rs

@@ -23,6 +23,7 @@ pub use pf::*;
 pub use requests::*;
 pub use rt::*;
 pub use rt_st_in::*;
+use serde::{Deserialize, Serialize};
 use std::{path::Path, sync::Arc};
 pub use succ::*;
 pub use syms::*;
@@ -41,7 +42,7 @@ macro_rules! log {
     }};
 }
 
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+#[derive(Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Project {
     pub root: Arc<Path>,
     pub interval_ms: Option<u64>,
@@ -71,10 +72,11 @@ mod requests {
     pub struct GetProjectState;
 
     #[define_requests::returns(String)]
-    pub struct Search<'e>(&'e str);
+    pub struct Search();
     #[derive(Default)]
     pub struct SearchState;
 
+    #[define_requests::never_persist]
     #[define_requests::returns(WithErrors<Syms<P>>)]
     pub struct Approach;
     #[derive(Default)]

src/components/req/src/lib.rs

@@ -6,7 +6,7 @@ pub trait Like<T> {
     fn like_mut(&mut self) -> &mut T;
 }
 
-impl<'e> Like<Req<'e>> for Req<'e> {
+impl<'e> Like<Req> for Req {
     #[inline(always)]
     fn like(self) -> Self {
         self

src/components/req/src/like.rs

@@ -1,4 +1,8 @@
-use crate::{Aft, Approach, AsSyms, IsDiv, IsImpure, Like, Minor, Req, RunDispatch, St, UnLike};
+use crate::{
+    Aft, Approach, AsSyms, IsDiv, IsImpure, Like, Minor, Req, RunDispatch, ShouldPersist, St,
+    UnLike,
+};
+use serde::{Deserialize, Serialize};
 use std::{fmt::Debug, hash::Hash};
 
 pub trait Pf: Clone + Debug + Default {
@@ -9,9 +13,12 @@ pub trait Pf: Clone + Debug + Default {
         + Eq
         + Send
         + IsImpure
+        + ShouldPersist
         + From<Approach>
         + RunDispatch<'e, Self>
-        + UnLike<Req<'e>>;
+        + UnLike<Req>
+        + Serialize
+        + Deserialize<'e>;
     type Rev: Copy
         + Clone
         + Debug
@@ -22,7 +29,17 @@ pub trait Pf: Clone + Debug + Default {
         + Ord
         + Send
         + IsDiv
-        + Minor;
-    type Aft<'e>: Debug + Clone + Send + AsSyms<Self> + PartialEq + Eq + Like<Aft<Self>>;
+        + Minor
+        + Serialize
+        + for<'de> Deserialize<'de>;
+    type Aft<'e>: Debug
+        + Clone
+        + Send
+        + AsSyms<Self>
+        + PartialEq
+        + Eq
+        + Like<Aft<Self>>
+        + Serialize
+        + Deserialize<'e>;
     type St<'e>: Debug + Default + Send + Like<St>;
 }

src/components/req/src/pf.rs

@@ -22,13 +22,13 @@ pub trait Rt<'e, P: Pf>: Send {
 
 pub trait Th<'e, P: Pf>
 where
-    P::Req<'e>: UnLike<Req<'e>>,
+    P::Req<'e>: UnLike<Req>,
 {
     type Rt: Rt<'e, P>;
     fn rt(&self) -> &Self::Rt;
     fn demand<R>(&mut self, req: R) -> Result<&R::Aft<'e>, Suspend>
     where
-        R: Into<Req<'e>> + UnwrapAft<'e, P>;
+        R: Into<Req> + UnwrapAft<'e, P>;
 }
 
 pub trait Ch<'e, P: Pf> {

src/components/req/src/rt.rs

@@ -1,11 +1,11 @@
-use crate::{Pf, TaskStatus};
-use serde::ser::SerializeMap;
+use crate::{Pf, ShouldPersist, TaskStatus, TaskStatusKind};
+use serde::ser::{SerializeMap, SerializeSeq};
 use std::{collections::HashMap, io::Write, path::Path};
 
 const HEADER: &[u8] =
     b"This file is a local cache and *not* sharable. It should be ignored for version control purposes.\n";
 const COMPILER_BUILT_AT: u64 = compile_time::unix!();
-const HUMAN_READABLE: bool = true;
+const HUMAN_READABLE: bool = false;
 
 #[derive(Default)]
 pub struct Cache<'e, P: Pf> {
@@ -66,8 +66,29 @@ impl<'e, P: Pf> serde::Serialize for Kv<'e, P> {
     where
         S: serde::Serializer,
     {
-        let map = serializer.serialize_map(Some(0))?;
-        map.end()
+        let mut include = vec![];
+
+        for (key, value) in self.inner.iter() {
+            if !key.should_persist() {
+                continue;
+            }
+            match value {
+                Some(status) => match &status.kind {
+                    TaskStatusKind::Running(_) => (),
+                    TaskStatusKind::Completed(completed) => {
+                        include.push((key, &completed.aft));
+                    }
+                    TaskStatusKind::Restarting(_) => (),
+                },
+                None => (),
+            }
+        }
+
+        let mut seq = serializer.serialize_seq(Some(include.len()))?;
+        for entry in include {
+            seq.serialize_element(&entry)?;
+        }
+        seq.end()
     }
 }