virtui-manager 1.1.6__py3-none-any.whl → 1.4.0__py3-none-any.whl

vmanager/vmanager.py

@@ -4,7 +4,9 @@ Main interface
 import os
 import sys
 import re
+import threading
 from threading import RLock
+from concurrent.futures import ThreadPoolExecutor
 import logging
 import argparse
 from collections import deque
@@ -22,8 +24,10 @@ from textual.worker import Worker, WorkerState
 
 from .config import load_config, save_config, get_log_path
 from .constants import (
-        VmAction, VmStatus, ButtonLabels, ButtonIds,
-        ErrorMessages, AppInfo, StatusText, ServerPallette,
+        WarningMessages,
+        SuccessMessages,
+        VmAction, VmStatus, ButtonLabels, BindingDescriptions,
+        ErrorMessages, AppInfo, StatusText, ServerPallette, QuickMessages, ProgressMessages,
         )
 from .events import VmActionRequest, VMSelectionChanged, VmCardUpdateRequest #,VMNameClicked
 from .libvirt_error_handler import register_error_handler
@@ -34,6 +38,7 @@ from .modals.server_modals import ServerManagementModal
 from .modals.server_prefs_modals import ServerPrefModal
 from .modals.select_server_modals import SelectOneServerModal, SelectServerModal
 from .modals.selection_modals import PatternSelectModal
