waldur-site-agent-moab 0.8.2__tar.gz

waldur_site_agent_moab-0.8.2/.gitignore

@@ -0,0 +1,7 @@
+venv/
+.idea/
+.vscode/
+dist/
+**__pycache__
+.DS_Store
+.coverage

waldur_site_agent_moab-0.8.2/.python-version

@@ -0,0 +1 @@
+3.9

waldur_site_agent_moab-0.8.2/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: waldur-site-agent-moab
+Version: 0.8.2
+Summary: MOAB plugin for Waldur Site Agent
+Author-email: OpenNode Team <info@opennodecloud.com>
+Requires-Python: <4,>=3.9
+Requires-Dist: waldur-site-agent>=0.7.0
+Description-Content-Type: text/markdown
+
+# MOAB plugin for Waldur Site Agent
+
+This plugin provides MOAB cluster management capabilities for Waldur Site Agent.
+
+## Installation
+
+See the main [Installation Guide](../../docs/installation.md) for platform-specific installation instructions.

waldur_site_agent_moab-0.8.2/README.md

@@ -0,0 +1,7 @@
+# MOAB plugin for Waldur Site Agent
+
+This plugin provides MOAB cluster management capabilities for Waldur Site Agent.
+
+## Installation
+
+See the main [Installation Guide](../../docs/installation.md) for platform-specific installation instructions.

waldur_site_agent_moab-0.8.2/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "waldur-site-agent-moab"
+version = "0.8.2"
+description = "MOAB plugin for Waldur Site Agent"
+readme = "README.md"
+authors = [{ name = "OpenNode Team", email = "info@opennodecloud.com" }]
+requires-python = ">=3.9, <4"
+dependencies = [
+    "waldur-site-agent>=0.7.0"
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.uv.sources]
+waldur-site-agent = { workspace = true }
+
+# Entry points for exporting backends
+[project.entry-points."waldur_site_agent.backends"]
+moab = "waldur_site_agent_moab.backend:MoabBackend"

waldur_site_agent_moab-0.8.2/waldur_site_agent_moab/__init__.py

@@ -0,0 +1 @@
+"""Module for MOAB-related functions and classes."""

waldur_site_agent_moab-0.8.2/waldur_site_agent_moab/backend.py

@@ -0,0 +1,124 @@
+"""Moab-specific backend classes and functions."""
+
+from typing import Optional
+
+from waldur_api_client.models.resource import Resource as WaldurResource
+
+from waldur_site_agent.backend import BackendType, logger
+from waldur_site_agent.backend import utils as backend_utils
+from waldur_site_agent.backend.backends import BaseBackend
+from waldur_site_agent.backend.exceptions import BackendError
+from waldur_site_agent_moab.client import MoabClient
+from waldur_site_agent_moab.parser import MoabReportLine
+
+
+class MoabBackend(BaseBackend):
+    """MOAB backend class."""
+
+    def __init__(self, moab_settings: dict, moab_components: dict[str, dict]) -> None:
+        """Init backend data and creates a corresponding client."""
+        super().__init__(moab_settings, moab_components)
+        self.backend_type = BackendType.MOAB.value
+        self.client = MoabClient()
+        self.backend_components["deposit"]["unit_factor"] = 1
+
+    def ping(self, raise_exception: bool = False) -> bool:
+        """Check if MOAB is online."""
+        try:
+            self.client.list_resources()
+        except BackendError as err:
+            if raise_exception:
+                raise
+            logger.info("Error: %s", err)
+            return False
+        else:
+            return True
+
+    def diagnostics(self) -> bool:
+        """Logs info about the MOAB cluster."""
+        return True
+
+    def list_components(self) -> list[str]:
+        """Return deposit component."""
+        return ["deposit"]
+
+    def _get_usage_report(self, resource_backend_ids: list[str]) -> dict:
+        """Get usage report."""
+        report: dict[str, dict[str, dict[str, float]]] = {}
+        lines: list[MoabReportLine] = self.client.get_usage_report(resource_backend_ids)
+
+        for line in lines:
+            report.setdefault(line.account, {}).setdefault(line.user, {})
+            user_usage_existing = report[line.account][line.user]
+            user_usage_new = backend_utils.sum_dicts([user_usage_existing, line.usages])
+            report[line.account][line.user] = user_usage_new
+
+        for account_usage in report.values():
+            usages_per_user = list(account_usage.values())
+            total = backend_utils.sum_dicts(usages_per_user)
+            account_usage["TOTAL_ACCOUNT_USAGE"] = {
+                key: float(round(value, 2)) for key, value in total.items()
+            }
+            for username, user_usage in account_usage.items():
+                account_usage[username] = {
+                    key: float(round(value, 2)) for key, value in user_usage.items()
+                }
+
+        return report
+
+    def _pre_create_resource(
+        self, waldur_resource: WaldurResource, user_context: Optional[dict] = None
+    ) -> None:
+        """Override parent method to validate slug fields."""
+        if not waldur_resource.project_slug:
+            logger.warning(
+                "Resource %s has unset or missing project slug. project_slug: %s",
+                waldur_resource.uuid,
+                waldur_resource.project_slug,
+            )
+            msg = (
+                f"Resource {waldur_resource.uuid} has unset or missing slug fields. "
+                f"project_slug: {waldur_resource.project_slug}. "
+                "Cannot create backend resources with invalid slug values."
+            )
+            raise BackendError(msg)
+
+        del user_context
+
+        project_backend_id = self._get_project_backend_id(waldur_resource.project_slug)
+
+        customer_backend_id = None
+
+        # Create project resource
+        self._create_backend_resource(
+            project_backend_id,
+            waldur_resource.project_name,
+            project_backend_id,
+            customer_backend_id,
+        )
+
+    def downscale_resource(self, resource_backend_id: str) -> bool:
+        """Temporary placeholder."""
+        del resource_backend_id
+        return False
+
+    def pause_resource(self, resource_backend_id: str) -> bool:
+        """Temporary placeholder."""
+        del resource_backend_id
+        return False
+
+    def restore_resource(self, resource_backend_id: str) -> bool:
+        """Temporary placeholder."""
+        del resource_backend_id
+        return False
+
+    def get_resource_metadata(self, _: str) -> dict:
+        """Temporary placeholder."""
+        return {}
+
+    def _collect_resource_limits(
+        self, waldur_resource: WaldurResource
+    ) -> tuple[dict[str, int], dict[str, int]]:
+        """Collect deposit limit only with no conversion."""
+        deposit_limit = {"deposit": waldur_resource["limits"]["deposit"]}
+        return deposit_limit, deposit_limit

