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

vmanager/modals/host_stats.py

@@ -0,0 +1,199 @@
+"""
+Host Stats modals
+"""
+import logging
+import threading
+from textual.app import ComposeResult
+from textual.widgets import Static, Label
+from textual.reactive import reactive
+from textual.events import Click, Message
+from textual.worker import get_current_worker
+
+from ..libvirt_utils import get_host_resources, get_active_vm_allocation
+from ..utils import extract_server_name_from_uri
+
+class SingleHostStat(Static):
+    """
+    Displays stats for a single host.
+    """
+    server_name = reactive("")
+
+    class ServerLabelClicked(Message):
+        """Posted when the server label is clicked."""
+        def __init__(self, server_uri: str, server_name: str) -> None:
+            super().__init__()
+            self.server_uri = server_uri
+            self.server_name = server_name
+
+    DEFAULT_CSS = """
+    SingleHostStat {
+        layout: horizontal;
+        height: auto;
+        padding: 0 1;
+        background: $boost;
+        align-vertical: middle;
+    }
+    .stat-label {
+        color: $text;
+    }
+    """
+
+    def __init__(self, uri: str, name: str, vm_service, server_color: str = "white"):
+        super().__init__()
+        self.uri = uri
+        self.server_name = name
+        self.vm_service = vm_service
+        self.server_color = server_color
+        self.server_label = Label("", id=f"single_host_stat_label_{self.server_name.replace(' ', '_').replace('.', '_')}")
+        self.cpu_label = Label("", classes="stat-label")
+        self.mem_label = Label("", classes="stat-label")
+        self.host_res = None
+
+    def compose(self) -> ComposeResult:
+        self.server_label.styles.color = self.server_color
+        self.server_label.styles.text_style = "bold"
+        self.server_label.update(f"{self.server_name} ")
+        yield self.server_label
+        yield self.cpu_label
+        yield Label(" ")
+        yield self.mem_label
+
+    def on_click(self, event: Click) -> None:
+        """Called when the user clicks on a widget."""
+        if event.control.id == self.server_label.id:
+            self.post_message(self.ServerLabelClicked(self.uri, self.server_name))
+
+    def update_stats(self):
+        """Fetches and updates stats for this host."""
+        def _fetch_and_update():
+            try:
+                # Check cancellation before potentially expensive op
+                try:
+                    if get_current_worker().is_cancelled:
+                        return
+                except Exception:
+                    pass
+
+                conn = self.vm_service.connect(self.uri)
+                if not conn:
+                    if threading.current_thread() is threading.main_thread():
+                        self.cpu_label.update("Offline")
+                        self.mem_label.update("Offline")
+                    else:
+                        self.app.call_from_thread(self.cpu_label.update, "Offline")
+                        self.app.call_from_thread(self.mem_label.update, "Offline")
+                    return
+
+                if self.host_res is None:
+                    self.host_res = get_host_resources(conn)
+
+                current_alloc = get_active_vm_allocation(conn)
+                
+                # Check cancellation again after expensive op
+                try:
+                    if get_current_worker().is_cancelled:
+                        return
+                except Exception:
+                    pass
+
+                total_cpus = self.host_res.get('total_cpus', 1)
+                total_mem = self.host_res.get('available_memory', 1) # MB
+
+                used_cpus = current_alloc.get('active_allocated_vcpus', 0)
+                used_mem = current_alloc.get('active_allocated_memory', 0) # MB
+
+                cpu_pct = (used_cpus / total_cpus) * 100
+                mem_pct = (used_mem / total_mem) * 100
+                # Format memory string (GB if > 1024 MB)
+                def fmt_mem(mb):
+                    if mb >= 1024:
+                        return f"{mb/1024:.1f}G"
+                    return f"{mb}M"
+
+                # UI Updates need to be on main thread
+                def _update_ui():
+                    def get_status_bck(pct):
+                        if pct >= 90:
+                            return ("red")
+                        if pct >= 75:
+                            return ("orange")
+                        if pct >= 55:
+                            return ("yellow")
+                        return ("green")
+
+                    self.cpu_label.update(f"{used_cpus}/{total_cpus}CPU")
+                    self.cpu_label.styles.background = get_status_bck(cpu_pct)
+
+                    self.mem_label.update(f"{fmt_mem(used_mem)}/{fmt_mem(total_mem)}")
+                    self.mem_label.styles.background = get_status_bck(mem_pct)
+
+                if threading.current_thread() is threading.main_thread():
+                    _update_ui()
+                else:
+                    self.app.call_from_thread(_update_ui)
+
+            except Exception as e:
+                logging.error(f"Error updating host stats for {self.name}: {e}")
+                if threading.current_thread() is threading.main_thread():
+                    self.cpu_label.update("Err")
+                    self.mem_label.update("Err")
+                else:
+                    self.app.call_from_thread(self.cpu_label.update, "Err")
+                    self.app.call_from_thread(self.mem_label.update, "Err")
+
+        _fetch_and_update()
+
+class HostStats(Static):
+    """
+    Container for multiple SingleHostStat widgets.
+    """
+    DEFAULT_CSS = """
+    HostStats {
+        layout: grid;
+        grid-size: 3;
+        overflow-y: auto;
+        margin-bottom: 0;
+        margin-top: 0;
+        display: none;
+    }
+    """
+
+    def __init__(self, vm_service, get_server_color_callback):
+        super().__init__()
+        self.vm_service = vm_service
+        self.get_server_color = get_server_color_callback
+        self.active_hosts = {}
+
+    def update_hosts(self, active_uris, servers):
+        """
+        Reconciles the list of active hosts.
+        """
+        current_uris = set(active_uris)
+        existing_uris = set(self.active_hosts.keys())
+
+        # Remove stale
+        for uri in existing_uris - current_uris:
+            widget = self.active_hosts.pop(uri)
+            widget.remove()
+
+        # Add new hosts
+        for uri in current_uris - existing_uris:
+            name = self._get_server_name(uri, servers)
+            color = self.get_server_color(uri)
+            widget = SingleHostStat(uri, name, self.vm_service, color)
+            self.active_hosts[uri] = widget
+            self.mount(widget)
+            self.app.set_timer(0.5, widget.update_stats)
+
+    def _get_server_name(self, uri: str, servers) -> str:
+        """Helper to get server name from URI."""
+        if servers:
+            for s in servers:
+                if s['uri'] == uri:
+                    return s.get('name', extract_server_name_from_uri(uri))
+        return extract_server_name_from_uri(uri)
+
+    def refresh_stats(self):
+        """Triggers update on all children."""
+        for widget in self.active_hosts.values():
+            widget.update_stats()