+from .modals.capabilities_modal import CapabilitiesTreeModal
 from .modals.cache_stats_modal import CacheStatsModal
 from .modals.utils_modals import (
     show_error_message,
@@ -49,6 +54,7 @@ from .modals.vmanager_modals import (
 )
 from .modals.virsh_modals import VirshShellScreen
 from .modals.provisioning_modals import InstallVMModal
+from .modals.host_dashboard_modal import HostDashboardModal
 from .utils import (
     check_novnc_path,
     check_r_viewer,
@@ -56,21 +62,22 @@ from .utils import (
     generate_webconsole_keys_if_needed,
     get_server_color_cached,
     setup_cache_monitoring,
+    setup_logging
 )
-from .libvirt_utils import get_internal_id
 from .vm_queries import (
     get_status,
 )
+from .libvirt_utils import (
+        get_internal_id, get_host_resources,
+        get_active_vm_allocation
+        )
 from .vm_service import VMService
 from .vmcard import VMCard
 from .vmcard_pool import VMCardPool
 from .webconsole_manager import WebConsoleManager
+from .modals.host_stats import HostStats, SingleHostStat
 
-log_config = load_config()
-log_level_str = log_config.get("LOG_LEVEL", "INFO")
-log_level = getattr(logging, log_level_str, logging.INFO)
-file_handler = logging.FileHandler(get_log_path())
-file_handler.setLevel(log_level)
+setup_logging()
 
 class WorkerManager:
     """A class to manage and track Textual workers."""
@@ -158,26 +165,28 @@ class VMManagerTUI(App):
     """A Textual application to manage VMs."""
 
     BINDINGS = [
-        Binding(key="v", action="view_log", description="Log"),
-        Binding(key="f", action="filter_view", description="Filter", show=False),
-        Binding(key="k", action="compact_view", description="CompactView", show=True),
-        #Binding(key="p", action="server_preferences", description="ServerPrefs"),
-        Binding(key="c", action="config", description="Config", show=True),
-        Binding(key="b", action="bulk_cmd", description="BulkCMD", show=False),
-        Binding(key="s", action="select_server", description="SelServers", show=False),
-        Binding(key="l", action="manage_server", description="ServList", show=False),
-        Binding(key="p", action="pattern_select", description="PatternSel", show=False),
-        Binding(key="ctrl+a", action="toggle_select_all", description="Sel/Des All"),
-        Binding(key="ctrl+u", action="unselect_all", description="Unselect All"),
-        Binding(key="left", action="previous_page", description="Previous Page", show=False),
-        Binding(key="right", action="next_page", description="Next Page", show=False),
-        Binding(key="up", action="filter_running", description="Running VMs", show=False),
-        Binding(key="down", action="filter_all", description="All VMs", show=False),
-        Binding(key="ctrl+v", action="virsh_shell", description="Virsh", show=False ),
-        Binding(key="i", action="install_vm", description="InstallVM", show=True),
-        Binding(key="ctrl+l", action="toggle_stats_logging", description="Log Stats", show=False),
-        Binding(key="ctrl+s", action="show_cache_stats", description="Show cache Stats", show=False),
-        Binding(key="q", action="quit", description="Quit"),
+        Binding(key="v", action="view_log", description=BindingDescriptions.LOG),
+        Binding(key="f", action="filter_view", description=BindingDescriptions.FILTER, show=False),
+        Binding(key="k", action="compact_view", description=BindingDescriptions.COMPACT_VIEW, show=True),
+        #Binding(key="p", action="server_preferences", description=BindingDescriptions.SERVER_PREFS),
+        Binding(key="c", action="config", description=BindingDescriptions.CONFIG, show=True),
+        Binding(key="b", action="bulk_cmd", description=BindingDescriptions.BULK_CMD, show=False),
+        Binding(key="s", action="select_server", description=BindingDescriptions.SELECT_SERVERS, show=False),
+        Binding(key="l", action="manage_server", description=BindingDescriptions.MANAGE_SERVERS, show=False),
+        Binding(key="p", action="pattern_select", description=BindingDescriptions.PATTERN_SELECT, show=False),
+        Binding(key="ctrl+a", action="toggle_select_all", description=BindingDescriptions.SELECT_ALL),
+        Binding(key="ctrl+u", action="unselect_all", description=BindingDescriptions.UNSELECT_ALL),
+        Binding(key="left", action="previous_page", description=BindingDescriptions.PREVIOUS_PAGE, show=False),
+        Binding(key="right", action="next_page", description=BindingDescriptions.NEXT_PAGE, show=False),
+        Binding(key="up", action="filter_running", description=BindingDescriptions.RUNNING_VMS, show=False),
+        Binding(key="down", action="filter_all", description=BindingDescriptions.ALL_VMS, show=False),
+        Binding(key="ctrl+v", action="virsh_shell", description=BindingDescriptions.VIRSH_SHELL, show=False ),
+        Binding(key="h", action="host_capabilities", description=BindingDescriptions.HOST_CAPABILITIES, show=False),
+        Binding(key="H", action="host_dashboard", description=BindingDescriptions.HOST_DASHBOARD, show=False),
+        Binding(key="i", action="install_vm", description=BindingDescriptions.INSTALL_VM, show=True),
+        Binding(key="ctrl+l", action="toggle_stats_logging", description=BindingDescriptions.TOGGLE_STATS, show=False),
+        Binding(key="ctrl+s", action="show_cache_stats", description=BindingDescriptions.CACHE_STATS, show=False),
+        Binding(key="q", action="quit", description=BindingDescriptions.QUIT),
     ]
 
     config = load_config()
@@ -244,6 +253,8 @@ class VMManagerTUI(App):
         self.last_increase = {}  # Dict {uri: last_how_many_more}
         self.last_method_increase = {}  # Dict {(uri, method): last_increase}
         self.r_viewer = None
+        self.host_stats = HostStats(self.vm_service, self.get_server_color)
+        self._hide_stats_timer = None
 
     def on_unmount(self) -> None:
         """Called when the application is unmounted."""
@@ -273,7 +284,7 @@ class VMManagerTUI(App):
             target = self.show_warning_message
         elif level == "progress":
             target = self.show_in_progress_message
-        
+
         try:
             self.call_from_thread(target, message)
         except RuntimeError:
@@ -296,12 +307,36 @@ class VMManagerTUI(App):
         except RuntimeError:
             self.worker_manager._cleanup_finished_workers()
 
+    def _trigger_host_stats_refresh(self):
+        """Triggers a refresh of host statistics, cancelling any existing refresh."""
+        # Show host stats
+        self.host_stats.styles.display = "block"
+
+        # Reset hide timer
+        if self._hide_stats_timer:
+            self._hide_stats_timer.stop()
+        self._hide_stats_timer = self.set_timer(10.0, self._hide_host_stats)
+
+        self.worker_manager.cancel("host_stats_refresh")
+        self.worker_manager.run(
+            self.host_stats.refresh_stats,
+            name="host_stats_refresh",
+            description="Refreshing host stats"
+        )
+
+    def _hide_host_stats(self):
+        """Hides the host stats widget."""
+        self.host_stats.styles.display = "none"
+        self._hide_stats_timer = None
+
     def on_vm_update(self, internal_id: str):
         """Callback from VMService for specific VM updates."""
         try:
             self.call_from_thread(self.post_message, VmCardUpdateRequest(internal_id))
+            self.call_from_thread(self._trigger_host_stats_refresh)
         except RuntimeError:
             self.post_message(VmCardUpdateRequest(internal_id))
+            self._trigger_host_stats_refresh()
 
     def watch_bulk_operation_in_progress(self, in_progress: bool) -> None:
         """
@@ -334,13 +369,12 @@ class VMManagerTUI(App):
     def compose(self) -> ComposeResult:
         """Create child widgets for the app."""
         self.ui["vms_container"] = Vertical(id="vms-container")
-        self.ui["error_footer"] = Static(id="error-footer", classes="error-message")
         self.ui["page_info"] = Label("", id="page-info", classes="")
         self.ui["prev_button"] = Button(
-                ButtonLabels.PREVIOUS_PAGE, id=ButtonIds.PREV_BUTTON, variant="primary", classes="ctrlpage"
+                ButtonLabels.PREVIOUS_PAGE, id="prev-button", variant="primary", classes="ctrlpage"
             )
         self.ui["next_button"] = Button(
-                ButtonLabels.NEXT_PAGE, id=ButtonIds.NEXT_BUTTON, variant="primary", classes="ctrlpage"
+                ButtonLabels.NEXT_PAGE, id="next-button", variant="primary", classes="ctrlpage"
             )
         self.ui["pagination_controls"] = Horizontal(
             self.ui["prev_button"],
@@ -356,30 +390,28 @@ class VMManagerTUI(App):
         yield Header()
         with Horizontal(classes="top-controls"):
             yield Button(
-                ButtonLabels.SELECT_SERVER, id=ButtonIds.SELECT_SERVER_BUTTON, classes="Buttonpage"
+                ButtonLabels.SELECT_SERVER, id="select_server_button", classes="Buttonpage"
             )
-            yield Button(ButtonLabels.MANAGE_SERVERS, id=ButtonIds.MANAGE_SERVERS_BUTTON, classes="Buttonpage")
+            yield Button(ButtonLabels.MANAGE_SERVERS, id="manage_servers_button", classes="Buttonpage")
             yield Button(
-                ButtonLabels.SERVER_PREFERENCES, id=ButtonIds.SERVER_PREFERENCES_BUTTON, classes="Buttonpage"
+                ButtonLabels.SERVER_PREFERENCES, id="server_preferences_button", classes="Buttonpage"
             )
-            yield Button(ButtonLabels.FILTER_VM, id=ButtonIds.FILTER_BUTTON, classes="Buttonpage")
-            #yield Button(ButtonLabels.VIEW_LOG, id=ButtonIds.VIEW_LOG_BUTTON, classes="Buttonpage")
+            yield Button(ButtonLabels.FILTER_VM, id="filter_button", classes="Buttonpage")
+            #yield Button(ButtonLabels.VIEW_LOG, id="view-log-button", classes="Buttonpage")
             # yield Button("Virsh Shell", id="virsh_shell_button", classes="Buttonpage")
-            yield Button(ButtonLabels.BULK_CMD, id=ButtonIds.BULK_SELECTED_VMS, classes="Buttonpage")
-            yield Button(ButtonLabels.PATTERN_SELECT, id=ButtonIds.PATTERN_SELECT_BUTTON, classes="Buttonpage")
-            #yield Button(ButtonLabels.CONFIG, id=ButtonIds.CONFIG_BUTTON, classes="Buttonpage")
+            yield Button(ButtonLabels.BULK_CMD, id="bulk_selected_vms", classes="Buttonpage")
+            yield Button(ButtonLabels.PATTERN_SELECT, id="pattern_select_button", classes="Buttonpage")
+            #yield Button(ButtonLabels.CONFIG, id="config-button", classes="Buttonpage")
             #yield Button(
-            #    ButtonLabels.COMPACT_VIEW, id=ButtonIds.COMPACT_VIEW_BUTTON, classes="Buttonpage"
+            #    ButtonLabels.COMPACT_VIEW, id="compact-view-button", classes="Buttonpage"
             #)
             yield Link("About", url="https://aginies.github.io/virtui-manager/")
 
         yield self.ui["pagination_controls"]
+        yield self.host_stats
         yield self.ui["vms_container"]
-        yield self.ui["error_footer"]
         yield Footer()
-        self.show_success_message(
-            "In some Terminal use [b]Shift[/b] key while selecting text with the mouse to copy it."
-        )
+        self.show_success_message(SuccessMessages.TERMINAL_COPY_HINT)
 
     def reload_servers(self, new_servers):
         self.servers = new_servers
@@ -398,7 +430,7 @@ class VMManagerTUI(App):
             )
             self.r_viewer_available = False
         else:
-            self.show_quick_message(f"The remove viewer {self.r_viewer} has been selected.")
+            self.show_quick_message(QuickMessages.REMOTE_VIEWER_SELECTED.format(viewer=self.r_viewer))
 
         if not check_websockify():
             self.show_error_message(
@@ -426,9 +458,7 @@ class VMManagerTUI(App):
             vms_container.styles.grid_size_columns = 2
 
         if not self.servers:
-            self.show_success_message(
-                "No servers configured. Please add one via 'Servers List'."
-            )
+            self.show_success_message(SuccessMessages.NO_SERVERS_CONFIGURED)
         else:
             # Launch initial connection and cache loading in background
             if self.active_uris:
@@ -441,10 +471,10 @@ class VMManagerTUI(App):
         """Connects to servers in background and then triggers cache loading."""
         if self.active_uris:
             for uri in self.active_uris:
-                self.call_from_thread(self.show_in_progress_message, f"Connecting to [b]{uri}[/b]...")
+                self.call_from_thread(self.show_in_progress_message, ProgressMessages.CONNECTING_TO_SERVER.format(uri=uri))
                 success = self.connect_libvirt(uri)
                 if success:
-                    self.call_from_thread(self.show_success_message, f"Connected to [b]{uri}[/b]")
+                    self.call_from_thread(self.show_success_message, SuccessMessages.CONNECTED_TO_SERVER.format(uri=uri))
                 else:
                     error_msg = self.vm_service.connection_manager.get_connection_error(uri)
                     if error_msg:
@@ -461,7 +491,7 @@ class VMManagerTUI(App):
         # Log libvirt call statistics
         call_stats = self.vm_service.connection_manager.get_stats()
         if call_stats:
-            logging.info("=== Libvirt Call Statistics ===")
+            logging.debug("=== Libvirt Call Statistics ===")
             for uri, methods in sorted(call_stats.items()):
                 server_name = uri
                 for s in self.servers:
@@ -479,7 +509,7 @@ class VMManagerTUI(App):
                 if total_increase > 0:
                     increase_pct = 100 - (previous_how_many_more*100 / total_increase)
 
-                logging.info(f"{server_name} ({uri}): {total_calls} calls | +{total_increase} ({increase_pct:.1f}%)")
+                logging.debug(f"{server_name} ({uri}): {total_calls} calls | +{total_increase} ({increase_pct:.1f}%)")
                 previous_how_many_more = how_many_more
 
                 # Initialize previous method calls dict for this URI if needed
@@ -493,7 +523,7 @@ class VMManagerTUI(App):
 
                     self.last_method_calls[uri][method] = count
                     how_many_more_count = count - prev_method_count
-                    logging.info(f"  - {method}: {count} calls (+{how_many_more_count})")
+                    logging.debug(f"  - {method}: {count} calls (+{how_many_more_count})")
 
                 self.last_increase[uri] = how_many_more
                 self.last_total_calls[uri] = total_calls
@@ -510,13 +540,13 @@ class VMManagerTUI(App):
                 self._stats_interval_timer = None
             self._stats_logging_active = False
             setup_cache_monitoring(enable=False)
-            self.show_success_message("Statistics logging and monitoring disabled.")
+            self.show_success_message(SuccessMessages.STATS_LOGGING_DISABLED)
         else:
             setup_cache_monitoring(enable=True)
             self._log_cache_statistics()
             self._stats_interval_timer = self.set_interval(10, self._log_cache_statistics)
             self._stats_logging_active = True
-            self.show_success_message("Statistics logging and monitoring enabled (every 10s).")
+            self.show_success_message(SuccessMessages.STATS_LOGGING_ENABLED)
 
     def _initial_cache_worker(self):
         """Pre-loads VM cache before displaying the UI."""
@@ -545,10 +575,10 @@ class VMManagerTUI(App):
                             if s['uri'] == uri:
                                 server_name = s['name']
                                 break
-                        self.call_from_thread(self.show_error_message, f"Server [b]{server_name}[/b]: {error_msg}")
+                        self.call_from_thread(self.show_error_message, ErrorMessages.SERVER_CONNECTION_ERROR.format(server_name=server_name, error_msg=error_msg))
 
                         if self.vm_service.connection_manager.is_max_retries_reached(uri):
-                             self.call_from_thread(self.remove_active_uri, uri)
+                            self.call_from_thread(self.remove_active_uri, uri)
 
             # Pre-cache info and XML only for the first page of VMs
             # Full info will be loaded on-demand when cards are displayed
@@ -573,14 +603,14 @@ class VMManagerTUI(App):
 
             if active_vms_on_page:
                 vms_list_str = ", ".join(active_vms_on_page)
-                self.call_from_thread(self.show_quick_message, f"Caching VM state for: {vms_list_str}")
+                self.call_from_thread(self.show_quick_message, QuickMessages.CACHING_VM_STATE.format(vms_list=vms_list_str))
 
             self.call_from_thread(self._on_initial_cache_complete)
 
         except Exception as e:
             self.call_from_thread(
-                self.show_error_message, 
-                f"Error during initial cache loading: {e}"
+                self.show_error_message,
+                ErrorMessages.ERROR_DURING_INITIAL_CACHE_LOADING.format(error=e)
             )
 
     def _on_initial_cache_complete(self):
@@ -588,7 +618,7 @@ class VMManagerTUI(App):
         self.initial_cache_loading = False
         self.initial_cache_complete = True
         if self.servers:
-            self.show_quick_message("VM data loaded. Displaying VMs...")
+            self.show_quick_message(QuickMessages.VM_DATA_LOADED)
             self.refresh_vm_list()
 
     def _update_layout_for_size(self):
@@ -630,7 +660,7 @@ class VMManagerTUI(App):
         vms_container.styles.grid_size_columns = cols
 
         old_vms_per_page = self.VMS_PER_PAGE
-        
+
         self.VMS_PER_PAGE = cols * rows
         if self.compact_view:
             self.VMS_PER_PAGE = cols * rows + cols
@@ -646,9 +676,7 @@ class VMManagerTUI(App):
         self.vm_card_pool.prefill_pool()
 
         if self.VMS_PER_PAGE > 9 and old_vms_per_page <= 9 and not self.compact_view:
-            self.show_warning_message(
-                f"Displaying [b]{self.VMS_PER_PAGE}[/b] VMs per page. CPU usage may increase; 9 is recommended for optimal performance."
-            )
+            self.show_warning_message(WarningMessages.VMS_PER_PAGE_PERFORMANCE_WARNING.format(vms_per_page=self.VMS_PER_PAGE))
 
         self.refresh_vm_list(force=True)
 
@@ -676,7 +704,7 @@ class VMManagerTUI(App):
             if conn:
                 yield conn
             else:
-                self.show_error_message(f"Failed to open connection to [b]{uri}[/b]")
+                self.show_error_message(ErrorMessages.FAILED_TO_OPEN_CONNECTION.format(uri=uri))
 
     def connect_libvirt(self, uri: str) -> None:
         """Connects to libvirt."""
@@ -705,11 +733,11 @@ class VMManagerTUI(App):
     def show_warning_message(self, message: str):
         show_warning_message(self, message)
 
-    @on(Button.Pressed, f"#{ButtonIds.COMPACT_VIEW_BUTTON}")
+    @on(Button.Pressed, f"#compact-view-button")
     def action_compact_view(self) -> None:
         """Toggle compact view."""
         if self.bulk_operation_in_progress:
-            self.show_warning_message("Compact view is locked during bulk operations.")
+            self.show_warning_message(WarningMessages.COMPACT_VIEW_LOCKED)
             return
 
         if not self.compact_view:
@@ -754,8 +782,7 @@ class VMManagerTUI(App):
         uris_to_connect = [uri for uri in selected_uris if uri not in self.active_uris]
         # Show connecting message for each new server
         for uri in uris_to_connect:
-            self.show_in_progress_message(f"Connecting to [b]{uri}[/b]...")
-
+            self.show_in_progress_message(ProgressMessages.CONNECTING_TO_SERVER.format(uri=uri))
         for uri in uris_to_disconnect:
             # Cleanup UI caches for VMs on this server
             uuids_to_release = [
@@ -795,11 +822,11 @@ class VMManagerTUI(App):
                         server_name = s['name']
                         break
                 if success:
-                    self.call_from_thread(self.show_success_message, f"Connected to [b]{server_name}[/b]")
+                    self.call_from_thread(self.show_success_message, SuccessMessages.SERVER_CONNECTED.format(name=server_name))
                 else:
                     error_msg = self.vm_service.connection_manager.get_connection_error(uri)
                     if error_msg:
-                        self.call_from_thread(self.show_error_message, f"Failed to connect to [b]{server_name}[/b]: {error_msg}")
+                        self.call_from_thread(self.show_error_message, ErrorMessages.SERVER_FAILED_TO_CONNECT.format(server_name=server_name, error_msg=error_msg))
 
         if uris_to_connect:
             self.worker_manager.run(show_connection_results, name="show_connection_results")
@@ -868,7 +895,7 @@ class VMManagerTUI(App):
         if self.sort_by != VmStatus.RUNNING:
             self.sort_by = VmStatus.RUNNING
             self.current_page = 0
-            self.show_quick_message("Filter: Running VMs")
+            self.show_quick_message(QuickMessages.FILTER_RUNNING_VMS)
             self.refresh_vm_list()
 
     def action_filter_all(self) -> None:
@@ -876,7 +903,7 @@ class VMManagerTUI(App):
         if self.sort_by != VmStatus.DEFAULT:
             self.sort_by = VmStatus.DEFAULT
             self.current_page = 0
-            self.show_quick_message("Filter: All VMs")
+            self.show_quick_message(QuickMessages.FILTER_ALL_VMS)
             self.refresh_vm_list()
 
     @on(FilterModal.FilterChanged)
@@ -899,7 +926,7 @@ class VMManagerTUI(App):
             self.search_text = new_search
             self.filtered_server_uris = new_selected_servers
             self.current_page = 0
-            self.show_in_progress_message("Loading VM data from remote server(s)...")
+            self.show_in_progress_message(ProgressMessages.LOADING_VM_DATA_FROM_REMOTE_SERVERS)
             self.refresh_vm_list()
 
     def action_config(self) -> None:
@@ -919,7 +946,7 @@ class VMManagerTUI(App):
                 logging.getLogger().setLevel(new_log_level)
                 for handler in logging.getLogger().handlers:
                     handler.setLevel(new_log_level)
-                self.show_success_message(f"Log level changed to {new_log_level_str}")
+                self.show_success_message(SuccessMessages.LOG_LEVEL_CHANGED.format(level=new_log_level_str))
 
             # Update remote viewer if changed
             self.r_viewer = check_r_viewer(self.config.get("REMOTE_VIEWER"))
@@ -930,10 +957,10 @@ class VMManagerTUI(App):
                 self.r_viewer_available = True
 
             if (self.config.get("STATS_INTERVAL") != old_stats_interval):
-                self.show_in_progress_message("Configuration updated. Refreshing VM list...")
+                self.show_in_progress_message(ProgressMessages.CONFIG_UPDATED_REFRESHING_VM_LIST)
                 self.refresh_vm_list(force=False, optimize_for_current_page=True)
             else:
-                self.show_success_message("Configuration updated.")
+                self.show_success_message(SuccessMessages.CONFIG_UPDATED)
 
     @on(Button.Pressed, "#config_button")
     def on_config_button_pressed(self, event: Button.Pressed) -> None:
@@ -985,7 +1012,7 @@ class VMManagerTUI(App):
                         self.call_from_thread(self.push_screen, modal)
                     except Exception as e:
                         self.call_from_thread(loading.dismiss)
-                        self.call_from_thread(self.show_error_message, f"Error launching preferences: {e}")
+                        self.call_from_thread(self.show_error_message, ErrorMessages.PREFERENCES_LAUNCH_ERROR.format(error=e))
 
                 self.worker_manager.run(show_prefs, name="launch_server_prefs")
             else:
@@ -1004,7 +1031,7 @@ class VMManagerTUI(App):
         Handles 0, 1, or multiple active servers.
         """
         if len(self.active_uris) == 0:
-            self.show_error_message("Not connected to any server.")
+            self.show_error_message(ErrorMessages.NOT_CONNECTED_TO_ANY_SERVER)
             return
 
         if len(self.active_uris) == 1:
@@ -1038,6 +1065,34 @@ class VMManagerTUI(App):
         """Callback for the virsh shell button."""
         self.action_virsh_shell()
 
+    def action_host_dashboard(self) -> None:
+        """Show Host Resource Dashboard."""
+        def launch_dashboard_modal(uri: str):
+            conn = self.vm_service.connect(uri)
+            if conn:
+                # Find server name
+                server_name = uri
+                for s in self.servers:
+                    if s['uri'] == uri:
+                        server_name = s['name']
+                        break
+                self.push_screen(HostDashboardModal(conn, server_name))
+            else:
+                self.show_error_message(ErrorMessages.COULD_NOT_CONNECT_TO_SERVER.format(uri=uri))
+
+        self._select_server_and_run(launch_dashboard_modal, "Select a server for Dashboard", "View Dashboard")
+
+    def action_host_capabilities(self) -> None:
+        """Show Host Capabilities."""
+        def launch_caps_modal(uri: str):
+            conn = self.vm_service.connect(uri)
+            if conn:
+                self.push_screen(CapabilitiesTreeModal(conn))
+            else:
+                self.show_error_message(ErrorMessages.COULD_NOT_CONNECT_TO_SERVER.format(uri=uri))
+
+        self._select_server_and_run(launch_caps_modal, "Select a server for Capabilities", "View")
+
     def action_install_vm(self) -> None:
         """Launch the VM Installation Modal."""
         def launch_install_modal(uri: str):
@@ -1057,7 +1112,7 @@ class VMManagerTUI(App):
         def action_worker():
             domain = self.vm_service.find_domain_by_uuid(self.active_uris, message.internal_id)
             if not domain:
-                self.call_from_thread(self.show_error_message, f"Could not find VM with ID [b]{message.internal_id}[/b]")
+                self.call_from_thread(self.show_error_message, ErrorMessages.VM_NOT_FOUND_BY_ID.format(vm_id=message.internal_id))
                 return
 
             #vm_name = domain.name()
@@ -1069,6 +1124,41 @@ class VMManagerTUI(App):
             try:
                 # Message are done by events
                 if message.action == VmAction.START:
+                    # Check resources
+                    try:
+                        conn = domain.connect()
+                        host_res = get_host_resources(conn)
+                        current_alloc = get_active_vm_allocation(conn)
+
+                        # domain.info() -> [state, maxMem(KB), memory(KB), nrVirtCpu, cpuTime]
+                        vm_info = domain.info()
+                        vm_mem_mb = vm_info[1] // 1024
+                        vm_vcpus = vm_info[3]
+
+                        host_mem_mb = host_res.get('available_memory', 0)
+                        host_cpus = host_res.get('total_cpus', 0)
+
+                        active_mem_mb = current_alloc.get('active_allocated_memory', 0)
+                        active_vcpus = current_alloc.get('active_allocated_vcpus', 0)
+
+                        overcommit_mem = (active_mem_mb + vm_mem_mb) > host_mem_mb
+                        overcommit_cpu = (active_vcpus + vm_vcpus) > host_cpus
+
+                        if overcommit_mem or overcommit_cpu:
+                            warnings = []
+                            if overcommit_mem:
+                                warnings.append(f"Memory: {active_mem_mb + vm_mem_mb} MB > {host_mem_mb} MB")
+                            if overcommit_cpu:
+                                warnings.append(f"vCPUs: {active_vcpus + vm_vcpus} > {host_cpus}")
+
+                            warning_msg = (
+                                f"Starting VM '{vm_name}' will exceed host capacity (Active Allocation):\n"
+                                f"{chr(10).join(warnings)}"
+                            )
+                            self.show_warning_message(warning_msg)
+                    except Exception as e:
+                        logging.error(f"Error checking resources before start: {e}")
+
                     self.vm_service.start_vm(domain)
                 elif message.action == VmAction.STOP:
                     self.vm_service.stop_vm(domain)
@@ -1088,10 +1178,17 @@ class VMManagerTUI(App):
             except Exception as e:
                 self.call_from_thread(
                     self.show_error_message,
-                    f"Error on VM [b]{vm_name}[/b] during '{message.action}': {e}",
+                    ErrorMessages.ERROR_ON_VM_DURING_ACTION.format(vm_name=vm_name, action=message.action, error=e),
                 )
             finally:
                 self.vm_service.unsuppress_vm_events(message.internal_id)
+                
+                # Show stats update since event was suppressed
+                try:
+                    self.call_from_thread(self._trigger_host_stats_refresh)
+                except RuntimeError:
+                    pass
+
                 # Always try to unset the flag from the main thread
                 def unset_flag():
                     if self.bulk_operation_in_progress:
@@ -1129,7 +1226,7 @@ class VMManagerTUI(App):
         for card in self.query(VMCard):
             card.is_selected = False
 
-        self.show_quick_message("All VMs unselected.")
+        self.show_quick_message(QuickMessages.ALL_VMS_UNSELECTED)
 
     @on(VMSelectionChanged)
     def on_vm_selection_changed(self, message: VMSelectionChanged) -> None:
@@ -1150,7 +1247,7 @@ class VMManagerTUI(App):
         delete_storage_flag = result.get('delete_storage', False)
 
         if not action_type:
-            self.show_error_message("No action type received from bulk action modal.")
+            self.show_error_message(ErrorMessages.NO_ACTION_TYPE_BULK_MODAL)
             return
 
         selected_uuids_copy = list(self.selected_vm_uuids)  # Take a copy for the worker
@@ -1162,7 +1259,7 @@ class VMManagerTUI(App):
             selected_domains = list(found_domains_map.values())
 
             if not selected_domains:
-                self.show_error_message("Could not find any of the selected VMs for editing.")
+                self.show_error_message(ErrorMessages.VM_NOT_FOUND_FOR_EDITING)
                 return
 
             # Check if all selected VMs are stopped
@@ -1172,7 +1269,7 @@ class VMManagerTUI(App):
                     active_vms.append(domain.name())
 
             if active_vms:
-                self.show_error_message(f"All VMs must be stopped for bulk editing. Running VMs: {', '.join(active_vms)}")
+                self.show_error_message(ErrorMessages.VMS_MUST_BE_STOPPED_FOR_BULK_EDITING.format(running_vms=', '.join(active_vms)))
                 # Restore selection since we are aborting
                 self.selected_vm_uuids = set(selected_uuids_copy)
                 return
@@ -1209,9 +1306,9 @@ class VMManagerTUI(App):
                         # Clear selection after launching modal
                         self.selected_vm_uuids.clear()
                     else:
-                        self.show_error_message("Could not load details for reference VM.")
+                        self.show_error_message(ErrorMessages.COULD_NOT_LOAD_DETAILS_FOR_REFERENCE_VM)
                 except Exception as e:
-                    self.app.show_error_message(f"Error preparing bulk edit: {e}")
+                    self.app.show_error_message(ErrorMessages.BULK_EDIT_PREP_ERROR.format(error=e))
 
             warning_message = "This will apply configuration changes to all selected VMs based on the settings you choose.\n\nSome changes modify the VM's XML directly. All change cannot be undone.\n\nAre you sure you want to proceed?"
             self.app.push_screen(ConfirmationDialog(warning_message), on_confirm)
@@ -1257,16 +1354,16 @@ class VMManagerTUI(App):
             )
 
             summary = f"Bulk action '{action_type}' complete. Successful: {len(successful_vms)}, Failed: {len(failed_vms)}"
-            logging.info(summary) 
+            logging.info(summary)
 
             if successful_vms:
-                self.call_from_thread(self.show_success_message, f"Bulk action [b]{action_type}[/b] successful for {len(successful_vms)} VMs.")
+                self.call_from_thread(self.show_success_message, SuccessMessages.BULK_ACTION_SUCCESS_TEMPLATE.format(action_type=action_type, count=len(successful_vms)))
             if failed_vms:
-                self.call_from_thread(self.show_error_message, f"Bulk action [b]{action_type}[/b] failed for {len(failed_vms)} VMs.")
+                self.call_from_thread(self.show_error_message, ErrorMessages.BULK_ACTION_FAILED_TEMPLATE.format(action_type=action_type, count=len(failed_vms)))
 
         except Exception as e:
             logging.error(f"An unexpected error occurred during bulk action service call: {e}", exc_info=True)
-            self.call_from_thread(self.show_error_message, f"A fatal error occurred during bulk action: {e}")
+            self.call_from_thread(self.show_error_message, ErrorMessages.FATAL_ERROR_BULK_ACTION.format(error=e))
 
         finally:
             # Ensure these are called on the main thread
@@ -1310,7 +1407,7 @@ class VMManagerTUI(App):
                 vms_per_page,
                 uris_to_query,
                 force=force,
-                optimize_for_current_page=current_page,
+                optimize_for_current_page=optimize_for_current_page,
                 on_complete=on_complete,
             ),
             name="list_vms"