waldur_site_agent_moab-0.8.2/waldur_site_agent_moab/client.py

@@ -0,0 +1,172 @@
+"""CLI-client for MOAB."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from waldur_site_agent.backend import clients, exceptions, logger
+from waldur_site_agent.backend import utils as backend_utils
+from waldur_site_agent.backend.structures import Association, ClientResource
+from waldur_site_agent_moab.parser import MoabReportLine
+
+
+class MoabClient(clients.BaseClient):
+    """This class implements Python client for MOAB.
+
+    See also MOAB Accounting Manager 9.1.1 Administrator Guide
+    http://docs.adaptivecomputing.com/9-1-1/MAM/help.htm
+    """
+
+    def list_resources(self) -> list[ClientResource]:
+        """Return list of accounts in MOAB."""
+        output = self.execute_command(
+            ["mam-list-accounts", "--raw", "--quiet", "--show", "Name,Description,Organization"]
+        )
+        return [self._parse_account(line) for line in output.splitlines() if "|" in line]
+
+    def _parse_account(self, line: str) -> ClientResource:
+        parts = line.split("|")
+        return ClientResource(name=parts[0], description=parts[1], organization=parts[2])
+
+    def _get_fund_id(self, account: str) -> Optional[int]:
+        command_fund = f"mam-list-funds --raw --quiet -a {account} --show Id"
+        fund_output = self.execute_command(command_fund.split())
+        fund_data = fund_output.splitlines()
+
+        if len(fund_data) == 0:
+            logger.warning("No funds were found for account %s", account)
+            return None
+
+        # Assuming an account has only one fund
+        fund_id_str = fund_data[0].strip()
+
+        return int(fund_id_str)
+
+    def get_resource(self, resource_id: str) -> ClientResource | None:
+        """Get MOAB account info."""
+        command = (
+            f"mam-list-accounts --raw --quiet --show Name,Description,Organization -a {resource_id}"
+        )
+        output = self.execute_command(command.split())
+        lines = [line for line in output.splitlines() if "|" in line]
+        if len(lines) == 0:
+            return None
+        return self._parse_account(lines[0])
+
+    def create_resource(
+        self, name: str, description: str, organization: str, parent_name: Optional[str] = None
+    ) -> str:
+        """Create account in MOAB."""
+        del parent_name
+        command_account = f'mam-create-account -a {name} -d "{description}" -o {organization}'
+        self.execute_command(command_account.split())
+
+        logger.info("Creating fund for the account")
+        command_fund = f"mam-create-fund -a {name}"
+        return self.execute_command(command_fund.split())
+
+    def delete_resource(self, name: str) -> str:
+        """Delete account from MOAB."""
+        command_account = f"mam-delete-account -a {name}"
+        self.execute_command(command_account.split())
+
+        fund_id = self._get_fund_id(name)
+
+        if fund_id is None:
+            logger.warning("Skipping fund deletion.")
+            return ""
+
+        logger.info("Deleting the account fund %s", fund_id)
+
+        command_fund = f"mam-delete-fund -f {fund_id}"
+        return self.execute_command(command_fund.split())
+
+    def set_resource_limits(self, resource_id: str, limits_dict: dict[str, int]) -> str | None:
+        """Set the limits for the account with the specified name."""
+        if limits_dict.get("deposit", 0) < 0:
+            logger.warning(
+                "Skipping limit update because pricing "
+                "package is not created for the related service settings."
+            )
+            return None
+
+        fund_id = self._get_fund_id(resource_id)
+
+        if fund_id is None:
+            raise exceptions.BackendError(
+                f"The account {resource_id} does not have a linked fund, unable to set a deposit"
+            )
+
+        command_deposit = f"mam-deposit -a {resource_id} -z {limits_dict['deposit']} -f {fund_id}"
+        return self.execute_command(command_deposit.split())
+
+    def get_resource_limits(self, _: str) -> dict[str, int]:
+        """Get account limits."""
+        return {}
+
+    def get_resource_user_limits(self, _: str) -> dict[str, dict[str, int]]:
+        """Get per-user limits for the account."""
+        return {}
+
+    def set_resource_user_limits(
+        self, resource_id: str, username: str, limits_dict: dict[str, int]
+    ) -> str:
+        """Set account limits for a specific user."""
+        # The method is a placeholder and is not implemented yet
+        del resource_id, username, limits_dict
+        return ""
+
+    def get_association(self, user: str, resource_id: str) -> Association | None:
+        """Get association between user and account."""
+        command = (
+            f"mam-list-funds --raw --quiet -u {user} -a {resource_id} --show Constraints,Balance"
+        )
+        output = self.execute_command(command.split())
+        lines = [line for line in output.splitlines() if "|" in line]
+        if len(lines) == 0:
+            return None
+
+        return Association(
+            account=resource_id, user=user, value=int(float(lines[0].split("|")[-1]))
+        )
+
+    def create_association(self, username: str, resource_id: str, _: Optional[str] = None) -> str:
+        """Create association between user and account in MOAB."""
+        command = f"mam-modify-account --add-user +{username} -a {resource_id}"
+        return self.execute_command(command.split())
+
+    def delete_association(self, username: str, resource_id: str) -> str:
+        """Delete association between user and account."""
+        command = f"mam-modify-account --del-user {username} -a {resource_id}"
+        return self.execute_command(command.split())
+
+    def get_usage_report(self, resource_ids: list[str]) -> list:
+        """Get usages records from MOAB."""
+        template = (
+            "mam-list-usagerecords --raw --quiet --show "
+            "Account,User,Charge "
+            "-a %(account)s -s %(start)s -e %(end)s"
+        )
+        month_start, month_end = backend_utils.format_current_month()
+
+        report_lines = []
+        for account in resource_ids:
+            command = template % {
+                "account": account,
+                "start": month_start,
+                "end": month_end,
+            }
+            lines = self.execute_command(command.split()).splitlines()
+            report_lines_to_add = [MoabReportLine(line) for line in lines if "|" in line]
+            report_lines.extend(report_lines_to_add)
+
+        return report_lines
+
+    def list_resource_users(self, resource_id: str) -> list[str]:
+        """Returns list of users linked to the account."""
+        # TODO: make use of -A flag (fetch only active users)
+        command = f"mam-list-users -a {resource_id} --raw --show Name,DefaultAccount --quiet"
+        output = self.execute_command(command.split())
+        return [
+            line.split("|")[0] for line in output.splitlines() if "|" in line and line[-1] != "|"
+        ]

waldur_site_agent_moab-0.8.2/waldur_site_agent_moab/parser.py

@@ -0,0 +1,32 @@
+"""Parsing classes for MOAB."""
+
+import decimal
+from functools import cached_property
+
+
+class MoabReportLine:
+    """Parser for report lines from MOAB."""
+
+    def __init__(self, line: str) -> None:
+        """Constructor."""
+        self._parts = line.split("|")
+
+    @cached_property
+    def account(self) -> str:
+        """Parses account name."""
+        return self._parts[0].strip()
+
+    @cached_property
+    def user(self) -> str:
+        """Parses username."""
+        return self._parts[1]
+
+    @cached_property
+    def charge(self) -> decimal.Decimal:
+        """Parses charge."""
+        return decimal.Decimal(self._parts[2])
+
+    @cached_property
+    def usages(self) -> dict[str, decimal.Decimal]:
+        """Return deposit usage from the report line."""
+        return {"deposit": self.charge}