qontract-reconcile 0.10.2.dev299__tar.gz → 0.10.2.dev303__tar.gz

{qontract_reconcile-0.10.2.dev299 → qontract_reconcile-0.10.2.dev303}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qontract-reconcile
-Version: 0.10.2.dev299
+Version: 0.10.2.dev303
 Summary: Collection of tools to reconcile services with their desired state as defined in the app-interface DB.
 Project-URL: homepage, https://github.com/app-sre/qontract-reconcile
 Project-URL: repository, https://github.com/app-sre/qontract-reconcile

{qontract_reconcile-0.10.2.dev299 → qontract_reconcile-0.10.2.dev303}/reconcile/gql_definitions/status_board/status_board.py

@@ -51,11 +51,19 @@ query StatusBoard {
             childrenApps {
               name
               onboardingStatus
+              saasFiles {
+                name
+                managedResourceTypes
+              }
             }
             parentApp {
               name
               onboardingStatus
             }
+            saasFiles {
+              name
+              managedResourceTypes
+            }
           }
         }
       }
@@ -96,9 +104,15 @@ class ProductV1(ConfiguredBaseModel):
     name: str = Field(..., alias="name")
 
 
+class SaasFileV2(ConfiguredBaseModel):
+    name: str = Field(..., alias="name")
+    managed_resource_types: list[str] = Field(..., alias="managedResourceTypes")
+
+
 class AppV1_AppV1(ConfiguredBaseModel):
     name: str = Field(..., alias="name")
     onboarding_status: str = Field(..., alias="onboardingStatus")
+    saas_files: Optional[list[SaasFileV2]] = Field(..., alias="saasFiles")
 
 
 class NamespaceV1_AppV1_AppV1(ConfiguredBaseModel):
@@ -106,11 +120,17 @@ class NamespaceV1_AppV1_AppV1(ConfiguredBaseModel):
     onboarding_status: str = Field(..., alias="onboardingStatus")
 
 
+class AppV1_SaasFileV2(ConfiguredBaseModel):
+    name: str = Field(..., alias="name")
+    managed_resource_types: list[str] = Field(..., alias="managedResourceTypes")
+
+
 class AppV1(ConfiguredBaseModel):
     name: str = Field(..., alias="name")
     onboarding_status: str = Field(..., alias="onboardingStatus")
     children_apps: Optional[list[AppV1_AppV1]] = Field(..., alias="childrenApps")
     parent_app: Optional[NamespaceV1_AppV1_AppV1] = Field(..., alias="parentApp")
+    saas_files: Optional[list[AppV1_SaasFileV2]] = Field(..., alias="saasFiles")
 
 
 class NamespaceV1(ConfiguredBaseModel):

{qontract_reconcile-0.10.2.dev299 → qontract_reconcile-0.10.2.dev303}/reconcile/status_board.py

