workload-profile-controller 0.1.0__py3-none-any.whl

workload_profile_controller/application.py

@@ -0,0 +1,13 @@
+from .backends.proxmox.factory import create_proxmox_backend
+from .config_loader import load_config
+from .controller import Controller
+
+
+def create_controller(config_path: str) -> Controller:
+    config = load_config(config_path)
+    backend = create_proxmox_backend()
+
+    return Controller(
+        config=config,
+        backend=backend,
+    )

workload_profile_controller/backend.py

@@ -0,0 +1,21 @@
+from enum import Enum
+from typing import Protocol
+
+
+class ResourceStatus(Enum):
+    RUNNING = "running"
+    STOPPED = "stopped"
+    STARTING = "starting"
+    STOPPING = "stopping"
+    UNKNOWN = "unknown"
+
+
+class Backend(Protocol):
+    def get_status(self, resource_id: str) -> ResourceStatus:
+        ...
+
+    def start(self, resource_id: str) -> None:
+        ...
+
+    def stop(self, resource_id: str) -> None:
+        ...

workload_profile_controller/backends/proxmox/auth.py

@@ -0,0 +1,15 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class ProxmoxToken:
+    user: str
+    token_name: str
+    secret: str
+
+    def authorization_header(self) -> str:
+        return (
+            "PVEAPIToken="
+            f"{self.user}!{self.token_name}="
+            f"{self.secret}"
+        )

workload_profile_controller/backends/proxmox/backend.py

@@ -0,0 +1,97 @@
+from ...backend import Backend, ResourceStatus
+from .discovery import ProxmoxDiscovery
+from .inventory import ProxmoxResourceType
+from .resource_client import ProxmoxResourceClient
+from .task_waiter import TaskWaiter
+
+
+class ProxmoxBackend(Backend):
+    def __init__(
+        self,
+        discovery: ProxmoxDiscovery,
+        resource_client: ProxmoxResourceClient,
+        task_waiter: TaskWaiter,
+    ):
+        self._discovery = discovery
+        self._resource_client = resource_client
+        self._task_waiter = task_waiter
+
+    def get_status(self, resource_id: str) -> ResourceStatus:
+        inventory = self._discovery.discover()
+        resource = inventory.resolve(resource_id)
+
+        if resource.resource_type == ProxmoxResourceType.QEMU:
+            data = self._resource_client.get_qemu_status(
+                resource.proxmox_id
+            )
+        elif resource.resource_type == ProxmoxResourceType.LXC:
+            data = self._resource_client.get_lxc_status(
+                resource.proxmox_id
+            )
+        else:
+            raise RuntimeError(
+                f"Unsupported Proxmox resource type: "
+                f"{resource.resource_type}"
+            )
+
+        status = data["status"]
+
+        if status == "running":
+            return ResourceStatus.RUNNING
+
+        if status == "stopped":
+            return ResourceStatus.STOPPED
+
+        if status == "starting":
+            return ResourceStatus.STARTING
+
+        if status == "stopping":
+            return ResourceStatus.STOPPING
+
+        return ResourceStatus.UNKNOWN
+
+    def start(self, resource_id: str) -> None:
+        inventory = self._discovery.discover()
+        resource = inventory.resolve(resource_id)
+
+        if resource.resource_type == ProxmoxResourceType.QEMU:
+            upid = self._resource_client.start_qemu(
+                resource.proxmox_id
+            )
+            self._task_waiter.wait(upid)
+            return
+
+        if resource.resource_type == ProxmoxResourceType.LXC:
+            upid = self._resource_client.start_lxc(
+                resource.proxmox_id
+            )
+            self._task_waiter.wait(upid)
+            return
+
+        raise RuntimeError(
+            f"Unsupported Proxmox resource type: "
+            f"{resource.resource_type}"
+        )
+
+    def stop(self, resource_id: str) -> None:
+        inventory = self._discovery.discover()
+        resource = inventory.resolve(resource_id)
+
+        if resource.resource_type == ProxmoxResourceType.QEMU:
+            upid = self._resource_client.stop_qemu(
+                resource.proxmox_id
+            )
+            self._task_waiter.wait(upid)
+            return
+
+        if resource.resource_type == ProxmoxResourceType.LXC:
+            upid = self._resource_client.stop_lxc(
+                resource.proxmox_id
+            )
+            self._task_waiter.wait(upid)
+            return
+
+        raise RuntimeError(
+            f"Unsupported Proxmox resource type: "
+            f"{resource.resource_type}"
+        )