vmanager/modals/migration_modals.py

@@ -387,7 +387,7 @@ class MigrationModal(ModalScreen):
 
         write_log("\n[bold]--- Migration process finished ---[/]")
         self.app.call_from_thread(lambda: setattr(progress_bar.styles, "display", "none"))
-        self.app.call_from_thread(self.app.refresh_vm_list)
+        self.app.call_from_thread(self.app.refresh_vm_list, force=True)
         self.app.call_from_thread(final_ui_state)
 
     @on(Checkbox.Changed, "#custom")

vmanager/modals/utils_modals.py

@@ -20,7 +20,7 @@ from textual.widgets import (
 )
 
 from .base_modals import BaseDialog, BaseModal
-from ..constants import ButtonLabels
+from ..constants import ButtonLabels, StaticText
 
 
 def _sanitize_message(message: str) -> str:

vmanager/utils.py

@@ -13,6 +13,9 @@ from typing import List, Tuple, Union, Callable
 from urllib.parse import urlparse
 from .constants import AppInfo
 
+def is_running_under_flatpak():
+    return 'FLATPAK_ID' in os.environ
+
 def find_free_port(start: int, end: int) -> int:
     """
     Find a free port in the specified range.
@@ -268,6 +271,20 @@ def check_websockify() -> bool:
         return False
 
 
+def check_tmux() -> bool:
+    """
+    Checks if running inside a tmux session and tmux command is available.
+
+    Returns:
+        bool: True if inside tmux and tmux is installed, False otherwise
+    """
+    try:
+        return os.environ.get("TMUX") is not None and shutil.which("tmux") is not None
+    except Exception as e:
+        logging.error(f"Error checking tmux: {e}")
+        return False
+
+
 def check_is_firewalld_running() -> Union[str, bool]:
     """
     Check if firewalld is running.
@@ -464,7 +481,7 @@ def generate_tooltip_markdown(
 ) -> str:
     """Generate tooltip markdown (pure function, cacheable)."""
     mem_display = format_memory_display(memory)
