jumpstarter-kubernetes 0.6.0__tar.gz → 0.7.1__tar.gz

{jumpstarter_kubernetes-0.6.0 → jumpstarter_kubernetes-0.7.1}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: jumpstarter-kubernetes
-Version: 0.6.0
+Version: 0.7.1
 Project-URL: Homepage, https://jumpstarter.dev
-Project-URL: source_archive, https://github.com/jumpstarter-dev/repo/archive/c2927a2abac82d224c7bd28f9ed83c57b5222e65.zip
+Project-URL: source_archive, https://github.com/jumpstarter-dev/repo/archive/7a5a95ea4fab743def1fe84f93165fbd49fc2de7.zip
 Author-email: Kirk Brauer <kbrauer@hatci.com>
 License-Expression: Apache-2.0
 Requires-Python: >=3.11

{jumpstarter_kubernetes-0.6.0 → jumpstarter_kubernetes-0.7.1}/jumpstarter_kubernetes/__init__.py

@@ -1,4 +1,12 @@
 from .clients import ClientsV1Alpha1Api, V1Alpha1Client, V1Alpha1ClientList, V1Alpha1ClientStatus
+from .cluster import (
+    create_kind_cluster,
+    create_minikube_cluster,
+    delete_kind_cluster,
+    delete_minikube_cluster,
+    kind_installed,
+    minikube_installed,
+)
 from .exporters import (
     ExportersV1Alpha1Api,
     V1Alpha1Exporter,
@@ -6,7 +14,11 @@ from .exporters import (
     V1Alpha1ExporterList,
     V1Alpha1ExporterStatus,
 )
-from .install import helm_installed, install_helm_chart
+from .install import (
+    helm_installed,
+    install_helm_chart,
+    uninstall_helm_chart,
+)
 from .leases import (
     LeasesV1Alpha1Api,
     V1Alpha1Lease,
@@ -36,4 +48,11 @@ __all__ = [
     "V1Alpha1List",
     "helm_installed",
     "install_helm_chart",
+    "uninstall_helm_chart",
+    "minikube_installed",
+    "kind_installed",
+    "create_minikube_cluster",
+    "create_kind_cluster",
+    "delete_minikube_cluster",
+    "delete_kind_cluster",
 ]

{jumpstarter_kubernetes-0.6.0 → jumpstarter_kubernetes-0.7.1}/jumpstarter_kubernetes/clients.py

@@ -53,6 +53,21 @@ class V1Alpha1Client(JsonBaseModel):
             else None,
         )
 
+    @classmethod
+    def rich_add_columns(cls, table):
+        table.add_column("NAME")
+        table.add_column("ENDPOINT")
+        # table.add_column("AGE")
+
+    def rich_add_rows(self, table):
+        table.add_row(
+            self.metadata.name,
+            self.status.endpoint if self.status is not None else "",
+        )
+
+    def rich_add_names(self, names):
+        names.append(f"client.jumpstarter.dev/{self.metadata.name}")
+
 
 class V1Alpha1ClientList(V1Alpha1List[V1Alpha1Client]):
     kind: Literal["ClientList"] = Field(default="ClientList")
@@ -61,6 +76,18 @@ class V1Alpha1ClientList(V1Alpha1List[V1Alpha1Client]):
     def from_dict(dict: dict):
         return V1Alpha1ClientList(items=[V1Alpha1Client.from_dict(c) for c in dict.get("items", [])])
 
+    @classmethod
+    def rich_add_columns(cls, table):
+        V1Alpha1Client.rich_add_columns(table)
+
+    def rich_add_rows(self, table):
+        for client in self.items:
+            client.rich_add_rows(table)
+
+    def rich_add_names(self, names):
+        for client in self.items:
+            client.rich_add_names(names)
+
 
 class ClientsV1Alpha1Api(AbstractAsyncCustomObjectApi):
     """Interact with the clients custom resource API"""

jumpstarter_kubernetes-0.7.1/jumpstarter_kubernetes/cluster.py

@@ -0,0 +1,201 @@
+import asyncio
+import shutil
+from typing import Optional, Tuple
+
+
+def minikube_installed(minikube: str) -> bool:
+    """Check if Minikube is installed and available in the PATH."""
+    return shutil.which(minikube) is not None
+
+
+def kind_installed(kind: str) -> bool:
+    """Check if Kind is installed and available in the PATH."""
+    return shutil.which(kind) is not None
+
+
+async def run_command(cmd: list[str]) -> Tuple[int, str, str]:
+    """Run a command and return exit code, stdout, stderr"""
+    try:
+        process = await asyncio.create_subprocess_exec(
+            *cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+        )
+        stdout, stderr = await process.communicate()
+        return process.returncode, stdout.decode().strip(), stderr.decode().strip()
+    except FileNotFoundError as e:
+        raise RuntimeError(f"Command not found: {cmd[0]}") from e
+
+
+async def run_command_with_output(cmd: list[str]) -> int:
+    """Run a command with real-time output streaming and return exit code"""
+    try:
+        process = await asyncio.create_subprocess_exec(*cmd)
+        return await process.wait()
+    except FileNotFoundError as e:
+        raise RuntimeError(f"Command not found: {cmd[0]}") from e
+
+
+async def minikube_cluster_exists(minikube: str, cluster_name: str) -> bool:
+    """Check if a Minikube cluster exists."""
+    if not minikube_installed(minikube):
+        return False
+
+    try:
+        returncode, _, _ = await run_command([minikube, "status", "-p", cluster_name])
+        return returncode == 0
+    except RuntimeError:
+        return False
+
+
+async def kind_cluster_exists(kind: str, cluster_name: str) -> bool:
+    """Check if a Kind cluster exists."""
+    if not kind_installed(kind):
+        return False
+
+    try:
+        returncode, _, _ = await run_command([kind, "get", "kubeconfig", "--name", cluster_name])
+        return returncode == 0
+    except RuntimeError:
+        return False
+
+
+async def delete_minikube_cluster(minikube: str, cluster_name: str) -> bool:
+    """Delete a Minikube cluster."""
+    if not minikube_installed(minikube):
+        raise RuntimeError(f"{minikube} is not installed or not found in PATH.")
+
+    if not await minikube_cluster_exists(minikube, cluster_name):
+        return True  # Already deleted, consider it successful
+
+    returncode = await run_command_with_output([minikube, "delete", "-p", cluster_name])
+
+    if returncode == 0:
+        return True
+    else:
+        raise RuntimeError(f"Failed to delete Minikube cluster '{cluster_name}'")
+
+
+async def delete_kind_cluster(kind: str, cluster_name: str) -> bool:
+    """Delete a Kind cluster."""
+    if not kind_installed(kind):
+        raise RuntimeError(f"{kind} is not installed or not found in PATH.")
+
+    if not await kind_cluster_exists(kind, cluster_name):
+        return True  # Already deleted, consider it successful
+
+    returncode = await run_command_with_output([kind, "delete", "cluster", "--name", cluster_name])
+
+    if returncode == 0:
+        return True
+    else:
+        raise RuntimeError(f"Failed to delete Kind cluster '{cluster_name}'")
+
+
+async def create_minikube_cluster(
+    minikube: str, cluster_name: str, extra_args: Optional[list[str]] = None, force_recreate: bool = False
+) -> bool:
+    """Create a Minikube cluster."""
+    if extra_args is None:
+        extra_args = []
+
+    if not minikube_installed(minikube):
+        raise RuntimeError(f"{minikube} is not installed or not found in PATH.")
+
+    # Check if cluster already exists
+    cluster_exists = await minikube_cluster_exists(minikube, cluster_name)
+
+    if cluster_exists:
+        if not force_recreate:
+            raise RuntimeError(f"Minikube cluster '{cluster_name}' already exists.")
+        else:
+            if not await delete_minikube_cluster(minikube, cluster_name):
+                return False
+
+    has_cpus_flag = any(a == "--cpus" or a.startswith("--cpus=") for a in extra_args)
+    if not has_cpus_flag:
+        try:
+            rc, out, _ = await run_command([minikube, "config", "get", "cpus"])
+            has_config_cpus = rc == 0 and out.strip().isdigit() and int(out.strip()) > 0
+        except RuntimeError:
+            # If we cannot query minikube (e.g., not installed in test env), default CPUs
+            has_config_cpus = False
+        if not has_config_cpus:
+            extra_args.append("--cpus=4")
+
+    command = [
+        minikube,
+        "start",
+        "--profile",
+        cluster_name,
+        "--extra-config=apiserver.service-node-port-range=8000-9000",
+    ]
+    command.extend(extra_args)
+
+    returncode = await run_command_with_output(command)
+
+    if returncode == 0:
+        return True
+    else:
+        raise RuntimeError(f"Failed to create Minikube cluster '{cluster_name}'")
+
+
+async def create_kind_cluster(
+    kind: str, cluster_name: str, extra_args: Optional[list[str]] = None, force_recreate: bool = False
+) -> bool:
+    """Create a Kind cluster."""
+    if extra_args is None:
+        extra_args = []
+
+    if not kind_installed(kind):
+        raise RuntimeError(f"{kind} is not installed or not found in PATH.")
+
+    # Check if cluster already exists
+    cluster_exists = await kind_cluster_exists(kind, cluster_name)
+
+    if cluster_exists:
+        if not force_recreate:
+            raise RuntimeError(f"Kind cluster '{cluster_name}' already exists.")
+        else:
+            if not await delete_kind_cluster(kind, cluster_name):
+                return False
+
+    cluster_config = """kind: Cluster
+apiVersion: kind.x-k8s.io/v1alpha4
+kubeadmConfigPatches:
+- |
+  kind: ClusterConfiguration
+  apiServer:
+    extraArgs:
+      "service-node-port-range": "3000-32767"
+- |
+  kind: InitConfiguration
+  nodeRegistration:
+    kubeletExtraArgs:
+      node-labels: "ingress-ready=true"
+nodes:
+- role: control-plane
+  extraPortMappings:
+  - containerPort: 80
+    hostPort: 5080
+    protocol: TCP
+  - containerPort: 30010
+    hostPort: 8082
+    protocol: TCP
+  - containerPort: 30011
+    hostPort: 8083
+    protocol: TCP
+  - containerPort: 443
+    hostPort: 5443
+    protocol: TCP
+"""
+
+    command = [kind, "create", "cluster", "--name", cluster_name, "--config=/dev/stdin"]
+    command.extend(extra_args)
+
+    kind_process = await asyncio.create_subprocess_exec(*command, stdin=asyncio.subprocess.PIPE)
+
+    await kind_process.communicate(input=cluster_config.encode())
+
+    if kind_process.returncode == 0:
+        return True
+    else:
+        raise RuntimeError(f"Failed to create Kind cluster '{cluster_name}'")

jumpstarter_kubernetes-0.7.1/jumpstarter_kubernetes/cluster_test.py

@@ -0,0 +1,395 @@
+import asyncio
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from jumpstarter_kubernetes.cluster import (
+    create_kind_cluster,
+    create_minikube_cluster,
+    delete_kind_cluster,
+    delete_minikube_cluster,
+    kind_cluster_exists,
+    kind_installed,
+    minikube_cluster_exists,
+    minikube_installed,
+    run_command,
+    run_command_with_output,
+)
+
+
+class TestClusterDetection:
+    """Test cluster tool detection functions."""
+
+    @patch("jumpstarter_kubernetes.cluster.shutil.which")
+    def test_kind_installed_true(self, mock_which):
+        mock_which.return_value = "/usr/local/bin/kind"
+        assert kind_installed("kind") is True
+        mock_which.assert_called_once_with("kind")
+
+    @patch("jumpstarter_kubernetes.cluster.shutil.which")
+    def test_kind_installed_false(self, mock_which):
+        mock_which.return_value = None
+        assert kind_installed("kind") is False
+        mock_which.assert_called_once_with("kind")
+
+    @patch("jumpstarter_kubernetes.cluster.shutil.which")
+    def test_minikube_installed_true(self, mock_which):
+        mock_which.return_value = "/usr/local/bin/minikube"
+        assert minikube_installed("minikube") is True
+        mock_which.assert_called_once_with("minikube")
+
+    @patch("jumpstarter_kubernetes.cluster.shutil.which")
+    def test_minikube_installed_false(self, mock_which):
+        mock_which.return_value = None
+        assert minikube_installed("minikube") is False
+        mock_which.assert_called_once_with("minikube")
+
+
+class TestCommandExecution:
+    """Test command execution utilities."""
+
+    @pytest.mark.asyncio
+    async def test_run_command_success(self):
+        with patch("asyncio.create_subprocess_exec") as mock_subprocess:
+            mock_process = AsyncMock()
+            mock_process.communicate.return_value = (b"output\n", b"")
+            mock_process.returncode = 0
+            mock_subprocess.return_value = mock_process
+
+            returncode, stdout, stderr = await run_command(["echo", "test"])
+
+            assert returncode == 0
+            assert stdout == "output"
+            assert stderr == ""
+            mock_subprocess.assert_called_once_with(
+                "echo", "test", stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+            )
+
+    @pytest.mark.asyncio
+    async def test_run_command_failure(self):
+        with patch("asyncio.create_subprocess_exec") as mock_subprocess:
+            mock_process = AsyncMock()
+            mock_process.communicate.return_value = (b"", b"error message\n")
+            mock_process.returncode = 1
+            mock_subprocess.return_value = mock_process
+
+            returncode, stdout, stderr = await run_command(["false"])
+
+            assert returncode == 1
+            assert stdout == ""
+            assert stderr == "error message"
+
+    @pytest.mark.asyncio
+    async def test_run_command_not_found(self):
+        with patch("asyncio.create_subprocess_exec", side_effect=FileNotFoundError("command not found")):
+            with pytest.raises(RuntimeError, match="Command not found: nonexistent"):
+                await run_command(["nonexistent"])
+
+    @pytest.mark.asyncio
+    async def test_run_command_with_output_success(self):
+        with patch("asyncio.create_subprocess_exec") as mock_subprocess:
+            mock_process = AsyncMock()
+            mock_process.wait.return_value = 0
+            mock_subprocess.return_value = mock_process
+
+            returncode = await run_command_with_output(["echo", "test"])
+
+            assert returncode == 0
+            mock_subprocess.assert_called_once_with("echo", "test")
+
+    @pytest.mark.asyncio
+    async def test_run_command_with_output_not_found(self):
+        with patch("asyncio.create_subprocess_exec", side_effect=FileNotFoundError("command not found")):
+            with pytest.raises(RuntimeError, match="Command not found: nonexistent"):
+                await run_command_with_output(["nonexistent"])
+
+
+class TestClusterExistence:
+    """Test cluster existence checking functions."""
+
+    @pytest.mark.asyncio
+    @patch("jumpstarter_kubernetes.cluster.kind_installed")
+    @patch("jumpstarter_kubernetes.cluster.run_command")
+    async def test_kind_cluster_exists_true(self, mock_run_command, mock_kind_installed):
+        mock_kind_installed.return_value = True
+        mock_run_command.return_value = (0, "", "")
+
+        result = await kind_cluster_exists("kind", "test-cluster")
+
+        assert result is True
+        mock_run_command.assert_called_once_with(["kind", "get", "kubeconfig", "--name", "test-cluster"])
+
+    @pytest.mark.asyncio
+    @patch("jumpstarter_kubernetes.cluster.kind_installed")
+    @patch("jumpstarter_kubernetes.cluster.run_command")
+    async def test_kind_cluster_exists_false(self, mock_run_command, mock_kind_installed):
+        mock_kind_installed.return_value = True
+        mock_run_command.return_value = (1, "", "cluster not found")
+
+        result = await kind_cluster_exists("kind", "test-cluster")
+
+        assert result is False
+
+    @pytest.mark.asyncio
+    @patch("jumpstarter_kubernetes.cluster.kind_installed")
+    async def test_kind_cluster_exists_kind_not_installed(self, mock_kind_installed):
+        mock_kind_installed.return_value = False
+
+        result = await kind_cluster_exists("kind", "test-cluster")
+
+        assert result is False
+
+    @pytest.mark.asyncio
+    @patch("jumpstarter_kubernetes.cluster.kind_installed")
+    @patch("jumpstarter_kubernetes.cluster.run_command")
+    async def test_kind_cluster_exists_runtime_error(self, mock_run_command, mock_kind_installed):
+        mock_kind_installed.return_value = True
+        mock_run_command.side_effect = RuntimeError("Command failed")
+
+        result = await kind_cluster_exists("kind", "test-cluster")
+
+        assert result is False
+
+    @pytest.mark.asyncio
+    @patch("jumpstarter_kubernetes.cluster.minikube_installed")
+    @patch("jumpstarter_kubernetes.cluster.run_command")
+    async def test_minikube_cluster_exists_true(self, mock_run_command, mock_minikube_installed):
+        mock_minikube_installed.return_value = True
+        mock_run_command.return_value = (0, "", "")
+
+        result = await minikube_cluster_exists("minikube", "test-cluster")
+
+        assert result is True
+        mock_run_command.assert_called_once_with(["minikube", "status", "-p", "test-cluster"])
+
+    @pytest.mark.asyncio
+    @patch("jumpstarter_kubernetes.cluster.minikube_installed")
+    async def test_minikube_cluster_exists_minikube_not_installed(self, mock_minikube_installed):
+        mock_minikube_installed.return_value = False
+
+        result = await minikube_cluster_exists("minikube", "test-cluster")
+
+        assert result is False
+
+
+class TestKindClusterOperations:
+    """Test Kind cluster creation and deletion."""
+
+    @pytest.mark.asyncio
+    @patch("jumpstarter_kubernetes.cluster.kind_installed")
+    @patch("jumpstarter_kubernetes.cluster.kind_cluster_exists")
+    @patch("asyncio.create_subprocess_exec")
+    async def test_create_kind_cluster_success(self, mock_subprocess, mock_cluster_exists, mock_kind_installed):
+        mock_kind_installed.return_value = True
+        mock_cluster_exists.return_value = False
+
+        mock_process = AsyncMock()
+        mock_process.returncode = 0
+        mock_process.communicate.return_value = (b"", b"")
+        mock_subprocess.return_value = mock_process
+
+        result = await create_kind_cluster("kind", "test-cluster")
+
+        assert result is True
+        mock_subprocess.assert_called_once()
+        args, kwargs = mock_subprocess.call_args
+        assert args[0] == "kind"
+        assert args[1] == "create"
+        assert args[2] == "cluster"
+        assert "--name" in args
+        assert "test-cluster" in args
+        assert kwargs["stdin"] == asyncio.subprocess.PIPE
+
+    @pytest.mark.asyncio
+    @patch("jumpstarter_kubernetes.cluster.kind_installed")
+    async def test_create_kind_cluster_not_installed(self, mock_kind_installed):
+        mock_kind_installed.return_value = False
+
+        with pytest.raises(RuntimeError, match="kind is not installed"):
+            await create_kind_cluster("kind", "test-cluster")
+
+    @pytest.mark.asyncio
+    @patch("jumpstarter_kubernetes.cluster.kind_installed")
+    @patch("jumpstarter_kubernetes.cluster.kind_cluster_exists")
+    async def test_create_kind_cluster_already_exists(self, mock_cluster_exists, mock_kind_installed):
+        mock_kind_installed.return_value = True
+        mock_cluster_exists.return_value = True
+
+        with pytest.raises(RuntimeError, match="Kind cluster 'test-cluster' already exists"):
+            await create_kind_cluster("kind", "test-cluster")
+
+    @pytest.mark.asyncio
+    @patch("jumpstarter_kubernetes.cluster.kind_installed")
+    @patch("jumpstarter_kubernetes.cluster.kind_cluster_exists")
+    @patch("jumpstarter_kubernetes.cluster.delete_kind_cluster")
+    @patch("asyncio.create_subprocess_exec")
+    async def test_create_kind_cluster_force_recreate(
+        self, mock_subprocess, mock_delete, mock_cluster_exists, mock_kind_installed
+    ):
+        mock_kind_installed.return_value = True
+        mock_cluster_exists.return_value = True
+        mock_delete.return_value = True
+
+        mock_process = AsyncMock()
+        mock_process.returncode = 0
+        mock_process.communicate.return_value = (b"", b"")
+        mock_subprocess.return_value = mock_process
+
+        result = await create_kind_cluster("kind", "test-cluster", force_recreate=True)
+
+        assert result is True
+        mock_delete.assert_called_once_with("kind", "test-cluster")
+
+    @pytest.mark.asyncio
+    @patch("jumpstarter_kubernetes.cluster.kind_installed")
+    @patch("jumpstarter_kubernetes.cluster.kind_cluster_exists")
+    @patch("asyncio.create_subprocess_exec")
+    async def test_create_kind_cluster_with_extra_args(self, mock_subprocess, mock_cluster_exists, mock_kind_installed):
+        mock_kind_installed.return_value = True
+        mock_cluster_exists.return_value = False
+
+        mock_process = AsyncMock()
+        mock_process.returncode = 0
+        mock_process.communicate.return_value = (b"", b"")
+        mock_subprocess.return_value = mock_process
+
+        result = await create_kind_cluster("kind", "test-cluster", extra_args=["--verbosity=1"])
+
+        assert result is True
+        args, _ = mock_subprocess.call_args
+        assert "--verbosity=1" in args
+
+    @pytest.mark.asyncio
+    @patch("jumpstarter_kubernetes.cluster.kind_installed")
+    @patch("jumpstarter_kubernetes.cluster.kind_cluster_exists")
+    @patch("jumpstarter_kubernetes.cluster.run_command_with_output")
+    async def test_delete_kind_cluster_success(self, mock_run_command, mock_cluster_exists, mock_kind_installed):
+        mock_kind_installed.return_value = True
+        mock_cluster_exists.return_value = True
+        mock_run_command.return_value = 0
+
+        result = await delete_kind_cluster("kind", "test-cluster")
+
+        assert result is True
+        mock_run_command.assert_called_once_with(["kind", "delete", "cluster", "--name", "test-cluster"])
+
+    @pytest.mark.asyncio
+    @patch("jumpstarter_kubernetes.cluster.kind_installed")
+    async def test_delete_kind_cluster_not_installed(self, mock_kind_installed):
+        mock_kind_installed.return_value = False
+
+        with pytest.raises(RuntimeError, match="kind is not installed"):
+            await delete_kind_cluster("kind", "test-cluster")
+
+    @pytest.mark.asyncio
+    @patch("jumpstarter_kubernetes.cluster.kind_installed")
+    @patch("jumpstarter_kubernetes.cluster.kind_cluster_exists")
+    async def test_delete_kind_cluster_already_deleted(self, mock_cluster_exists, mock_kind_installed):
+        mock_kind_installed.return_value = True
+        mock_cluster_exists.return_value = False
+
+        result = await delete_kind_cluster("kind", "test-cluster")
+
+        assert result is True  # Already deleted, consider successful
+
+
+class TestMinikubeClusterOperations:
+    """Test Minikube cluster creation and deletion."""
+
+    @pytest.mark.asyncio
+    @patch("jumpstarter_kubernetes.cluster.minikube_installed")
+    @patch("jumpstarter_kubernetes.cluster.minikube_cluster_exists")
+    @patch("jumpstarter_kubernetes.cluster.run_command_with_output")
+    async def test_create_minikube_cluster_success(
+        self, mock_run_command, mock_cluster_exists, mock_minikube_installed
+    ):
+        mock_minikube_installed.return_value = True
+        mock_cluster_exists.return_value = False
+        mock_run_command.return_value = 0
+
+        result = await create_minikube_cluster("minikube", "test-cluster")
+
+        assert result is True
+        mock_run_command.assert_called_once()
+        args = mock_run_command.call_args[0][0]
+        assert args[0] == "minikube"
+        assert args[1] == "start"
+        assert "--profile" in args
+        assert "test-cluster" in args
+        assert "--extra-config=apiserver.service-node-port-range=8000-9000" in args
+
+    @pytest.mark.asyncio
+    @patch("jumpstarter_kubernetes.cluster.minikube_installed")
+    async def test_create_minikube_cluster_not_installed(self, mock_minikube_installed):
+        mock_minikube_installed.return_value = False
+
+        with pytest.raises(RuntimeError, match="minikube is not installed"):
+            await create_minikube_cluster("minikube", "test-cluster")
+
+    @pytest.mark.asyncio
+    @patch("jumpstarter_kubernetes.cluster.minikube_installed")
+    @patch("jumpstarter_kubernetes.cluster.minikube_cluster_exists")
+    async def test_create_minikube_cluster_already_exists(self, mock_cluster_exists, mock_minikube_installed):
+        mock_minikube_installed.return_value = True
+        mock_cluster_exists.return_value = True
+
+        with pytest.raises(RuntimeError, match="Minikube cluster 'test-cluster' already exists"):
+            await create_minikube_cluster("minikube", "test-cluster")
+
+    @pytest.mark.asyncio
+    @patch("jumpstarter_kubernetes.cluster.minikube_installed")
+    @patch("jumpstarter_kubernetes.cluster.minikube_cluster_exists")
+    @patch("jumpstarter_kubernetes.cluster.run_command_with_output")
+    async def test_create_minikube_cluster_with_extra_args(
+        self, mock_run_command, mock_cluster_exists, mock_minikube_installed
+    ):
+        mock_minikube_installed.return_value = True
+        mock_cluster_exists.return_value = False
+        mock_run_command.return_value = 0
+
+        result = await create_minikube_cluster("minikube", "test-cluster", extra_args=["--memory=4096"])
+
+        assert result is True
+        args = mock_run_command.call_args[0][0]
+        assert "--memory=4096" in args
+
+    @pytest.mark.asyncio
+    @patch("jumpstarter_kubernetes.cluster.minikube_installed")
+    @patch("jumpstarter_kubernetes.cluster.minikube_cluster_exists")
+    @patch("jumpstarter_kubernetes.cluster.run_command_with_output")
+    async def test_delete_minikube_cluster_success(
+        self, mock_run_command, mock_cluster_exists, mock_minikube_installed
+    ):
+        mock_minikube_installed.return_value = True
+        mock_cluster_exists.return_value = True
+        mock_run_command.return_value = 0
+
+        result = await delete_minikube_cluster("minikube", "test-cluster")
+
+        assert result is True
+        mock_run_command.assert_called_once_with(["minikube", "delete", "-p", "test-cluster"])
+
+    @pytest.mark.asyncio
+    @patch("jumpstarter_kubernetes.cluster.minikube_installed")
+    @patch("jumpstarter_kubernetes.cluster.minikube_cluster_exists")
+    async def test_delete_minikube_cluster_already_deleted(self, mock_cluster_exists, mock_minikube_installed):
+        mock_minikube_installed.return_value = True
+        mock_cluster_exists.return_value = False
+
+        result = await delete_minikube_cluster("minikube", "test-cluster")
+
+        assert result is True  # Already deleted, consider successful
+
+    @pytest.mark.asyncio
+    @patch("jumpstarter_kubernetes.cluster.minikube_installed")
+    @patch("jumpstarter_kubernetes.cluster.minikube_cluster_exists")
+    @patch("jumpstarter_kubernetes.cluster.run_command_with_output")
+    async def test_delete_minikube_cluster_failure(
+        self, mock_run_command, mock_cluster_exists, mock_minikube_installed
+    ):
+        mock_minikube_installed.return_value = True
+        mock_cluster_exists.return_value = True
+        mock_run_command.return_value = 1
+
+        with pytest.raises(RuntimeError, match="Failed to delete Minikube cluster 'test-cluster'"):
+            await delete_minikube_cluster("minikube", "test-cluster")

jumpstarter_kubernetes-0.7.1/jumpstarter_kubernetes/datetime.py

@@ -0,0 +1,32 @@
+from datetime import datetime, timezone
+
+
+def time_since(t_str: str):
+    # Format the elapsed time in a readable way
+    t = datetime.strptime(t_str, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=timezone.utc)
+    now = datetime.now(timezone.utc)
+    elapsed = now - t
+
+    # Format the elapsed time in a readable way
+    if elapsed.total_seconds() < 60:
+        return f"{int(elapsed.total_seconds())}s"
+    elif elapsed.total_seconds() < 3600:
+        minutes = int(elapsed.total_seconds() // 60)
+        seconds = int(elapsed.total_seconds() % 60)
+        return f"{minutes}m{seconds}s" if seconds > 0 else f"{minutes}m"
+    elif elapsed.total_seconds() < 86400:
+        hours = int(elapsed.total_seconds() // 3600)
+        minutes = int((elapsed.total_seconds() % 3600) // 60)
+        return f"{hours}h{minutes}m" if minutes > 0 and hours < 2 else f"{hours}h"
+    elif elapsed.total_seconds() < 2592000:
+        days = elapsed.days
+        hours = int((elapsed.total_seconds() % 86400) // 3600)
+        return f"{days}d{hours}h" if hours > 0 else f"{days}d"
+    elif elapsed.total_seconds() < 31536000:
+        months = int(elapsed.days / 30)
+        days = elapsed.days % 30
+        return f"{months}mo{days}d" if days > 0 else f"{months}mo"
+    else:
+        years = int(elapsed.days / 365)
+        months = int((elapsed.days % 365) / 30)
+        return f"{years}y{months}mo" if months > 0 else f"{years}y"

{jumpstarter_kubernetes-0.6.0 → jumpstarter_kubernetes-0.7.1}/jumpstarter_kubernetes/exporters.py

@@ -5,6 +5,7 @@ from typing import Literal
 from kubernetes_asyncio.client.models import V1ObjectMeta, V1ObjectReference
 from pydantic import Field
 
+from .datetime import time_since
 from .json import JsonBaseModel
 from .list import V1Alpha1List
 from .serialize import SerializeV1ObjectMeta, SerializeV1ObjectReference
@@ -57,6 +58,47 @@ class V1Alpha1Exporter(JsonBaseModel):
             ),
         )
 
+    @classmethod
+    def rich_add_columns(cls, table, devices: bool = False):
+        if devices:
+            table.add_column("NAME")
+            table.add_column("ENDPOINT")
+            table.add_column("AGE")
+            table.add_column("LABELS")
+            table.add_column("UUID")
+        else:
+            table.add_column("NAME")
+            table.add_column("ENDPOINT")
+            table.add_column("DEVICES")
+            table.add_column("AGE")
+
+    def rich_add_rows(self, table, devices: bool = False):
+        if devices:
+            if self.status is not None:
+                for d in self.status.devices:
+                    labels = []
+                    if d.labels is not None:
+                        for label in d.labels:
+                            labels.append(f"{label}:{str(d.labels[label])}")
+                    table.add_row(
+                        self.metadata.name,
+                        self.status.endpoint,
+                        time_since(self.metadata.creation_timestamp),
+                        ",".join(labels),
+                        d.uuid,
+                    )
+
+        else:
+            table.add_row(
+                self.metadata.name,
+                self.status.endpoint,
+                str(len(self.status.devices) if self.status and self.status.devices else 0),
+                time_since(self.metadata.creation_timestamp),
+            )
+
+    def rich_add_names(self, names):
+        names.append(f"exporter.jumpstarter.dev/{self.metadata.name}")
+
 
 class V1Alpha1ExporterList(V1Alpha1List[V1Alpha1Exporter]):
     kind: Literal["ExporterList"] = Field(default="ExporterList")
@@ -65,6 +107,18 @@ class V1Alpha1ExporterList(V1Alpha1List[V1Alpha1Exporter]):
     def from_dict(dict: dict):
         return V1Alpha1ExporterList(items=[V1Alpha1Exporter.from_dict(c) for c in dict["items"]])
 
+    @classmethod
+    def rich_add_columns(cls, table, **kwargs):
+        V1Alpha1Exporter.rich_add_columns(table, **kwargs)
+
+    def rich_add_rows(self, table, **kwargs):
+        for exporter in self.items:
+            exporter.rich_add_rows(table, **kwargs)
+
+    def rich_add_names(self, names):
+        for exporter in self.items:
+            exporter.rich_add_names(names)
+
 
 class ExportersV1Alpha1Api(AbstractAsyncCustomObjectApi):
     """Interact with the exporters custom resource API"""

{jumpstarter_kubernetes-0.6.0 → jumpstarter_kubernetes-0.7.1}/jumpstarter_kubernetes/install.py

@@ -4,6 +4,7 @@ from typing import Literal, Optional
 
 
 def helm_installed(name: str) -> bool:
+    """Check if Helm is installed and available in the PATH."""
     return shutil.which(name) is not None
 
 
@@ -20,8 +21,6 @@ async def install_helm_chart(
     context: Optional[str],
     helm: Optional[str] = "helm",
 ):
-    grpc_port = grpc_endpoint.split(":")[1]
-    router_port = router_endpoint.split(":")[1]
     args = [
         helm,
         "upgrade",
@@ -42,10 +41,6 @@ async def install_helm_chart(
         "--set",
         f"jumpstarter-controller.grpc.nodeport.enabled={'true' if mode == 'nodeport' else 'false'}",
         "--set",
-        f"jumpstarter-controller.grpc.nodeport.port={grpc_port}",
-        "--set",
-        f"jumpstarter-controller.grpc.nodeport.routerPort={router_port}",
-        "--set",
         f"jumpstarter-controller.grpc.mode={mode}",
         "--version",
         version,
@@ -63,3 +58,28 @@ async def install_helm_chart(
     # Attempt to install Jumpstarter using Helm
     process = await asyncio.create_subprocess_exec(*args)
     await process.wait()
+
+
+async def uninstall_helm_chart(
+    name: str, namespace: str, kubeconfig: Optional[str], context: Optional[str], helm: Optional[str] = "helm"
+):
+    args = [
+        helm,
+        "uninstall",
+        name,
+        "--namespace",
+        namespace,
+        "--wait",
+    ]
+
+    if kubeconfig is not None:
+        args.append("--kubeconfig")
+        args.append(kubeconfig)
+
+    if context is not None:
+        args.append("--kube-context")
+        args.append(context)
+
+    # Attempt to install Jumpstarter using Helm
+    process = await asyncio.create_subprocess_exec(*args)
+    await process.wait()

{jumpstarter_kubernetes-0.6.0 → jumpstarter_kubernetes-0.7.1}/jumpstarter_kubernetes/leases.py

@@ -3,6 +3,7 @@ from typing import Literal, Optional
 from kubernetes_asyncio.client.models import V1Condition, V1ObjectMeta, V1ObjectReference
 from pydantic import Field
 
+from .datetime import time_since
 from .json import JsonBaseModel
 from .list import V1Alpha1List
 from .serialize import SerializeV1Condition, SerializeV1ObjectMeta, SerializeV1ObjectReference
@@ -76,6 +77,56 @@ class V1Alpha1Lease(JsonBaseModel):
             ),
         )
 
+    @classmethod
+    def rich_add_columns(cls, table):
+        table.add_column("NAME")
+        table.add_column("CLIENT")
+        table.add_column("SELECTOR")
+        table.add_column("EXPORTER")
+        table.add_column("DURATION")
+        table.add_column("STATUS")
+        table.add_column("REASON")
+        table.add_column("BEGIN")
+        table.add_column("END")
+        table.add_column("AGE")
+
+    def get_reason(self):
+        condition = self.status.conditions[-1] if len(self.status.conditions) > 0 else None
+        reason = condition.reason if condition is not None else "Unknown"
+        status = condition.status if condition is not None else "False"
+        if reason == "Ready":
+            if status == "True":
+                return "Ready"
+            else:
+                return "Waiting"
+        elif reason == "Expired":
+            if status == "True":
+                return "Expired"
+            else:
+                return "Complete"
+        else:
+            return reason
+
+    def rich_add_rows(self, table):
+        selectors = []
+        for label in self.spec.selector.match_labels:
+            selectors.append(f"{label}:{str(self.spec.selector.match_labels[label])}")
+        table.add_row(
+            self.metadata.name,
+            self.spec.client.name if self.spec.client is not None else "",
+            ",".join(selectors) if len(selectors) > 0 else "*",
+            self.status.exporter.name if self.status.exporter is not None else "",
+            self.spec.duration,
+            "Ended" if self.status.ended else "InProgress",
+            self.get_reason(),
+            self.status.begin_time if self.status.begin_time is not None else "",
+            self.status.end_time if self.status.end_time is not None else "",
+            time_since(self.metadata.creation_timestamp),
+        )
+
+    def rich_add_names(self, names):
+        names.append(f"lease.jumpstarter.dev/{self.metadata.name}")
+
 
 class V1Alpha1LeaseList(V1Alpha1List[V1Alpha1Lease]):
     kind: Literal["LeaseList"] = Field(default="LeaseList")
@@ -84,6 +135,18 @@ class V1Alpha1LeaseList(V1Alpha1List[V1Alpha1Lease]):
     def from_dict(dict: dict):
         return V1Alpha1LeaseList(items=[V1Alpha1Lease.from_dict(c) for c in dict["items"]])
 
+    @classmethod
+    def rich_add_columns(cls, table):
+        V1Alpha1Lease.rich_add_columns(table)
+
+    def rich_add_rows(self, table):
+        for lease in self.items:
+            lease.rich_add_rows(table)
+
+    def rich_add_names(self, names):
+        for lease in self.items:
+            lease.rich_add_names(names)
+
 
 class LeasesV1Alpha1Api(AbstractAsyncCustomObjectApi):
     """Interact with the leases custom resource API"""

{jumpstarter_kubernetes-0.6.0 → jumpstarter_kubernetes-0.7.1}/pyproject.toml

@@ -12,7 +12,7 @@ readme = "README.md"
 license = "Apache-2.0"
 requires-python = ">=3.11"
 dependencies = [
-    "jumpstarter==0.6.0",
+    "jumpstarter==0.7.1",
     "pydantic>=2.8.2",
     "kubernetes>=31.0.0",
     "kubernetes-asyncio>=31.1.0",