@@ -1328,6 +1425,12 @@ class VMManagerTUI(App):
             ):
         """Worker to fetch, filter, and display VMs using a diffing strategy."""
         try:
+            # Update Host Stats
+            if threading.current_thread() is threading.main_thread():
+                self.host_stats.update_hosts(uris_to_query, self.servers)
+            else:
+                self.call_from_thread(self.host_stats.update_hosts, uris_to_query, self.servers)
+
             start_index = current_page * vms_per_page
             end_index = start_index + vms_per_page
             page_start = start_index if optimize_for_current_page else None
@@ -1353,22 +1456,18 @@ class VMManagerTUI(App):
             end_index = start_index + vms_per_page
             paginated_domains = domains_to_display[start_index:end_index]
 
-            # Collect data in worker thread
-            vm_data_list = []
-            page_uuids = set()
-
-            for domain, conn in paginated_domains:
+            # Parallelize fetching of VM info
+            def fetch_vm_data(item):
+                domain, conn = item
                 try:
                     uri = self.vm_service.get_uri_for_connection(conn) or conn.getURI()
                     uuid, vm_name = self.vm_service.get_vm_identity(domain, conn, known_uri=uri)
-                    page_uuids.add(uuid)
 
-                    # Get info from cache or fetch if not present. This is safe as we are in a worker.
+                    # Get info from cache or fetch if not present
                     info = self.vm_service._get_domain_info(domain)
                     cached_details = self.vm_service.get_cached_vm_details(uuid)
 
