[pdm-devel] [PATCH datacenter-manager v2 0/3] refactor api caching & try to reuse the cache

[pdm-devel] [PATCH datacenter-manager v2 0/3] refactor api caching & try to reuse the cache

[Dominik Csapak]

This series introduces a small refactored struct to access the api cache
(like we used for resources + subscription) so that we don't have to
repeat the same way for every bit of data we want to cache.

It also shows how we can add a mechanism to live update this cache
for e.g. pve resources api call and utilize it when the
remote is not reachable

changes from v2:
* use proper api type to convey that the result was cached
* abstract the 'update, fall back to cache' helper into the ApiCache
  struct (it'll probably be useful for more api calls)
* update the cli client for this too
* some smaller things @Lukas mentioned (thanks!)

Dominik Csapak (3):
  server: api: resources: change use of remote to reference
  server: introduce ApiCache abstraction
  api/ui: pve: get cluster resources from cache if remote is unreachable

 cli/client/src/pve.rs                        |   4 +-
 lib/pdm-api-types/src/resource.rs            |  24 +++
 lib/pdm-client/src/lib.rs                    |   4 +-
 server/src/api/pve/mod.rs                    |  63 ++++---
 server/src/api/resources.rs                  | 163 +++++--------------
 server/src/api_cache.rs                      | 128 +++++++++++++++
 server/src/lib.rs                            |   1 +
 server/src/metric_collection/top_entities.rs |   2 +-
 ui/src/pve/mod.rs                            |  27 ++-
 9 files changed, 259 insertions(+), 157 deletions(-)
 create mode 100644 server/src/api_cache.rs

-- 
2.47.3



_______________________________________________
pdm-devel mailing list
pdm-devel@lists.proxmox.com
https://lists.proxmox.com/cgi-bin/mailman/listinfo/pdm-devel

[pdm-devel] [PATCH datacenter-manager v2 1/3] server: api: resources: change use of remote to reference

[Dominik Csapak]

we don't need to take ownership here, and it makes the code easier
later.

Signed-off-by: Dominik Csapak <d.csapak@proxmox.com>
---
 server/src/api/resources.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/server/src/api/resources.rs b/server/src/api/resources.rs
index d629c654..c640e4a2 100644
--- a/server/src/api/resources.rs
+++ b/server/src/api/resources.rs
@@ -255,7 +255,7 @@ pub(crate) async fn get_resources_impl(
         }
         let filter = filters.clone();
         let handle = tokio::spawn(async move {
-            let (mut resources, error) = match get_resources_for_remote(remote, max_age).await {
+            let (mut resources, error) = match get_resources_for_remote(&remote, max_age).await {
                 Ok(resources) => (resources, None),
                 Err(error) => {
                     tracing::debug!("failed to get resources from remote - {error:?}");
@@ -700,7 +700,7 @@ static CACHE: LazyLock<RwLock<HashMap<String, CachedResources>>> =
 ///
 /// If recent enough cached data is available, it is returned
 /// instead of calling out to the remote.
-async fn get_resources_for_remote(remote: Remote, max_age: u64) -> Result<Vec<Resource>, Error> {
+async fn get_resources_for_remote(remote: &Remote, max_age: u64) -> Result<Vec<Resource>, Error> {
     let remote_name = remote.id.to_owned();
     if let Some(cached_resource) = get_cached_resources(&remote_name, max_age) {
         Ok(cached_resource.resources)
@@ -756,13 +756,13 @@ fn update_cached_resources(remote: &str, resources: &[Resource], now: i64) {
 }
 
 /// Fetch remote resources and map to pdm-native data types.
-async fn fetch_remote_resource(remote: Remote) -> Result<Vec<Resource>, Error> {
+async fn fetch_remote_resource(remote: &Remote) -> Result<Vec<Resource>, Error> {
     let mut resources = Vec::new();
     let remote_name = remote.id.to_owned();
 
     match remote.ty {
         RemoteType::Pve => {
-            let client = connection::make_pve_client(&remote)?;
+            let client = connection::make_pve_client(remote)?;
 
             let cluster_resources = client.cluster_resources(None).await?;
 
@@ -773,7 +773,7 @@ async fn fetch_remote_resource(remote: Remote) -> Result<Vec<Resource>, Error> {
             }
         }
         RemoteType::Pbs => {
-            let client = connection::make_pbs_client(&remote)?;
+            let client = connection::make_pbs_client(remote)?;
 
             let status = client.node_status().await?;
             resources.push(map_pbs_node_status(&remote_name, status));
-- 
2.47.3



_______________________________________________
pdm-devel mailing list
pdm-devel@lists.proxmox.com
https://lists.proxmox.com/cgi-bin/mailman/listinfo/pdm-devel

[pdm-devel] [PATCH datacenter-manager v2 2/3] server: introduce ApiCache abstraction

[Dominik Csapak]

Abstract our resources/subscription cache mechanism away into a struct
that takes care of the max-age logic and fetching/inserting.

This can be useful to have in general, and we don't need to copy it
every time.

We still have to use a LazyLock at the usage site and give the correct
Type, but we can deduplicate most of the access/update logic.

Signed-off-by: Dominik Csapak <d.csapak@proxmox.com>
---
changes from v1:
* add new CacheUpdateResult struct for the 'update_or_get_cache'
  method
* rename like Lukas suggested
* combine impl blocks

 server/src/api/resources.rs                  | 142 +++----------------
 server/src/api_cache.rs                      | 128 +++++++++++++++++
 server/src/lib.rs                            |   1 +
 server/src/metric_collection/top_entities.rs |   2 +-
 4 files changed, 150 insertions(+), 123 deletions(-)
 create mode 100644 server/src/api_cache.rs

diff --git a/server/src/api/resources.rs b/server/src/api/resources.rs
index c640e4a2..0df9c781 100644
--- a/server/src/api/resources.rs
+++ b/server/src/api/resources.rs
@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 use std::str::FromStr;
-use std::sync::{LazyLock, RwLock};
+use std::sync::LazyLock;
 
 use anyhow::{bail, format_err, Error};
 use futures::future::join_all;
@@ -28,6 +28,7 @@ use proxmox_sortable_macro::sortable;
 use proxmox_subscription::SubscriptionStatus;
 use pve_api_types::{ClusterResource, ClusterResourceType};
 
+use crate::api_cache::ApiCache;
 use crate::connection;
 use crate::metric_collection::top_entities;
 
@@ -521,14 +522,8 @@ async fn get_top_entities(
     Ok(res)
 }
 
-#[derive(Clone)]
-struct CachedSubscriptionState {
-    node_info: HashMap<String, Option<NodeSubscriptionInfo>>,
-    timestamp: i64,
-}
-
-static SUBSCRIPTION_CACHE: LazyLock<RwLock<HashMap<String, CachedSubscriptionState>>> =
-    LazyLock::new(|| RwLock::new(HashMap::new()));
+static SUBSCRIPTION_CACHE: LazyLock<ApiCache<HashMap<String, Option<NodeSubscriptionInfo>>>> =
+    LazyLock::new(ApiCache::new);
 
 /// Get the subscription state for a given remote.
 ///
@@ -538,63 +533,12 @@ async fn get_subscription_info_for_remote(
     remote: &Remote,
     max_age: u64,
 ) -> Result<HashMap<String, Option<NodeSubscriptionInfo>>, Error> {
-    if let Some(cached_subscription) = get_cached_subscription_info(&remote.id, max_age) {
-        Ok(cached_subscription.node_info)
-    } else {
-        let node_info = fetch_remote_subscription_info(remote).await?;
-        let now = proxmox_time::epoch_i64();
-        update_cached_subscription_info(&remote.id, &node_info, now);
-        Ok(node_info)
-    }
-}
-
-fn get_cached_subscription_info(remote: &str, max_age: u64) -> Option<CachedSubscriptionState> {
-    let cache = SUBSCRIPTION_CACHE
-        .read()
-        .expect("subscription mutex poisoned");
-
-    if let Some(cached_subscription) = cache.get(remote) {
-        let now = proxmox_time::epoch_i64();
-        let diff = now - cached_subscription.timestamp;
-
-        if diff > max_age as i64 || diff < 0 {
-            // value is too old or from the future
-            None
-        } else {
-            Some(cached_subscription.clone())
-        }
-    } else {
-        None
-    }
-}
-
-/// Update cached subscription data.
-///
-/// If the cache already contains more recent data we don't insert the passed resources.
-fn update_cached_subscription_info(
-    remote: &str,
-    node_info: &HashMap<String, Option<NodeSubscriptionInfo>>,
-    now: i64,
-) {
-    // there is no good way to recover from this, so panicking should be fine
-    let mut cache = SUBSCRIPTION_CACHE
-        .write()
-        .expect("subscription mutex poisoned");
-
-    if let Some(cached_resource) = cache.get(remote) {
-        // skip updating if the data is new enough
-        if cached_resource.timestamp >= now {
-            return;
-        }
-    }
-
-    cache.insert(
-        remote.into(),
-        CachedSubscriptionState {
-            node_info: node_info.clone(),
-            timestamp: now,
-        },
-    );
+    let (data, _) = SUBSCRIPTION_CACHE
+        .get_value_or_update(&remote.id, max_age as i64, |_| async move {
+            fetch_remote_subscription_info(remote).await
+        })
+        .await?;
+    Ok(data)
 }
 
 /// Maps a list of node subscription infos into a single [`RemoteSubscriptionState`]
@@ -687,14 +631,7 @@ async fn fetch_remote_subscription_info(
     Ok(list)
 }
 
-#[derive(Clone)]
-pub struct CachedResources {
-    pub resources: Vec<Resource>,
-    pub timestamp: i64,
-}
-
-static CACHE: LazyLock<RwLock<HashMap<String, CachedResources>>> =
-    LazyLock::new(|| RwLock::new(HashMap::new()));
+static CACHE: LazyLock<ApiCache<Vec<Resource>>> = LazyLock::new(ApiCache::new);
 
 /// Get resources for a given remote.
 ///
@@ -702,57 +639,18 @@ static CACHE: LazyLock<RwLock<HashMap<String, CachedResources>>> =
 /// instead of calling out to the remote.
 async fn get_resources_for_remote(remote: &Remote, max_age: u64) -> Result<Vec<Resource>, Error> {
     let remote_name = remote.id.to_owned();
-    if let Some(cached_resource) = get_cached_resources(&remote_name, max_age) {
-        Ok(cached_resource.resources)
-    } else {
-        let resources = fetch_remote_resource(remote).await?;
-        let now = proxmox_time::epoch_i64();
-        update_cached_resources(&remote_name, &resources, now);
-        Ok(resources)
-    }
+    let (data, _) = CACHE
+        .get_value_or_update(&remote_name, max_age as i64, |_| async move {
+            fetch_remote_resource(remote).await
+        })
+        .await?;
+    Ok(data)
 }
 
 /// Read cached resource data from the cache
-pub fn get_cached_resources(remote: &str, max_age: u64) -> Option<CachedResources> {
-    // there is no good way to recover from this, so panicking should be fine
-    let cache = CACHE.read().expect("mutex poisoned");
-
-    if let Some(cached_resource) = cache.get(remote) {
-        let now = proxmox_time::epoch_i64();
-        let diff = now - cached_resource.timestamp;
-
-        if diff > max_age as i64 || diff < 0 {
-            // value is too old or from the future
-            None
-        } else {
-            Some(cached_resource.clone())
-        }
-    } else {
-        None
-    }
-}
-
-/// Update cached resource data.
-///
-/// If the cache already contains more recent data we don't insert the passed resources.
-fn update_cached_resources(remote: &str, resources: &[Resource], now: i64) {
-    // there is no good way to recover from this, so panicking should be fine
-    let mut cache = CACHE.write().expect("mutex poisoned");
-
-    if let Some(cached_resource) = cache.get(remote) {
-        // skip updating if existing data is newer
-        if cached_resource.timestamp >= now {
-            return;
-        }
-    }
-
-    cache.insert(
-        remote.into(),
-        CachedResources {
-            timestamp: now,
-            resources: resources.into(),
-        },
-    );
+pub fn get_cached_resources(remote: &str, max_age: u64) -> Option<Vec<Resource>> {
+    let (data, _) = CACHE.get_value(remote, max_age as i64)?;
+    Some(data)
 }
 
 /// Fetch remote resources and map to pdm-native data types.
diff --git a/server/src/api_cache.rs b/server/src/api_cache.rs
new file mode 100644
index 00000000..64b4ec04
--- /dev/null
+++ b/server/src/api_cache.rs
@@ -0,0 +1,128 @@
+use std::{collections::HashMap, future::Future, sync::RwLock};
+
+use anyhow::Error;
+
+pub struct CacheUpdateResult<T> {
+    pub data: T,
+    pub cache: bool,
+    pub cached_timestamp: i64,
+    pub error: Option<Error>,
+}
+
+/// Holds the given data per remote with a timestamp indicating the last update
+pub struct ApiCache<CacheType> {
+    data: RwLock<HashMap<String, (i64, CacheType)>>,
+}
+
+impl<CacheType> ApiCache<CacheType> {
+    /// Creates a new instance of `ApiCache`
+    pub fn new() -> Self {
+        Self {
+            data: RwLock::new(HashMap::new()),
+        }
+    }
+
+    fn update_cache(&self, remote: &str, data: CacheType, now: i64) {
+        // there is no good way to recover from this, so panicking should be fine
+        let mut cache = self.data.write().expect("cache mutex poisoned");
+
+        if let Some((timestamp, _)) = cache.get(remote) {
+            // skip updating if existing data is newer
+            if *timestamp >= now {
+                return;
+            }
+        }
+
+        cache.insert(remote.into(), (now, data));
+    }
+}
+
+impl<CacheType> Default for ApiCache<CacheType> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<CacheType> ApiCache<CacheType>
+where
+    CacheType: Clone,
+{
+    /// Returns the cached value and the cached timestamp for the given remote if it's not older than `max_age`
+    pub fn get_value(&self, remote: &str, max_age: i64) -> Option<(CacheType, i64)> {
+        let cache = self.data.read().expect("cache mutex poisoned");
+        if let Some((timestamp, cached_data)) = cache.get(remote) {
+            let now = proxmox_time::epoch_i64();
+            let diff = now - timestamp;
+            if diff > max_age || diff < 0 {
+                // value is too old or from the future
+                None
+            } else {
+                Some((cached_data.clone(), *timestamp))
+            }
+        } else {
+            None
+        }
+    }
+
+    /// Returns data for the given remote that is not older than `max_age` either
+    /// from the cache or updated via the given `update_func`
+    pub async fn get_value_or_update<S, F, R>(
+        &self,
+        remote: &str,
+        max_age: i64,
+        update_func: F,
+    ) -> Result<(CacheType, i64), Error>
+    where
+        S: Into<CacheType>,
+        F: Fn(&str) -> R,
+        R: Future<Output = Result<S, Error>>,
+    {
+        if let Some(cached_data) = self.get_value(remote, max_age) {
+            Ok(cached_data)
+        } else {
+            let data = update_func(remote).await?;
+            let now = proxmox_time::epoch_i64();
+
+            let data: CacheType = data.into();
+            self.update_cache(remote, data.clone(), now);
+            Ok((data, now))
+        }
+    }
+
+    /// Returns data for the given remote. Tries to update the value (and cache).
+    /// If that's not possible tries to load any cached value.
+    pub async fn update_or_get_cache<S, F, R>(
+        &self,
+        remote: &str,
+        update_func: F,
+    ) -> Result<CacheUpdateResult<CacheType>, Error>
+    where
+        S: Into<CacheType>,
+        F: Fn(&str) -> R,
+        R: Future<Output = Result<S, Error>>,
+    {
+        match update_func(remote).await {
+            Ok(data) => {
+                let data: CacheType = data.into();
+                let now = proxmox_time::epoch_i64();
+
+                self.update_cache(remote, data.clone(), now);
+                Ok(CacheUpdateResult {
+                    data,
+                    cache: false,
+                    cached_timestamp: now,
+                    error: None,
+                })
+            }
+            Err(err) => match self.get_value(remote, i64::MAX) {
+                Some((data, timestamp)) => Ok(CacheUpdateResult {
+                    data,
+                    cache: true,
+                    cached_timestamp: timestamp,
+                    error: Some(err),
+                }),
+                None => Err(err.context("cache was empty and could not update")),
+            },
+        }
+    }
+}
diff --git a/server/src/lib.rs b/server/src/lib.rs
index 964807eb..1f8508c9 100644
--- a/server/src/lib.rs
+++ b/server/src/lib.rs
@@ -2,6 +2,7 @@
 
 pub mod acl;
 pub mod api;
+pub mod api_cache;
 pub mod auth;
 pub mod context;
 pub mod env;
diff --git a/server/src/metric_collection/top_entities.rs b/server/src/metric_collection/top_entities.rs
index ea121eef..715d0eeb 100644
--- a/server/src/metric_collection/top_entities.rs
+++ b/server/src/metric_collection/top_entities.rs
@@ -50,7 +50,7 @@ pub fn calculate_top(
         if let Some(data) =
             crate::api::resources::get_cached_resources(remote_name, i64::MAX as u64)
         {
-            for res in data.resources {
+            for res in data {
                 let id = res.id().to_string();
                 let name = format!("pve/{remote_name}/{id}");
                 match &res {
-- 
2.47.3



_______________________________________________
pdm-devel mailing list
pdm-devel@lists.proxmox.com
https://lists.proxmox.com/cgi-bin/mailman/listinfo/pdm-devel

[pdm-devel] [PATCH datacenter-manager v2 3/3] api/ui: pve: get cluster resources from cache if remote is unreachable

[Dominik Csapak]

so that the last cached data can be shown instead of an error.
This now means that we'll always use the full api call here and filter
on the PDM side to get a fresh version in the cache.

To show a notice in the ui that it was loaded from the cache, we need to
add a marker property in the result, and need to extract that in the
pdm-client so the gui has access to that.

Also fix the CLI client to properly show the data.

Signed-off-by: Dominik Csapak <d.csapak@proxmox.com>
---
changes from v1:
* update cli client too
* use the new ApiCache mechanism for updated values
* use proper api type for conveying the cache result
* use the returned error in the ui if it exists

 cli/client/src/pve.rs             |  4 +-
 lib/pdm-api-types/src/resource.rs | 24 ++++++++++++
 lib/pdm-client/src/lib.rs         |  4 +-
 server/src/api/pve/mod.rs         | 63 +++++++++++++++++++++----------
 server/src/api/resources.rs       | 15 +++++++-
 ui/src/pve/mod.rs                 | 27 ++++++++++---
 6 files changed, 106 insertions(+), 31 deletions(-)

diff --git a/cli/client/src/pve.rs b/cli/client/src/pve.rs
index 1b124036..520119e0 100644
--- a/cli/client/src/pve.rs
+++ b/cli/client/src/pve.rs
@@ -230,14 +230,14 @@ async fn cluster_resources(
 ) -> Result<(), Error> {
     const CLUSTER_LIST_SCHEMA: Schema = ArraySchema::new(
         "cluster resources",
-        &pve_api_types::ClusterResource::API_SCHEMA,
+        &pdm_api_types::resource::PveResource::API_SCHEMA,
     )
     .schema();
 
     let data = client()?.pve_cluster_resources(&remote, kind).await?;
 
     format_and_print_result_full(
-        &mut serde_json::to_value(data)?,
+        &mut serde_json::to_value(data.list)?,
         &ReturnType {
             optional: false,
             schema: &CLUSTER_LIST_SCHEMA,
diff --git a/lib/pdm-api-types/src/resource.rs b/lib/pdm-api-types/src/resource.rs
index b2192505..0118eb05 100644
--- a/lib/pdm-api-types/src/resource.rs
+++ b/lib/pdm-api-types/src/resource.rs
@@ -642,3 +642,27 @@ pub struct TopEntities {
     /// The top entries for Node Memory
     pub node_memory: Vec<TopEntity>,
 }
+
+#[api(
+    properties: {
+        list: {
+            type: Array,
+            items: {
+                type: PveResource,
+            },
+        },
+    },
+)]
+#[derive(Serialize, Deserialize, Clone, PartialEq)]
+#[serde(rename_all = "kebab-case")]
+/// List of [`PveResource`] with additional information about the cache
+pub struct PveResourceList {
+    /// The list of resources
+    pub list: Vec<PveResource>,
+    /// If the data came from the cache or not
+    pub cache: bool,
+    /// The timestamp of updating or the cache (if it was retrieved from there)
+    pub cached_timestamp: i64,
+    /// Any error from updating
+    pub error: Option<String>,
+}
diff --git a/lib/pdm-client/src/lib.rs b/lib/pdm-client/src/lib.rs
index 2f36fab1..ddf41436 100644
--- a/lib/pdm-client/src/lib.rs
+++ b/lib/pdm-client/src/lib.rs
@@ -4,7 +4,7 @@ use std::collections::HashMap;
 use std::time::Duration;
 
 use pdm_api_types::remotes::{RemoteType, TlsProbeOutcome};
-use pdm_api_types::resource::{PveResource, RemoteResources, ResourceType, TopEntities};
+use pdm_api_types::resource::{PveResourceList, RemoteResources, ResourceType, TopEntities};
 use pdm_api_types::rrddata::{
     LxcDataPoint, NodeDataPoint, PbsDatastoreDataPoint, PbsNodeDataPoint, PveStorageDataPoint,
     QemuDataPoint,
@@ -408,7 +408,7 @@ impl<T: HttpApiClient> PdmClient<T> {
         &self,
         remote: &str,
         kind: Option<pve_api_types::ClusterResourceKind>,
-    ) -> Result<Vec<PveResource>, Error> {
+    ) -> Result<PveResourceList, Error> {
         let query = ApiPathBuilder::new(format!("/api2/extjs/pve/remotes/{remote}/resources"))
             .maybe_arg("kind", &kind)
             .build();
diff --git a/server/src/api/pve/mod.rs b/server/src/api/pve/mod.rs
index 0de82323..4051100a 100644
--- a/server/src/api/pve/mod.rs
+++ b/server/src/api/pve/mod.rs
@@ -16,19 +16,19 @@ use proxmox_sortable_macro::sortable;
 use pdm_api_types::remotes::{
     NodeUrl, Remote, RemoteListEntry, RemoteType, TlsProbeOutcome, REMOTE_ID_SCHEMA,
 };
-use pdm_api_types::resource::PveResource;
+use pdm_api_types::resource::{PveResource, PveResourceList, Resource};
 use pdm_api_types::{
     Authid, RemoteUpid, HOST_OPTIONAL_PORT_FORMAT, PRIV_RESOURCE_AUDIT, PRIV_RESOURCE_DELETE,
     PRIV_SYS_MODIFY,
 };
 
 use pve_api_types::ClusterNodeStatus;
+use pve_api_types::ClusterResourceKind;
 use pve_api_types::ListRealm;
 use pve_api_types::PveUpid;
-use pve_api_types::{ClusterResourceKind, ClusterResourceType};
-
-use super::resources::{map_pve_lxc, map_pve_node, map_pve_qemu, map_pve_storage};
 
+use crate::api::resources::get_updated_resources_or_cache;
+use crate::api_cache::CacheUpdateResult;
 use crate::connection::PveClient;
 use crate::connection::{self, probe_tls_connection};
 use crate::remote_tasks;
@@ -175,9 +175,7 @@ pub async fn list_nodes(
         },
     },
     returns: {
-        type: Array,
-        description: "List all the resources in a PVE cluster.",
-        items: { type: PveResource },
+        type: PveResourceList,
     },
     access: {
         permission: &Permission::Privilege(&["resource", "{remote}"], PRIV_RESOURCE_AUDIT, false),
@@ -191,7 +189,7 @@ pub async fn cluster_resources(
     remote: String,
     kind: Option<ClusterResourceKind>,
     rpcenv: &mut dyn RpcEnvironment,
-) -> Result<Vec<PveResource>, Error> {
+) -> Result<PveResourceList, Error> {
     let (remotes, _) = pdm_config::remotes::config()?;
     let user_info = CachedUserInfo::new()?;
     let auth_id: Authid = rpcenv
@@ -202,13 +200,37 @@ pub async fn cluster_resources(
         http_bail!(UNAUTHORIZED, "user has no access to resource list");
     }
 
-    let cluster_resources = connect_to_remote(&remotes, &remote)?
-        .cluster_resources(kind)
-        .await?
+    let remote = get_remote(&remotes, &remote)?;
+
+    let CacheUpdateResult {
+        data,
+        cache,
+        cached_timestamp,
+        error,
+    } = get_updated_resources_or_cache(remote).await?;
+
+    let cluster_resources = data
         .into_iter()
-        .filter_map(|r| map_pve_resource(&remote, r));
+        .filter(|res| match kind {
+            Some(kind) => matches!(
+                (kind, res),
+                (ClusterResourceKind::Vm, Resource::PveQemu(_))
+                    | (ClusterResourceKind::Vm, Resource::PveLxc(_))
+                    | (ClusterResourceKind::Storage, Resource::PveStorage(_))
+                    | (ClusterResourceKind::Node, Resource::PveNode(_))
+                    | (ClusterResourceKind::Sdn, Resource::PveSdn(_))
+            ),
+            None => true,
+        })
+        .filter_map(map_pve_resource)
+        .collect();
 
-    Ok(cluster_resources.collect())
+    Ok(PveResourceList {
+        list: cluster_resources,
+        cache,
+        cached_timestamp,
+        error: error.map(|err| err.to_string()),
+    })
 }
 
 #[api(
@@ -245,13 +267,14 @@ pub async fn cluster_status(
     Ok(status)
 }
 
-fn map_pve_resource(remote: &str, resource: pve_api_types::ClusterResource) -> Option<PveResource> {
-    match resource.ty {
-        ClusterResourceType::Node => map_pve_node(remote, resource).map(PveResource::Node),
-        ClusterResourceType::Lxc => map_pve_lxc(remote, resource).map(PveResource::Lxc),
-        ClusterResourceType::Qemu => map_pve_qemu(remote, resource).map(PveResource::Qemu),
-        ClusterResourceType::Storage => map_pve_storage(remote, resource).map(PveResource::Storage),
-        _ => None,
+fn map_pve_resource(resource: Resource) -> Option<PveResource> {
+    match resource {
+        Resource::PveStorage(storage) => Some(PveResource::Storage(storage)),
+        Resource::PveQemu(qemu) => Some(PveResource::Qemu(qemu)),
+        Resource::PveLxc(lxc) => Some(PveResource::Lxc(lxc)),
+        Resource::PveNode(node) => Some(PveResource::Node(node)),
+        Resource::PveSdn(sdn) => Some(PveResource::Sdn(sdn)),
+        Resource::PbsNode(_) | Resource::PbsDatastore(_) => None,
     }
 }
 
diff --git a/server/src/api/resources.rs b/server/src/api/resources.rs
index 0df9c781..f81dfedc 100644
--- a/server/src/api/resources.rs
+++ b/server/src/api/resources.rs
@@ -28,7 +28,7 @@ use proxmox_sortable_macro::sortable;
 use proxmox_subscription::SubscriptionStatus;
 use pve_api_types::{ClusterResource, ClusterResourceType};
 
-use crate::api_cache::ApiCache;
+use crate::api_cache::{ApiCache, CacheUpdateResult};
 use crate::connection;
 use crate::metric_collection::top_entities;
 
@@ -647,6 +647,19 @@ async fn get_resources_for_remote(remote: &Remote, max_age: u64) -> Result<Vec<R
     Ok(data)
 }
 
+/// Tries to update the resources and returns data from the cache if it was not
+/// possible to reach the remote.
+pub async fn get_updated_resources_or_cache(
+    remote: &Remote,
+) -> Result<CacheUpdateResult<Vec<Resource>>, Error> {
+    let remote_name = &remote.id;
+    CACHE
+        .update_or_get_cache(remote_name, |_| async move {
+            fetch_remote_resource(remote).await
+        })
+        .await
+}
+
 /// Read cached resource data from the cache
 pub fn get_cached_resources(remote: &str, max_age: u64) -> Option<Vec<Resource>> {
     let (data, _) = CACHE.get_value(remote, max_age as i64)?;
diff --git a/ui/src/pve/mod.rs b/ui/src/pve/mod.rs
index 058424a9..8ea85da7 100644
--- a/ui/src/pve/mod.rs
+++ b/ui/src/pve/mod.rs
@@ -11,7 +11,7 @@ use yew::{
 use pwt::{
     css::AlignItems,
     state::NavigationContainer,
-    widget::{Button, Container, Fa},
+    widget::{error_message, Button, Container, Fa},
 };
 use pwt::{
     css::FlexFit,
@@ -20,7 +20,7 @@ use pwt::{
     widget::{Column, Panel, Row},
 };
 
-use pdm_api_types::resource::{PveResource, ResourceType};
+use pdm_api_types::resource::{PveResource, PveResourceList, ResourceType};
 
 pub mod lxc;
 pub mod node;
@@ -122,13 +122,15 @@ impl GuestInfo {
 
 pub enum Msg {
     SelectedView(tree::PveTreeNode),
-    ResourcesList(Result<Vec<PveResource>, Error>),
+    ResourcesList(Result<PveResourceList, Error>),
 }
 
 pub struct PveRemoteComp {
     view: tree::PveTreeNode,
     resources: Rc<Vec<PveResource>>,
     last_error: Option<String>,
+    from_cache: bool,
+    update_error: Option<String>,
 }
 
 impl LoadableComponent for PveRemoteComp {
@@ -142,6 +144,8 @@ impl LoadableComponent for PveRemoteComp {
             view: PveTreeNode::Root,
             resources: Rc::new(Vec::new()),
             last_error: None,
+            from_cache: false,
+            update_error: None,
         }
     }
 
@@ -151,9 +155,11 @@ impl LoadableComponent for PveRemoteComp {
                 self.view = node;
             }
             Msg::ResourcesList(res) => match res {
-                Ok(res) => {
+                Ok(resource_list) => {
                     self.last_error = None;
-                    self.resources = Rc::new(res);
+                    self.from_cache = resource_list.cache;
+                    self.resources = Rc::new(resource_list.list);
+                    self.update_error = resource_list.error;
                 }
                 Err(err) => {
                     self.last_error = Some(err.to_string());
@@ -245,7 +251,16 @@ impl LoadableComponent for PveRemoteComp {
                                     let link = link.clone();
                                     move |_| link.send_reload()
                                 },
-                            )),
+                            ))
+                            .with_optional_child(self.from_cache.then_some({
+                                let mut error_text =
+                                    tr!("Could not reach remote, data shown from cache.");
+                                if let Some(err) = self.update_error.as_ref() {
+                                    error_text.push(' ');
+                                    error_text.push_str(&tr!("Got error: {0}", err));
+                                }
+                                error_message(&error_text)
+                            })),
                     ),
             )
             .with_child(
-- 
2.47.3



_______________________________________________
pdm-devel mailing list
pdm-devel@lists.proxmox.com
https://lists.proxmox.com/cgi-bin/mailman/listinfo/pdm-devel