Allow validation of Openshift allocations when changing quotas

As part of allowing the validation of allocation change
requests (acr) [1], various functions have been added to the
plugin that are mostly called from Coldfront to validate an acr.
Among these changes are:

- Several new functions to `utils.py` to perform basic tasks
- Functions in the openshift allocator to obtain the usage of a Openshift project
- Refactoring of how the Openshift quota value is parsed
- New unit tests

[1] nerc-project/coldfront-nerc#138

Author: QuanMPhm

src/coldfront_plugin_cloud/management/commands/validate_allocations.py

@@ -1,13 +1,12 @@
 import logging
-import re
 
 from coldfront_plugin_cloud import attributes
 from coldfront_plugin_cloud import openstack
 from coldfront_plugin_cloud import openshift
 from coldfront_plugin_cloud import utils
 from coldfront_plugin_cloud import tasks
 
-from django.core.management.base import BaseCommand, CommandError
+from django.core.management.base import BaseCommand
 from coldfront.core.resource.models import Resource
 from coldfront.core.allocation.models import (
     Allocation,
@@ -242,51 +241,7 @@ def handle(self, *args, **options):
 
                 expected_value = allocation.get_attribute(attr)
                 current_value = quota.get(key, None)
-
-                PATTERN = r"([0-9]+)(m|Ki|Mi|Gi|Ti|Pi|Ei|K|M|G|T|P|E)?"
-
-                suffix = {
-                    "Ki": 2**10,
-                    "Mi": 2**20,
-                    "Gi": 2**30,
-                    "Ti": 2**40,
-                    "Pi": 2**50,
-                    "Ei": 2**60,
-                    "m": 10**-3,
-                    "K": 10**3,
-                    "M": 10**6,
-                    "G": 10**9,
-                    "T": 10**12,
-                    "P": 10**15,
-                    "E": 10**18,
-                }
-
-                if current_value and current_value != "0":
-                    result = re.search(PATTERN, current_value)
-
-                    if result is None:
-                        raise CommandError(
-                            f"Unable to parse current_value = '{current_value}' for {attr}"
-                        )
-
-                    value = int(result.groups()[0])
-                    unit = result.groups()[1]
-
-                    # Convert to number i.e. without any unit suffix
-
-                    if unit is not None:
-                        current_value = value * suffix[unit]
-                    else:
-                        current_value = value
-
-                    # Convert some attributes to units that coldfront uses
-
-                    if "RAM" in attr:
-                        current_value = round(current_value / suffix["Mi"])
-                    elif "Storage" in attr:
-                        current_value = round(current_value / suffix["Gi"])
-                elif current_value and current_value == "0":
-                    current_value = 0
+                current_value = utils.parse_openshift_quota_value(attr, current_value)
 
                 if expected_value is None and current_value is not None:
                     msg = (

src/coldfront_plugin_cloud/openshift.py

@@ -200,6 +200,13 @@ def get_quota(self, project_id):
 
         return combined_quota
 
+    def get_quota_used(self, project_id):
+        cloud_quotas = self._openshift_get_resourcequotas(project_id)
+        combined_quota_used = {}
+        for cloud_quota in combined_quota_used:
+            combined_quota_used.update(cloud_quotas["status"]["used"])
+        return combined_quota_used
+
     def create_project_defaults(self, project_id):
         pass
 

src/coldfront_plugin_cloud/tasks.py

@@ -191,3 +191,24 @@ def remove_user_from_allocation(allocation_user_pk):
             allocator.remove_role_from_user(username, project_id)
         else:
             logger.warning("No project has been created. Nothing to disable.")
+
+
+def get_allocation_cloud_usage(allocation_pk):
+    """
+    Obtains the current quota usage for the allocation.
+
+    For example, the output for an Openshift quota would be:
+
+    {
+        "limits.cpu": "1",
+        "limits.memory": "2Gi",
+        "limits.ephemeral-storage": "10Gi",
+    }
+    """
+    allocation = Allocation.objects.get(pk=allocation_pk)
+    if allocator := find_allocator(allocation):
+        if project_id := allocation.get_attribute(attributes.ALLOCATION_PROJECT_ID):
+            return allocator.get_quota_used(project_id)
+        else:
+            logger.warning("No project has been created. No quota to check.")
+            return

src/coldfront_plugin_cloud/tests/unit/test_utils.py

@@ -29,3 +29,64 @@ def test_env_safe_name(self):
         self.assertEqual(utils.env_safe_name(42), "42")
         self.assertEqual(utils.env_safe_name(None), "NONE")
         self.assertEqual(utils.env_safe_name("hello"), "HELLO")
+
+
+class TestCheckIfQuotaAttr(base.TestCase):
+    def test_valid_quota_attr(self):
+        self.assertTrue(utils.check_if_quota_attr("OpenShift Limit on CPU Quota"))
+
+    def test_invalid_quota_attr(self):
+        self.assertFalse(utils.check_if_quota_attr("Test"))
+        self.assertFalse(utils.check_if_quota_attr("Allocated Project ID"))
+
+
+class TestColdfrontToOpenshiftQuotaName(base.TestCase):
+    def test_valid_mapping(self):
+        result = utils.coldfront_to_openshift_quota_name("OpenShift Limit on CPU Quota")
+        self.assertEqual(result, "limits.cpu")
+
+    def test_missing_mapping(self):
+        with self.assertRaises(TypeError):
+            utils.coldfront_to_openshift_quota_name("Unknown Quota")
+
+
+class TestGetNewCloudQuota(base.TestCase):
+    def test_get_requested_quota(self):
+        data = [
+            {"name": "OpenShift Limit on CPU Quota", "new_value": "2"},
+            {"name": "OpenShift Limit on RAM Quota (MiB)", "new_value": ""},
+        ]
+
+        result = utils.get_new_cloud_quota(data)
+        self.assertEqual(result, {"OpenShift Limit on CPU Quota": "2"})
+
+
+class TestCheckChangeRequests(base.TestBase):
+    def test_check_usage(self):
+        # No error case, usage is lower
+        test_quota_usage = {
+            "limits.cpu": "1",
+            "limits.memory": "2Gi",
+            "limits.ephemeral-storage": "10Gi",  # Other quotas should be ignored
+            "requests.storage": "40Gi",
+            "requests.nvidia.com/gpu": "0",
+            "persistentvolumeclaims": "4",
+        }
+        test_requested_quota = {"OpenShift Limit on CPU Quota": "2"}
+
+        self.assertEqual(
+            [], utils.check_cloud_usage_is_lower(test_requested_quota, test_quota_usage)
+        )
+
+        # Requested cpu (2) lower than current used, should return errors
+        test_quota_usage["limits.cpu"] = "16"
+        self.assertEqual(
+            [
+                (
+                    "Current quota usage for OpenShift Limit on CPU Quota "
+                    "(16) is higher than "
+                    "the requested amount (2)."
+                )
+            ],
+            utils.check_cloud_usage_is_lower(test_requested_quota, test_quota_usage),
+        )

src/coldfront_plugin_cloud/utils.py

@@ -13,6 +13,7 @@
 )
 
 from coldfront_plugin_cloud import attributes
+from coldfront_plugin_cloud import openshift
 
 
 def env_safe_name(name):
@@ -244,3 +245,115 @@ def get_included_duration(
         total_interval_duration -= (e_interval_end - e_interval_start).total_seconds()
 
     return math.ceil(total_interval_duration)
+
+
+def parse_openshift_quota_value(attr_name, quota_value):
+    PATTERN = r"([0-9]+)(m|Ki|Mi|Gi|Ti|Pi|Ei|K|M|G|T|P|E)?"
+
+    suffix = {
+        "Ki": 2**10,
+        "Mi": 2**20,
+        "Gi": 2**30,
+        "Ti": 2**40,
+        "Pi": 2**50,
+        "Ei": 2**60,
+        "m": 10**-3,
+        "K": 10**3,
+        "M": 10**6,
+        "G": 10**9,
+        "T": 10**12,
+        "P": 10**15,
+        "E": 10**18,
+    }
+
+    if quota_value and quota_value != "0":
+        result = re.search(PATTERN, quota_value)
+
+        if result is None:
+            raise ValueError(
+                f"Unable to parse quota_value = '{quota_value}' for {attr_name}"
+            )
+
+        value = int(result.groups()[0])
+        unit = result.groups()[1]
+
+        # Convert to number i.e. without any unit suffix
+
+        if unit is not None:
+            quota_value = value * suffix[unit]
+        else:
+            quota_value = value
+
+        # Convert some attributes to units that coldfront uses
+
+        if "RAM" in attr_name:
+            return round(quota_value / suffix["Mi"])
+        elif "Storage" in attr_name:
+            return round(quota_value / suffix["Gi"])
+        return quota_value
+    elif quota_value and quota_value == "0":
+        return 0
+
+
+def check_if_quota_attr(attr_name: str):
+    for quota_attr in attributes.ALLOCATION_QUOTA_ATTRIBUTES:
+        if attr_name == quota_attr.name:
+            return True
+    return False
+
+
+def coldfront_to_openshift_quota_name(coldfront_quota_name: str):
+    """Converts the Coldfront quota name to OpenShift equivalent.
+
+    :param coldfront_quota_name: Coldfront quota name.
+    :return: OpenShift equivalent quota name.
+    """
+    quota_key_lambda_func = openshift.OpenShiftResourceAllocator.QUOTA_KEY_MAPPING.get(
+        coldfront_quota_name, None
+    )
+    return list(quota_key_lambda_func(1).keys())[0]
+
+
+def get_new_cloud_quota(change_request_data: list[dict[str, str]]):
+    """
+    Converts change request data to a dictionary of requested quota changes.
+    Ignores attributes with empty `new_value` str, meaning no change requested for them
+    Input typically looks like:
+    [
+        {
+            "name": "OpenShift Limit on CPU Quota",
+            "new_value": "2",
+            ...
+        },
+        {
+            "name": "OpenShift Limit on RAM Quota (MiB)",
+            "new_value": "",
+            ...
+        }
+    ]
+    """
+    requested_quota = {}
+    for form in change_request_data:
+        if check_if_quota_attr(form["name"]) and form["new_value"]:
+            requested_quota[form["name"]] = form["new_value"]
+    return requested_quota
+
+
+def check_cloud_usage_is_lower(
+    requested_quota: dict[str, str], cloud_quota_usage: dict[str, str]
+):
+    usage_errors = []
+    for quota_name, requested_quota_value in requested_quota.items():
+        cloud_quota_name = coldfront_to_openshift_quota_name(quota_name)
+        if int(requested_quota_value) < parse_openshift_quota_value(
+            quota_name, cloud_quota_usage[cloud_quota_name]
+        ):
+            usage_errors.append(
+                (
+                    f"Current quota usage for {quota_name} "
+                    f"({cloud_quota_usage[cloud_quota_name]}) is higher than "
+                    f"the requested amount ({requested_quota_value})."
+                )
+            )
+
+    return usage_errors