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

vmanager/modals/xml_modals.py

@@ -6,6 +6,7 @@ from textual.widgets import Button, TextArea
 from textual.widgets.text_area import LanguageDoesNotExist
 from textual.containers import Vertical, Horizontal
 from .base_modals import BaseModal
+from ..constants import ButtonLabels
 
 class XMLDisplayModal(BaseModal[str | None]):
     """A modal screen for displaying and editing XML."""
@@ -32,8 +33,8 @@ class XMLDisplayModal(BaseModal[str | None]):
             with Vertical(id="dialog-buttons"):
                 with Horizontal():
                     if not self.read_only:
-                        yield Button("Save", variant="primary", id="save-btn")
-                    yield Button("Close", id="close-btn")
+                        yield Button(ButtonLabels.SAVE, variant="primary", id="save-btn")
+                    yield Button(ButtonLabels.CLOSE, id="close-btn")
 
     def on_mount(self) -> None:
         self.query_one(TextArea).focus()

vmanager/network_manager.py

@@ -9,6 +9,7 @@ import xml.etree.ElementTree as ET
 from functools import lru_cache
 import libvirt
 from .utils import log_function_call
+from .libvirt_utils import get_host_domain_capabilities
 
 
 @lru_cache(maxsize=16)
@@ -246,7 +247,9 @@ def get_host_network_info(conn: libvirt.virConnect):
     """
     networks = []
     try:
-        caps_xml = conn.getCapabilities()
+        caps_xml = get_host_domain_capabilities(conn)
+        if not caps_xml:
+            return networks
         root = ET.fromstring(caps_xml)
         for interface in root.findall(".//interface"):
             ip_elem = interface.find("ip")

vmanager/storage_manager.py

@@ -16,6 +16,119 @@ from .libvirt_utils import (
         )
 from .vm_queries import get_vm_disks_info
 
+
+def _safe_is_pool_active(pool: libvirt.virStoragePool) -> bool:
+    """
+    Safely check if a storage pool is active without blocking the UI.
+    Returns False if the check fails or times out.
+    """
+    try:
+        return pool.isActive()
+    except libvirt.libvirtError as e:
+        logging.debug(f"Failed to check if pool '{pool.name()}' is active: {e}")
+        return False
+    except Exception as e:
+        logging.debug(f"Unexpected error checking pool '{pool.name()}' status: {e}")
+        return False
+
+
+def _ensure_pool_active(pool: libvirt.virStoragePool) -> bool:
+    """
+    Ensure a storage pool is active. If not active, try to activate it.
+    Returns True if pool is active (or was successfully activated), False otherwise.
+    """
+    if _safe_is_pool_active(pool):
+        return True
+    
+    try:
+        logging.info(f"Pool '{pool.name()}' is not active, attempting to activate...")
+        pool.create(0)
+        return True
+    except libvirt.libvirtError as e:
+        logging.error(f"Failed to activate pool '{pool.name()}': {e}")
+        return False
+    except Exception as e:
+        logging.error(f"Unexpected error activating pool '{pool.name()}': {e}")
+        return False
+
+
+def _safe_get_pool_info(pool: libvirt.virStoragePool) -> tuple:
+    """
+    Safely get pool info without blocking the UI.
+    Returns (capacity, allocation, available) or (0, 0, 0) on failure.
+    """
+    try:
+        info = pool.info()
+        return info[1], info[2], info[3]  # capacity, allocation, available
+    except libvirt.libvirtError as e:
+        logging.debug(f"Failed to get info for pool '{pool.name()}': {e}")
+        return 0, 0, 0
+    except Exception as e:
+        logging.debug(f"Unexpected error getting info for pool '{pool.name()}': {e}")
+        return 0, 0, 0
+
+
+def _safe_get_pool_autostart(pool: libvirt.virStoragePool) -> bool:
+    """
+    Safely get pool autostart setting without blocking the UI.
+    Returns False on failure.
+    """
+    try:
+        return pool.autostart() == 1
+    except libvirt.libvirtError as e:
+        logging.debug(f"Failed to get autostart for pool '{pool.name()}': {e}")
+        return False
+    except Exception as e:
+        logging.debug(f"Unexpected error getting autostart for pool '{pool.name()}': {e}")
+        return False
+
+
+def _safe_refresh_pool(pool: libvirt.virStoragePool) -> bool:
+    """
+    Safely refresh a storage pool without blocking the UI.
+    Returns True on success, False on failure.
+    """
+    try:
+        pool.refresh(0)
+        return True
+    except libvirt.libvirtError as e:
+        logging.debug(f"Failed to refresh pool '{pool.name()}': {e}")
+        return False
+    except Exception as e:
+        logging.debug(f"Unexpected error refreshing pool '{pool.name()}': {e}")
+        return False
+
+
+def _safe_get_volume_info(vol: libvirt.virStorageVol) -> tuple:
+    """
+    Safely get volume info without blocking the UI.
+    Returns (type, capacity, allocation) or (0, 0, 0) on failure.
+    """
+    try:
+        vol_type, capacity, allocation = _safe_get_volume_info(vol)
+        return vol_type, capacity, allocation
+    except libvirt.libvirtError as e:
+        logging.debug(f"Failed to get info for volume '{vol.name()}': {e}")
+        return 0, 0, 0
+    except Exception as e:
+        logging.debug(f"Unexpected error getting info for volume '{vol.name()}': {e}")
+        return 0, 0, 0
+
+
+def _safe_get_volume_path(vol: libvirt.virStorageVol) -> str:
+    """
+    Safely get volume path without blocking the UI.
+    Returns empty string on failure.
+    """
+    try:
+        return vol.path()
+    except libvirt.libvirtError as e:
+        logging.debug(f"Failed to get path for volume '{vol.name()}': {e}")
+        return ""
+    except Exception as e:
+        logging.debug(f"Unexpected error getting path for volume '{vol.name()}': {e}")
+        return ""
+
 @lru_cache(maxsize=16)
 def list_storage_pools(conn: libvirt.virConnect) -> List[Dict[str, Any]]:
     """
