jumpstarter-kubernetes 0.7.3__tar.gz

jumpstarter_kubernetes-0.7.3/.gitignore

@@ -0,0 +1,166 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/build/
+docs/build_all/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff cache
+.ruff_cache/

jumpstarter_kubernetes-0.7.3/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: jumpstarter-kubernetes
+Version: 0.7.3
+Project-URL: Homepage, https://jumpstarter.dev
+Project-URL: source_archive, https://github.com/jumpstarter-dev/repo/archive/db953ec55e643f00dbb26a3da0a50dccf68dd74d.zip
+Author-email: Kirk Brauer <kbrauer@hatci.com>
+License-Expression: Apache-2.0
+Requires-Python: >=3.11
+Requires-Dist: jumpstarter
+Requires-Dist: kubernetes-asyncio>=31.1.0
+Requires-Dist: kubernetes>=31.0.0
+Requires-Dist: pydantic>=2.8.2
+Description-Content-Type: text/markdown
+
+# Jumpstarter Kubernetes Library

jumpstarter_kubernetes-0.7.3/README.md

@@ -0,0 +1 @@
+# Jumpstarter Kubernetes Library

jumpstarter_kubernetes-0.7.3/jumpstarter_kubernetes/__init__.py

@@ -0,0 +1,58 @@
+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,
+    V1Alpha1ExporterDevice,
+    V1Alpha1ExporterList,
+    V1Alpha1ExporterStatus,
+)
+from .install import (
+    helm_installed,
+    install_helm_chart,
+    uninstall_helm_chart,
+)
+from .leases import (
+    LeasesV1Alpha1Api,
+    V1Alpha1Lease,
+    V1Alpha1LeaseList,
+    V1Alpha1LeaseSelector,
+    V1Alpha1LeaseSpec,
+    V1Alpha1LeaseStatus,
+)
+from .list import V1Alpha1List
+
+__all__ = [
+    "ClientsV1Alpha1Api",
+    "V1Alpha1Client",
+    "V1Alpha1ClientList",
+    "V1Alpha1ClientStatus",
+    "ExportersV1Alpha1Api",
+    "V1Alpha1Exporter",
+    "V1Alpha1ExporterList",
+    "V1Alpha1ExporterStatus",
+    "V1Alpha1ExporterDevice",
+    "LeasesV1Alpha1Api",
+    "V1Alpha1Lease",
+    "V1Alpha1LeaseStatus",
+    "V1Alpha1LeaseList",
+    "V1Alpha1LeaseSelector",
+    "V1Alpha1LeaseSpec",
+    "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.7.3/jumpstarter_kubernetes/clients.py

@@ -0,0 +1,165 @@
+import asyncio
+import base64
+import logging
+from typing import Literal, Optional
+
+from kubernetes_asyncio.client.models import V1ObjectMeta, V1ObjectReference
+from pydantic import Field
+
+from .json import JsonBaseModel
+from .list import V1Alpha1List
+from .serialize import SerializeV1ObjectMeta, SerializeV1ObjectReference
+from .util import AbstractAsyncCustomObjectApi
+from jumpstarter.config.client import ClientConfigV1Alpha1, ClientConfigV1Alpha1Drivers
+from jumpstarter.config.common import ObjectMeta
+
+logger = logging.getLogger(__name__)
+
+CREATE_CLIENT_DELAY = 1
+CREATE_CLIENT_COUNT = 10
+
+
+class V1Alpha1ClientStatus(JsonBaseModel):
+    credential: Optional[SerializeV1ObjectReference] = None
+    endpoint: str
+
+
+class V1Alpha1Client(JsonBaseModel):
+    api_version: Literal["jumpstarter.dev/v1alpha1"] = Field(alias="apiVersion", default="jumpstarter.dev/v1alpha1")
+    kind: Literal["Client"] = Field(default="Client")
+    metadata: SerializeV1ObjectMeta
+    status: Optional[V1Alpha1ClientStatus]
+
+    @staticmethod
+    def from_dict(dict: dict):
+        return V1Alpha1Client(
+            api_version=dict["apiVersion"],
+            kind=dict["kind"],
+            metadata=V1ObjectMeta(
+                creation_timestamp=dict["metadata"]["creationTimestamp"],
+                generation=dict["metadata"]["generation"],
+                name=dict["metadata"]["name"],
+                namespace=dict["metadata"]["namespace"],
+                resource_version=dict["metadata"]["resourceVersion"],
+                uid=dict["metadata"]["uid"],
+            ),
+            status=V1Alpha1ClientStatus(
+                credential=V1ObjectReference(name=dict["status"]["credential"]["name"])
+                if "credential" in dict["status"]
+                else None,
+                endpoint=dict["status"].get("endpoint", ""),
+            )
+            if "status" in dict
+            else None,
+        )
+
+    @classmethod
+    def rich_add_columns(cls, table):
+        table.add_column("NAME", no_wrap=True)
+        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")
+
+    @staticmethod
+    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"""
+
+    async def create_client(
+        self, name: str, labels: dict[str, str] | None = None, oidc_username: str | None = None
+    ) -> V1Alpha1Client:
+        """Create a client object in the cluster async"""
+        # Create the namespaced client object
+        await self.api.create_namespaced_custom_object(
+            namespace=self.namespace,
+            group="jumpstarter.dev",
+            plural="clients",
+            version="v1alpha1",
+            body={
+                "apiVersion": "jumpstarter.dev/v1alpha1",
+                "kind": "Client",
+                "metadata": {"name": name} | {"labels": labels} if labels is not None else {},
+                "spec": {"username": oidc_username} if oidc_username is not None else {},
+            },
+        )
+        # Wait for the credentials to become available
+        # NOTE: Watch is not working here with the Python kubernetes library
+        count = 0
+        updated_client = {}
+        # Retry for a maximum of 10s
+        while count < CREATE_CLIENT_COUNT:
+            # Try to get the updated client resource
+            updated_client = await self.api.get_namespaced_custom_object(
+                namespace=self.namespace, group="jumpstarter.dev", plural="clients", version="v1alpha1", name=name
+            )
+            # check if the client status is updated with the credentials
+            if "status" in updated_client:
+                if "credential" in updated_client["status"]:
+                    return V1Alpha1Client.from_dict(updated_client)
+            count += 1
+            await asyncio.sleep(CREATE_CLIENT_DELAY)
+        raise Exception("Timeout waiting for client credentials")
+
+    async def list_clients(self) -> V1Alpha1List[V1Alpha1Client]:
+        """List the client objects in the cluster async"""
+        res = await self.api.list_namespaced_custom_object(
+            namespace=self.namespace, group="jumpstarter.dev", plural="clients", version="v1alpha1"
+        )
+        return V1Alpha1ClientList.from_dict(res)
+
+    async def get_client(self, name: str) -> V1Alpha1Client:
+        """Get a single client object from the cluster async"""
+        result = await self.api.get_namespaced_custom_object(
+            namespace=self.namespace, group="jumpstarter.dev", plural="clients", version="v1alpha1", name=name
+        )
+        return V1Alpha1Client.from_dict(result)
+
+    async def get_client_config(self, name: str, allow: list[str], unsafe=False) -> ClientConfigV1Alpha1:
+        """Get a client config for a specified client name"""
+        client = await self.get_client(name)
+        secret = await self.core_api.read_namespaced_secret(client.status.credential.name, self.namespace)
+        endpoint = client.status.endpoint
+        token = base64.b64decode(secret.data["token"]).decode("utf8")
+        return ClientConfigV1Alpha1(
+            alias=name,
+            metadata=ObjectMeta(
+                namespace=client.metadata.namespace,
+                name=client.metadata.name,
+            ),
+            endpoint=endpoint,
+            token=token,
+            drivers=ClientConfigV1Alpha1Drivers(allow=allow, unsafe=unsafe),
+        )
+
+    async def delete_client(self, name: str):
+        """Delete a client object"""
+        await self.api.delete_namespaced_custom_object(
+            namespace=self.namespace, group="jumpstarter.dev", plural="clients", version="v1alpha1", name=name
+        )

jumpstarter_kubernetes-0.7.3/jumpstarter_kubernetes/clients_test.py

@@ -0,0 +1,58 @@
+from kubernetes_asyncio.client.models import V1ObjectMeta
+
+from jumpstarter_kubernetes import V1Alpha1Client, V1Alpha1ClientStatus
+
+TEST_CLIENT = V1Alpha1Client(
+    api_version="jumpstarter.dev/v1alpha1",
+    kind="Client",
+    metadata=V1ObjectMeta(
+        creation_timestamp="2021-10-01T00:00:00Z",
+        generation=1,
+        name="test-client",
+        namespace="default",
+        resource_version="1",
+        uid="7a25eb81-6443-47ec-a62f-50165bffede8",
+    ),
+    status=V1Alpha1ClientStatus(credential=None, endpoint="https://test-client"),
+)
+
+
+def test_client_dump_json():
+    assert (
+        TEST_CLIENT.dump_json()
+        == """{
+    "apiVersion": "jumpstarter.dev/v1alpha1",
+    "kind": "Client",
+    "metadata": {
+        "creationTimestamp": "2021-10-01T00:00:00Z",
+        "generation": 1,
+        "name": "test-client",
+        "namespace": "default",
+        "resourceVersion": "1",
+        "uid": "7a25eb81-6443-47ec-a62f-50165bffede8"
+    },
+    "status": {
+        "credential": null,
+        "endpoint": "https://test-client"
+    }
+}"""
+    )
+
+
+def test_client_dump_yaml():
+    assert (
+        TEST_CLIENT.dump_yaml()
+        == """apiVersion: jumpstarter.dev/v1alpha1
+kind: Client
+metadata:
+  creationTimestamp: '2021-10-01T00:00:00Z'
+  generation: 1
+  name: test-client
+  namespace: default
+  resourceVersion: '1'
+  uid: 7a25eb81-6443-47ec-a62f-50165bffede8
+status:
+  credential: null
+  endpoint: https://test-client
+"""
+    )

jumpstarter_kubernetes-0.7.3/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}'")