workload-profile-controller 0.1.0__tar.gz → 1.0.0__tar.gz

{workload_profile_controller-0.1.0/src/workload_profile_controller.egg-info → workload_profile_controller-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workload-profile-controller
-Version: 0.1.0
+Version: 1.0.0
 Summary: Safe and configurable workload profile controller
 License-Expression: MIT
 Project-URL: Repository, https://github.com/lack0fcode/workload-profile-controller
@@ -22,6 +22,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: PyYAML>=6.0
 Requires-Dist: python-dotenv>=1.2
+Requires-Dist: boto3>=1.35
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: ruff>=0.12; extra == "dev"

{workload_profile_controller-0.1.0 → workload_profile_controller-1.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "workload-profile-controller"
-version = "0.1.0"
+version = "1.0.0"
 description = "Safe and configurable workload profile controller"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -34,6 +34,7 @@ classifiers = [
 dependencies = [
     "PyYAML>=6.0",
     "python-dotenv>=1.2",
+    "boto3>=1.35",
 ]
 
 [project.optional-dependencies]

workload_profile_controller-1.0.0/src/workload_profile_controller/application.py

@@ -0,0 +1,22 @@
+from .backends.aws.factory import create_aws_backend
+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)
+
+    if config.backend == "proxmox":
+        backend = create_proxmox_backend()
+    elif config.backend == "aws":
+        backend = create_aws_backend()
+    else:
+        raise ValueError(
+            f"Unsupported backend: {config.backend}"
+        )
+
+    return Controller(
+        config=config,
+        backend=backend,
+    )

workload_profile_controller-1.0.0/src/workload_profile_controller/backends/aws/backend.py

@@ -0,0 +1,51 @@
+from ...backend import Backend, ResourceStatus
+from .discovery import AwsDiscovery
+from .resource_client import AwsResourceClient
+
+
+class AwsBackend(Backend):
+    def __init__(
+        self,
+        discovery: AwsDiscovery,
+        resource_client: AwsResourceClient,
+    ):
+        self._discovery = discovery
+        self._resource_client = resource_client
+
+    def get_status(self, resource_id: str) -> ResourceStatus:
+        inventory = self._discovery.discover()
+        resource = inventory.resolve(resource_id)
+
+        state = self._resource_client.get_instance_state(
+            resource.instance_id,
+        )
+
+        if state == "running":
+            return ResourceStatus.RUNNING
+
+        if state == "stopped":
+            return ResourceStatus.STOPPED
+
+        if state == "pending":
+            return ResourceStatus.STARTING
+
+        if state == "stopping":
+            return ResourceStatus.STOPPING
+
+        return ResourceStatus.UNKNOWN
+
+    def start(self, resource_id: str) -> None:
+        inventory = self._discovery.discover()
+        resource = inventory.resolve(resource_id)
+
+        self._resource_client.start_instance(
+            resource.instance_id,
+        )
+
+    def stop(self, resource_id: str) -> None:
+        inventory = self._discovery.discover()
+        resource = inventory.resolve(resource_id)
+
+        self._resource_client.stop_instance(
+            resource.instance_id,
+        )

workload_profile_controller-1.0.0/src/workload_profile_controller/backends/aws/config.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class AwsConfig:
+    region: str
+    profile: str | None = None
+    endpoint_url: str | None = None
+    timeout: float = 5.0
+    operation_timeout: float = 120.0

workload_profile_controller-1.0.0/src/workload_profile_controller/backends/aws/config_loader.py

@@ -0,0 +1,28 @@
+import os
+
+from dotenv import load_dotenv
+
+from .config import AwsConfig
+
+
+load_dotenv()
+
+
+def load_aws_config() -> AwsConfig:
+    return AwsConfig(
+        region=os.environ["WPC_AWS_REGION"],
+        profile=os.environ.get("WPC_AWS_PROFILE"),
+        endpoint_url=os.environ.get("WPC_AWS_ENDPOINT_URL"),
+        timeout=float(
+            os.environ.get(
+                "WPC_AWS_TIMEOUT",
+                "5.0",
+            )
+        ),
+        operation_timeout=float(
+            os.environ.get(
+                "WPC_AWS_OPERATION_TIMEOUT",
+                "120.0",
+            )
+        ),
+    )

workload_profile_controller-1.0.0/src/workload_profile_controller/backends/aws/discovery.py

@@ -0,0 +1,78 @@
+from collections.abc import Mapping, Sequence
+
+from .inventory import AwsInventory, AwsResource
+from .resource_client import AwsResourceClient
+
+
+class AwsDiscovery:
+    def __init__(self, resource_client: AwsResourceClient):
+        self._resource_client = resource_client
+
+    def discover(self) -> AwsInventory:
+        return self.build_inventory(
+            reservations=self._resource_client.list_instances(),
+        )
+
+    @staticmethod
+    def build_inventory(
+        reservations: Sequence[Mapping[str, object]],
+    ) -> AwsInventory:
+        resources = []
+
+        for reservation in reservations:
+            instances = reservation.get("Instances", [])
+
+            if not isinstance(instances, Sequence):
+                continue
+
+            for instance in instances:
+                if not isinstance(instance, Mapping):
+                    continue
+
+                resource = AwsDiscovery._build_resource(instance)
+
+                if resource is not None:
+                    resources.append(resource)
+
+        return AwsInventory(resources)
+
+    @staticmethod
+    def _build_resource(
+        data: Mapping[str, object],
+    ) -> AwsResource | None:
+        instance_id = data.get("InstanceId")
+        tags = data.get("Tags", [])
+
+        if not isinstance(instance_id, str):
+            return None
+
+        name = AwsDiscovery._get_name_tag(tags)
+
+        if name is None:
+            return None
+
+        return AwsResource(
+            instance_id=instance_id,
+            name=name,
+        )
+
+    @staticmethod
+    def _get_name_tag(
+        tags: object,
+    ) -> str | None:
+        if not isinstance(tags, Sequence):
+            return None
+
+        for tag in tags:
+            if not isinstance(tag, Mapping):
+                continue
+
+            if tag.get("Key") == "Name":
+                value = tag.get("Value")
+
+                if isinstance(value, str):
+                    return value
+
+                return None
+
+        return None

workload_profile_controller-1.0.0/src/workload_profile_controller/backends/aws/factory.py

@@ -0,0 +1,21 @@
+from .backend import AwsBackend
+from .config_loader import load_aws_config
+from .discovery import AwsDiscovery
+from .resource_client import AwsResourceClient
+
+
+def create_aws_backend() -> AwsBackend:
+    config = load_aws_config()
+
+    resource_client = AwsResourceClient(
+        config=config,
+    )
+
+    discovery = AwsDiscovery(
+        resource_client=resource_client,
+    )
+
+    return AwsBackend(
+        discovery=discovery,
+        resource_client=resource_client,
+    )

workload_profile_controller-1.0.0/src/workload_profile_controller/backends/aws/inventory.py

@@ -0,0 +1,44 @@
+from dataclasses import dataclass
+
+from ...errors import ResourceAmbiguousError, ResourceNotFoundError
+
+
+@dataclass(frozen=True)
+class AwsResource:
+    instance_id: str
+    name: str
+
+
+class AwsInventory:
+    def __init__(self, resources: list[AwsResource]):
+        self._resources = tuple(
+            sorted(
+                resources,
+                key=lambda resource: (
+                    resource.name,
+                    resource.instance_id,
+                ),
+            )
+        )
+
+    def list_resources(self) -> tuple[AwsResource, ...]:
+        return self._resources
+
+    def resolve(self, name: str) -> AwsResource:
+        matches = tuple(
+            resource
+            for resource in self._resources
+            if resource.name == name
+        )
+
+        if not matches:
+            raise ResourceNotFoundError(
+                f"AWS resource not found: {name}"
+            )
+
+        if len(matches) > 1:
+            raise ResourceAmbiguousError(
+                f"AWS resource name is ambiguous: {name}"
+            )
+
+        return matches[0]

workload_profile_controller-1.0.0/src/workload_profile_controller/backends/aws/resource_client.py

@@ -0,0 +1,131 @@
+import time
+from collections.abc import Mapping
+
+import boto3
+
+from ...errors import InvalidResourceStateError, TaskTimeoutError
+from .config import AwsConfig
+
+
+class AwsResourceClient:
+    def __init__(self, config: AwsConfig):
+        session = boto3.Session(
+            profile_name=config.profile,
+            region_name=config.region,
+        )
+
+        self._client = session.client(
+            "ec2",
+            endpoint_url=config.endpoint_url,
+        )
+
+        self._operation_timeout = config.operation_timeout
+
+    def list_instances(self):
+        paginator = self._client.get_paginator(
+            "describe_instances",
+        )
+
+        reservations = []
+
+        for page in paginator.paginate():
+            reservations.extend(page["Reservations"])
+
+        return reservations
+
+    def get_instance_state(self, instance_id: str) -> str:
+        response = self._client.describe_instances(
+            InstanceIds=[instance_id],
+        )
+
+        reservations = response.get("Reservations", [])
+
+        if not isinstance(reservations, list):
+            raise InvalidResourceStateError(
+                f"AWS instance has no state: {instance_id}",
+            )
+
+        for reservation in reservations:
+            if not isinstance(reservation, Mapping):
+                continue
+
+            instances = reservation.get("Instances", [])
+
+            if not isinstance(instances, list):
+                continue
+
+            for instance in instances:
+                if not isinstance(instance, Mapping):
+                    continue
+
+                if instance.get("InstanceId") != instance_id:
+                    continue
+
+                state = instance.get("State", {})
+
+                if not isinstance(state, Mapping):
+                    break
+
+                state_name = state.get("Name")
+
+                if isinstance(state_name, str):
+                    return state_name
+
+                break
+
+        raise InvalidResourceStateError(
+            f"AWS instance has no state: {instance_id}",
+        )
+
+    def start_instance(self, instance_id: str) -> None:
+        self._client.start_instances(
+            InstanceIds=[instance_id],
+        )
+
+        self._wait_for_state(
+            instance_id=instance_id,
+            desired_state="running",
+            transitional_state="pending",
+        )
+
+    def stop_instance(self, instance_id: str) -> None:
+        self._client.stop_instances(
+            InstanceIds=[instance_id],
+        )
+
+        self._wait_for_state(
+            instance_id=instance_id,
+            desired_state="stopped",
+            transitional_state="stopping",
+        )
+
+    def _wait_for_state(
+        self,
+        instance_id: str,
+        desired_state: str,
+        transitional_state: str,
+    ) -> None:
+        started_at = time.monotonic()
+
+        while True:
+            state = self.get_instance_state(instance_id)
+
+            if state == desired_state:
+                return
+
+            if state != transitional_state:
+                raise InvalidResourceStateError(
+                    "AWS instance entered unexpected state: "
+                    f"{instance_id}: {state}",
+                )
+
+            if (
+                time.monotonic() - started_at
+                >= self._operation_timeout
+            ):
+                raise TaskTimeoutError(
+                    "AWS instance operation timed out: "
+                    f"{instance_id}",
+                )
+
+            time.sleep(1.0)

{workload_profile_controller-0.1.0 → workload_profile_controller-1.0.0}/src/workload_profile_controller/cli.py

@@ -31,14 +31,19 @@ def create_parser() -> argparse.ArgumentParser:
         help="Show the current resource status.",
     )
 
+    subparsers.add_parser(
+        "reconcile",
+        help="Detect the current profile.",
+    )
+
     plan_parser = subparsers.add_parser(
-    "plan",
-    help="Plan a transition without changing resources.",
+        "plan",
+        help="Plan a transition without changing resources.",
     )
 
     plan_parser.add_argument(
-    "target_profile",
-    help="Target profile to plan.",
+        "target_profile",
+        help="Target profile to plan.",
     )
 
     transition_parser = subparsers.add_parser(
@@ -79,6 +84,16 @@ def main(argv=None) -> int:
 
         return 0
 
+    if args.command == "reconcile":
+        controller = create_controller(args.config)
+        current_profile = controller.reconcile()
+
+        print(
+            f"Current profile: {current_profile}"
+        )
+
+        return 0
+
     if args.command == "plan":
         controller = create_controller(args.config)
 

{workload_profile_controller-0.1.0 → workload_profile_controller-1.0.0}/src/workload_profile_controller/config.py

@@ -18,4 +18,5 @@ class ProfileConfig:
 @dataclass(frozen=True)
 class Config:
     resources: dict[str, ResourceConfig]
-    profiles: dict[str, ProfileConfig]
+    profiles: dict[str, ProfileConfig]
+    backend: str = "proxmox"

{workload_profile_controller-0.1.0 → workload_profile_controller-1.0.0}/src/workload_profile_controller/config_loader.py

@@ -33,6 +33,7 @@ def load_config(path: str | Path) -> Config:
     config = Config(
         resources=resources,
         profiles=profiles,
+        backend=data.get("backend", "proxmox"),
     )
 
     validate_config(config)

{workload_profile_controller-0.1.0 → workload_profile_controller-1.0.0}/src/workload_profile_controller/config_validator.py

@@ -1,7 +1,12 @@
 from .config import Config
 
-
 def validate_config(config: Config) -> None:
+    # R-11 — Supported backend
+    if config.backend not in {"proxmox", "aws"}:
+        raise ValueError(
+            f"Unsupported backend: {config.backend}"
+        )
+
     # R-01 — At least one resource
     if not config.resources:
         raise ValueError("At least one resource is required")

{workload_profile_controller-0.1.0 → workload_profile_controller-1.0.0/src/workload_profile_controller.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workload-profile-controller
-Version: 0.1.0
+Version: 1.0.0
 Summary: Safe and configurable workload profile controller
 License-Expression: MIT
 Project-URL: Repository, https://github.com/lack0fcode/workload-profile-controller
@@ -22,6 +22,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: PyYAML>=6.0
 Requires-Dist: python-dotenv>=1.2
+Requires-Dist: boto3>=1.35
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: ruff>=0.12; extra == "dev"

{workload_profile_controller-0.1.0 → workload_profile_controller-1.0.0}/src/workload_profile_controller.egg-info/SOURCES.txt

@@ -17,6 +17,14 @@ src/workload_profile_controller.egg-info/entry_points.txt
 src/workload_profile_controller.egg-info/requires.txt
 src/workload_profile_controller.egg-info/top_level.txt
 src/workload_profile_controller/backends/__init__.py
+src/workload_profile_controller/backends/aws/__init__.py
+src/workload_profile_controller/backends/aws/backend.py
+src/workload_profile_controller/backends/aws/config.py
+src/workload_profile_controller/backends/aws/config_loader.py
+src/workload_profile_controller/backends/aws/discovery.py
+src/workload_profile_controller/backends/aws/factory.py
+src/workload_profile_controller/backends/aws/inventory.py
+src/workload_profile_controller/backends/aws/resource_client.py
 src/workload_profile_controller/backends/proxmox/__init__.py
 src/workload_profile_controller/backends/proxmox/auth.py
 src/workload_profile_controller/backends/proxmox/backend.py

{workload_profile_controller-0.1.0 → workload_profile_controller-1.0.0}/src/workload_profile_controller.egg-info/requires.txt

@@ -1,5 +1,6 @@
 PyYAML>=6.0
 python-dotenv>=1.2
+boto3>=1.35
 
 [dev]
 pytest>=8.0

workload_profile_controller-0.1.0/src/workload_profile_controller/application.py

@@ -1,13 +0,0 @@
-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,
-    )