[pdm-devel] [PATCH proxmox-datacenter-manager 04/15] task cache: remove max-age machanism

[Lukas Wagner]

This commit removes the time-based caching policy for remote tasks. It
will be replaced by another cache replacement policy based on total
number of tasks in an upcoming commit.

Suggested-by: Dominik Csapak <d.csapak at proxmox.com>
Signed-off-by: Lukas Wagner <l.wagner at proxmox.com>
---
 server/src/api/remote_tasks.rs | 11 ++---------
 server/src/task_cache.rs       | 31 +++++++++----------------------
 2 files changed, 11 insertions(+), 31 deletions(-)

diff --git a/server/src/api/remote_tasks.rs b/server/src/api/remote_tasks.rs
index 57b59fd..da3b718 100644
--- a/server/src/api/remote_tasks.rs
+++ b/server/src/api/remote_tasks.rs
@@ -21,13 +21,6 @@ const SUBDIRS: SubdirMap = &sorted!([("list", &Router::new().get(&API_METHOD_LIS
     },
     input: {
         properties: {
-            "max-age": {
-                type: Integer,
-                optional: true,
-                // TODO: sensible default max-age
-                default: 300,
-                description: "Maximum age of cached task data",
-            },
             filters: {
                 type: TaskFilters,
                 flatten: true,
@@ -36,8 +29,8 @@ const SUBDIRS: SubdirMap = &sorted!([("list", &Router::new().get(&API_METHOD_LIS
     },
 )]
 /// Get the list of tasks for all remotes.
-async fn list_tasks(max_age: i64, filters: TaskFilters) -> Result<Vec<TaskListItem>, Error> {
-    let tasks = task_cache::get_tasks(max_age, filters).await?;
+async fn list_tasks(filters: TaskFilters) -> Result<Vec<TaskListItem>, Error> {
+    let tasks = task_cache::get_tasks(filters).await?;
 
     Ok(tasks)
 }
diff --git a/server/src/task_cache.rs b/server/src/task_cache.rs
index 211beb4..f24af3f 100644
--- a/server/src/task_cache.rs
+++ b/server/src/task_cache.rs
@@ -20,7 +20,7 @@ use crate::{api::pve, task_utils};
 
 /// Get tasks for all remotes
 // FIXME: filter for privileges
-pub async fn get_tasks(max_age: i64, filters: TaskFilters) -> Result<Vec<TaskListItem>, Error> {
+pub async fn get_tasks(filters: TaskFilters) -> Result<Vec<TaskListItem>, Error> {
     let (remotes, _) = pdm_config::remotes::config()?;
 
     let mut all_tasks = Vec::new();
@@ -42,9 +42,7 @@ pub async fn get_tasks(max_age: i64, filters: TaskFilters) -> Result<Vec<TaskLis
     invalidate_cache_for_finished_tasks(&mut cache);
 
     for (remote_name, remote) in &remotes.sections {
-        let now = proxmox_time::epoch_i64();
-
-        if let Some(tasks) = cache.get_tasks(remote_name.as_str(), now, max_age) {
+        if let Some(tasks) = cache.get_tasks(remote_name.as_str()) {
             // Data in cache is recent enough and has not been invalidated.
             all_tasks.extend(tasks);
         } else {
@@ -55,7 +53,7 @@ pub async fn get_tasks(max_age: i64, filters: TaskFilters) -> Result<Vec<TaskLis
                     continue;
                 }
             };
-            cache.set_tasks(remote_name.as_str(), tasks.clone(), now);
+            cache.set_tasks(remote_name.as_str(), tasks.clone());
 
             all_tasks.extend(tasks);
         }
@@ -305,10 +303,7 @@ impl TaskCache {
 
         for (remote_name, entry) in self.new_or_updated.remote_tasks.drain() {
             if let Some(existing_entry) = content.remote_tasks.get_mut(&remote_name) {
-                // Only update entry if nobody else has updated it in the meanwhile
-                if existing_entry.timestamp < entry.timestamp {
-                    *existing_entry = entry;
-                }
+                *existing_entry = entry;
             } else {
                 content.remote_tasks.insert(remote_name, entry);
             }
@@ -329,25 +324,18 @@ impl TaskCache {
     }
 
     // Update task data for a given remote.
-    fn set_tasks(&mut self, remote: &str, tasks: Vec<TaskListItem>, timestamp: i64) {
+    fn set_tasks(&mut self, remote: &str, tasks: Vec<TaskListItem>) {
         self.dirty = true;
         self.new_or_updated
             .remote_tasks
-            .insert(remote.to_string(), TaskCacheEntry { timestamp, tasks });
+            .insert(remote.to_string(), TaskCacheEntry { tasks });
     }
 
     // Get task data for a given remote.
-    fn get_tasks(&self, remote: &str, now: i64, max_age: i64) -> Option<Vec<TaskListItem>> {
+    fn get_tasks(&self, remote: &str) -> Option<Vec<TaskListItem>> {
         if let Some(entry) = self.content.remote_tasks.get(remote) {
-            if (entry.timestamp + max_age) < now {
-                return None;
-            }
-
             Some(entry.tasks.clone())
         } else if let Some(entry) = self.new_or_updated.remote_tasks.get(remote) {
-            if (entry.timestamp + max_age) < now {
-                return None;
-            }
             Some(entry.tasks.clone())
         } else {
             None
@@ -378,7 +366,6 @@ impl TaskCache {
 #[derive(Debug, Serialize, Deserialize)]
 /// Per-remote entry in the task cache.
 struct TaskCacheEntry {
-    timestamp: i64,
     tasks: Vec<TaskListItem>,
 }
 
@@ -569,12 +556,12 @@ mod tests {
             });
         }
 
-        cache.set_tasks("some-remote", tasks.clone(), now);
+        cache.set_tasks("some-remote", tasks.clone());
         cache.save()?;
 
         let cache = TaskCache::new(temp_file.path().into(), options)?;
 
-        let res = cache.get_tasks("some-remote", now, 10000).unwrap();
+        let res = cache.get_tasks("some-remote").unwrap();
         assert_eq!(tasks, res);
 
         Ok(())
-- 
2.39.5