-                    # Explicitly get state from cache/service which might be event-updated
-                    # This avoids flickering if domain.info() (fetched by _get_domain_info) lags behind events
+                    # Explicitly get state from cache/service
                     state_tuple = self.vm_service._get_domain_state(domain, internal_id=uuid)
 
                     effective_state = None
@@ -1394,7 +1493,7 @@ class VMManagerTUI(App):
                         cpu = 0
                         memory = 0
 
-                    vm_data = {
+                    return {
                         'uuid': uuid,
                         'name': vm_name,
                         'status': status,
@@ -1405,19 +1504,28 @@ class VMManagerTUI(App):
                         'conn': conn,
                         'uri': uri
                     }
-                    vm_data_list.append(vm_data)
-
                 except libvirt.libvirtError as e:
                     if e.get_error_code() == libvirt.VIR_ERR_NO_DOMAIN:
                         logging.warning(f"Skipping display of non-existent VM during refresh.")
-                        continue
+                        return None
                     else:
                         try:
                             name_for_error = vm_name if 'vm_name' in locals() else domain.name()
                         except:
                             name_for_error = "Unknown"
-                        self.call_from_thread(self.show_error_message, f"Error getting info for VM '{name_for_error}': {e}")
-                        continue
+                        self.call_from_thread(self.show_error_message, ErrorMessages.VM_INFO_ERROR.format(vm_name=name_for_error, error=e))
+                        return None
+
+            vm_data_list = []
+            page_uuids = set()
+
+            with ThreadPoolExecutor(max_workers=20) as executor:
+                results = list(executor.map(fetch_vm_data, paginated_domains))
+
+            for result in results:
+                if result:
+                    vm_data_list.append(result)
+                    page_uuids.add(result['uuid'])
 
             # Cleanup cache: remove cards for VMs that no longer exist at all
             all_uuids_from_libvirt = set(all_active_uuids)
@@ -1550,7 +1658,7 @@ class VMManagerTUI(App):
                         self.filtered_server_uris = [u for u in self.filtered_server_uris if u not in uris_to_remove]
 
                     if removed_names:
-                        self.show_error_message(f"Server(s) {', '.join(removed_names)} disconnected and autoconnect disabled due to connection failures.")
+                        self.show_error_message(ErrorMessages.SERVER_DISCONNECTED_AUTOCONNECT_DISABLED.format(names=', '.join(removed_names)))
 
                 if config_changed:
                     self.config['servers'] = self.servers
@@ -1563,7 +1671,7 @@ class VMManagerTUI(App):
             self.call_from_thread(update_ui_on_main_thread)
 
         except Exception as e:
-            self.call_from_thread(self.show_error_message, f"Error fetching VM data: {e}")
+            self.call_from_thread(self.show_error_message, ErrorMessages.ERROR_FETCHING_VM_DATA.format(error=e))
         finally:
             if on_complete:
                 self.call_from_thread(on_complete)
@@ -1613,7 +1721,7 @@ class VMManagerTUI(App):
     def action_pattern_select(self) -> None:
         """Handles the 'Pattern Sel' button press."""
         if not self.active_uris:
-            self.show_error_message("No active servers.")
+            self.show_error_message(ErrorMessages.NO_ACTIVE_SERVERS)
             return
 
         # Gather all known VMs from cache
@@ -1638,7 +1746,7 @@ class VMManagerTUI(App):
                     continue
 
         if not available_vms:
-            self.show_error_message("No VMs found in cache. Try refreshing first.")
+            self.show_error_message(ErrorMessages.NO_VMS_IN_CACHE)
             return
 
         # Prepare server list for the modal, matching FilterModal logic
@@ -1661,7 +1769,7 @@ class VMManagerTUI(App):
             if selected_uuids:
                 # Add found UUIDs to current selection
                 self.selected_vm_uuids.update(selected_uuids)
-                self.show_success_message(f"Selected {len(selected_uuids)} VMs matching pattern.")
+                self.show_success_message(SuccessMessages.VMS_SELECTED_BY_PATTERN.format(count=len(selected_uuids)))
                 self.refresh_vm_list()
 
         self.push_screen(PatternSelectModal(available_vms, available_servers, selected_servers), handle_result)
@@ -1672,7 +1780,7 @@ class VMManagerTUI(App):
         """Handles the 'Bulk Selected' button press."""
         self._collapse_all_action_collapsibles()
         if not self.selected_vm_uuids:
-            self.show_error_message("No VMs selected.")
+            self.show_error_message(ErrorMessages.NO_VMS_SELECTED)
             return
 
         uuids_snapshot = list(self.selected_vm_uuids)
@@ -1683,7 +1791,7 @@ class VMManagerTUI(App):
 
             # Use the service to find specific domains by their internal ID (UUID@URI)
             # This correctly handles cases where identical UUIDs exist on different servers
-            found_domains_map = self.vm_service.find_domains_by_uuids(self.active_uris, uuids)
+            found_domains_map = self.vm_service.find_domains_by_uuids(self.active_uris, uuids, check_validity=False)
 
             all_names = set()
             for domain in found_domains_map.values():
@@ -1701,9 +1809,7 @@ class VMManagerTUI(App):
                     self.push_screen, BulkActionModal(vm_names_list), self.handle_bulk_action_result
                 )
             else:
