virtui-manager 1.1.5__py3-none-any.whl → 1.3.0__py3-none-any.whl

vmanager/dialog.css

@@ -11,6 +11,7 @@ SelectOneServerModal,
 ConfirmationDialog,
 ChangeNetworkDialog,
 XMLDisplayModal,
+CapabilitiesTreeModal,
 SelectDiskModal,
 AddDiskModal,
 EditDiskModal,
@@ -227,6 +228,7 @@ AddDiskModal,
 EditDiskModal,
 WebConsoleDialog,
 XMLDisplayModal,
+CapabilitiesTreeModal,
 MigrationModal,
 MoveVolumeModal,
 SelectDiskModal > #dialog,
@@ -586,3 +588,25 @@ Button:hover {
 Button.-active {
     background: $primary-darken-2;
 }
+
+/* === Capabilities Tree Modal === */
+CapabilitiesTreeModal > #capabilities-dialog {
+  width: 90%;
+  height: 90%;
+  border: round $primary;
+  background: $surface;
+  padding: 1;
+}
+
+CapabilitiesTreeModal #xml-tree {
+  height: 80%;
+  border: round $primary;
+  margin-bottom: 1;
+}
+
+CapabilitiesTreeModal #dialog-title {
+  width: 100%;
+  content-align: center middle;
+  margin-bottom: 1;
+  text-style: bold;
+}

vmanager/firmware_manager.py

@@ -6,6 +6,7 @@ import json
 import libvirt
 import xml.etree.ElementTree as ET
 from .utils import log_function_call
+from .libvirt_utils import get_host_domain_capabilities
 
 FIRMWARE_META_BASE_DIR = "/usr/share/qemu/firmware/"
 
@@ -92,7 +93,9 @@ def get_host_sev_capabilities(conn):
     if conn is None:
         return sev_caps
     try:
-        caps_xml = conn.getCapabilities()
+        caps_xml = get_host_domain_capabilities(conn)
+        if not caps_xml:
+            return sev_caps
         root = ET.fromstring(caps_xml)
         sev_elem = root.find('.//host/cpu/sev')
         if sev_elem is not None:

vmanager/i18n.py

@@ -0,0 +1,32 @@
+import gettext
+import os
+import locale
+import logging
+
+# Setup path to locales
+# This assumes the 'locales' directory is next to this file
+LOCALE_DIR = os.path.join(os.path.dirname(__file__), 'locales')
+DOMAIN = 'virtui-manager'
+
+_ = lambda s: s
+
+def setup_i18n():
+    global _
+    try:
+        lang, _ = locale.getdefaultlocale()
+    except Exception:
+        lang = 'en'
+        
+    if not lang:
+        lang = 'en'
+
+    try:
+        t = gettext.translation(DOMAIN, LOCALE_DIR, fallback=True)
+        _ = t.gettext
+        logging.debug(f"i18n initialized for domain '{DOMAIN}' with locale dir '{LOCALE_DIR}'")
+    except Exception as e:
+        logging.warning(f"Failed to initialize i18n: {e}")
+        _ = lambda s: s
+
+import sys
+setup_i18n()

vmanager/libvirt_utils.py

@@ -130,13 +130,126 @@ def get_cpu_models(conn: libvirt.virConnect, arch: str):
         print(f"Error getting CPU models for arch {arch}: {e}")
         return []
 