workload_profile_controller/backends/proxmox/config.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class ProxmoxConfig:
+    host: str
+    node: str
+    user: str
+    token_name: str
+    token_secret: str
+    verify_tls: bool = True
+    ca_file: str | None = None
+    tls_server_name: str | None = None
+    timeout: float = 5.0
+    task_timeout: float = 120.0
+    shutdown_timeout: float = 120.0

workload_profile_controller/backends/proxmox/config_loader.py

@@ -0,0 +1,46 @@
+import os
+
+from dotenv import load_dotenv
+
+from .config import ProxmoxConfig
+
+load_dotenv()
+
+
+def load_proxmox_config() -> ProxmoxConfig:
+    return ProxmoxConfig(
+        host=os.environ["PVE_PROXMOX_HOST"],
+        node=os.environ["PVE_PROXMOX_NODE"],
+        user=os.environ["PVE_PROXMOX_USER"],
+        token_name=os.environ["PVE_PROXMOX_TOKEN_NAME"],
+        token_secret=os.environ["PVE_PROXMOX_TOKEN_SECRET"],
+        verify_tls=os.environ.get(
+            "PVE_PROXMOX_VERIFY_TLS",
+            "true",
+        ).lower() == "true",
+        ca_file=os.environ.get(
+            "PVE_PROXMOX_CA_FILE",
+        ),
+        tls_server_name=os.environ.get(
+            "PVE_PROXMOX_TLS_SERVER_NAME",
+        ),
+        timeout=float(
+            os.environ.get(
+                "PVE_PROXMOX_TIMEOUT",
+                "5.0",
+            )
+        
+        ),
+        task_timeout=float(
+            os.environ.get(
+                "PVE_PROXMOX_TASK_TIMEOUT",
+                "120.0",
+            )  
+        ),
+                shutdown_timeout=float(
+            os.environ.get(
+                "PVE_PROXMOX_SHUTDOWN_TIMEOUT",
+                "120.0",
+            )
+        ),
+    )

workload_profile_controller/backends/proxmox/discovery.py

@@ -0,0 +1,54 @@
+from collections.abc import Mapping, Sequence
+
+from .inventory import (
+    ProxmoxInventory,
+    ProxmoxResource,
+    ProxmoxResourceType,
+)
+from .resource_client import ProxmoxResourceClient
+
+
+class ProxmoxDiscovery:
+    def __init__(self, resource_client: ProxmoxResourceClient):
+        self._resource_client = resource_client
+
+    def discover(self) -> ProxmoxInventory:
+        return self.build_inventory(
+            qemu_data=self._resource_client.list_qemu(),
+            lxc_data=self._resource_client.list_lxc(),
+        )
+
+    @staticmethod
+    def build_inventory(
+        qemu_data: Sequence[Mapping[str, object]],
+        lxc_data: Sequence[Mapping[str, object]],
+    ) -> ProxmoxInventory:
+        resources = [
+            *(
+                ProxmoxDiscovery._build_resource(
+                    item,
+                    ProxmoxResourceType.QEMU,
+                )
+                for item in qemu_data
+            ),
+            *(
+                ProxmoxDiscovery._build_resource(
+                    item,
+                    ProxmoxResourceType.LXC,
+                )
+                for item in lxc_data
+            ),
+        ]
+
+        return ProxmoxInventory(resources)
+
+    @staticmethod
+    def _build_resource(
+        data: Mapping[str, object],
+        resource_type: ProxmoxResourceType,
+    ) -> ProxmoxResource:
+        return ProxmoxResource(
+            resource_type=resource_type,
+            proxmox_id=int(data["vmid"]),
+            name=str(data["name"]),
+        )

workload_profile_controller/backends/proxmox/errors.py

@@ -0,0 +1,13 @@
+class ProxmoxHttpError(Exception):
+    def __init__(
+        self,
+        status_code: int,
+        reason: str,
+    ):
+        self.status_code = status_code
+        self.reason = reason
+
+        super().__init__(
+            f"Proxmox API request failed: "
+            f"HTTP {status_code} {reason}"
+        )

workload_profile_controller/backends/proxmox/factory.py

