chroot-distro 2.2.0__tar.gz → 2.2.1__tar.gz

{chroot_distro-2.2.0 → chroot_distro-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chroot-distro
-Version: 2.2.0
+Version: 2.2.1
 Summary: chroot-distro is a lightweight Linux container management utility built around chroot.
 Project-URL: Homepage, https://github.com/sabamdarif/chroot-distro
 Project-URL: Repository, https://github.com/sabamdarif/chroot-distro

{chroot_distro-2.2.0 → chroot_distro-2.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "chroot-distro"
-version = "2.2.0"
+version = "2.2.1"
 description = "chroot-distro is a lightweight Linux container management utility built around chroot."
 readme = "README.md"
 requires-python = ">=3.10"

chroot_distro-2.2.1/src/chroot_distro/commands/kill.py

@@ -0,0 +1,157 @@
+import contextlib
+import os
+import signal
+import subprocess
+import sys
+import time
+
+import chroot_distro.helpers.mount_manager as mount_manager
+import chroot_distro.helpers.namespace as namespace
+import chroot_distro.helpers.session as session
+from chroot_distro.locking import ContainerLock
+from chroot_distro.message import crit_error, log_info, warn
+from chroot_distro.names import require_valid_name
+from chroot_distro.paths import container_rootfs
+
+_SIGTERM_GRACE_SECS = 1.0
+_SIGKILL_WAIT_SECS = 2.0
+
+
+def _wait_until_gone(container_name: str, timeout: float) -> list[int]:
+    """Poll for active chroot PIDs until none remain or *timeout* elapses."""
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        remaining = session.get_active_chroot_pids(container_name)
+        if not remaining:
+            return []
+        time.sleep(0.1)
+    return session.get_active_chroot_pids(container_name)
+
+
+def command_kill(args) -> None:
+    """Forcibly stop all processes in a container and tear it down.
+
+    First try standard unmount, then lazy unmount. If mounts remain or processes
+    are active, kill all processes and retry unmounting. If still failing,
+    try forceful unmount and print a detailed error if mounts remain.
+    """
+    container_name = args.container_name
+    require_valid_name(container_name)
+
+    rootfs_dir = container_rootfs(container_name)
+    if not os.path.isdir(rootfs_dir):
+        crit_error(f"container '{container_name}' is not installed.")
+        sys.exit(1)
+
+    holder = namespace.get_live_holder(container_name)
+
+    active_pids = session.get_active_chroot_pids(container_name)
+    active_mounts = mount_manager.get_active_mounts(rootfs_dir, holder=holder)
+    if not active_pids and holder is None and not active_mounts:
+        log_info(f"Container '{container_name}' is not running.")
+        return
+
+    umount_bin = mount_manager._resolve_umount()
+
+    def run_umount(target_path: str, flags: list[str] | None = None) -> bool:
+        cmd = [umount_bin]
+        if flags:
+            cmd.extend(flags)
+        cmd.append(target_path)
+
+        if holder is not None:
+            res = holder.run(cmd, capture_output=True, text=True)
+        else:
+            res = subprocess.run(cmd, capture_output=True, text=True, check=False)
+        return res.returncode == 0
+
+    lock = ContainerLock(container_name, exclusive=True, command="kill")
+    acquired = lock.acquire()
+    if not acquired:
+        log_info(f"Container '{container_name}' is busy (active sessions exist). Forcing cleanup...")
+
+    try:
+        # Step 1: Try standard unmount
+        active_mounts = mount_manager.get_active_mounts(rootfs_dir, holder=holder)
+        if active_mounts:
+            log_info("Attempting standard unmount of active mount points...")
+            for m in active_mounts:
+                run_umount(m)
+
+        # Step 2: Try lazy unmount if mounts remain
+        active_mounts = mount_manager.get_active_mounts(rootfs_dir, holder=holder)
+        if active_mounts:
+            log_info("Some mounts remain busy. Attempting lazy unmount...")
+            for m in active_mounts:
+                run_umount(m, ["-l"])
+
+        # Step 3: Kill processes and unmount again if active PIDs or mounts remain
+        active_pids = session.get_active_chroot_pids(container_name)
+        active_mounts = mount_manager.get_active_mounts(rootfs_dir, holder=holder)
+        if active_pids or active_mounts:
+            if active_pids:
+                log_info(
+                    f"Killing {len(active_pids)} process(es) in container '{container_name}' (PIDs: {active_pids})..."
+                )
+                for pid in active_pids:
+                    with contextlib.suppress(OSError):
+                        os.kill(pid, signal.SIGTERM)
+
+                remaining = _wait_until_gone(container_name, _SIGTERM_GRACE_SECS)
+                if remaining:
+                    log_info(f"Processes {remaining} did not exit; sending SIGKILL...")
+                    for pid in remaining:
+                        with contextlib.suppress(OSError):
+                            os.kill(pid, signal.SIGKILL)
+                    remaining = _wait_until_gone(container_name, _SIGKILL_WAIT_SECS)
+                    if remaining:
+                        warn(f"Some processes could not be killed: {remaining}")
+
+            # Now that processes have been signaled, attempt to acquire the exclusive lock
+            if not acquired:
+                acquired = lock.acquire()
+
+            # Retry unmounting after killing processes
+            active_mounts = mount_manager.get_active_mounts(rootfs_dir, holder=holder)
+            if active_mounts:
+                log_info("Retrying standard unmount after killing processes...")
+                for m in active_mounts:
+                    run_umount(m)
+
+                active_mounts = mount_manager.get_active_mounts(rootfs_dir, holder=holder)
+                if active_mounts:
+                    log_info("Retrying lazy unmount after killing processes...")
+                    for m in active_mounts:
+                        run_umount(m, ["-l"])
+
+        # Step 4: Forceful unmount and detailed error if still failed
+        active_mounts = mount_manager.get_active_mounts(rootfs_dir, holder=holder)
+        if active_mounts:
+            log_info("Some mounts still remain. Attempting forceful unmount...")
+            for m in active_mounts:
+                run_umount(m, ["-f"])
+
+            active_mounts = mount_manager.get_active_mounts(rootfs_dir, holder=holder)
+            if active_mounts:
+                active_pids = session.get_active_chroot_pids(container_name)
+                crit_error(
+                    f"Failed to kill and unmount container '{container_name}'.\n"
+                    f"Remaining active mounts:\n" + "\n".join(f"  - {m}" for m in active_mounts) + "\n"
+                    f"Remaining active process PIDs: {active_pids if active_pids else 'None'}"
+                )
+                sys.exit(1)
+
+        # Cleanup namespace and sessions
+        session.reset(container_name)
+        if holder is not None:
+            namespace.release_holder(container_name)
+            namespace.clear_isolation_mode(container_name)
+
+        log_info(f"Container '{container_name}' successfully killed and unmounted.")
+
+    finally:
+        if acquired:
+            lock.release()
+
+
+__all__ = ("command_kill",)

chroot_distro-2.2.1/tests/unit/test_kill.py

@@ -0,0 +1,317 @@
+import signal
+import sys
+from unittest.mock import MagicMock, call, patch
+
+import pytest
+
+from chroot_distro.commands.kill import command_kill
+from chroot_distro.exceptions import LockConflictError
+from chroot_distro.parser import build_parser
+
+
+def test_parser_kill():
+    parser = build_parser()
+    args = parser.parse_args(["kill", "ubuntu"])
+    assert args.command == "kill"
+    assert args.container_name == "ubuntu"
+
+
+@patch("chroot_distro.commands.kill.container_rootfs", return_value="/mock/containers/ubuntu/rootfs")
+@patch("os.path.isdir", return_value=False)
+@patch("chroot_distro.commands.kill.crit_error")
+def test_kill_container_not_installed(mock_crit_error, mock_isdir, mock_rootfs):
+    args = MagicMock()
+    args.container_name = "ubuntu"
+
+    with pytest.raises(SystemExit) as exc_info:
+        command_kill(args)
+
+    assert exc_info.value.code == 1
+    mock_crit_error.assert_called_once_with("container 'ubuntu' is not installed.")
+
+
+@patch("chroot_distro.commands.kill.namespace.get_live_holder", return_value=None)
+@patch("chroot_distro.commands.kill.container_rootfs", return_value="/mock/containers/ubuntu/rootfs")
+@patch("os.path.isdir", return_value=True)
+@patch("chroot_distro.commands.kill.session")
+@patch("chroot_distro.commands.kill.mount_manager")
+@patch("chroot_distro.commands.kill.log_info")
+def test_kill_not_running(mock_log, mock_mount, mock_session, mock_isdir, mock_rootfs, *_mocks):
+    args = MagicMock()
+    args.container_name = "ubuntu"
+
+    mock_session.get_active_chroot_pids.return_value = []
+    mock_mount.get_active_mounts.return_value = []
+
+    command_kill(args)
+
+    mock_log.assert_called_once_with("Container 'ubuntu' is not running.")
+
+
+@patch("chroot_distro.commands.kill.namespace.get_live_holder", return_value=None)
+@patch("chroot_distro.commands.kill.container_rootfs", return_value="/mock/containers/ubuntu/rootfs")
+@patch("os.path.isdir", return_value=True)
+@patch("chroot_distro.commands.kill.ContainerLock")
+@patch("chroot_distro.commands.kill.session")
+@patch("chroot_distro.commands.kill.mount_manager")
+@patch("chroot_distro.commands.kill.log_info")
+@patch("subprocess.run")
+def test_kill_standard_unmount_success(
+    mock_run, mock_log, mock_mount, mock_session, mock_lock, mock_isdir, mock_rootfs, *_mocks
+):
+    """If standard unmount succeeds, we don't need lazy/kill/forceful."""
+    args = MagicMock()
+    args.container_name = "ubuntu"
+
+    mock_session.get_active_chroot_pids.return_value = []
+    # get_active_mounts returns active mounts for first check, then empty for subsequent checks
+    mock_mount.get_active_mounts.side_effect = [
+        ["/mock/containers/ubuntu/rootfs/proc"],  # initial check
+        ["/mock/containers/ubuntu/rootfs/proc"],  # Step 1 check
+        [],  # Step 2 check
+        [],  # Step 3 check
+        [],  # Step 4 check
+    ]
+    mock_mount._resolve_umount.return_value = "/bin/umount"
+
+    mock_lock_instance = MagicMock()
+    mock_lock_instance.acquire.return_value = True
+    mock_lock.return_value = mock_lock_instance
+
+    mock_run_res = MagicMock()
+    mock_run_res.returncode = 0
+    mock_run.return_value = mock_run_res
+
+    command_kill(args)
+
+    mock_lock_instance.acquire.assert_called_once()
+    mock_run.assert_called_once_with(
+        ["/bin/umount", "/mock/containers/ubuntu/rootfs/proc"], capture_output=True, text=True, check=False
+    )
+    mock_session.reset.assert_called_once_with("ubuntu")
+    mock_log.assert_any_call("Container 'ubuntu' successfully killed and unmounted.")
+    mock_lock_instance.release.assert_called_once()
+
+
+@patch("chroot_distro.commands.kill.namespace.get_live_holder", return_value=None)
+@patch("chroot_distro.commands.kill.container_rootfs", return_value="/mock/containers/ubuntu/rootfs")
+@patch("os.path.isdir", return_value=True)
+@patch("chroot_distro.commands.kill.ContainerLock")
+@patch("chroot_distro.commands.kill.session")
+@patch("chroot_distro.commands.kill.mount_manager")
+@patch("chroot_distro.commands.kill.log_info")
+@patch("subprocess.run")
+def test_kill_lazy_unmount_success(
+    mock_run, mock_log, mock_mount, mock_session, mock_lock, mock_isdir, mock_rootfs, *_mocks
+):
+    """If standard unmount fails, lazy unmount succeeds."""
+    args = MagicMock()
+    args.container_name = "ubuntu"
+
+    mock_session.get_active_chroot_pids.return_value = []
+    # get_active_mounts sequences:
+    mock_mount.get_active_mounts.side_effect = [
+        ["/mock/containers/ubuntu/rootfs/proc"],  # initial check
+        ["/mock/containers/ubuntu/rootfs/proc"],  # Step 1 check
+        ["/mock/containers/ubuntu/rootfs/proc"],  # Step 2 check
+        [],  # Step 3 check
+        [],  # Step 4 check
+    ]
+    mock_mount._resolve_umount.return_value = "/bin/umount"
+
+    mock_lock_instance = MagicMock()
+    mock_lock_instance.acquire.return_value = True
+    mock_lock.return_value = mock_lock_instance
+
+    # Standard umount fails, lazy umount succeeds
+    mock_run_res_fail = MagicMock(returncode=1)
+    mock_run_res_ok = MagicMock(returncode=0)
+    mock_run.side_effect = [mock_run_res_fail, mock_run_res_ok]
+
+    command_kill(args)
+
+    mock_run.assert_has_calls(
+        [
+            call(["/bin/umount", "/mock/containers/ubuntu/rootfs/proc"], capture_output=True, text=True, check=False),
+            call(
+                ["/bin/umount", "-l", "/mock/containers/ubuntu/rootfs/proc"],
+                capture_output=True,
+                text=True,
+                check=False,
+            ),
+        ]
+    )
+    mock_session.reset.assert_called_once_with("ubuntu")
+    mock_log.assert_any_call("Container 'ubuntu' successfully killed and unmounted.")
+
+
+@patch("chroot_distro.commands.kill.namespace.get_live_holder", return_value=None)
+@patch("chroot_distro.commands.kill.container_rootfs", return_value="/mock/containers/ubuntu/rootfs")
+@patch("os.path.isdir", return_value=True)
+@patch("chroot_distro.commands.kill.ContainerLock")
+@patch("chroot_distro.commands.kill.session")
+@patch("chroot_distro.commands.kill.mount_manager")
+@patch("chroot_distro.commands.kill.log_info")
+@patch("subprocess.run")
+@patch("chroot_distro.commands.kill.os.kill")
+@patch("chroot_distro.commands.kill.time.sleep")
+@patch("chroot_distro.commands.kill.time.time")
+def test_kill_process_then_unmount(
+    mock_time,
+    mock_sleep,
+    mock_kill,
+    mock_run,
+    mock_log,
+    mock_mount,
+    mock_session,
+    mock_lock,
+    mock_isdir,
+    mock_rootfs,
+    *_mocks,
+):
+    """Processes are active, we terminate them and successfully retry unmounting."""
+    args = MagicMock()
+    args.container_name = "ubuntu"
+
+    # PIDs sequence:
+    # 1. Initial check (PIDs active) -> [1000]
+    # 2. Step 3 check                -> [1000]
+    # 3. _wait_until_gone loop check -> [] (exited after SIGTERM)
+    mock_session.get_active_chroot_pids.side_effect = [[1000], [1000], []]
+
+    # Mounts sequence:
+    # 1. Initial check                               -> ["/mock/containers/ubuntu/rootfs/proc"]
+    # 2. Step 1 (standard)                           -> ["/mock/containers/ubuntu/rootfs/proc"]
+    # 3. Step 2 (lazy)                               -> ["/mock/containers/ubuntu/rootfs/proc"]
+    # 4. Step 3 (post-kill standard retry)           -> ["/mock/containers/ubuntu/rootfs/proc"]
+    # 5. Step 3 (post-kill lazy retry)               -> []
+    # 6. Step 4 (forceful check)                     -> []
+    mock_mount.get_active_mounts.side_effect = [
+        ["/mock/containers/ubuntu/rootfs/proc"],
+        ["/mock/containers/ubuntu/rootfs/proc"],
+        ["/mock/containers/ubuntu/rootfs/proc"],
+        ["/mock/containers/ubuntu/rootfs/proc"],
+        ["/mock/containers/ubuntu/rootfs/proc"],
+        [],
+        [],
+    ]
+    mock_mount._resolve_umount.return_value = "/bin/umount"
+
+    mock_lock_instance = MagicMock()
+    mock_lock_instance.acquire.return_value = True
+    mock_lock.return_value = mock_lock_instance
+
+    mock_time.side_effect = [0, 0.1, 0.2, 0.3]
+
+    # Standard umounts fail, lazy umounts succeed
+    mock_run_res_fail = MagicMock(returncode=1)
+    mock_run_res_ok = MagicMock(returncode=0)
+    mock_run.side_effect = [
+        mock_run_res_fail,  # Step 1 standard
+        mock_run_res_fail,  # Step 2 lazy
+        mock_run_res_fail,  # Step 3 post-kill standard
+        mock_run_res_ok,  # Step 3 post-kill lazy
+    ]
+
+    command_kill(args)
+
+    mock_kill.assert_called_once_with(1000, signal.SIGTERM)
+    mock_session.reset.assert_called_once_with("ubuntu")
+    mock_log.assert_any_call("Container 'ubuntu' successfully killed and unmounted.")
+
+
+@patch("chroot_distro.commands.kill.namespace.get_live_holder", return_value=None)
+@patch("chroot_distro.commands.kill.container_rootfs", return_value="/mock/containers/ubuntu/rootfs")
+@patch("os.path.isdir", return_value=True)
+@patch("chroot_distro.commands.kill.ContainerLock")
+@patch("chroot_distro.commands.kill.session")
+@patch("chroot_distro.commands.kill.mount_manager")
+@patch("chroot_distro.commands.kill.log_info")
+@patch("subprocess.run")
+@patch("chroot_distro.commands.kill.crit_error")
+def test_kill_forceful_failure_diagnostic(
+    mock_crit_error, mock_run, mock_log, mock_mount, mock_session, mock_lock, mock_isdir, mock_rootfs, *_mocks
+):
+    """If forceful unmount also fails, we output detailed diagnostics."""
+    args = MagicMock()
+    args.container_name = "ubuntu"
+
+    mock_session.get_active_chroot_pids.return_value = []
+    # get_active_mounts always returns a mount
+    mock_mount.get_active_mounts.return_value = ["/mock/containers/ubuntu/rootfs/proc"]
+    mock_mount._resolve_umount.return_value = "/bin/umount"
+
+    mock_lock_instance = MagicMock()
+    mock_lock_instance.acquire.return_value = True
+    mock_lock.return_value = mock_lock_instance
+
+    # All umount commands fail
+    mock_run.return_value = MagicMock(returncode=1)
+
+    with pytest.raises(SystemExit) as exc_info:
+        command_kill(args)
+
+    assert exc_info.value.code == 1
+    mock_crit_error.assert_called_once_with(
+        "Failed to kill and unmount container 'ubuntu'.\n"
+        "Remaining active mounts:\n"
+        "  - /mock/containers/ubuntu/rootfs/proc\n"
+        "Remaining active process PIDs: None"
+    )
+
+
+@patch("chroot_distro.commands.kill.namespace.get_live_holder", return_value=None)
+@patch("chroot_distro.commands.kill.container_rootfs", return_value="/mock/containers/ubuntu/rootfs")
+@patch("os.path.isdir", return_value=True)
+@patch("chroot_distro.commands.kill.ContainerLock")
+@patch("chroot_distro.commands.kill.session")
+@patch("chroot_distro.commands.kill.mount_manager")
+@patch("chroot_distro.commands.kill.log_info")
+@patch("subprocess.run")
+@patch("chroot_distro.commands.kill.os.kill")
+@patch("chroot_distro.commands.kill.time.sleep")
+@patch("chroot_distro.commands.kill.time.time")
+def test_kill_lock_conflict_bypass(
+    mock_time,
+    mock_sleep,
+    mock_kill,
+    mock_run,
+    mock_log,
+    mock_mount,
+    mock_session,
+    mock_lock,
+    mock_isdir,
+    mock_rootfs,
+    *_mocks,
+):
+    """When container lock is busy initially, we bypass it, kill processes, and acquire it afterward."""
+    args = MagicMock()
+    args.container_name = "ubuntu"
+
+    mock_session.get_active_chroot_pids.side_effect = [[1000], [1000], []]
+    mock_mount.get_active_mounts.side_effect = [
+        ["/mock/containers/ubuntu/rootfs/proc"],  # initial check
+        ["/mock/containers/ubuntu/rootfs/proc"],  # Step 1 standard
+        ["/mock/containers/ubuntu/rootfs/proc"],  # Step 2 lazy
+        ["/mock/containers/ubuntu/rootfs/proc"],  # Step 3 post-kill standard
+        [],  # Step 3 post-kill lazy
+        [],  # Step 4 check
+    ]
+    mock_mount._resolve_umount.return_value = "/bin/umount"
+
+    mock_lock_instance = MagicMock()
+    # First acquire fails, second acquire (after processes killed) succeeds
+    mock_lock_instance.acquire.side_effect = [False, True]
+    mock_lock.return_value = mock_lock_instance
+
+    mock_time.side_effect = [0, 0.1, 0.2, 0.3]
+    mock_run.return_value = MagicMock(returncode=0)
+
+    command_kill(args)
+
+    # We logged a warning/info about lock conflict
+    mock_log.assert_any_call("Container 'ubuntu' is busy (active sessions exist). Forcing cleanup...")
+    # Two calls to acquire
+    assert mock_lock_instance.acquire.call_count == 2
+    # Lock released at the end
+    mock_lock_instance.release.assert_called_once()

{chroot_distro-2.2.0 → chroot_distro-2.2.1}/uv.lock

@@ -330,7 +330,7 @@ wheels = [
 
 [[package]]
 name = "chroot-distro"
-version = "2.2.0"
+version = "2.2.1"
 source = { editable = "." }
 dependencies = [
     { name = "backports-zstd", marker = "python_full_version < '3.14'" },

chroot_distro-2.2.0/src/chroot_distro/commands/kill.py

@@ -1,88 +0,0 @@
-import contextlib
-import os
-import signal
-import sys
-import time
-
-import chroot_distro.helpers.mount_manager as mount_manager
-import chroot_distro.helpers.namespace as namespace
-import chroot_distro.helpers.session as session
-from chroot_distro.locking import ContainerLock
-from chroot_distro.message import crit_error, log_info, warn
-from chroot_distro.names import require_valid_name
-from chroot_distro.paths import container_rootfs
-
-_SIGTERM_GRACE_SECS = 1.0
-_SIGKILL_WAIT_SECS = 2.0
-
-
-def _wait_until_gone(container_name: str, timeout: float) -> list[int]:
-    """Poll for active chroot PIDs until none remain or *timeout* elapses."""
-    deadline = time.time() + timeout
-    while time.time() < deadline:
-        remaining = session.get_active_chroot_pids(container_name)
-        if not remaining:
-            return []
-        time.sleep(0.1)
-    return session.get_active_chroot_pids(container_name)
-
-
-def command_kill(args) -> None:
-    """Forcibly stop all processes in a container and tear it down.
-
-    The abrupt counterpart to ``unmount``: send SIGTERM, then SIGKILL after a
-    short grace period, then unmount and release the namespace holder.
-    """
-    container_name = args.container_name
-    require_valid_name(container_name)
-
-    rootfs_dir = container_rootfs(container_name)
-    if not os.path.isdir(rootfs_dir):
-        crit_error(f"container '{container_name}' is not installed.")
-        sys.exit(1)
-
-    with ContainerLock(container_name, exclusive=True, command="kill"):
-        active_pids = session.get_active_chroot_pids(container_name)
-        holder = namespace.get_live_holder(container_name)
-
-        if not active_pids and holder is None and not mount_manager.get_active_mounts(rootfs_dir):
-            log_info(f"Container '{container_name}' is not running.")
-            return
-
-        if active_pids:
-            log_info(f"Killing {len(active_pids)} process(es) in container '{container_name}' (PIDs: {active_pids})...")
-            for pid in active_pids:
-                with contextlib.suppress(OSError):
-                    os.kill(pid, signal.SIGTERM)
-
-            remaining = _wait_until_gone(container_name, _SIGTERM_GRACE_SECS)
-            if remaining:
-                log_info(f"Processes {remaining} did not exit; sending SIGKILL...")
-                for pid in remaining:
-                    with contextlib.suppress(OSError):
-                        os.kill(pid, signal.SIGKILL)
-                remaining = _wait_until_gone(container_name, _SIGKILL_WAIT_SECS)
-                if remaining:
-                    warn(f"Some processes could not be killed: {remaining}")
-
-        session.reset(container_name)
-
-        log_info("Unmounting active mount points under rootfs...")
-        try:
-            mount_manager.unmount_all(rootfs_dir, holder=holder)
-        except Exception as e:
-            crit_error(f"Failed to unmount: {e}")
-            sys.exit(1)
-
-        if holder is not None:
-            namespace.release_holder(container_name)
-            namespace.clear_isolation_mode(container_name)
-
-        remaining_mounts = mount_manager.get_active_mounts(rootfs_dir)
-        if remaining_mounts:
-            warn(f"Some active mounts remain: {remaining_mounts}")
-        else:
-            log_info(f"Container '{container_name}' killed and unmounted.")
-
-
-__all__ = ("command_kill",)