@@ -35,15 +148,17 @@ def list_storage_pools(conn: libvirt.virConnect) -> List[Dict[str, Any]]:
                 except libvirt.libvirtError:
                     name = "Unknown Pool"
 
-                is_active = pool.isActive()
-                info = pool.info()
+                is_active = _safe_is_pool_active(pool)
+                capacity, allocation, _ = _safe_get_pool_info(pool)
+                autostart = _safe_get_pool_autostart(pool)
+                
                 pools_info.append({
                     'name': name,
                     'pool': pool,
                     'status': 'active' if is_active else 'inactive',
-                    'autostart': pool.autostart() == 1,
-                    'capacity': info[1],
-                    'allocation': info[2],
+                    'autostart': autostart,
+                    'capacity': capacity,
+                    'allocation': allocation,
                 })
             except libvirt.libvirtError as e:
                 # If we fail to get details (e.g. NFS down), still list the pool but as unavailable
@@ -74,7 +189,7 @@ def list_storage_volumes(pool: libvirt.virStoragePool) -> List[Dict[str, Any]]:
     Lists all storage volumes in a given pool.
     """
     volumes_info = []
-    if not pool or not pool.isActive():
+    if not pool or not _safe_is_pool_active(pool):
         return volumes_info
 
     try:
@@ -82,13 +197,13 @@ def list_storage_volumes(pool: libvirt.virStoragePool) -> List[Dict[str, Any]]:
         for name in vol_names:
             try:
                 vol = pool.storageVolLookupByName(name)
-                info = vol.info() # type, capacity, allocation
+                vol_type, capacity, allocation = _safe_get_volume_info(vol)
                 volumes_info.append({
                     'name': name,
                     'volume': vol,
-                    'type': info[0],
-                    'capacity': info[1],
-                    'allocation': info[2],
+                    'type': vol_type,
+                    'capacity': capacity,
+                    'allocation': allocation,
                 })
             except libvirt.libvirtError:
                 continue
@@ -178,8 +293,8 @@ def create_volume(pool: libvirt.virStoragePool, name: str, size_gb: int, vol_for
     """
     Creates a new storage volume in a pool.
     """
-    if not pool.isActive():
-        msg = f"Pool '{pool.name()}' is not active."
+    if not _ensure_pool_active(pool):
+        msg = f"Pool '{pool.name()}' is not active and could not be activated."
         logging.error(msg)
         raise Exception(msg)
 
@@ -252,8 +367,8 @@ def attach_volume(pool: libvirt.virStoragePool, name: str, path: str, vol_format
     """
     Attaches an existing file as a storage volume in a pool.
     """
-    if not pool.isActive():
-        msg = f"Pool '{pool.name()}' is not active."
+    if not _ensure_pool_active(pool):
+        msg = f"Pool '{pool.name()}' is not active and could not be activated."
         logging.error(msg)
         raise Exception(msg)
 
@@ -309,7 +424,7 @@ def attach_volume(pool: libvirt.virStoragePool, name: str, path: str, vol_format
 
     try:
         # Refresh the pool to make sure libvirt knows about the file if it was just copied.
-        pool.refresh(0)
+        _safe_refresh_pool(pool)
         vol = pool.storageVolLookupByName(name)
         if vol:
             logging.warning(f"Volume '{name}' already exists in pool '{pool.name()}'. Not creating.")
@@ -320,7 +435,7 @@ def attach_volume(pool: libvirt.virStoragePool, name: str, path: str, vol_format
     try:
         pool.createXML(vol_xml, 0)
         # Refresh again after creating the volume from XML
-        pool.refresh(0)
+        _safe_refresh_pool(pool)
     except libvirt.libvirtError as e:
         # If creation fails, attempt to clean up the copied file
         if pool_type == 'dir' and 'dest_path' in locals() and os.path.exists(dest_path):
@@ -336,8 +451,8 @@ def create_overlay_volume(pool: libvirt.virStoragePool, name: str, backing_vol_p
     Creates a qcow2 overlay volume backed by another volume (backing file).
     The new volume will record changes, while the backing file remains untouched.
     """
