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

vmanager/vmcard.py

@@ -28,7 +28,7 @@ from .vm_actions import (
         clone_vm, rename_vm, create_vm_snapshot,
         restore_vm_snapshot, delete_vm_snapshot,
         create_external_overlay, commit_disk_changes,
-        discard_overlay, delete_vm
+        discard_overlay, delete_vm, hibernate_vm
         )
 
 from .vm_queries import (
@@ -51,6 +51,7 @@ from .utils import (
         extract_server_name_from_uri,
         generate_tooltip_markdown,
         remote_viewer_cmd,
+        check_tmux,
 )
 from .constants import (
     ButtonLabels, TabTitles, StatusText,
@@ -66,12 +67,14 @@ class VMCardActions(Static):
     def compose(self):
         self.card.ui["start"] = Button(ButtonLabels.START, id="start", variant="success")
         self.card.ui["shutdown"] = Button(ButtonLabels.SHUTDOWN, id="shutdown", variant="primary")
+        self.card.ui["hibernate"] = Button(ButtonLabels.HIBERNATE_VM, id="hibernate", variant="primary")
         self.card.ui["stop"] = Button(ButtonLabels.FORCE_OFF, id="stop", variant="error")
         self.card.ui["pause"] = Button(ButtonLabels.PAUSE, id="pause", variant="primary")
         self.card.ui["resume"] = Button(ButtonLabels.RESUME, id="resume", variant="success")
         self.card.ui["configure-button"] = Button(ButtonLabels.CONFIGURE, id="configure-button", variant="primary")
         self.card.ui["web_console"] = Button(ButtonLabels.WEB_CONSOLE, id="web_console", variant="default")
         self.card.ui["connect"] = Button(ButtonLabels.CONNECT, id="connect", variant="default")
+        self.card.ui["tmux_console"] = Button(ButtonLabels.TEXT_CONSOLE, id="tmux_console", variant="default")
         
         self.card.ui["snapshot_take"] = Button(ButtonLabels.SNAPSHOT, id="snapshot_take", variant="primary")
         self.card.ui["snapshot_restore"] = Button(ButtonLabels.RESTORE_SNAPSHOT, id="snapshot_restore", variant="primary")
@@ -100,16 +103,18 @@ class VMCardActions(Static):
                         yield self.card.ui["pause"]
                         yield self.card.ui["resume"]
                     with Vertical():
-                        yield self.card.ui["configure-button"]
                         yield self.card.ui["web_console"]
                         yield self.card.ui["connect"]
-            with TabPane(self.card._get_snapshot_tab_title(num_snapshots=0), id="snapshot-tab"):
+                        if os.environ.get("TMUX") and check_tmux():
+                            yield self.card.ui["tmux_console"]
+            with TabPane(TabTitles.STATE_MANAGEMENT, id="snapshot-tab"):
                 with Horizontal():
                     with Vertical():
                         yield self.card.ui["snapshot_take"]
                         yield self.card.ui["snapshot_restore"]
                         yield self.card.ui["snapshot_delete"]
                     with Vertical():
+                        yield self.card.ui["hibernate"]
                         yield self.card.ui["create_overlay"]
                         yield self.card.ui["commit_disk"]
                         yield self.card.ui["discard_overlay"]
@@ -122,6 +127,7 @@ class VMCardActions(Static):
                         yield self.card.ui["clone"]
                         yield self.card.ui["migration"]
                     with Vertical():
+                        yield self.card.ui["configure-button"]
                         yield self.card.ui["xml"]
                         yield Static(classes="button-separator")
                         yield self.card.ui["rename-button"]
@@ -184,21 +190,19 @@ class VMCard(Static):
     def _get_snapshot_tab_title(self, num_snapshots: int = -1) -> str:
         """Get snapshot tab title. Pass num_snapshots to avoid blocking libvirt call."""
         if num_snapshots == -1:
-             # If no count provided, don't fetch it here to avoid blocking.
-             # For now, return default if we can't get it cheaply.
-             return TabTitles.SNAP_OVER_UPDATE # TabTitles.SNAPSHOT + "/" + TabTitles.OVERLAY
+            # If no count provided, don't fetch it here to avoid blocking.
+            # For now, return default if we can't get it cheaply.
+            return TabTitles.SNAP_OVER_UPDATE
 
         if self.vm:
             try:
-                if num_snapshots == 0:
-                    return TabTitles.SNAPSHOT + "/" + TabTitles.OVERLAY
-                elif num_snapshots == 1:
-                    return TabTitles.SNAPSHOT + "(" + str(num_snapshots) + ")" + "/" + TabTitles.OVERLAY
-                elif num_snapshots >= 2:
-                    return TabTitles.SNAPSHOTS + "(" + str(num_snapshots) + ")" "/" + TabTitles.OVERLAY
+                if num_snapshots <= 0:
+                    return TabTitles.STATE_MANAGEMENT
+                else:
+                    return f"{TabTitles.STATE_MANAGEMENT}({num_snapshots})"
             except libvirt.libvirtError:
                 pass # Domain might be transient or invalid
-        return TabTitles.SNAPSHOT + "/" + TabTitles.OVERLAY
+        return TabTitles.STATE_MANAGEMENT
 
     def update_snapshot_tab_title(self, num_snapshots: int = -1) -> None:
         """Updates the snapshot tab title."""
@@ -342,7 +346,7 @@ class VMCard(Static):
         """Updates the tooltip for the VM name using Markdown."""
         if not self.display or not self.ui or "vmname" not in self.ui:
             return
-        
+
         uuid = self.internal_id
         if not uuid:
             return
@@ -388,7 +392,7 @@ class VMCard(Static):
             if ips:
                 ip_display = ", ".join(ips)
 
-        cpu_model_display = f" ({self.cpu_model})" if self.cpu_model else ""
+        cpu_model_display = f" {self.cpu_model}" if self.cpu_model else ""
 
         tooltip_md = generate_tooltip_markdown(
             uuid=uuid_display,
@@ -397,7 +401,7 @@ class VMCard(Static):
             ip=ip_display,
             boot=self.boot_device or "N/A",
             cpu=self.cpu,
-            cpu_model=self.cpu_model or "",
+            cpu_model=cpu_model_display or "",
             memory=self.memory
         )
 
@@ -576,8 +580,7 @@ class VMCard(Static):
                 logging.warning(f"Could not find #info-container on VMCard {self.name} when switching to detailed view.")
             except Exception as e:
                 # Catch-all for potential mounting errors (e.g. already mounted elsewhere?)
-                 logging.warning(f"Error restoring collapsible in detailed view: {e}")
-
+                logging.warning(f"Error restoring collapsible in detailed view: {e}")
 
             # Ensure sparklines visibility is correct
             self.watch_stats_view_mode(self.stats_view_mode, self.stats_view_mode)
@@ -890,6 +893,7 @@ class VMCard(Static):
 
         self.ui["start"].display = is_stopped
         self.ui["shutdown"].display = is_running or is_blocked
+        self.ui["hibernate"].display = is_running or is_blocked
         self.ui["stop"].display = is_running or is_paused or is_pmsuspended or is_blocked
         self.ui["delete"].display = is_running or is_paused or is_stopped or is_pmsuspended or is_blocked
         self.ui["clone"].display = is_stopped
@@ -993,7 +997,7 @@ class VMCard(Static):
 
             def update_ui():
                 self._update_slow_buttons(snapshot_summary, has_overlay)
-            
+
             try:
                 self.app.call_from_thread(update_ui)
             except RuntimeError:
@@ -1065,12 +1069,14 @@ class VMCard(Static):
 
         button_handlers = {
             "shutdown": self._handle_shutdown_button,
+            "hibernate": self._handle_hibernate_button,
             "stop": self._handle_stop_button,
             "pause": self._handle_pause_button,
             "resume": self._handle_resume_button,
             "xml": self._handle_xml_button,
             "connect": self._handle_connect_button,
             "web_console": self._handle_web_console_button,
+            "tmux_console": self._handle_tmux_console_button,
             "snapshot_take": self._handle_snapshot_take_button,
             "snapshot_restore": self._handle_snapshot_restore_button,
             "snapshot_delete": self._handle_snapshot_delete_button,
@@ -1243,6 +1249,27 @@ class VMCard(Static):
         if self.status in (StatusText.RUNNING, StatusText.PAUSED):
             self.post_message(VmActionRequest(self.internal_id, VmAction.STOP))
 
+    def _handle_hibernate_button(self, event: Button.Pressed) -> None:
+        """Handles the save button press."""
+        logging.info(f"Attempting to save (hibernate) VM: {self.name}")
+
+        def do_save():
+            self.stop_background_activities()
+            self.app.vm_service.suppress_vm_events(self.internal_id)
+            try:
+                hibernate_vm(self.vm)
+                self.app.call_from_thread(self.app.show_success_message, SuccessMessages.VM_SAVED_TEMPLATE.format(vm_name=self.name))
+                self.app.vm_service.invalidate_vm_state_cache(self.internal_id)
+                self.app.call_from_thread(setattr, self, 'status', StatusText.STOPPED)
+                self.app.call_from_thread(self.update_button_layout)
+            except Exception as e:
+                self.app.call_from_thread(self.app.show_error_message, ErrorMessages.ERROR_ON_VM_DURING_ACTION.format(vm_name=self.name, action='save', error=e))
+            finally:
+                self.app.vm_service.unsuppress_vm_events(self.internal_id)
+
+        if self.status in (StatusText.RUNNING, StatusText.PAUSED):
+            self.app.worker_manager.run(do_save, name=f"save_{self.internal_id}")
+
     def stop_background_activities(self):
         """ Stop background activities before action """
         with self._timer_lock:
@@ -1324,7 +1351,7 @@ class VMCard(Static):
                             self.app.refresh_vm_list()
                         except libvirt.libvirtError as e:
                             self.app.show_error_message(ErrorMessages.INVALID_XML_TEMPLATE.format(vm_name=self.name, error=e))
-                            logging.error(error_msg)
+                            logging.error(e)
                     else:
                         self.app.show_success_message(SuccessMessages.NO_XML_CHANGES)
 
@@ -1430,6 +1457,50 @@ class VMCard(Static):
         else:
             self.app.worker_manager.run(worker, name=f"start_console_{self.vm.name()}")
 
+    def _handle_tmux_console_button(self, event: Button.Pressed) -> None:
+        """Handles the text console button press by opening a new tmux window."""
+        logging.info(f"Attempting to open text console for VM: {self.name}")
+
+        # Check if running in tmux
+        if not os.environ.get("TMUX"):
+             self.app.show_error_message("This feature requires running inside tmux.")
+             return
+
+        try:
+             # Use cached values to avoid libvirt calls where possible
+            uri = self.app.vm_service.get_uri_for_connection(self.conn)
+            if not uri:
+                uri = self.conn.getURI()
+
+            # Get proper domain name
+            _, domain_name = self.app.vm_service.get_vm_identity(self.vm, self.conn)
+
+            # Construct command
+            # tmux new-window -n "Console: <vm_name>" "virsh -c <uri> console <vm_name>; read"
+            help_msg = (
+                "echo '---------------------------------------------------------'; "
+                "echo 'Tmux Navigation Help:'; "
+                "echo ' Ctrl+B N or P - Move to the next or previous window.'; "
+                "echo ' Ctrl+B W      - Open a panel to navigate across windows in multiple sessions.'; "
+                "echo ' Ctrl+]        - Close the current view.'; "
+                "echo ' Ctrl+B ?      - View all keybindings. Press Q to exit.';"
+                "echo '---------------------------------------------------------'; "
+                "echo 'Starting console...'; sleep 1;"
+            )
+            cmd = [
+                "tmux", "new-window",
+                "-n", f"{domain_name}",
+                f"{help_msg} virsh -c {uri} console {domain_name}; echo '\nConsole session ended. Press Enter to close window.'; read"
+            ]
+
+            logging.info(f"Launching tmux console: {' '.join(cmd)}")
+            subprocess.Popen(cmd)
+            self.app.show_quick_message(f"Opened console for {domain_name}")
+
+        except Exception as e:
+            logging.error(f"Failed to open tmux console: {e}")
+            self.app.show_error_message(f"Failed to open console: {e}")
+
     def _handle_snapshot_take_button(self, event: Button.Pressed) -> None:
         """Handles the snapshot take button press."""
         logging.info(f"Attempting to take snapshot for VM: {self.name}")
@@ -1922,8 +1993,6 @@ class VMCard(Static):
                 finally:
                     self.app.vm_service.unsuppress_vm_events(internal_id)
 
-            num_snapshots = self.vm.snapshotNum(0)
-
             def on_confirm_rename(confirmed: bool, delete_snapshots=False) -> None:
                 if confirmed:
                     do_rename()
@@ -1960,10 +2029,10 @@ class VMCard(Static):
             def get_details_worker():
                 try:
                     result = self.app.vm_service.get_vm_details(
-                        active_uris, 
-                        uuid, 
-                        domain=vm_obj, 
-                        conn=conn_obj, 
+                        active_uris,
+                        uuid,
+                        domain=vm_obj,
+                        conn=conn_obj,
                         cached_ips=cached_ips
                     )
 
@@ -1975,22 +2044,27 @@ class VMCard(Static):
 
                         vm_info, domain, conn_for_domain = result
 
-                        def on_detail_modal_dismissed(res):
+                        def on_detail_modal_dismissed(_=None):
                             self.post_message(VmCardUpdateRequest(self.internal_id))
                             self._perform_tooltip_update()
 
                         self.app.push_screen(
-                            VMDetailModal(vm_name, vm_info, domain, conn_for_domain, self.app.vm_service.invalidate_vm_state_cache),
+                            VMDetailModal(
+                                vm_name,
+                                vm_info,
+                                domain,
+                                conn_for_domain,
+                                self.app.vm_service.invalidate_vm_state_cache),
                             on_detail_modal_dismissed
-                        )
+                            )
 
                     self.app.call_from_thread(show_details)
 
                 except Exception as e:
-                    def show_error():
+                    def show_error(error_instance):
                         loading_modal.dismiss()
-                        self.app.show_error_message(ErrorMessages.ERROR_GETTING_VM_DETAILS_TEMPLATE.format(vm_name=vm_name, error=e))
-                    self.app.call_from_thread(show_error)
+                        self.app.show_error_message(ErrorMessages.ERROR_GETTING_VM_DETAILS_TEMPLATE.format(vm_name=vm_name, error=error_instance))
+                    self.app.call_from_thread(show_error, e)
 
             self.app.worker_manager.run(get_details_worker, name=f"get_details_{uuid}")
 
@@ -2003,27 +2077,16 @@ class VMCard(Static):
             self.app.show_error_message(ErrorMessages.SELECT_AT_LEAST_TWO_SERVERS_FOR_MIGRATION)
             return
 
-        selected_vm_uuids = self.app.selected_vm_uuids
+        selected_vm_uuids = list(self.app.selected_vm_uuids)
         selected_vms = []
         if selected_vm_uuids:
+            found_domains_dict = self.app.vm_service.find_domains_by_uuids(self.app.active_uris, selected_vm_uuids)
             for uuid in selected_vm_uuids:
-                #Use cached domain lookup instead of iterating all URIs
-                with self.app.vm_service._cache_lock:
-                    domain = self.app.vm_service._domain_cache.get(uuid)
-
+                domain = found_domains_dict.get(uuid)
                 if domain:
-                    try:
-                        # Verify domain is still valid
-                        domain.info()
-                        selected_vms.append(domain)
-                        found_domain = True
-                    except libvirt.libvirtError:
-                        found_domain = False
+                    selected_vms.append(domain)
                 else:
-                    found_domain = False
-            if not vm_info:
-                self.app.show_error_message(ErrorMessages.SELECTED_VM_NOT_FOUND_ON_ACTIVE_SERVER_TEMPLATE.format(uuid=uuid))
-
+                    self.app.show_error_message(ErrorMessages.SELECTED_VM_NOT_FOUND_ON_ACTIVE_SERVER_TEMPLATE.format(uuid=uuid))
         if not selected_vms:
             selected_vms = [self.vm]
 
@@ -2053,7 +2116,7 @@ class VMCard(Static):
                     state, _ = state_tuple
                     if state in [libvirt.VIR_DOMAIN_RUNNING, libvirt.VIR_DOMAIN_PAUSED]:
                         active_vms.append(vm)
-            except:
+            except Exception:
                 # Fallback to isActive() if cache lookup fails
                 if vm.isActive():
                     active_vms.append(vm)
@@ -2118,7 +2181,7 @@ class VMCard(Static):
             try:
                 # Use vm_service to get XML (handles caching)
                 self.app.vm_service._get_domain_xml(self.vm, internal_id=self.internal_id)
-                
+
                 # Update tooltip on main thread
                 self.app.call_from_thread(self._perform_tooltip_update)
                 self.app.call_from_thread(self.app.show_quick_message, f"Info refreshed for {self.name}")

vmanager/webconsole_manager.py

@@ -17,7 +17,7 @@ from urllib.parse import urlparse
 
 import libvirt
 
-from .constants import AppInfo
+from .constants import AppInfo, ErrorMessages, SuccessMessages
 from .events import VmCardUpdateRequest
 from .config import load_config, get_log_path
 from .vm_queries import get_vm_graphics_info