-                self.call_from_thread(
-                    self.show_error_message, "Could not retrieve names for selected VMs."
-                )
+                self.call_from_thread(self.show_error_message, ErrorMessages.BULK_ACTION_VM_NAMES_RETRIEVAL_FAILED)
 
         self.worker_manager.run(
             get_names_and_show_modal,
@@ -1760,7 +1866,7 @@ class VMManagerTUI(App):
                     else:
                         cpu = 0
                         memory = 0
-                
+
                 logging.debug(f"Updating card {vm_internal_id} with status {status}")
                 # Update card on main thread
                 def update_ui():
@@ -1780,6 +1886,27 @@ class VMManagerTUI(App):
             update_single_card, name=f"update_card_{vm_internal_id}"
         )
 
+    @on(SingleHostStat.ServerLabelClicked)
+    def on_single_host_stat_server_label_clicked(self, message: SingleHostStat.ServerLabelClicked) -> None:
+        """Called when a server label is clicked in the host stats."""
+        available_servers = []
+        for uri in self.active_uris:
+            name = uri
+            for s in self.servers:
+                if s['uri'] == uri:
+                    name = s['name']
+                    break
+            available_servers.append({'name': name, 'uri': uri, 'color': self.get_server_color(uri)})
+
+        self.push_screen(
+            FilterModal(
+                current_search=self.search_text,
+                current_status=self.sort_by,
+                available_servers=available_servers,
+                selected_servers=[message.server_uri] # Pre-select the clicked server
+            )
+        )
+
 
 def main():
     """Entry point for vmanager TUI application."""