@@ -0,0 +1,43 @@
+from .auth import ProxmoxToken
+from .backend import ProxmoxBackend
+from .config_loader import load_proxmox_config
+from .discovery import ProxmoxDiscovery
+from .http_client import ProxmoxHttpClient
+from .resource_client import ProxmoxResourceClient
+from .task_waiter import TaskWaiter
+
+
+def create_proxmox_backend() -> ProxmoxBackend:
+    config = load_proxmox_config()
+
+    token = ProxmoxToken(
+        user=config.user,
+        token_name=config.token_name,
+        secret=config.token_secret,
+    )
+
+    http_client = ProxmoxHttpClient(
+        config=config,
+        token=token,
+    )
+
+    resource_client = ProxmoxResourceClient(
+        http_client=http_client,
+        node=config.node,
+        shutdown_timeout=config.shutdown_timeout,
+    )
+
+    discovery = ProxmoxDiscovery(
+        resource_client=resource_client,
+    )
+
+    task_waiter = TaskWaiter(
+        get_status=resource_client.get_task_status,
+        timeout=config.task_timeout,
+    )
+
+    return ProxmoxBackend(
+        discovery=discovery,
+        resource_client=resource_client,
+        task_waiter=task_waiter,
+    )

workload_profile_controller/backends/proxmox/http_client.py

@@ -0,0 +1,107 @@
+import http.client
+import json
+import socket
+import ssl
+import urllib.parse
+from collections.abc import Mapping
+from typing import Any
+
+from .auth import ProxmoxToken
+from .config import ProxmoxConfig
+from .errors import ProxmoxHttpError
+
+
+class _ProxmoxHTTPSConnection(http.client.HTTPSConnection):
+    def __init__(
+        self,
+        connect_host: str,
+        tls_server_name: str | None,
+        context: ssl.SSLContext,
+        timeout: float,
+    ):
+        super().__init__(
+            host=connect_host,
+            port=8006,
+            timeout=timeout,
+            context=context,
+        )
+
+        self._tls_server_name = tls_server_name
+
+    def connect(self):
+        self.sock = socket.create_connection(
+            (self.host, self.port),
+            self.timeout,
+        )
+
+        self.sock = self._context.wrap_socket(
+            self.sock,
+            server_hostname=self._tls_server_name or self.host,
+        )
+
+
+class ProxmoxHttpClient:
+    def __init__(
+        self,
+        config: ProxmoxConfig,
+        token: ProxmoxToken,
+    ):
+        self._config = config
+        self._token = token
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        data: Mapping[str, Any] | None = None,
+    ) -> Any:
+        body = None
+
+        if data is not None:
+            body = urllib.parse.urlencode(data).encode("utf-8")
+
+        context = self._create_ssl_context()
+
+        connection = _ProxmoxHTTPSConnection(
+            connect_host=self._config.host,
+            tls_server_name=self._config.tls_server_name,
+            context=context,
+            timeout=self._config.timeout,
+        )
+
+        try:
+            connection.request(
+                method,
+                f"/api2/json{path}",
+                body=body,
+                headers={
+                    "Authorization": (
+                        self._token.authorization_header()
+                    ),
+                },
+            )
+
+            response = connection.getresponse()
+            if response.status < 200 or response.status >= 300:
+                reason = response.reason or "Unknown error"
+                response.read()
+
+                raise ProxmoxHttpError(
+                    status_code=response.status,
+                    reason=reason,
+                )
+
+            payload = json.load(response)
+
+            return payload["data"]
+
+        finally:
+            connection.close()
+
+    def _create_ssl_context(self) -> ssl.SSLContext:
+        if self._config.verify_tls:
+            return ssl.create_default_context(
+                cafile=self._config.ca_file,
+            )
+
+        return ssl._create_unverified_context()

workload_profile_controller/backends/proxmox/inventory.py

@@ -0,0 +1,52 @@
+from dataclasses import dataclass
+from enum import Enum
+
+from ...errors import ResourceAmbiguousError, ResourceNotFoundError
+
+
+class ProxmoxResourceType(Enum):
+    QEMU = "qemu"
+    LXC = "lxc"
+
+
+@dataclass(frozen=True)
+class ProxmoxResource:
+    resource_type: ProxmoxResourceType
+    proxmox_id: int
+    name: str
+
+
+class ProxmoxInventory:
+    def __init__(self, resources: list[ProxmoxResource]):
+        self._resources = tuple(
+            sorted(
+                resources,
+                key=lambda resource: (
+                    resource.name,
+                    resource.resource_type.value,
+                    resource.proxmox_id,
+                ),
+            )
+        )
+
+    def list_resources(self) -> tuple[ProxmoxResource, ...]:
+        return self._resources
+
+    def resolve(self, name: str) -> ProxmoxResource:
+        matches = tuple(
+            resource
+            for resource in self._resources
+            if resource.name == name
+        )
+
+        if not matches:
+            raise ResourceNotFoundError(
+                f"Proxmox resource not found: {name}"
+            )
+
+        if len(matches) > 1:
+            raise ResourceAmbiguousError(
+                f"Proxmox resource name is ambiguous: {name}"
+            )
+
+        return matches[0]