-    if not pool.isActive():
-        msg = f"Pool '{pool.name()}' is not active."
+    if not _ensure_pool_active(pool):
+        msg = f"Pool '{pool.name()}' is not active and could not be activated."
         logging.error(msg)
         raise Exception(msg)
 
@@ -347,7 +462,7 @@ def create_overlay_volume(pool: libvirt.virStoragePool, name: str, backing_vol_p
     if not backing_vol:
         raise Exception(f"Could not find backing volume for path '{backing_vol_path}' to determine capacity.")
 
-    capacity = backing_vol.info()[1]
+    _, capacity, _ = _safe_get_volume_info(backing_vol)
 
     vol_xml = f"""
     <volume>
@@ -418,7 +533,7 @@ def find_vms_using_volume(conn: libvirt.virConnect, vol_path: str, vol_name: str
                         try:
                             p = conn.storagePoolLookupByName(pool_name)
                             v = p.storageVolLookupByName(volume_name_from_xml)
-                            if v.path() == vol_path:
+                            if _safe_get_volume_path(v) == vol_path:
                                 vms_using_volume.append(domain)
                                 break  # Found it, move to the next domain
                         except libvirt.libvirtError:
@@ -486,11 +601,11 @@ def move_volume(conn: libvirt.virConnect, source_pool_name: str, dest_pool_name:
     source_vol = source_pool.storageVolLookupByName(volume_name)
 
     # Check for available space before starting the move
-    source_info = source_vol.info()
-    source_capacity = source_info[1]  # in bytes
+    _, source_capacity, _ = _safe_get_volume_info(source_vol)  # in bytes
 
     # Check if the volume is in use by any running VMs before starting the move
-    vms_using_volume = find_vms_using_volume(conn, source_vol.path(), source_vol.name())
+    source_path = _safe_get_volume_path(source_vol)
+    vms_using_volume = find_vms_using_volume(conn, source_path, source_vol.name())
     running_vms = [vm.name() for vm in vms_using_volume if vm.state()[0] == libvirt.VIR_DOMAIN_RUNNING]
 
     if running_vms:
@@ -501,8 +616,7 @@ def move_volume(conn: libvirt.virConnect, source_pool_name: str, dest_pool_name:
     if vms_using_volume:
         log_and_callback(f"Volume is used by offline VM(s):\n{[vm.name() for vm in vms_using_volume]}.\nTheir configuration will be updated after the move.\nWait Until the process is finished (can take a lot of time).")
 
-    source_info = source_vol.info()
-    source_capacity = source_info[1]
+    _, source_capacity, _ = _safe_get_volume_info(source_vol)
     source_format = "qcow2"  # Default
     try:
         source_format = ET.fromstring(source_vol.XMLDesc(0)).findtext("target/format[@type]", "qcow2")
@@ -626,11 +740,11 @@ def move_volume(conn: libvirt.virConnect, source_pool_name: str, dest_pool_name:
 
         # Refresh destination pool to make the new volume visible
         log_and_callback(f"Refreshing destination pool '{dest_pool.name()}'...")
-        dest_pool.refresh(0)
+        _safe_refresh_pool(dest_pool)
 
         # Update any VM configurations that use this volume
-        old_path = source_vol.path()
-        new_path = new_vol.path()
+        old_path = _safe_get_volume_path(source_vol)
+        new_path = _safe_get_volume_path(new_vol)
         old_pool_name = source_pool.name()
         new_pool_name = dest_pool.name()
 
@@ -673,7 +787,7 @@ def move_volume(conn: libvirt.virConnect, source_pool_name: str, dest_pool_name:
 
         # Refresh source pool to remove the old volume from listings
         log_and_callback(f"Refreshing source pool '{source_pool.name()}'...")
-        source_pool.refresh(0)
+        _safe_refresh_pool(source_pool)
         log_and_callback("\nMove Finished, you can close this window")
 
     except Exception as e:
@@ -708,8 +822,12 @@ def delete_storage_pool(pool: libvirt.virStoragePool):
     """
     try:
         # If pool is active, destroy it first (make it inactive)
-        if pool.isActive():
-            pool.destroy()
+        if _safe_is_pool_active(pool):
+            try:
+                pool.destroy()
+            except libvirt.libvirtError as e:
+                logging.warning(f"Failed to destroy active pool '{pool.name()}': {e}")
+                # Continue with undefine even if destroy fails
         # Undefine the pool (delete it)
         pool.undefine()
     except libvirt.libvirtError as e:
@@ -729,7 +847,7 @@ def get_all_storage_volumes(conn: libvirt.virConnect) -> List[libvirt.virStorage
     pools_info = list_storage_pools(conn)
     for pool_info in pools_info:
         pool = pool_info['pool']
-        if pool.isActive():
+        if _safe_is_pool_active(pool):
             try:
                 all_volumes.extend(pool.listAllVolumes())
             except libvirt.libvirtError:
@@ -749,7 +867,7 @@ def list_unused_volumes(conn: libvirt.virConnect, pool_name: str = None) -> List
     if pool_name:
         try:
             pool = conn.storagePoolLookupByName(pool_name)
-            if not pool.isActive():
+            if not _safe_is_pool_active(pool):
                 return []
             all_volumes = pool.listAllVolumes()
         except libvirt.libvirtError:
@@ -795,7 +913,8 @@ def list_unused_volumes(conn: libvirt.virConnect, pool_name: str = None) -> List
 
     unused_volumes = []
     for vol in all_volumes:
-        if vol.path() not in used_disk_paths:
+        vol_path = _safe_get_volume_path(vol)
+        if vol_path and vol_path not in used_disk_paths:
             unused_volumes.append(vol)
 
     return unused_volumes
@@ -916,8 +1035,7 @@ def copy_volume_across_hosts(source_conn: libvirt.virConnect, dest_conn: libvirt
         log_and_callback(f"[red]ERROR:[/ ] Could not find source/destination resources: {e}")
         raise
 
-    source_info = source_vol.info()
-    source_capacity = source_info[1]
+    _, source_capacity, _ = _safe_get_volume_info(source_vol)
     source_format = "qcow2"
     try:
         source_format = ET.fromstring(source_vol.XMLDesc(0)).findtext("target/format[@type]", "qcow2")
@@ -1093,13 +1211,13 @@ def copy_volume_across_hosts(source_conn: libvirt.virConnect, dest_conn: libvirt
             if upload_error: raise upload_error
 
         log_and_callback("Transfer complete.")
-        dest_pool.refresh(0)
+        _safe_refresh_pool(dest_pool)
 
         return {
-            "old_disk_path": source_vol.path(),
+            "old_disk_path": _safe_get_volume_path(source_vol),
             "new_pool_name": dest_pool.name(),
             "new_volume_name": dest_vol.name(),
-            "new_disk_path": dest_vol.path(),
+            "new_disk_path": _safe_get_volume_path(dest_vol),
         }
 
     except Exception as e:

vmanager/utils.py

@@ -268,6 +268,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.
@@ -428,9 +442,9 @@ class CacheMonitor:
     def log_stats(self) -> None:
         """Log cache statistics."""
         stats = self.get_all_stats()
-        logging.info("=== Cache Statistics ===")
+        logging.debug("=== Cache Statistics ===")
         for name, data in stats.items():
-            logging.info(
+            logging.debug(
                 f"{name}: {data['hit_rate']:.1f}% hit rate "
                 f"({data['hits']} hits, {data['misses']} misses, "
                 f"{data['current_size']}/{data['max_size']} entries)"
@@ -464,7 +478,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"
@@ -482,10 +496,10 @@ def setup_cache_monitoring(enable: bool = True):
     cache_monitor = CacheMonitor()
     cache_monitor.tracked_functions.clear()
     if not enable:
-        logging.info("Cache monitoring disabled.")
+        logging.debug("Cache monitoring disabled.")
         return
 
-    logging.info("Cache monitoring enabled.")
+    logging.debug("Cache monitoring enabled.")
     cache_monitor.track(format_server_names)
     cache_monitor.track(extract_server_name_from_uri)
     cache_monitor.track(get_server_color_cached)
@@ -543,5 +557,38 @@ def setup_cache_monitoring(enable: bool = True):
 
     return cache_monitor
 
-# Disabled by default
-#setup_cache_monitoring(enable=False)
+
+def setup_logging():
+    """Configures the logging for the application."""
+    from .config import load_config, get_log_path
+    config = load_config()
+    log_level_str = config.get("LOG_LEVEL", "INFO").upper()
+    log_level = getattr(logging, log_level_str, logging.INFO)
+    log_path = get_log_path()
+
+    # Ensure directory exists
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    root_logger = logging.getLogger()
+
+    for handler in root_logger.handlers[:]:
+        if isinstance(handler, logging.StreamHandler) and not isinstance(handler, logging.FileHandler):
+            root_logger.removeHandler(handler)
+
+    # Check if we already added a FileHandler to this path
+    has_file_handler = False
+    for handler in root_logger.handlers:
+        if isinstance(handler, logging.FileHandler) and handler.baseFilename == str(log_path.absolute()):
+            has_file_handler = True
+            break
+
+    if not has_file_handler:
+        file_handler = logging.FileHandler(log_path)
+        file_handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
+        root_logger.addHandler(file_handler)
+    
+    root_logger.setLevel(log_level)
+
+    if not has_file_handler:
+        logging.info("--- Logging initialized ---")
+
+    setup_cache_monitoring(enable=False)

vmanager/vm_actions.py

@@ -13,7 +13,8 @@ from .libvirt_utils import (
         _get_disabled_disks_elem,
         _get_backing_chain_elem,
         get_overlay_backing_path,
-        get_internal_id
+        get_internal_id,
+        get_host_domain_capabilities
         )
 from .utils import log_function_call
 from .vm_queries import get_vm_disks_info, get_vm_tpm_info, _get_domain_root, get_vm_snapshots
@@ -1872,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.
@@ -2186,30 +2199,33 @@ def check_server_migration_compatibility(source_conn: libvirt.virConnect, dest_c
         source_tpm_info = get_vm_tpm_info(source_root)
         if source_tpm_info:
             try:
-                dest_caps_xml = dest_conn.getCapabilities()
-                dest_caps_root = ET.fromstring(dest_caps_xml)
-
-                # Check if destination host supports TPM devices at all
-                if not dest_caps_root.find(".//devices/tpm"):
-                    issues.append({
-                        'severity': 'ERROR',
-                        'message': f"Source VM '{domain_name}' uses TPM, but destination host '{dest_conn.getURI()}' does not appear to support TPM devices."
-                    })
+                dest_caps_xml = get_host_domain_capabilities(dest_conn)
+                if dest_caps_xml:
+                    dest_caps_root = ET.fromstring(dest_caps_xml)
+
+                    # Check if destination host supports TPM devices at all
+                    if not dest_caps_root.find(".//devices/tpm"):
+                        issues.append({
+                            'severity': 'ERROR',
+                            'message': f"Source VM '{domain_name}' uses TPM, but destination host '{dest_conn.getURI()}' does not appear to support TPM devices."
+                        })
+                    else:
+                        for tpm_dev in source_tpm_info:
+                            if tpm_dev['type'] == 'passthrough':
+                                # More specific check for passthrough TPM
+                                issues.append({
+                                    'severity': 'WARNING',
+                                    'message': f"Source VM '{domain_name}' uses passthrough TPM ({tpm_dev['model']}). Passthrough TPM migration is often problematic due to hardware dependencies. Manual verification on destination host '{dest_conn.getURI()}' recommended."
+                                })
+                            elif tpm_dev['type'] == 'emulated' and is_live:
+                                # Emulated TPM should generally be fine for cold migration.
+                                # Live migration of emulated TPM might be tricky.
+                                issues.append({
+                                    'severity': 'WARNING',
+                                    'message': f"Source VM '{domain_name}' uses emulated TPM. Live migration with TPM can sometimes have issues; cold migration is safer."
+                                })
                 else:
-                    for tpm_dev in source_tpm_info:
-                        if tpm_dev['type'] == 'passthrough':
-                            # More specific check for passthrough TPM
-                            issues.append({
-                                'severity': 'WARNING',
-                                'message': f"Source VM '{domain_name}' uses passthrough TPM ({tpm_dev['model']}). Passthrough TPM migration is often problematic due to hardware dependencies. Manual verification on destination host '{dest_conn.getURI()}' recommended."
-                            })
-                        elif tpm_dev['type'] == 'emulated' and is_live:
-                            # Emulated TPM should generally be fine for cold migration.
-                            # Live migration of emulated TPM might be tricky.
-                            issues.append({
-                                'severity': 'WARNING',
-                                'message': f"Source VM '{domain_name}' uses emulated TPM. Live migration with TPM can sometimes have issues; cold migration is safer."
-                            })
+                    issues.append({'severity': 'WARNING', 'message': f"Could not retrieve destination host capabilities for TPM check."})
 
             except libvirt.libvirtError as e:
                 issues.append({'severity': 'WARNING', 'message': f"Could not retrieve destination host capabilities for TPM check: {e}"})
@@ -2227,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)