qontract-reconcile 0.10.2.dev310__py3-none-any.whl → 0.10.2.dev439__py3-none-any.whl

reconcile/aws_version_sync/integration.py

@@ -7,12 +7,7 @@ from enum import StrEnum
 from typing import Any
 
 import semver
-from pydantic import (
-    BaseModel,
-    ValidationError,
-    root_validator,
-    validator,
-)
+from pydantic import BaseModel, ValidationError, field_validator, model_validator
 
 from reconcile.aws_version_sync.merge_request_manager.merge_request import (
     Renderer,
@@ -81,7 +76,7 @@ class SupportedResourceProvider(StrEnum):
     ELASTICACHE = "elasticache"
 
 
-class ExternalResource(BaseModel):
+class ExternalResource(BaseModel, arbitrary_types_allowed=True):
     namespace_file: str | None = None
     provider: str = "aws"
     provisioner: ExternalResourceProvisioner
@@ -94,9 +89,6 @@ class ExternalResource(BaseModel):
     # used to map AWS cache name to resource_identifier
     redis_replication_group_id: str | None = None
 
-    class Config:
-        arbitrary_types_allowed = True
-
     @property
     def key(self) -> tuple:
         return (
@@ -104,10 +96,10 @@ class ExternalResource(BaseModel):
             self.provisioner.uid,
             self.resource_provider,
             self.resource_identifier,
-            self.resource_engine,
         )
 
-    @validator("resource_engine_version", pre=True)
+    @field_validator("resource_engine_version", mode="before")
+    @classmethod
     def parse_resource_engine_version(
         cls, v: str | semver.VersionInfo
     ) -> semver.VersionInfo:
@@ -115,7 +107,8 @@ class ExternalResource(BaseModel):
             return v
         return parse_semver(str(v), optional_minor_and_patch=True)
 
-    @root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def set_resource_engine_version_format(cls, values: dict) -> dict:
         resource_engine_version, resource_engine_version_format = (
             str(values.get("resource_engine_version")),
@@ -220,6 +213,7 @@ class AVSIntegration(QontractReconcileIntegration[AVSIntegrationParams]):
         clusters: Iterable[ClusterV1],
         timeout: int,
         elasticache_replication_group_id_to_identifier: ReplicationGroupIdToIdentifier,
+        supported_providers: Iterable[str],
         prom_get_func: Callable = prom_get,
     ) -> list[ExternalResource]:
         metrics: list[ExternalResource] = []
@@ -232,81 +226,123 @@ class AVSIntegration(QontractReconcileIntegration[AVSIntegrationParams]):
             )
 
             # RDS resources
