jumpstarter-kubernetes 0.6.0__py3-none-any.whl

jumpstarter_kubernetes/__init__.py

@@ -0,0 +1,39 @@
+from .clients import ClientsV1Alpha1Api, V1Alpha1Client, V1Alpha1ClientList, V1Alpha1ClientStatus
+from .exporters import (
+    ExportersV1Alpha1Api,
+    V1Alpha1Exporter,
+    V1Alpha1ExporterDevice,
+    V1Alpha1ExporterList,
+    V1Alpha1ExporterStatus,
+)
+from .install import helm_installed, install_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",
+]

jumpstarter_kubernetes/clients.py

@@ -0,0 +1,138 @@
+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,
+        )
+
+
+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", [])])
+
+
+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/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/exporters.py

@@ -0,0 +1,146 @@
+import asyncio
+import base64
+from typing import Literal
+
+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.common import ObjectMeta
+from jumpstarter.config.exporter import ExporterConfigV1Alpha1
+
+CREATE_EXPORTER_DELAY = 1
+CREATE_EXPORTER_COUNT = 10
+
+
+class V1Alpha1ExporterDevice(JsonBaseModel):
+    labels: dict[str, str]
+    uuid: str
+
+
+class V1Alpha1ExporterStatus(JsonBaseModel):
+    credential: SerializeV1ObjectReference
+    devices: list[V1Alpha1ExporterDevice]
+    endpoint: str
+
+
+class V1Alpha1Exporter(JsonBaseModel):
+    api_version: Literal["jumpstarter.dev/v1alpha1"] = Field(alias="apiVersion", default="jumpstarter.dev/v1alpha1")
+    kind: Literal["Exporter"] = Field(default="Exporter")
+    metadata: SerializeV1ObjectMeta
+    status: V1Alpha1ExporterStatus
+
+    @staticmethod
+    def from_dict(dict: dict):
+        return V1Alpha1Exporter(
+            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=V1Alpha1ExporterStatus(
+                credential=V1ObjectReference(name=dict["status"]["credential"]["name"])
+                if "credential" in dict["status"]
+                else None,
+                endpoint=dict["status"]["endpoint"],
+                devices=[V1Alpha1ExporterDevice(labels=d["labels"], uuid=d["uuid"]) for d in dict["status"]["devices"]]
+                if "devices" in dict["status"]
+                else [],
+            ),
+        )
+
+
+class V1Alpha1ExporterList(V1Alpha1List[V1Alpha1Exporter]):
+    kind: Literal["ExporterList"] = Field(default="ExporterList")
+
+    @staticmethod
+    def from_dict(dict: dict):
+        return V1Alpha1ExporterList(items=[V1Alpha1Exporter.from_dict(c) for c in dict["items"]])
+
+
+class ExportersV1Alpha1Api(AbstractAsyncCustomObjectApi):
+    """Interact with the exporters custom resource API"""
+
+    async def list_exporters(self) -> V1Alpha1List[V1Alpha1Exporter]:
+        """List the exporter objects in the cluster"""
+        res = await self.api.list_namespaced_custom_object(
+            namespace=self.namespace, group="jumpstarter.dev", plural="exporters", version="v1alpha1"
+        )
+        return V1Alpha1ExporterList.from_dict(res)
+
+    async def get_exporter(self, name: str) -> V1Alpha1Exporter:
+        """Get a single exporter object from the cluster"""
+        result = await self.api.get_namespaced_custom_object(
+            namespace=self.namespace, group="jumpstarter.dev", plural="exporters", version="v1alpha1", name=name
+        )
+        return V1Alpha1Exporter.from_dict(result)
+
+    async def create_exporter(
+        self, name: str, labels: dict[str, str] | None = None, oidc_username: str | None = None
+    ) -> V1Alpha1Exporter:
+        """Create an exporter in the cluster"""
+        # Create the namespaced exporter object
+        await self.api.create_namespaced_custom_object(
+            namespace=self.namespace,
+            group="jumpstarter.dev",
+            plural="exporters",
+            version="v1alpha1",
+            body={
+                "apiVersion": "jumpstarter.dev/v1alpha1",
+                "kind": "Exporter",
+                "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_exporter = {}
+        # Retry for a maximum of 10s
+        while count < CREATE_EXPORTER_COUNT:
+            # Try to get the updated client resource
+            updated_exporter = await self.api.get_namespaced_custom_object(
+                namespace=self.namespace, group="jumpstarter.dev", plural="exporters", version="v1alpha1", name=name
+            )
+            # check if the client status is updated with the credentials
+            if "status" in updated_exporter:
+                if "credential" in updated_exporter["status"]:
+                    return V1Alpha1Exporter.from_dict(updated_exporter)
+            count += 1
+            await asyncio.sleep(CREATE_EXPORTER_DELAY)
+        raise Exception("Timeout waiting for exporter credentials")
+
+    async def get_exporter_config(self, name: str) -> ExporterConfigV1Alpha1:
+        """Get an exporter config for a specified exporter name"""
+        exporter = await self.get_exporter(name)
+        secret = await self.core_api.read_namespaced_secret(exporter.status.credential.name, self.namespace)
+        endpoint = exporter.status.endpoint
+        token = base64.b64decode(secret.data["token"]).decode("utf8")
+        return ExporterConfigV1Alpha1(
+            alias=name,
+            metadata=ObjectMeta(
+                namespace=exporter.metadata.namespace,
+                name=exporter.metadata.name,
+            ),
+            endpoint=endpoint,
+            token=token,
+            export={},
+        )
+
+    async def delete_exporter(self, name: str):
+        """Delete an exporter object"""
+        await self.api.delete_namespaced_custom_object(
+            namespace=self.namespace,
+            name=name,
+            group="jumpstarter.dev",
+            plural="exporters",
+            version="v1alpha1",
+        )

jumpstarter_kubernetes/exporters_test.py

@@ -0,0 +1,77 @@
+from kubernetes_asyncio.client.models import V1ObjectMeta, V1ObjectReference
+
+from jumpstarter_kubernetes.exporters import V1Alpha1Exporter, V1Alpha1ExporterDevice, V1Alpha1ExporterStatus
+
+TEST_EXPORTER = V1Alpha1Exporter(
+    api_version="jumpstarter.dev/v1alpha1",
+    kind="Exporter",
+    metadata=V1ObjectMeta(
+        creation_timestamp="2021-10-01T00:00:00Z",
+        generation=1,
+        name="test-exporter",
+        namespace="default",
+        resource_version="1",
+        uid="7a25eb81-6443-47ec-a62f-50165bffede8",
+    ),
+    status=V1Alpha1ExporterStatus(
+        credential=V1ObjectReference(name="test-credential"),
+        devices=[V1Alpha1ExporterDevice(labels={"test": "label"}, uuid="f4cf49ab-fc64-46c6-94e7-a40502eb77b1")],
+        endpoint="https://test-exporter",
+    ),
+)
+
+
+def test_exporter_dump_json():
+    assert (
+        TEST_EXPORTER.dump_json()
+        == """{
+    "apiVersion": "jumpstarter.dev/v1alpha1",
+    "kind": "Exporter",
+    "metadata": {
+        "creationTimestamp": "2021-10-01T00:00:00Z",
+        "generation": 1,
+        "name": "test-exporter",
+        "namespace": "default",
+        "resourceVersion": "1",
+        "uid": "7a25eb81-6443-47ec-a62f-50165bffede8"
+    },
+    "status": {
+        "credential": {
+            "name": "test-credential"
+        },
+        "devices": [
+            {
+                "labels": {
+                    "test": "label"
+                },
+                "uuid": "f4cf49ab-fc64-46c6-94e7-a40502eb77b1"
+            }
+        ],
+        "endpoint": "https://test-exporter"
+    }
+}"""
+    )
+
+
+def test_exporter_dump_yaml():
+    assert (
+        TEST_EXPORTER.dump_yaml()
+        == """apiVersion: jumpstarter.dev/v1alpha1
+kind: Exporter
+metadata:
+  creationTimestamp: '2021-10-01T00:00:00Z'
+  generation: 1
+  name: test-exporter
+  namespace: default
+  resourceVersion: '1'
+  uid: 7a25eb81-6443-47ec-a62f-50165bffede8
+status:
+  credential:
+    name: test-credential
+  devices:
+  - labels:
+      test: label
+    uuid: f4cf49ab-fc64-46c6-94e7-a40502eb77b1
+  endpoint: https://test-exporter
+"""
+    )

jumpstarter_kubernetes/install.py

@@ -0,0 +1,65 @@
+import asyncio
+import shutil
+from typing import Literal, Optional
+
+
+def helm_installed(name: str) -> bool:
+    return shutil.which(name) is not None
+
+
+async def install_helm_chart(
+    chart: str,
+    name: str,
+    namespace: str,
+    basedomain: str,
+    grpc_endpoint: str,
+    router_endpoint: str,
+    mode: Literal["nodeport"] | Literal["ingress"] | Literal["route"],
+    version: str,
+    kubeconfig: Optional[str],
+    context: Optional[str],
+    helm: Optional[str] = "helm",
+):
+    grpc_port = grpc_endpoint.split(":")[1]
+    router_port = router_endpoint.split(":")[1]
+    args = [
+        helm,
+        "upgrade",
+        name,
+        "--install",
+        chart,
+        "--create-namespace",
+        "--namespace",
+        namespace,
+        "--set",
+        f"global.baseDomain={basedomain}",
+        "--set",
+        f"jumpstarter-controller.grpc.endpoint={grpc_endpoint}",
+        "--set",
+        f"jumpstarter-controller.grpc.routerEndpoint={router_endpoint}",
+        "--set",
+        "global.metrics.enabled=false",
+        "--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,
+        "--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/json.py

@@ -0,0 +1,14 @@
+import yaml
+from pydantic import BaseModel, ConfigDict
+
+
+class JsonBaseModel(BaseModel):
+    """A Pydantic BaseModel with additional Jumpstarter JSON options applied."""
+
+    def dump_json(self):
+        return self.model_dump_json(indent=4, by_alias=True)
+
+    def dump_yaml(self):
+        return yaml.safe_dump(self.model_dump(mode="json", by_alias=True), indent=2)
+
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)

jumpstarter_kubernetes/leases.py

@@ -0,0 +1,103 @@
+from typing import Literal, Optional
+
+from kubernetes_asyncio.client.models import V1Condition, V1ObjectMeta, V1ObjectReference
+from pydantic import Field
+
+from .json import JsonBaseModel
+from .list import V1Alpha1List
+from .serialize import SerializeV1Condition, SerializeV1ObjectMeta, SerializeV1ObjectReference
+from .util import AbstractAsyncCustomObjectApi
+
+
+class V1Alpha1LeaseStatus(JsonBaseModel):
+    begin_time: Optional[str] = Field(alias="beginTime")
+    conditions: list[SerializeV1Condition]
+    end_time: Optional[str] = Field(alias="endTime")
+    ended: bool
+    exporter: Optional[SerializeV1ObjectReference]
+
+
+class V1Alpha1LeaseSelector(JsonBaseModel):
+    match_labels: dict[str, str] = Field(alias="matchLabels")
+
+
+class V1Alpha1LeaseSpec(JsonBaseModel):
+    client: SerializeV1ObjectReference
+    duration: Optional[str]
+    selector: V1Alpha1LeaseSelector
+
+
+class V1Alpha1Lease(JsonBaseModel):
+    api_version: Literal["jumpstarter.dev/v1alpha1"] = Field(alias="apiVersion", default="jumpstarter.dev/v1alpha1")
+    kind: Literal["Lease"] = Field(default="Lease")
+    metadata: SerializeV1ObjectMeta
+    spec: V1Alpha1LeaseSpec
+    status: V1Alpha1LeaseStatus
+
+    @staticmethod
+    def from_dict(dict: dict):
+        return V1Alpha1Lease(
+            api_version=dict["apiVersion"],
+            kind=dict["kind"],
+            metadata=V1ObjectMeta(
+                creation_timestamp=dict["metadata"]["creationTimestamp"],
+                generation=dict["metadata"]["generation"],
+                managed_fields=dict["metadata"]["managedFields"],
+                name=dict["metadata"]["name"],
+                namespace=dict["metadata"]["namespace"],
+                resource_version=dict["metadata"]["resourceVersion"],
+                uid=dict["metadata"]["uid"],
+            ),
+            status=V1Alpha1LeaseStatus(
+                begin_time=dict["status"]["beginTime"] if "beginTime" in dict["status"] else None,
+                end_time=dict["status"]["endTime"] if "endTime" in dict["status"] else None,
+                ended=dict["status"]["ended"],
+                exporter=V1ObjectReference(name=dict["status"]["exporterRef"]["name"])
+                if "exporterRef" in dict["status"]
+                else None,
+                conditions=[
+                    V1Condition(
+                        last_transition_time=cond["lastTransitionTime"],
+                        message=cond["message"],
+                        observed_generation=cond["observedGeneration"],
+                        reason=cond["reason"],
+                        status=cond["status"],
+                        type=cond["type"],
+                    )
+                    for cond in dict["status"]["conditions"]
+                ],
+            ),
+            spec=V1Alpha1LeaseSpec(
+                client=V1ObjectReference(name=dict["spec"]["clientRef"]["name"])
+                if "clientRef" in dict["spec"]
+                else None,
+                duration=dict["spec"]["duration"] if "duration" in dict["spec"] else None,
+                selector=V1Alpha1LeaseSelector(match_labels=dict["spec"]["selector"]["matchLabels"]),
+            ),
+        )
+
+
+class V1Alpha1LeaseList(V1Alpha1List[V1Alpha1Lease]):
+    kind: Literal["LeaseList"] = Field(default="LeaseList")
+
+    @staticmethod
+    def from_dict(dict: dict):
+        return V1Alpha1LeaseList(items=[V1Alpha1Lease.from_dict(c) for c in dict["items"]])
+
+
+class LeasesV1Alpha1Api(AbstractAsyncCustomObjectApi):
+    """Interact with the leases custom resource API"""
+
+    async def list_leases(self) -> V1Alpha1List[V1Alpha1Lease]:
+        """List the lease objects in the cluster async"""
+        result = await self.api.list_namespaced_custom_object(
+            namespace=self.namespace, group="jumpstarter.dev", plural="leases", version="v1alpha1"
+        )
+        return V1Alpha1LeaseList.from_dict(result)
+
+    async def get_lease(self, name: str) -> V1Alpha1Lease:
+        """Get a single lease object from the cluster async"""
+        result = await self.api.get_namespaced_custom_object(
+            namespace=self.namespace, group="jumpstarter.dev", plural="leases", version="v1alpha1", name=name
+        )
+        return V1Alpha1Lease.from_dict(result)

jumpstarter_kubernetes/list.py

@@ -0,0 +1,15 @@
+from typing import Generic, Literal, TypeVar
+
+from pydantic import Field
+
+from .json import JsonBaseModel
+
+T = TypeVar("T")
+
+
+class V1Alpha1List(JsonBaseModel, Generic[T]):
+    """A generic list result type."""
+
+    api_version: Literal["jumpstarter.dev/v1alpha1"] = Field(alias="apiVersion", default="jumpstarter.dev/v1alpha1")
+    items: list[T]
+    kind: Literal["List"] = Field(default="List")

jumpstarter_kubernetes/serialize.py

@@ -0,0 +1,14 @@
+from typing import Annotated, Any, Dict
+
+from kubernetes_asyncio.client.models import V1Condition, V1ObjectMeta, V1ObjectReference
+from pydantic import WrapSerializer
+
+
+def k8s_obj_to_dict(value: Any, handler, info) -> Dict[str, Any]:
+    result = value.to_dict(serialize=True)
+    return {k: v for k, v in result.items() if v is not None}
+
+
+SerializeV1Condition = Annotated[V1Condition, WrapSerializer(k8s_obj_to_dict)]
+SerializeV1ObjectMeta = Annotated[V1ObjectMeta, WrapSerializer(k8s_obj_to_dict)]
+SerializeV1ObjectReference = Annotated[V1ObjectReference, WrapSerializer(k8s_obj_to_dict)]

jumpstarter_kubernetes/test_leases.py

@@ -0,0 +1,117 @@
+from kubernetes_asyncio.client.models import V1Condition, V1ObjectMeta, V1ObjectReference
+
+from jumpstarter_kubernetes import V1Alpha1Lease, V1Alpha1LeaseSelector, V1Alpha1LeaseSpec, V1Alpha1LeaseStatus
+
+TEST_LEASE = V1Alpha1Lease(
+    api_version="jumpstarter.dev/v1alpha1",
+    kind="Lease",
+    metadata=V1ObjectMeta(
+        creation_timestamp="2021-10-01T00:00:00Z",
+        generation=1,
+        name="test-lease",
+        namespace="default",
+        resource_version="1",
+        uid="7a25eb81-6443-47ec-a62f-50165bffede8",
+    ),
+    spec=V1Alpha1LeaseSpec(
+        client=V1ObjectReference(name="test-client"),
+        duration="1h",
+        selector=V1Alpha1LeaseSelector(match_labels={"test": "label", "another": "something"}),
+    ),
+    status=V1Alpha1LeaseStatus(
+        begin_time="2021-10-01T00:00:00Z",
+        conditions=[
+            V1Condition(
+                last_transition_time="2021-10-01T00:00:00Z", status="True", type="Active", message="", reason=""
+            )
+        ],
+        end_time="2021-10-01T01:00:00Z",
+        ended=False,
+        exporter=V1ObjectReference(name="test-exporter"),
+    ),
+)
+
+
+def test_lease_dump_json():
+    print(TEST_LEASE.dump_json())
+    assert (
+        TEST_LEASE.dump_json()
+        == """{
+    "apiVersion": "jumpstarter.dev/v1alpha1",
+    "kind": "Lease",
+    "metadata": {
+        "creationTimestamp": "2021-10-01T00:00:00Z",
+        "generation": 1,
+        "name": "test-lease",
+        "namespace": "default",
+        "resourceVersion": "1",
+        "uid": "7a25eb81-6443-47ec-a62f-50165bffede8"
+    },
+    "spec": {
+        "client": {
+            "name": "test-client"
+        },
+        "duration": "1h",
+        "selector": {
+            "matchLabels": {
+                "test": "label",
+                "another": "something"
+            }
+        }
+    },
+    "status": {
+        "beginTime": "2021-10-01T00:00:00Z",
+        "conditions": [
+            {
+                "lastTransitionTime": "2021-10-01T00:00:00Z",
+                "message": "",
+                "reason": "",
+                "status": "True",
+                "type": "Active"
+            }
+        ],
+        "endTime": "2021-10-01T01:00:00Z",
+        "ended": false,
+        "exporter": {
+            "name": "test-exporter"
+        }
+    }
+}"""
+    )
+
+
+def test_lease_dump_yaml():
+    print(TEST_LEASE.dump_yaml())
+    assert (
+        TEST_LEASE.dump_yaml()
+        == """apiVersion: jumpstarter.dev/v1alpha1
+kind: Lease
+metadata:
+  creationTimestamp: '2021-10-01T00:00:00Z'
+  generation: 1
+  name: test-lease
+  namespace: default
+  resourceVersion: '1'
+  uid: 7a25eb81-6443-47ec-a62f-50165bffede8
+spec:
+  client:
+    name: test-client
+  duration: 1h
+  selector:
+    matchLabels:
+      another: something
+      test: label
+status:
+  beginTime: '2021-10-01T00:00:00Z'
+  conditions:
+  - lastTransitionTime: '2021-10-01T00:00:00Z'
+    message: ''
+    reason: ''
+    status: 'True'
+    type: Active
+  endTime: '2021-10-01T01:00:00Z'
+  ended: false
+  exporter:
+    name: test-exporter
+"""
+    )

jumpstarter_kubernetes/util/__init__.py

@@ -0,0 +1,3 @@
+from .async_custom_object_api import AbstractAsyncCustomObjectApi
+
+__all__ = ["AbstractAsyncCustomObjectApi"]

jumpstarter_kubernetes/util/async_custom_object_api.py

@@ -0,0 +1,43 @@
+from contextlib import AbstractAsyncContextManager
+from typing import Optional, Self
+
+from kubernetes_asyncio import config
+from kubernetes_asyncio.client.api import CoreV1Api, CustomObjectsApi
+from kubernetes_asyncio.client.api_client import ApiClient
+
+
+class AbstractAsyncCustomObjectApi(AbstractAsyncContextManager):
+    """An abstract async custom object API client"""
+
+    _client: ApiClient
+    config_file: Optional[str]
+    context: Optional[str]
+    namespace: str
+    api: CustomObjectsApi
+    core_api: CoreV1Api
+
+    def __init__(self, namespace: str, config_file: Optional[str] = None, context: Optional[str] = None):
+        self.config_file = config_file
+        self.context = context
+        self.namespace = namespace
+
+    async def __aenter__(self) -> Self:
+        # Load the kubeconfig
+        await self._load_kube_config()
+        # Construct the API client and enter context
+        self._client = ApiClient()
+        await self._client.__aenter__()
+        # Construct the custom objects API client
+        self.api = CustomObjectsApi(self._client)
+        self.core_api = CoreV1Api(self._client)
+        return self
+
+    async def _load_kube_config(self):
+        await config.load_kube_config(self.config_file, self.context)
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        await self._client.__aexit__(exc_type, exc_value, traceback)
+        self._client = None
+        self.api = None
+        self.core_api = None
+        return None

jumpstarter_kubernetes-0.6.0.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: jumpstarter-kubernetes
+Version: 0.6.0
+Project-URL: Homepage, https://jumpstarter.dev
+Project-URL: source_archive, https://github.com/jumpstarter-dev/repo/archive/c2927a2abac82d224c7bd28f9ed83c57b5222e65.zip
+Author-email: Kirk Brauer <kbrauer@hatci.com>
+License-Expression: Apache-2.0
+Requires-Python: >=3.11
+Requires-Dist: jumpstarter==0.6.0
+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.6.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+jumpstarter_kubernetes/__init__.py,sha256=kYHnYJYZ4ly6q7dU2cIOgnbWnO64xU_HmkTMkY0ARpE,983
+jumpstarter_kubernetes/clients.py,sha256=uo43zmWhymfsatM5P87PnwJxzg4pWu9s7JTeamWny0Q,5711
+jumpstarter_kubernetes/clients_test.py,sha256=dGWdFlq08CULXQw_yPT-KXjvQS-BVU5dTB2kU2-2tFo,1457
+jumpstarter_kubernetes/exporters.py,sha256=4PS-kXuriJuKMlYIGcDGaB0lhZLkhg_zCoM-9LwuAD4,5903
+jumpstarter_kubernetes/exporters_test.py,sha256=aKZuw6AGN_FGCnKqTAOp3MRAXrThxKtBVboYYhK-e08,2079
+jumpstarter_kubernetes/install.py,sha256=HjfTwNAK_VKMoFXTqdwNuvagXDSaxS23qQ6ap5qGFGQ,1788
+jumpstarter_kubernetes/json.py,sha256=69BNuBjHASbWpPXIdjiZbcLLh7-DXhYREEUFWfREQec,452
+jumpstarter_kubernetes/leases.py,sha256=o-vmnLRypnDR7aWPxP1LZN28-c5gsD6S4ouoQMzHgyY,4235
+jumpstarter_kubernetes/list.py,sha256=sEJEQDAgxwYC8mmGzT_BG5OsSb4KRAMKLOOlyeH93xg,398
+jumpstarter_kubernetes/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jumpstarter_kubernetes/serialize.py,sha256=ZFKd-PkDaB5zKTn9lqUN7oeZ1ripst0wogIWiEZdndo,593
+jumpstarter_kubernetes/test_leases.py,sha256=uZE5-NF3vLow9GkQGcruq-7KPupfp4uMWWcj96T7NQ0,3042
+jumpstarter_kubernetes/util/__init__.py,sha256=oNVNglqOgDzvcibGGVoBBpcFNJv_w3x-iE0OEDKfZhM,110
+jumpstarter_kubernetes/util/async_custom_object_api.py,sha256=geIgT3yvNYJerwMy2V9bOOAmYXW4n1nA_5BFdsZw-Co,1486
+jumpstarter_kubernetes-0.6.0.dist-info/METADATA,sha256=5yY_P3sJA11-0gyNgqn3lKqREMQJyZXSC0lb94o5su8,550
+jumpstarter_kubernetes-0.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+jumpstarter_kubernetes-0.6.0.dist-info/RECORD,,

jumpstarter_kubernetes-0.6.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any