@@ -6,6 +6,9 @@ from abc import (
 from collections.abc import Iterable, Mapping
 from enum import Enum
 from itertools import chain
+from typing import (
+    Any,
+)
 
 from pydantic import BaseModel
 
@@ -13,7 +16,7 @@ from reconcile.gql_definitions.slo_documents.slo_documents import SLODocumentV1
 from reconcile.gql_definitions.status_board.status_board import StatusBoardV1
 from reconcile.typed_queries.slo_documents import get_slo_documents
 from reconcile.typed_queries.status_board import (
-    get_selected_app_names,
+    get_selected_app_data,
     get_status_board,
 )
 from reconcile.utils.differ import diff_mappings
@@ -31,6 +34,7 @@ from reconcile.utils.ocm.status_board import (
     get_application_services,
     get_managed_products,
     get_product_applications,
+    update_application,
     update_service,
 )
 from reconcile.utils.ocm_base_client import (
@@ -55,6 +59,7 @@ class AbstractStatusBoard(ABC, BaseModel):
     id: str | None
     name: str
     fullname: str
+    metadata: dict[str, Any] | ServiceMetadataSpec | None
 
     @abstractmethod
     def create(self, ocm: OCMBaseClient) -> None:
@@ -122,6 +127,7 @@ class Product(AbstractStatusBoard):
 class Application(AbstractStatusBoard):
     product: Product
     services: list["Service"] | None
+    metadata: dict[str, Any]
 
     def create(self, ocm: OCMBaseClient) -> None:
         if self.product.id:
@@ -131,9 +137,11 @@ class Application(AbstractStatusBoard):
             logging.warning("Missing product id for application")
 
     def update(self, ocm: OCMBaseClient) -> None:
-        err_msg = "Called update on StatusBoardHandler that doesn't have update method"
-        logging.error(err_msg)
-        raise UpdateNotSupportedError(err_msg)
+        if not self.id:
+            logging.error(f'Trying to update Application "{self.name}" without id')
+            return
+        spec = self.to_ocm_spec()
+        update_application(ocm, self.id, spec)
 
     def delete(self, ocm: OCMBaseClient) -> None:
         if not self.id:
@@ -149,6 +157,7 @@ class Application(AbstractStatusBoard):
         return {
             "name": self.name,
             "fullname": self.fullname,
+            "metadata": self.metadata,
             "product": {"id": product_id},
         }
 
@@ -248,12 +257,14 @@ class StatusBoardExporterIntegration(QontractReconcileIntegration):
         return QONTRACT_INTEGRATION
 
     @staticmethod
-    def get_product_apps(sb: StatusBoardV1) -> dict[str, set[str]]:
+    def get_product_apps(
+        sb: StatusBoardV1,
+    ) -> dict[str, dict[str, dict[str, dict[str, set[str]]]]]:
         global_selectors = (
             sb.global_app_selectors.exclude or [] if sb.global_app_selectors else []
         )
         return {
-            p.product_environment.product.name: get_selected_app_names(
+            p.product_environment.product.name: get_selected_app_data(
                 global_selectors, p
             )
             for p in sb.products
@@ -287,7 +298,7 @@ class StatusBoardExporterIntegration(QontractReconcileIntegration):
 
     @staticmethod
     def desired_abstract_status_board_map(
-        desired_product_apps: Mapping[str, set[str]],
+        desired_product_apps: Mapping[str, dict[str, dict[str, dict[str, set[str]]]]],
         slodocs: list[SLODocumentV1],
     ) -> dict[str, AbstractStatusBoard]:
         """
@@ -299,7 +310,11 @@ class StatusBoardExporterIntegration(QontractReconcileIntegration):
         desired_abstract_status_board_map: dict[str, AbstractStatusBoard] = {}
         for product_name, apps in desired_product_apps.items():
             product = Product(
-                id=None, name=product_name, fullname=product_name, applications=[]
+                id=None,
+                name=product_name,
+                fullname=product_name,
+                applications=[],
+                metadata={},
             )
             desired_abstract_status_board_map[product_name] = product
             for a in apps:
@@ -310,6 +325,7 @@ class StatusBoardExporterIntegration(QontractReconcileIntegration):
                     fullname=key,
                     services=[],
                     product=product,
+                    metadata=apps[a]["metadata"],
                 )
         for slodoc in slodocs:
             products = [
@@ -373,6 +389,99 @@ class StatusBoardExporterIntegration(QontractReconcileIntegration):
 
         return return_value
 
+    @staticmethod
+    def _compare_metadata(
+        current_metadata: dict[str, Any] | ServiceMetadataSpec,
+        desired_metadata: dict[str, Any] | ServiceMetadataSpec,
+    ) -> bool:
+        """
+        Compare metadata dictionaries with deep equality checking for nested structures.
+
+        :param current_metadata: The current metadata dictionary
+        :param desired_metadata: The desired metadata dictionary
+        :return: True if metadata are equal, False otherwise
+        """
+        # Convert TypedDict to regular dict to allow variable key access
+        current_dict = dict(current_metadata)
+        desired_dict = dict(desired_metadata)
+
+        if current_dict.keys() != desired_dict.keys():
+            return False
+
+        for key, current_value in current_dict.items():
+            desired_value = desired_dict[key]
+
+            # Handle None values
+            if current_value is None or desired_value is None:
+                if current_value is not desired_value:
+                    return False
+                continue
+
+            # Handle sets
+            if isinstance(current_value, set) and isinstance(desired_value, set):
+                if current_value != desired_value:
+                    return False
+            # Handle lists and tuples
+            elif isinstance(current_value, (list, tuple)) and isinstance(
+                desired_value, (list, tuple)
+            ):
+                if len(current_value) != len(desired_value):
+                    return False
+
+                try:
+                    sorted_current = sorted(current_value, key=repr)
+                    sorted_desired = sorted(desired_value, key=repr)
+                except Exception:
+                    # Fallback: compare without sorting
+                    sorted_current = list(current_value)
+                    sorted_desired = list(desired_value)
+
+                for c, d in zip(sorted_current, sorted_desired, strict=True):
+                    if isinstance(c, dict) and isinstance(d, dict):
+                        if not StatusBoardExporterIntegration._compare_metadata(c, d):
+                            return False
+                    elif isinstance(c, (list, tuple)) and isinstance(d, (list, tuple)):
+                        if not StatusBoardExporterIntegration._compare_metadata(
+                            {"x": c}, {"x": d}
+                        ):
+                            return False
+                    elif c != d:
+                        return False
+            # Handle nested dictionaries
+            elif isinstance(current_value, dict) and isinstance(desired_value, dict):
+                if not StatusBoardExporterIntegration._compare_metadata(
+                    current_value, desired_value
+                ):
+                    return False
+            # Handle primitive types
+            elif current_value != desired_value:
+                return False
+
+        return True
+
+    @staticmethod
+    def _status_board_objects_equal(
+        current: AbstractStatusBoard, desired: AbstractStatusBoard
+    ) -> bool:
+        """
+        Check if two AbstractStatusBoard objects are equal, including metadata comparison.
+
+        :param current: The current AbstractStatusBoard object
+        :param desired: The desired AbstractStatusBoard object
+        :return: True if objects are equal, False otherwise
+        """
+        # Check basic equality first (name, fullname)
+        if current.name != desired.name or current.fullname != desired.fullname:
+            return False
+
+        # Compare metadata with deep equality
+        if current.metadata and desired.metadata:
+            return StatusBoardExporterIntegration._compare_metadata(
+                current.metadata, desired.metadata
+            )
+        else:
+            return True
+
     @staticmethod
     def get_diff(
         desired_abstract_status_board_map: Mapping[str, AbstractStatusBoard],
@@ -383,6 +492,7 @@ class StatusBoardExporterIntegration(QontractReconcileIntegration):
         diff_result = diff_mappings(
             current_abstract_status_board_map,
             desired_abstract_status_board_map,
+            equal=StatusBoardExporterIntegration._status_board_objects_equal,
         )
 
         for pair in chain(diff_result.identical.values(), diff_result.change.values()):
@@ -398,6 +508,18 @@ class StatusBoardExporterIntegration(QontractReconcileIntegration):
             for o in diff_result.delete.values()
         )
 
+        # Handle Applications that need updates (metadata changes)
+        applications_to_update = [
+            a.desired
+            for _, a in diff_result.change.items()
+            if isinstance(a.desired, Application)
+        ]
+
+        return_list.extend(
+            StatusBoardHandler(action=Action.update, status_board_object=a)
+            for a in applications_to_update
+        )
+
         services_to_update = [
             s.desired
             for _, s in diff_result.change.items()
@@ -445,7 +567,9 @@ class StatusBoardExporterIntegration(QontractReconcileIntegration):
             ocm_api = init_ocm_base_client(sb.ocm, self.secret_reader)
 
             # Desired state
-            desired_product_apps: dict[str, set[str]] = self.get_product_apps(sb)
+            desired_product_apps: dict[
+                str, dict[str, dict[str, dict[str, set[str]]]]
+            ] = self.get_product_apps(sb)
             desired_abstract_status_board_map = self.desired_abstract_status_board_map(
                 desired_product_apps, slodocs
             )

qontract_reconcile-0.10.2.dev303/reconcile/typed_queries/status_board.py

@@ -0,0 +1,92 @@
+from collections.abc import Callable, Iterable
+from typing import Any
+
+from jsonpath_ng.ext import parser
+
+from reconcile.gql_definitions.status_board.status_board import (
+    StatusBoardProductV1,
+    StatusBoardV1,
+    query,
+)
+from reconcile.utils import gql
+from reconcile.utils.ocm.status_board import (
+    METADATA_MANAGED_BY_KEY,
+    METADATA_MANAGED_BY_VALUE,
+)
+
+
+def get_status_board(
+    query_func: Callable | None = None,
+) -> list[StatusBoardV1]:
+    if not query_func:
+        query_func = gql.get_api().query
+    return query(query_func).status_board_v1 or []
+
+
+def get_selected_app_data(
+    global_selectors: Iterable[str],
+    product: StatusBoardProductV1,
+) -> dict[str, dict[str, dict[str, set[str]]]]:
+    selected_app_data: dict[str, dict[str, dict[str, Any]]] = {}
+
+    apps: dict[str, Any] = {"apps": []}
+    for namespace in product.product_environment.namespaces or []:
+        prefix = ""
+        if namespace.app.parent_app:
+            prefix = f"{namespace.app.parent_app.name}-"
+        name = f"{prefix}{namespace.app.name}"
+
+        deployment_saas_files = set()
+        if namespace.app.saas_files:
+            deployment_saas_files = {
+                saas_file.name
+                for saas_file in namespace.app.saas_files
+                if "Deployment" in saas_file.managed_resource_types
+                or "ClowdApp" in saas_file.managed_resource_types
+            }
+
+        selected_app_data[name] = {
+            "metadata": {
+                METADATA_MANAGED_BY_KEY: METADATA_MANAGED_BY_VALUE,
+                "deploymentSaasFiles": set(deployment_saas_files),
+            },
+        }
+
+        app = namespace.app.dict(by_alias=True)
+        app["name"] = name
+        apps["apps"].append(app)
+
+        for child in namespace.app.children_apps or []:
+            name = f"{namespace.app.name}-{child.name}"
+            if name not in selected_app_data:
+                deployment_saas_files = set()
+                if child.saas_files:
+                    deployment_saas_files = {
+                        saas_file.name
+                        for saas_file in child.saas_files
+                        if "Deployment" in saas_file.managed_resource_types
+                    }
+
+                selected_app_data[name] = {
+                    "metadata": {
+                        METADATA_MANAGED_BY_KEY: METADATA_MANAGED_BY_VALUE,
+                        "deploymentSaasFiles": set(deployment_saas_files),
+                    },
+                }
+
+                child_dict = child.dict(by_alias=True)
+                child_dict["name"] = name
+                apps["apps"].append(child_dict)
+
+    selectors = set(global_selectors)
+    if product.app_selectors:
+        selectors.update(product.app_selectors.exclude or [])
+
+    for selector in selectors:
+        apps_to_remove: set[str] = set()
+        results = parser.parse(selector).find(apps)
+        apps_to_remove.update(match.value["name"] for match in results)
+        for app_name in apps_to_remove:
+            selected_app_data.pop(app_name, None)
+
+    return selected_app_data

{qontract_reconcile-0.10.2.dev299 → qontract_reconcile-0.10.2.dev303}/reconcile/utils/ocm/status_board.py

@@ -21,6 +21,7 @@ class IDSpec(TypedDict):
 
 
 class ApplicationOCMSpec(BaseOCMSpec):
+    metadata: dict[str, Any]
     product: IDSpec
 
 
@@ -117,6 +118,18 @@ def create_service(ocm_api: OCMBaseClient, spec: ServiceOCMSpec) -> str:
     return resp["id"]
 
 
+def update_application(
+    ocm_api: OCMBaseClient,
+    application_id: str,
+    spec: ApplicationOCMSpec,
+) -> None:
+    data = spec | {
+        "metadata": spec.get("metadata", {})
+        | {METADATA_MANAGED_BY_KEY: METADATA_MANAGED_BY_VALUE}
+    }
+    ocm_api.patch(f"/api/status-board/v1/applications/{application_id}", data=data)
+
+
 def update_service(
     ocm_api: OCMBaseClient,
     service_id: str,

{qontract_reconcile-0.10.2.dev299 → qontract_reconcile-0.10.2.dev303}/tools/qontract_cli.py

@@ -2772,7 +2772,7 @@ def slo_document_services(ctx: click.Context, status_board_instance: str) -> Non
         print(f"Status-board instance '{status_board_instance}' not found.")
         sys.exit(1)
 
-    desired_product_apps: dict[str, set[str]] = (
+    desired_product_apps: dict[str, dict[str, dict[str, dict[str, set[str]]]]] = (
         StatusBoardExporterIntegration.get_product_apps(sb)
     )
 

qontract_reconcile-0.10.2.dev299/reconcile/typed_queries/status_board.py

@@ -1,57 +0,0 @@
-from collections.abc import Callable, Iterable
-from typing import Any
-
-from jsonpath_ng.ext import parser
-
-from reconcile.gql_definitions.status_board.status_board import (
-    StatusBoardProductV1,
-    StatusBoardV1,
-    query,
-)
-from reconcile.utils import gql
-
-
-def get_status_board(
-    query_func: Callable | None = None,
-) -> list[StatusBoardV1]:
-    if not query_func:
-        query_func = gql.get_api().query
-    return query(query_func).status_board_v1 or []
-
-
-def get_selected_app_names(
-    global_selectors: Iterable[str],
-    product: StatusBoardProductV1,
-) -> set[str]:
-    selected_app_names: set[str] = set()
-
-    apps: dict[str, Any] = {"apps": []}
-    for namespace in product.product_environment.namespaces or []:
-        prefix = ""
-        if namespace.app.parent_app:
-            prefix = f"{namespace.app.parent_app.name}-"
-        name = f"{prefix}{namespace.app.name}"
-        selected_app_names.add(name)
-        app = namespace.app.dict(by_alias=True)
-        app["name"] = name
-        apps["apps"].append(app)
-
-        for child in namespace.app.children_apps or []:
-            name = f"{namespace.app.name}-{child.name}"
-            if name not in selected_app_names:
-                selected_app_names.add(f"{namespace.app.name}-{child.name}")
-                child_dict = child.dict(by_alias=True)
-                child_dict["name"] = name
-                apps["apps"].append(child_dict)
-
-    selectors = set(global_selectors)
-    if product.app_selectors:
-        selectors.update(product.app_selectors.exclude or [])
-
-    for selector in selectors:
-        apps_to_remove: set[str] = set()
-        results = parser.parse(selector).find(apps)
-        apps_to_remove.update(match.value["name"] for match in results)
-        selected_app_names -= apps_to_remove
-
-    return selected_app_names