-            try:
-                rds_metrics = prom_get_func(
-                    url=cluster.prometheus_url,
-                    params={"query": "aws_resources_exporter_rds_engineversion"},
-                    token=token,
-                    timeout=timeout,
+            if SupportedResourceProvider.RDS in supported_providers:
+                metrics.extend(
+                    self._fetch_rds_metrics(cluster, token, timeout, prom_get_func)
                 )
 
-                for m in rds_metrics:
-                    try:
-                        metrics.append(
-                            ExternalResource(
-                                provider="aws",
-                                provisioner=ExternalResourceProvisioner(
-                                    uid=m["aws_account_id"]
-                                ),
-                                resource_provider=SupportedResourceProvider.RDS,
-                                resource_identifier=m["dbinstance_identifier"],
-                                resource_engine=m["engine"],
-                                resource_engine_version=m["engine_version"],
-                            )
-                        )
-                    except ValidationError:
-                        # don't try to parse AWS extended support version numbers
-                        # See https://aws.amazon.com/about-aws/whats-new/2025/04/amazon-rds-postgresql-extended-support-11-22-rds-20250220-12-22-rds-20250220/ for more info
-                        if (
-                            EXTENDED_SUPPORT_VERSION_INDICATOR
-                            not in m["engine_version"]
-                        ):
-                            raise
-                    except Exception as e:
-                        logging.error(
-                            f"Failed to parse RDS metric for {m['dbinstance_identifier']}: {e}"
-                        )
-            except Exception as e:
+            # ElastiCache resources
+            if SupportedResourceProvider.ELASTICACHE in supported_providers:
+                metrics.extend(
+                    self._fetch_elasticache_metrics(
+                        cluster,
+                        token,
+                        timeout,
+                        elasticache_replication_group_id_to_identifier,
+                        prom_get_func,
+                    )
+                )
+
+        return metrics
+
+    def _fetch_rds_metrics(
+        self,
+        cluster: ClusterV1,
+        token: str | None,
+        timeout: int,
+        prom_get_func: Callable,
+    ) -> list[ExternalResource]:
+        """Fetch RDS metrics from the AWS resource exporter."""
+        metrics: list[ExternalResource] = []
+        try:
+            rds_metrics = prom_get_func(
+                url=cluster.prometheus_url,
+                params={"query": "aws_resources_exporter_rds_engineversion"},
+                token=token,
+                timeout=timeout,
+            )
+        except Exception as e:
+            logging.error(
+                f"Failed to get 'aws_resources_exporter_rds_engineversion' metrics for cluster {cluster.name}: {e}"
+            )
+            return []
+
+        for m in rds_metrics:
+            try:
+                metrics.append(
+                    ExternalResource(
+                        provider="aws",
+                        provisioner=ExternalResourceProvisioner(
+                            uid=m["aws_account_id"]
+                        ),
+                        resource_provider=SupportedResourceProvider.RDS,
+                        resource_identifier=m["dbinstance_identifier"],
+                        resource_engine=m["engine"],
+                        resource_engine_version=m["engine_version"],
+                    )
+                )
+            except ValidationError as e:
+                if EXTENDED_SUPPORT_VERSION_INDICATOR in m["engine_version"]:
+                    # don't try to parse AWS extended support version numbers
+                    # See https://aws.amazon.com/about-aws/whats-new/2025/04/amazon-rds-postgresql-extended-support-11-22-rds-20250220-12-22-rds-20250220/ for more info
+                    pass
+                else:
+                    logging.error(
+                        f"Failed to parse RDS metric for {m['dbinstance_identifier']}: {e}"
+                    )
+            except KeyError as e:
                 logging.error(
-                    f"Failed to get 'aws_resources_exporter_rds_engineversion' metrics for cluster {cluster.name}: {e}"
+                    f"Failed to parse RDS metric for {m['dbinstance_identifier']}: {e}"
                 )
+        return metrics
 
-            # ElastiCache resources
+    def _fetch_elasticache_metrics(
+        self,
+        cluster: ClusterV1,
+        token: str | None,
+        timeout: int,
+        elasticache_replication_group_id_to_identifier: ReplicationGroupIdToIdentifier,
+        prom_get_func: Callable,
+    ) -> list[ExternalResource]:
+        """Fetch ElastiCache metrics from the AWS resource exporter."""
+        metrics: list[ExternalResource] = []
+        try:
+            elasticache_metrics = prom_get_func(
+                url=cluster.prometheus_url,
+                params={"query": "aws_resources_exporter_elasticache_redisversion"},
+                token=token,
+                timeout=timeout,
+            )
+        except Exception as e:
+            logging.error(
+                f"Failed to get 'aws_resources_exporter_elasticache_redisversion' metrics for cluster {cluster.name}: {e}"
+            )
+            return []
+
+        for m in elasticache_metrics:
             try:
-                elasticache_metrics = prom_get_func(
-                    url=cluster.prometheus_url,
-                    params={"query": "aws_resources_exporter_elasticache_redisversion"},
-                    token=token,
-                    timeout=timeout,
+                metrics.append(
+                    ExternalResource(
+                        provider="aws",
+                        provisioner=ExternalResourceProvisioner(
+                            uid=m["aws_account_id"]
+                        ),
+                        resource_provider=SupportedResourceProvider.ELASTICACHE,
+                        # replication_group_id != resource_identifier!
+                        resource_identifier=elasticache_replication_group_id_to_identifier.get(
+                            (
+                                m["aws_account_id"],
+                                m["replication_group_id"],
+                            ),
+                            m["replication_group_id"],
+                        ),
+                        resource_engine=m["engine"],
+                        resource_engine_version=m["engine_version"],
+                    )
                 )
-                for m in elasticache_metrics:
-                    try:
-                        metrics.append(
-                            ExternalResource(
-                                provider="aws",
-                                provisioner=ExternalResourceProvisioner(
-                                    uid=m["aws_account_id"]
-                                ),
-                                resource_provider=SupportedResourceProvider.ELASTICACHE,
-                                # replication_group_id != resource_identifier!
-                                resource_identifier=elasticache_replication_group_id_to_identifier.get(
-                                    (
-                                        m["aws_account_id"],
-                                        m["replication_group_id"],
-                                    ),
-                                    m["replication_group_id"],
-                                ),
-                                resource_engine=m["engine"],
-                                resource_engine_version=m["engine_version"],
-                            )
-                        )
-                    except Exception as e:
-                        logging.error(
-                            f"Failed to parse ElastiCache metrics for {m['replication_group_id']}: {e}"
-                        )
-            except Exception as e:
+            except (ValidationError, KeyError) as e:
                 logging.error(
-                    f"Failed to get 'aws_resources_exporter_elasticache_redisversion' metrics for cluster {cluster.name}: {e}"
+                    f"Failed to parse ElastiCache metrics for {m['replication_group_id']}: {e}"
                 )
 
         return metrics
@@ -353,8 +389,8 @@ class AVSIntegration(QontractReconcileIntegration[AVSIntegrationParams]):
                         resource.provider == SupportedResourceProvider.ELASTICACHE
                         and str(values["engine_version"]).lower().endswith("x")
                     ):
-                        # AWS ElastiCache Redis 6 could use a version like 6.x. Then, we don't need to manage it
-                        continue
+                        # AWS ElastiCache Redis 6 could use a version like 6.x. Let's patch it to a fix version
+                        values["engine_version"] = "6.2"
 
                     if (
                         resource.provider == SupportedResourceProvider.RDS
@@ -400,7 +436,9 @@ class AVSIntegration(QontractReconcileIntegration[AVSIntegrationParams]):
             key=lambda r: r.key,
             equal=lambda external_resources_app_interface,
             external_resources_aws: external_resources_app_interface.resource_engine_version_string
-            == external_resources_aws.resource_engine_version_string,
+            == external_resources_aws.resource_engine_version_string
+            and external_resources_app_interface.resource_engine
+            == external_resources_aws.resource_engine,
         )
         for diff_pair in diff.change.values():
             aws_resource = diff_pair.desired
@@ -408,6 +446,8 @@ class AVSIntegration(QontractReconcileIntegration[AVSIntegrationParams]):
             if (
                 aws_resource.resource_engine_version
                 <= app_interface_resource.resource_engine_version
+                and aws_resource.resource_engine
+                == app_interface_resource.resource_engine
             ):
                 # do not downgrade the version
                 continue
@@ -422,7 +462,7 @@ class AVSIntegration(QontractReconcileIntegration[AVSIntegrationParams]):
                     provisioner_uid=app_interface_resource.provisioner.uid,
                     resource_provider=app_interface_resource.resource_provider,
                     resource_identifier=app_interface_resource.resource_identifier,
-                    resource_engine=app_interface_resource.resource_engine,
+                    resource_engine=aws_resource.resource_engine,
                     resource_engine_version=aws_resource.resource_engine_version_string,
                 )
             )