+def get_host_resources(conn: libvirt.virConnect) -> dict:
+    """
+    Retrieves host resource information (CPU, Memory).
+    """
+    try:
+        node_info = conn.getInfo()
+        # node_info: [model, memory (KB), cpus, mhz, nodes, sockets, cores, threads]
+        mem_stats = conn.getMemoryStats(libvirt.VIR_NODE_MEMORY_STATS_ALL_CELLS)
+        # mem_stats might have: total, free, buffers, cached
+        host_info = {
+            'model': node_info[0],
+            'total_memory': node_info[1] // 1024, # MB
+            'total_cpus': node_info[2],
+            'mhz': node_info[3],
+            'nodes': node_info[4],
+            'sockets': node_info[5],
+            'cores': node_info[6],
+            'threads': node_info[7],
+            'free_memory': mem_stats.get('free', 0) // 1024, # MB
+            'available_memory': mem_stats.get('total', 0) // 1024, # MB
+        }
+
+        if host_info['available_memory'] == 0:
+            host_info['available_memory'] = host_info['total_memory']
+
+        return host_info
+    except libvirt.libvirtError as e:
+        logging.error(f"Error getting host resources: {e}")
+        return {}
+
+def get_total_vm_allocation(conn: libvirt.virConnect, progress_callback=None) -> dict:
+    """
+    Calculates total resource allocation across all running or paused VMs on a host.
+    """
+    total_memory = 0
+    total_vcpus = 0
+    active_memory = 0
+    active_vcpus = 0
+
+    try:
+        domains = conn.listAllDomains(0)
+        total_vms = len(domains)
+
+        for i, domain in enumerate(domains):
+            if progress_callback:
+                progress_callback(i + 1, total_vms)
+
+            try:
+                # domain.info() returns [state, maxMem, memory, nrVirtCpu, cpuTime]
+                # memory is in Kilobytes
+                info = domain.info()
+                state = info[0]
+                max_mem = info[1]  # KB
+                n_cpus = info[3]
+
+                total_memory += max_mem
+                total_vcpus += n_cpus
+
+                if state in [libvirt.VIR_DOMAIN_RUNNING, libvirt.VIR_DOMAIN_PAUSED]:
+                    active_memory += max_mem
+                    active_vcpus += n_cpus
+
+            except libvirt.libvirtError:
+                continue
+
+        return {
+            'total_allocated_memory': total_memory // 1024,  # Convert to MB
+            'total_allocated_vcpus': total_vcpus,
+            'active_allocated_memory': active_memory // 1024,  # Convert to MB
+            'active_allocated_vcpus': active_vcpus,
+        }
+    except libvirt.libvirtError as e:
+        logging.error(f"Error calculating VM allocation: {e}")
+        return {}
+
+def get_active_vm_allocation(conn: libvirt.virConnect, progress_callback=None) -> dict:
+    """
+    Calculates resource allocation for only active (running/paused) VMs.
+    More efficient than get_total_vm_allocation for large numbers of inactive VMs.
+    """
+    active_memory = 0
+    active_vcpus = 0
+
+    try:
+        # Only list active domains
+        domains = conn.listAllDomains(libvirt.VIR_CONNECT_LIST_DOMAINS_ACTIVE)
+        total_vms = len(domains)
+
+        for i, domain in enumerate(domains):
+            if progress_callback:
+                progress_callback(i + 1, total_vms)
+
+            try:
+                info = domain.info()
+                max_mem = info[1]  # KB
+                n_cpus = info[3]
+
+                active_memory += max_mem
+                active_vcpus += n_cpus
+
+            except libvirt.libvirtError:
+                continue
+
+        return {
+            'active_allocated_memory': active_memory // 1024,  # Convert to MB
+            'active_allocated_vcpus': active_vcpus,
+        }
+    except libvirt.libvirtError as e:
+        logging.error(f"Error calculating active VM allocation: {e}")
+        return {}
+
 def get_host_architecture(conn: libvirt.virConnect) -> str:
     """
     Returns the host architecture (e.g., 'x86_64', 'aarch64').
     """
     try:
         # getCapabilities returns an XML string describing the host capabilities
-        caps_xml = conn.getCapabilities()
+        caps_xml = get_host_domain_capabilities(conn)
+        if not caps_xml:
+            return 'x86_64'
         root = ET.fromstring(caps_xml)
 
         arch = root.findtext('host/cpu/arch')
@@ -332,12 +445,14 @@ def get_host_numa_nodes(conn: libvirt.virConnect) -> int:
     """
     Returns the number of NUMA nodes on the host.
     """
+    caps_xml = get_host_domain_capabilities(conn)
+    if not caps_xml:
+        return 1
     try:
-        caps_xml = conn.getCapabilities()
         root = ET.fromstring(caps_xml)
         cells = root.findall(".//host/topology/cells/cell")
         return len(cells) if cells else 1
-    except (libvirt.libvirtError, ET.ParseError) as e:
+    except ET.ParseError as e:
         logging.error(f"Error getting host NUMA topology: {e}")
     return 1
 
@@ -439,3 +554,17 @@ def get_host_pci_devices(conn: libvirt.virConnect) -> list[dict]:
     except (libvirt.libvirtError, AttributeError) as e:
         logging.error(f"Error getting host PCI devices: {e}")
     return pci_devices
+
+@lru_cache(maxsize=8)
+def get_host_domain_capabilities(conn: libvirt.virConnect) -> str | None:
+    """
+    Get the host capabilities XML (which describes host and guest capabilities).
+    The result is cached per connection.
+    """
+    if not conn:
+        return None
+    try:
+        return conn.getCapabilities()
+    except libvirt.libvirtError as e:
+        logging.error(f"Error getting host capabilities: {e}")
+        return None