From: Dominik Csapak <d.csapak@proxmox.com>
To: pdm-devel@lists.proxmox.com
Subject: [PATCH datacenter-manager 6/8] ui: pve: tree: reuse `PveResource` for `PveTreeNode`
Date: Fri, 14 Aug 2026 15:44:02 +0200 [thread overview]
Message-ID: <20260814134548.3446943-7-d.csapak@proxmox.com> (raw)
In-Reply-To: <20260814134548.3446943-1-d.csapak@proxmox.com>
This has some advantages: We can't forget types that are represented in
the backend (as we already did with Network for example). And with the
new `ResourceView` type, we can reuse methods that were made for
`Resource`. The inner types are the same anyway, so this does not change
what data we can show.
While changing the PveTreeNode, refactor some code that can profit from
the newly abstracted ResourceView to make it more consistent with other
parts of PDM (like the ResrouceTree) and to save some lines.
Signed-off-by: Dominik Csapak <d.csapak@proxmox.com>
---
ui/src/pve/mod.rs | 40 ++++---
ui/src/pve/tree.rs | 292 +++++++++++++++++++++------------------------
2 files changed, 157 insertions(+), 175 deletions(-)
diff --git a/ui/src/pve/mod.rs b/ui/src/pve/mod.rs
index 1c32d26f..ae06179b 100644
--- a/ui/src/pve/mod.rs
+++ b/ui/src/pve/mod.rs
@@ -214,23 +214,31 @@ impl LoadableComponent for PveRemoteComp {
let content: Html = match &self.view {
PveTreeNode::Root => remote::PveRemotePanel::new(remote.clone()).into(),
- PveTreeNode::Node(node) => node::PveNodePanel::new(remote.clone(), node.node.clone())
- .pve_manager_version(self.get_pve_manager_version(&node.node))
+ PveTreeNode::Resource(r) => match r {
+ PveResource::Node(node) => {
+ node::PveNodePanel::new(remote.clone(), node.node.clone())
+ .pve_manager_version(self.get_pve_manager_version(&node.node))
+ .into()
+ }
+ PveResource::Qemu(qemu) => {
+ qemu::QemuPanel::new(remote.clone(), qemu.node.clone(), qemu.clone())
+ .pve_manager_version(self.get_pve_manager_version(&qemu.node))
+ .into()
+ }
+ PveResource::Lxc(lxc) => {
+ lxc::LxcPanel::new(remote.clone(), lxc.node.clone(), lxc.clone())
+ .pve_manager_version(self.get_pve_manager_version(&lxc.node))
+ .into()
+ }
+ PveResource::Storage(storage) => storage::StoragePanel::new(
+ remote.clone(),
+ storage.node.clone(),
+ storage.clone(),
+ )
.into(),
- PveTreeNode::Qemu(qemu) => {
- qemu::QemuPanel::new(remote.clone(), qemu.node.clone(), qemu.clone())
- .pve_manager_version(self.get_pve_manager_version(&qemu.node))
- .into()
- }
- PveTreeNode::Lxc(lxc) => {
- lxc::LxcPanel::new(remote.clone(), lxc.node.clone(), lxc.clone())
- .pve_manager_version(self.get_pve_manager_version(&lxc.node))
- .into()
- }
- PveTreeNode::Storage(storage) => {
- storage::StoragePanel::new(remote.clone(), storage.node.clone(), storage.clone())
- .into()
- }
+ // don't show anything for network for now
+ PveResource::Network(_) => Container::new().into(),
+ },
};
let content = NavigationContainer::new().with_child(content);
diff --git a/ui/src/pve/tree.rs b/ui/src/pve/tree.rs
index 0042331c..f68c728e 100644
--- a/ui/src/pve/tree.rs
+++ b/ui/src/pve/tree.rs
@@ -24,33 +24,31 @@ use pwt::{prelude::*, widget::Button};
use pdm_api_types::{
RemoteUpid,
- resource::{PveLxcResource, PveNodeResource, PveQemuResource, PveResource, PveStorageResource},
+ resource::{AsResourceView, PveNodeResource, PveResource},
};
-use crate::{get_deep_url, renderer::render_tree_column, widget::MigrateWindow};
+use crate::{
+ get_deep_url,
+ renderer::{render_resource_name, render_status_icon, render_tree_column},
+ widget::MigrateWindow,
+};
use super::{
GuestInfo, GuestType,
- utils::{self, render_guest_tags, render_lxc_name, render_qemu_name},
+ utils::{self, render_guest_tags},
};
#[derive(Clone, PartialEq)]
pub enum PveTreeNode {
Root,
- Node(PveNodeResource),
- Lxc(PveLxcResource),
- Qemu(PveQemuResource),
- Storage(PveStorageResource),
+ Resource(PveResource),
}
impl ExtractPrimaryKey for PveTreeNode {
fn extract_key(&self) -> Key {
Key::from(match self {
PveTreeNode::Root => "__root__",
- PveTreeNode::Node(node) => node.id.as_str(),
- PveTreeNode::Lxc(lxc) => lxc.id.as_str(),
- PveTreeNode::Qemu(qemu) => qemu.id.as_str(),
- PveTreeNode::Storage(storage) => storage.id.as_str(),
+ PveTreeNode::Resource(resource) => resource.as_resource_view().global_id(),
})
}
}
@@ -59,12 +57,15 @@ impl PveTreeNode {
fn get_path(&self) -> String {
match self {
PveTreeNode::Root => "datacenter".to_string(),
- PveTreeNode::Node(node) => format!("node+{}", node.node),
- PveTreeNode::Lxc(lxc) => format!("guest+{}", lxc.vmid),
- PveTreeNode::Qemu(qemu) => format!("guest+{}", qemu.vmid),
- PveTreeNode::Storage(storage) => {
- format!("storage+{}+{}", storage.node, storage.storage)
- }
+ PveTreeNode::Resource(resource) => match resource {
+ PveResource::Node(node) => format!("node+{}", node.node),
+ PveResource::Lxc(lxc) => format!("guest+{}", lxc.vmid),
+ PveResource::Qemu(qemu) => format!("guest+{}", qemu.vmid),
+ PveResource::Storage(storage) => {
+ format!("storage+{}+{}", storage.node, storage.storage)
+ }
+ PveResource::Network(network) => format!("network+{}", network.id()),
+ },
}
}
}
@@ -163,39 +164,16 @@ impl PveTreeComp {
let key = Key::from(node_info.id.as_str());
if let Some(mut node) = root.find_node_by_key_mut(&key) {
- *node.record_mut() = PveTreeNode::Node(node_info.clone());
+ *node.record_mut() = PveTreeNode::Resource(entry.clone());
} else {
- root.append(PveTreeNode::Node(node_info.clone()));
- }
- }
- PveResource::Qemu(qemu_info) => {
- let node_id = format!("remote/{}/node/{}", remote, qemu_info.node);
- let key = Key::from(node_id.as_str());
- let mut node = match root.find_node_by_key_mut(&key) {
- Some(node) => node,
- None => root.append(create_empty_node(node_id)),
- };
-
- if !self.loaded {
- node.set_expanded(true);
+ root.append(PveTreeNode::Resource(entry.clone()));
}
- node.append(PveTreeNode::Qemu(qemu_info.clone()));
}
- PveResource::Lxc(lxc_info) => {
- let node_id = format!("remote/{}/node/{}", remote, lxc_info.node);
- let key = Key::from(node_id.as_str());
- let mut node = match root.find_node_by_key_mut(&key) {
- Some(node) => node,
- None => root.append(create_empty_node(node_id)),
- };
+ PveResource::Qemu(_) | PveResource::Lxc(_) | PveResource::Storage(_) => {
+ // PVE resources always have a node
+ let node = entry.as_resource_view().node().unwrap();
+ let node_id = format!("remote/{remote}/node/{node}");
- if !self.loaded {
- node.set_expanded(true);
- }
- node.append(PveTreeNode::Lxc(lxc_info.clone()));
- }
- PveResource::Storage(storage) => {
- let node_id = format!("remote/{}/node/{}", remote, storage.node);
let key = Key::from(node_id.as_str());
let mut node = match root.find_node_by_key_mut(&key) {
Some(node) => node,
@@ -205,7 +183,7 @@ impl PveTreeComp {
if !self.loaded {
node.set_expanded(true);
}
- node.append(PveTreeNode::Storage(storage.clone()));
+ node.append(PveTreeNode::Resource(entry.clone()));
}
PveResource::Network(_) => {}
}
@@ -227,24 +205,28 @@ impl PveTreeComp {
(PveTreeNode::Root, PveTreeNode::Root) => std::cmp::Ordering::Equal,
(PveTreeNode::Root, _) => std::cmp::Ordering::Less,
(_, PveTreeNode::Root) => std::cmp::Ordering::Greater,
- (PveTreeNode::Node(a), PveTreeNode::Node(b)) => a.node.cmp(&b.node),
- (PveTreeNode::Node(_), _) => std::cmp::Ordering::Less,
- (_, PveTreeNode::Node(_)) => std::cmp::Ordering::Greater,
- (PveTreeNode::Lxc(a), PveTreeNode::Lxc(b)) => {
- cmp_guests(a.template, b.template, a.vmid, b.vmid)
- }
- (PveTreeNode::Lxc(_), PveTreeNode::Qemu(_)) => std::cmp::Ordering::Less,
- (PveTreeNode::Qemu(_), PveTreeNode::Lxc(_)) => std::cmp::Ordering::Greater,
- (PveTreeNode::Qemu(a), PveTreeNode::Qemu(b)) => {
- cmp_guests(a.template, b.template, a.vmid, b.vmid)
- }
- (PveTreeNode::Lxc(_) | PveTreeNode::Qemu(_), PveTreeNode::Storage(_)) => {
- std::cmp::Ordering::Less
- }
- (PveTreeNode::Storage(_), PveTreeNode::Lxc(_) | PveTreeNode::Qemu(_)) => {
- std::cmp::Ordering::Greater
- }
- (PveTreeNode::Storage(a), PveTreeNode::Storage(b)) => a.id.cmp(&b.id),
+ (PveTreeNode::Resource(a), PveTreeNode::Resource(b)) => match (a, b) {
+ (PveResource::Node(a), PveResource::Node(b)) => a.node.cmp(&b.node),
+ (PveResource::Node(_), _) => std::cmp::Ordering::Less,
+ (_, PveResource::Node(_)) => std::cmp::Ordering::Greater,
+ (PveResource::Lxc(a), PveResource::Lxc(b)) => {
+ cmp_guests(a.template, b.template, a.vmid, b.vmid)
+ }
+ (PveResource::Lxc(_), PveResource::Qemu(_)) => std::cmp::Ordering::Less,
+ (PveResource::Qemu(_), PveResource::Lxc(_)) => std::cmp::Ordering::Greater,
+ (PveResource::Qemu(a), PveResource::Qemu(b)) => {
+ cmp_guests(a.template, b.template, a.vmid, b.vmid)
+ }
+ (PveResource::Lxc(_) | PveResource::Qemu(_), PveResource::Storage(_)) => {
+ std::cmp::Ordering::Less
+ }
+ (PveResource::Storage(_), PveResource::Lxc(_) | PveResource::Qemu(_)) => {
+ std::cmp::Ordering::Greater
+ }
+ (PveResource::Storage(a), PveResource::Storage(b)) => a.id.cmp(&b.id),
+ (PveResource::Network(_), _) => std::cmp::Ordering::Greater,
+ (_, PveResource::Network(_)) => std::cmp::Ordering::Less,
+ },
});
let first_id = root
.children()
@@ -344,54 +326,49 @@ impl LoadableComponent for PveTreeComp {
let record = node.record().clone();
let link = ctx.link().clone();
- match record {
- PveTreeNode::Lxc(r) => ctx.link().spawn(async move {
- let res = match action {
- Action::Start => {
- crate::pdm_client()
- .pve_lxc_start(&remote, Some(&r.node), r.vmid)
- .await
- }
- Action::Shutdown => {
- crate::pdm_client()
- .pve_lxc_shutdown(&remote, Some(&r.node), r.vmid)
- .await
- }
- // LXC resume is not exposed yet; the UI never offers it.
- Action::Resume => return,
- };
+ let PveTreeNode::Resource(resource) = record else {
+ return false;
+ };
+ let resource = resource.as_resource_view();
- match res {
- Ok(upid) => link.show_task_progress(upid.to_string()),
- Err(err) => link.show_error(tr!("Error"), err.to_string(), true),
- }
- }),
- PveTreeNode::Qemu(r) => ctx.link().spawn(async move {
- let res = match action {
- Action::Start => {
- crate::pdm_client()
- .pve_qemu_start(&remote, Some(&r.node), r.vmid)
- .await
- }
- Action::Shutdown => {
- crate::pdm_client()
- .pve_qemu_shutdown(&remote, Some(&r.node), r.vmid)
- .await
- }
- Action::Resume => {
- crate::pdm_client()
- .pve_qemu_resume(&remote, Some(&r.node), r.vmid)
- .await
- }
- };
+ let Some(guest_node) = resource.node().map(|n| n.to_string()) else {
+ return false;
+ };
+ let Some(vmid) = resource.vmid() else {
+ return false;
+ };
+ let Some(guest_type) = resource.guest_type() else {
+ return false;
+ };
- match res {
- Ok(upid) => link.show_task_progress(upid.to_string()),
- Err(err) => link.show_error(tr!("Error"), err.to_string(), true),
+ ctx.link().spawn(async move {
+ let client = crate::pdm_client();
+ let node = Some(guest_node.as_str());
+ let res = match (guest_type.into(), action) {
+ (GuestType::Qemu, Action::Start) => {
+ client.pve_qemu_start(&remote, node, vmid).await
}
- }),
- _ => {}
- }
+ (GuestType::Qemu, Action::Shutdown) => {
+ client.pve_qemu_shutdown(&remote, node, vmid).await
+ }
+ (GuestType::Qemu, Action::Resume) => {
+ client.pve_qemu_resume(&remote, node, vmid).await
+ }
+ (GuestType::Lxc, Action::Start) => {
+ client.pve_lxc_start(&remote, node, vmid).await
+ }
+ (GuestType::Lxc, Action::Shutdown) => {
+ client.pve_lxc_shutdown(&remote, node, vmid).await
+ }
+ // LXC resume is not exposed yet, the UI never offers it.
+ (GuestType::Lxc, Action::Resume) => return,
+ };
+
+ match res {
+ Ok(upid) => link.show_task_progress(upid.to_string()),
+ Err(err) => link.show_error(tr!("Error"), err.to_string(), true),
+ }
+ });
}
Msg::KeySelected(key) => {
let key = key.unwrap_or_else(|| Key::from("__root__"));
@@ -430,26 +407,28 @@ impl LoadableComponent for PveTreeComp {
} else {
let text = self.filter.to_lowercase();
self.store.set_filter(move |node: &PveTreeNode| match node {
- PveTreeNode::Lxc(r) => {
+ PveTreeNode::Resource(PveResource::Lxc(r)) => {
r.vmid.to_string().to_lowercase().contains(&text)
|| r.name.to_lowercase().contains(&text)
|| "lxc".contains(&text)
|| r.tags.iter().any(|tag| tag.contains(&text))
}
- PveTreeNode::Qemu(r) => {
+ PveTreeNode::Resource(PveResource::Qemu(r)) => {
r.vmid.to_string().to_lowercase().contains(&text)
|| r.name.to_lowercase().contains(&text)
|| "qemu".contains(&text)
|| r.tags.iter().any(|tag| tag.contains(&text))
}
- PveTreeNode::Storage(r) => {
+ PveTreeNode::Resource(PveResource::Storage(r)) => {
r.storage.to_string().to_lowercase().contains(&text)
|| "storage".contains(&text)
}
// always show tree root node to ensure tree does not look odd.
// For now also always show all nodes (should we filter those without any
// matches for the node or for it's sub elements?
- PveTreeNode::Root | PveTreeNode::Node(_) => true,
+ PveTreeNode::Root | PveTreeNode::Resource(PveResource::Node(_)) => true,
+ // hide the networks for now
+ PveTreeNode::Resource(PveResource::Network(_)) => false,
});
}
}
@@ -582,7 +561,7 @@ impl LoadableComponent for PveTreeComp {
}
fn create_empty_node(node_id: String) -> PveTreeNode {
- PveTreeNode::Node(PveNodeResource {
+ PveTreeNode::Resource(PveResource::Node(PveNodeResource {
cgroup_mode: Default::default(),
cpu: Default::default(),
maxcpu: Default::default(),
@@ -593,7 +572,7 @@ fn create_empty_node(node_id: String) -> PveTreeNode {
uptime: Default::default(),
status: Default::default(),
level: Default::default(),
- })
+ }))
}
fn columns(
@@ -620,15 +599,8 @@ fn columns(
Container::new().with_child(Fa::new("server")),
tr!("Datacenter"),
),
- PveTreeNode::Node(r) => (utils::render_node_status_icon(r), r.node.to_string()),
- PveTreeNode::Qemu(r) => {
- (utils::render_qemu_status_icon(r), render_qemu_name(r, true))
- }
- PveTreeNode::Lxc(r) => {
- (utils::render_lxc_status_icon(r), render_lxc_name(r, true))
- }
- PveTreeNode::Storage(r) => {
- (utils::render_storage_status_icon(r), r.storage.clone())
+ PveTreeNode::Resource(r) => {
+ (render_status_icon(r), render_resource_name(r, true))
}
};
@@ -638,8 +610,12 @@ fn columns(
DataTableColumn::new(tr!("Tags"))
.flex(1)
.render(move |entry: &PveTreeNode| match entry {
- PveTreeNode::Lxc(lxc) => render_guest_tags(&lxc.tags[..]).into(),
- PveTreeNode::Qemu(qemu) => render_guest_tags(&qemu.tags[..]).into(),
+ PveTreeNode::Resource(PveResource::Lxc(lxc)) => {
+ render_guest_tags(&lxc.tags[..]).into()
+ }
+ PveTreeNode::Resource(PveResource::Qemu(qemu)) => {
+ render_guest_tags(&qemu.tags[..]).into()
+ }
_ => html! {},
})
.into(),
@@ -647,39 +623,37 @@ fn columns(
.width("180px")
.render(move |entry: &PveTreeNode| {
let (id, local_id, guest_info, node) = match entry {
- PveTreeNode::Lxc(r) => {
- let guest_info = GuestInfo::new(GuestType::Lxc, r.vmid);
- let local_id = guest_info.local_id();
- (
- r.id.as_str(),
- local_id,
- Some((guest_info, r.status.as_str(), r.template)),
- Some(r.node.clone()),
- )
- }
- PveTreeNode::Qemu(r) => {
- let guest_info = GuestInfo::new(GuestType::Qemu, r.vmid);
- let local_id = guest_info.local_id();
- (
- r.id.as_str(),
- local_id,
- Some((guest_info, r.status.as_str(), r.template)),
- Some(r.node.clone()),
- )
- }
PveTreeNode::Root => ("root", "root".to_string(), None, None),
- PveTreeNode::Node(r) => (
- r.id.as_str(),
- format!("node/{}", r.node),
- None,
- Some(r.node.clone()),
- ),
- PveTreeNode::Storage(r) => (
- r.id.as_str(),
- format!("storage/{}/{}", r.node, r.storage),
- None,
- Some(r.node.clone()),
- ),
+ PveTreeNode::Resource(r) => match r {
+ PveResource::Lxc(r) => {
+ let guest_info = GuestInfo::new(GuestType::Lxc, r.vmid);
+ let local_id = guest_info.local_id();
+ (
+ r.id.as_str(),
+ local_id,
+ Some((guest_info, r.status.as_str(), r.template)),
+ Some(r.node.clone()),
+ )
+ }
+ PveResource::Qemu(r) => {
+ let guest_info = GuestInfo::new(GuestType::Qemu, r.vmid);
+ let local_id = guest_info.local_id();
+ (
+ r.id.as_str(),
+ local_id,
+ Some((guest_info, r.status.as_str(), r.template)),
+ Some(r.node.clone()),
+ )
+ }
+ PveResource::Node(_)
+ | PveResource::Storage(_)
+ | PveResource::Network(_) => (
+ r.as_resource_view().global_id(),
+ r.as_resource_view().id(),
+ None,
+ r.as_resource_view().node().map(|n| n.to_string()),
+ ),
+ },
};
Row::new()
--
2.47.3
next prev parent reply other threads:[~2026-08-14 13:46 UTC|newest]
Thread overview: 9+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-08-14 13:43 [PATCH datacenter-manager 0/8] refactor and partially fix #7371 Dominik Csapak
2026-08-14 13:43 ` [PATCH datacenter-manager 1/8] lib: add new ResourceView type and move accessors there Dominik Csapak
2026-08-14 13:43 ` [PATCH datacenter-manager 2/8] lib: api types: resource: add 'node' helper to ResourceView Dominik Csapak
2026-08-14 13:43 ` [PATCH datacenter-manager 3/8] lib: api-types: add 'vmid' getter " Dominik Csapak
2026-08-14 13:44 ` [PATCH datacenter-manager 4/8] ui: pve: factor out the pve-manager version extraction Dominik Csapak
2026-08-14 13:44 ` [PATCH datacenter-manager 5/8] ui: renderer: use ResourceView for rendering Dominik Csapak
2026-08-14 13:44 ` Dominik Csapak [this message]
2026-08-14 13:44 ` [PATCH datacenter-manager 7/8] ui: pve: show ha maintenance mode for nodes Dominik Csapak
2026-08-14 13:44 ` [PATCH datacenter-manager 8/8] ui: pve: node selector: show maintenance badge with node name Dominik Csapak
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20260814134548.3446943-7-d.csapak@proxmox.com \
--to=d.csapak@proxmox.com \
--cc=pdm-devel@lists.proxmox.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.