@@ -475,6 +515,7 @@ class AVSIntegration(QontractReconcileIntegration[AVSIntegrationParams]):
                 for external_resource in external_resources_app_interface
                 if external_resource.redis_replication_group_id
             },
+            supported_providers=self.params.supported_providers,
         )
 
         self.reconcile(

reconcile/change_owners/bundle.py

@@ -62,8 +62,8 @@ class QontractServerDatafileDiff(BaseModel):
 
     datafilepath: str
     datafileschema: str
-    old: dict[str, Any] | None
-    new: dict[str, Any] | None
+    old: dict[str, Any] | None = None
+    new: dict[str, Any] | None = None
 
     @property
     def old_datafilepath(self) -> str | None:
@@ -119,7 +119,7 @@ class QontractServerResourcefileDiffState(BaseModel):
     content: str
     resourcefileschema: str | None = Field(..., alias="$schema")
     sha256sum: str
-    backrefs: list[QontractServerResourcefileBackref] | None
+    backrefs: list[QontractServerResourcefileBackref] | None = None
 
 
 class QontractServerResourcefileDiff(BaseModel):

reconcile/change_owners/change_log_tracking.py

@@ -155,7 +155,8 @@ class ChangeLogIntegration(QontractReconcileIntegration[ChangeLogIntegrationPara
             changes = aggregate_resource_changes(
                 bundle_changes=aggregate_file_moves(parse_bundle_changes(diff)),
                 content_store={
-                    c.path: c.dict(by_alias=True) for c in namespaces + jenkins_configs
+                    c.path: c.model_dump(by_alias=True)
+                    for c in namespaces + jenkins_configs
                 },
                 supported_schemas={
                     "/openshift/namespace-1.yml",
@@ -239,4 +240,4 @@ class ChangeLogIntegration(QontractReconcileIntegration[ChangeLogIntegrationPara
             change_log.items, key=lambda i: i.merged_at, reverse=True
         )
         if not dry_run:
-            integration_state.add(BUNDLE_DIFFS_OBJ, change_log.dict(), force=True)
+            integration_state.add(BUNDLE_DIFFS_OBJ, change_log.model_dump(), force=True)

reconcile/change_owners/change_owners.py

@@ -140,7 +140,7 @@ def write_coverage_report_to_mr(
     approver_reachability = set()
     for d in change_decisions:
         approvers = [
-            f"{cr.context} - {' '.join([f'@{a.org_username}' if a.tag_on_merge_requests else a.org_username for a in cr.approvers])}"
+            f"{cr.context} - {' '.join([f'@{a.org_username}' if (a.tag_on_merge_requests or len(cr.approvers) == 1) else a.org_username for a in cr.approvers])}"
             for cr in d.change_responsibles
         ]
         if d.coverable_by_fragment_decisions:

reconcile/change_owners/diff.py

@@ -1,5 +1,4 @@
 import copy
-import json
 from dataclasses import dataclass
 from enum import Enum
 from functools import reduce
@@ -11,6 +10,7 @@ from deepdiff.helper import CannotCompare
 from deepdiff.model import DiffLevel
 from deepdiff.path import parse_path
 
+from reconcile.utils.json import json_dumps
 from reconcile.utils.jsonpath import parse_jsonpath
 
 
@@ -75,7 +75,7 @@ class Diff:
     def _value_repr(self, value: Any | None) -> str | None:
         if value:
             if isinstance(value, dict | list):
-                return json.dumps(value, indent=2)
+                return json_dumps(value, indent=2)
             return str(value)
         return value
 
@@ -251,8 +251,6 @@ def deepdiff_path_to_jsonpath(deep_diff_path: str) -> jsonpath_ng.JSONPath:
             case int():
                 return jsonpath_ng.Index(element)
             case str():
-                if "." in element:
-                    return jsonpath_ng.Fields(f"'{element}'")
                 return jsonpath_ng.Fields(element)
 
     path_parts = [build_jsonpath_part(p) for p in parse_path(deep_diff_path)]

reconcile/checkpoint.py

@@ -26,6 +26,7 @@ from jira import Issue
 
 from reconcile.utils.constants import PROJ_ROOT
 from reconcile.utils.jira_client import JiraClient
+from reconcile.utils.secret_reader import SecretReaderBase
 
 DEFAULT_CHECKPOINT_LABELS = ("sre-checkpoint",)
 
@@ -61,7 +62,7 @@ def url_makes_sense(url: str) -> bool:
     return rs.status_code < HTTPStatus.NOT_FOUND
 
 
-def valid_owners(owners: Iterable[Mapping[str, str]]) -> bool:
+def valid_owners(owners: Iterable[Mapping[str, str | None]]) -> bool:
     """Confirm whether all the owners have a name and a valid email address."""
     return all(
         o["name"]
@@ -118,8 +119,8 @@ def file_ticket(
 def report_invalid_metadata(
     app: Mapping[str, Any],
     path: str,
-    board: Mapping[str, str | Mapping],
-    settings: Mapping[str, Any],
+    board: Mapping[str, Any],
+    secret_reader: SecretReaderBase,
     parent: str,
     dry_run: bool = False,
 ) -> None:
@@ -150,7 +151,14 @@ def report_invalid_metadata(
             path=path,
         )
     else:
-        jira = JiraClient(board, settings)
+        jira = JiraClient.create(
+            project_name=board["name"],
+            token=secret_reader.read_secret(board["server"]["token"]),
+            email=secret_reader.read_secret(board["server"]["email"])
+            if board["server"]["email"]
+            else None,
+            server_url=board["server"]["server_url"],
+        )
         do_cut = partial(
             file_ticket,  # type: ignore
             jira=jira,