-    cpu_display = f"{cpu} ({cpu_model})" if cpu_model else str(cpu)
+    cpu_display = f"{cpu} {cpu_model}" if cpu_model else str(cpu)
 
     return (
         f"`{uuid}`  \n"

vmanager/vm_actions.py

@@ -1873,6 +1873,18 @@ def stop_vm(domain: libvirt.virDomain):
     invalidate_cache(get_internal_id(domain))
     domain.shutdown()
 
+def hibernate_vm(domain: libvirt.virDomain):
+    """
+    Saves (hibernates) the VM state to disk and stops it.
+    """
+    if not domain:
+        raise ValueError("Invalid domain object.")
+    if not domain.isActive():
+        raise libvirt.libvirtError(f"VM '{domain.name()}' is not active, cannot save.")
+
+    invalidate_cache(get_internal_id(domain))
+    domain.managedSave(0)
+
 def pause_vm(domain: libvirt.virDomain):
     """
     Pauses the execution of the VM.
@@ -2231,6 +2243,14 @@ def check_vm_migration_compatibility(domain: libvirt.virDomain, dest_conn: libvi
     """
     issues = []
 
+    # Check for name collision
+    try:
+        dest_conn.lookupByName(domain.name())
+        issues.append({'severity': 'ERROR', 'message': f"A VM with the name '{domain.name()}' already exists on the destination host."})
+    except libvirt.libvirtError as e:
+        if e.get_error_code() != libvirt.VIR_ERR_NO_DOMAIN:
+             issues.append({'severity': 'WARNING', 'message': f"Could not check for name collision on destination: {e}"})
+
     try:
         xml_desc = domain.XMLDesc(0)
         root = ET.fromstring(xml_desc)

vmanager/vm_migration.py

@@ -286,7 +286,10 @@ def custom_migrate_vm(source_conn: libvirt.virConnect, dest_conn: libvirt.virCon
             raise
 
     # 2. Analyze storage and propose move actions
-    actions = []
+    actions = [{
+        "type": "vm_metadata",
+        "vm_name": domain.name()
+    }]
     root = ET.fromstring(xml_desc)
     disks = get_vm_disks_info(source_conn, root)
 

vmanager/vmanager.css

@@ -512,7 +512,15 @@ Toast.-inprogress {
 .Buttonpage { height: auto; width: auto; margin: 0 0; padding: 1 1; color: white; background: black; border: round; }
 .Buttonpage:hover { background: $primary-darken-2; }
 .button-details { height: 1; padding: 0 0; }
-.ctrlpage { height: 3vh; width: auto; margin: 0 0; padding: 0 0; color: white; text-style: underline; background: $background; }
+.ctrlpage {
+   height: 1;
+   width: auto;
+   margin: 0 0;
+   padding: 0 0;
+   color: white;
+   background: $background;
+   margin-bottom: 1;
+}
 .close-button { height: 1; width: auto; color: white; background: red; border: hidden; margin: 1 1; }
 #delete-server-btn, #delete-button, .cancel-button { background: red; width: 25% }
 .rename-button, .edit-button, .add-button { background: green; }

vmanager/vmanager.py

@@ -4,6 +4,7 @@ Main interface
 import os
 import sys
 import re
+import threading
 from threading import RLock
 from concurrent.futures import ThreadPoolExecutor
 import logging
@@ -61,19 +62,20 @@ from .utils import (
     generate_webconsole_keys_if_needed,
     get_server_color_cached,
     setup_cache_monitoring,
-    setup_logging
+    setup_logging, is_running_under_flatpak
 )
 from .vm_queries import (
     get_status,
 )
 from .libvirt_utils import (
         get_internal_id, get_host_resources,
-        get_total_vm_allocation, get_active_vm_allocation
+        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
 
 setup_logging()
 
@@ -251,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."""
@@ -280,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:
@@ -303,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:
         """
@@ -341,7 +369,6 @@ 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="prev-button", variant="primary", classes="ctrlpage"
@@ -381,8 +408,8 @@ class VMManagerTUI(App):
             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(SuccessMessages.TERMINAL_COPY_HINT)
 
@@ -551,7 +578,7 @@ class VMManagerTUI(App):
                         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
@@ -582,7 +609,7 @@ class VMManagerTUI(App):
 
         except Exception as e:
             self.call_from_thread(
-                self.show_error_message, 
+                self.show_error_message,
                 ErrorMessages.ERROR_DURING_INITIAL_CACHE_LOADING.format(error=e)
             )
 
@@ -633,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
@@ -1155,6 +1182,13 @@ class VMManagerTUI(App):
                 )
             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:
@@ -1257,7 +1291,7 @@ class VMManagerTUI(App):
 
                     if result:
                         vm_info, domain, conn = result
-                        from modals.vmdetails_modals import VMDetailModal # Import here to avoid circular dep if any
+                        from .modals.vmdetails_modals import VMDetailModal # Import here to avoid circular dep if any
 
                         self.push_screen(
                             VMDetailModal(
@@ -1292,7 +1326,7 @@ class VMManagerTUI(App):
 
     def _perform_bulk_action_worker(self, action_type: str, vm_uuids: list[str], delete_storage_flag: bool = False) -> None:
         """Worker function to orchestrate a bulk action using the VMService."""
-
+        bulk_failed = False
         # Stop workers for all selected VMs to prevent conflicts
         for uuid in vm_uuids:
             vm_card = self.vm_card_pool.active_cards.get(uuid)
@@ -1320,11 +1354,13 @@ 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:
+                bulk_failed = False
                 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:
+                bulk_failed = True
                 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:
@@ -1337,7 +1373,8 @@ class VMManagerTUI(App):
             # Unlock immediately so UI is not stuck if refresh fails
             def unlock_and_refresh():
                 self.bulk_operation_in_progress = False
-                self.refresh_vm_list(force=True)
+                if bulk_failed is False:
+                    self.refresh_vm_list(force=True)
 
             self.call_from_thread(unlock_and_refresh)
 
@@ -1352,6 +1389,13 @@ class VMManagerTUI(App):
 
     def refresh_vm_list(self, force: bool = False, optimize_for_current_page: bool = False, on_complete: Callable | None = None) -> None:
         """Refreshes the list of VMs by running the fetch-and-display logic in a worker."""
+        # Prevent refresh during bulk operations to maintain UI stability
+        if self.bulk_operation_in_progress:
+            logging.debug("Skipping refresh_vm_list because bulk operation is in progress.")
+            if on_complete:
+                on_complete()
+            return
+
         # Don't display VMs until initial cache is complete
         if self.initial_cache_loading and not self.initial_cache_complete:
             return
@@ -1391,6 +1435,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
@@ -1453,13 +1503,15 @@ class VMManagerTUI(App):
                         cpu = 0
                         memory = 0
 
+                    simple_uuid = uuid.split('@')[0] if '@' in uuid else uuid
+
                     return {
                         'uuid': uuid,
                         'name': vm_name,
                         'status': status,
                         'cpu': cpu,
                         'memory': memory,
-                        'is_selected': uuid in selected_uuids,
+                        'is_selected': simple_uuid in selected_uuids,
                         'domain': domain,
                         'conn': conn,
                         'uri': uri
@@ -1557,12 +1609,14 @@ class VMManagerTUI(App):
                     card.name = data['name']
                     card.cpu = data['cpu']
                     card.memory = data['memory']
-                    card.is_selected = data['is_selected']
+                    
                     card.server_border_color = self.get_server_color(data['uri'])
                     card.status = data['status']
                     card.internal_id = uuid
                     card.compact_view = self.compact_view
 
+                    card.is_selected = data['is_selected']
+
                 # Mount any new cards
                 if cards_to_mount:
                     vms_container.mount(*cards_to_mount)
@@ -1826,7 +1880,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():
@@ -1846,15 +1900,46 @@ 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."""
+    if is_running_under_flatpak():
+        ldir = "/app/share/locale"
+    else:
+        if not os.path.exists("locale"):
+            # Installed on the system
+            ldir = "/usr/share/locale"
+        else:
+            # Devel version from git
+            ldir = "locale"
+
     parser = argparse.ArgumentParser(description="A Textual application to manage VMs.")
     parser.add_argument("--cmd", action="store_true", help="Run in command-line interpreter mode.")
     args = parser.parse_args()
 
     if args.cmd:
-        from vmanager_cmd import VManagerCMD
+        from .vmanager_cmd import VManagerCMD
         VManagerCMD().cmdloop()
     else:
         terminal_size = os.get_terminal_size()

vmanager/vmcard.css

@@ -61,7 +61,7 @@ VMCard {
 
 #status, Button, .Buttonpage, #xml, #snapshot_take,
 #snapshot_restore, #snapshot_delete, .button-separator,
-#connect, #create_overlay, #commit_disk, #discard_overlay {
+#connect, #create_overlay, #commit_disk, #discard_overlay, #tmux_console {
   height: 1;
   padding: 0;
 }
@@ -134,6 +134,8 @@ Button {
 #pause:hover { background: #FFD700; }
 #connect { background: red; }
 #connect:hover { background: #FF4500; }
+#tmux_console { background: #008080; }
+#tmux_console:hover { background: #20B2AA; }
 #create_overlay { background: green; }
 #create_overlay:hover { background: lightgreen; }
 #commit_disk { background: #0000FF; }
@@ -156,3 +158,19 @@ Button {
   margin: 0 0;
   padding: 0 0;
 }
+
+.name-box {
+    height: 2;
+}
+
+.quick-actions {
+    width: 8;
+    height: 2;
+    padding: 0 0;
+}
+.btn-small {
+    min-width: 2;
+    height: 1;
+    border: none;
+    padding: 0 0;
+}