workload_profile_controller/backends/proxmox/resource_client.py

@@ -0,0 +1,87 @@
+import urllib.parse
+
+from .http_client import ProxmoxHttpClient
+from .task import TaskStatus
+
+
+class ProxmoxResourceClient:
+    def __init__(
+        self,
+        http_client: ProxmoxHttpClient,
+        node: str,
+        shutdown_timeout: float = 120.0,
+    ):
+        self._http_client = http_client
+        self._node = node
+        self._shutdown_timeout = shutdown_timeout
+
+    def list_qemu(self):
+        return self._http_client.request(
+            "GET",
+            f"/nodes/{self._node}/qemu",
+        )
+
+    def list_lxc(self):
+        return self._http_client.request(
+            "GET",
+            f"/nodes/{self._node}/lxc",
+        )
+
+    def get_qemu_status(self, proxmox_id: int):
+        return self._http_client.request(
+            "GET",
+            f"/nodes/{self._node}/qemu/{proxmox_id}/status/current",
+        )
+
+    def get_lxc_status(self, proxmox_id: int):
+        return self._http_client.request(
+            "GET",
+            f"/nodes/{self._node}/lxc/{proxmox_id}/status/current",
+        )
+
+    def start_qemu(self, proxmox_id: int):
+        return self._http_client.request(
+            "POST",
+            f"/nodes/{self._node}/qemu/{proxmox_id}/status/start",
+        )
+
+    def start_lxc(self, proxmox_id: int):
+        return self._http_client.request(
+            "POST",
+            f"/nodes/{self._node}/lxc/{proxmox_id}/status/start",
+        )
+
+    def stop_qemu(self, proxmox_id: int):
+        return self._http_client.request(
+            "POST",
+            f"/nodes/{self._node}/qemu/{proxmox_id}/status/shutdown",
+            data={
+                "timeout": int(self._shutdown_timeout),
+            },
+        )
+
+    def stop_lxc(self, proxmox_id: int):
+        return self._http_client.request(
+            "POST",
+            f"/nodes/{self._node}/lxc/{proxmox_id}/status/shutdown",
+            data={
+                "timeout": int(self._shutdown_timeout),
+            },
+        )
+
+    def get_task_status(self, upid: str) -> TaskStatus:
+        encoded_upid = urllib.parse.quote(
+            upid,
+            safe="",
+        )
+
+        data = self._http_client.request(
+            "GET",
+            f"/nodes/{self._node}/tasks/{encoded_upid}/status",
+        )
+
+        return TaskStatus(
+            upid=upid,
+            status=str(data["status"]),
+            exitstatus=data.get("exitstatus"),
+        )

workload_profile_controller/backends/proxmox/task.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class TaskStatus:
+    upid: str
+    status: str
+    exitstatus: str | None
+
+    @property
+    def is_finished(self) -> bool:
+        return self.status == "stopped"
+
+    @property
+    def is_successful(self) -> bool:
+        return self.is_finished and self.exitstatus == "OK"

workload_profile_controller/backends/proxmox/task_waiter.py

@@ -0,0 +1,53 @@
+from collections.abc import Callable
+from time import sleep, time
+
+from ...errors import TaskFailedError, TaskTimeoutError
+from .task import TaskStatus
+
+
+class TaskWaiter:
+    def __init__(
+        self,
+        get_status: Callable[[str], TaskStatus],
+        timeout: float = 30.0,
+        sleep_fn: Callable[[float], None] = sleep,
+        time_fn: Callable[[], float] = time,
+    ):
+        self._get_status = get_status
+        self._timeout = timeout
+        self._sleep = sleep_fn
+        self._time = time_fn
+
+    def wait(
+        self,
+        upid: str,
+        interval: float = 1.0,
+        timeout: float | None = None,
+    ) -> TaskStatus:
+        effective_timeout = (
+            self._timeout
+            if timeout is None
+            else timeout
+        )
+
+        started_at = self._time()
+
+        while True:
+            status = self._get_status(upid)
+
+            if status.is_finished:
+                if not status.is_successful:
+                    raise TaskFailedError(
+                        f"Task failed: {upid}"
+                    )
+
+                return status
+
+            elapsed = self._time() - started_at
+
+            if elapsed >= effective_timeout:
+                raise TaskTimeoutError(
+                    f"Task timed out: {upid}"
+                )
+
+            self._sleep(interval)